OLD | NEW |
| (Empty) |
1 /* | |
2 * Copyright 2013 The WebRTC project authors. All Rights Reserved. | |
3 * | |
4 * Use of this source code is governed by a BSD-style license | |
5 * that can be found in the LICENSE file in the root of the source | |
6 * tree. An additional intellectual property rights grant can be found | |
7 * in the file PATENTS. All contributing project authors may | |
8 * be found in the AUTHORS file in the root of the source tree. | |
9 */ | |
10 | |
11 #include <memory> | |
12 | |
13 #include "webrtc/api/test/peerconnectiontestwrapper.h" | |
14 // Notice that mockpeerconnectionobservers.h must be included after the above! | |
15 #include "webrtc/api/test/mockpeerconnectionobservers.h" | |
16 #ifdef WEBRTC_ANDROID | |
17 #include "webrtc/api/test/androidtestinitializer.h" | |
18 #endif | |
19 #include "webrtc/base/gunit.h" | |
20 #include "webrtc/base/logging.h" | |
21 #include "webrtc/base/ssladapter.h" | |
22 #include "webrtc/base/thread.h" | |
23 #include "webrtc/base/sslstreamadapter.h" | |
24 #include "webrtc/base/stringencode.h" | |
25 #include "webrtc/base/stringutils.h" | |
26 | |
27 #define MAYBE_SKIP_TEST(feature) \ | |
28 if (!(feature())) { \ | |
29 LOG(LS_INFO) << "Feature disabled... skipping"; \ | |
30 return; \ | |
31 } | |
32 | |
33 using webrtc::DataChannelInterface; | |
34 using webrtc::FakeConstraints; | |
35 using webrtc::MediaConstraintsInterface; | |
36 using webrtc::MediaStreamInterface; | |
37 using webrtc::PeerConnectionInterface; | |
38 | |
39 namespace { | |
40 | |
41 const int kMaxWait = 10000; | |
42 | |
43 } // namespace | |
44 | |
45 class PeerConnectionEndToEndTest | |
46 : public sigslot::has_slots<>, | |
47 public testing::Test { | |
48 public: | |
49 typedef std::vector<rtc::scoped_refptr<DataChannelInterface> > | |
50 DataChannelList; | |
51 | |
52 PeerConnectionEndToEndTest() { | |
53 RTC_CHECK(network_thread_.Start()); | |
54 RTC_CHECK(worker_thread_.Start()); | |
55 caller_ = new rtc::RefCountedObject<PeerConnectionTestWrapper>( | |
56 "caller", &network_thread_, &worker_thread_); | |
57 callee_ = new rtc::RefCountedObject<PeerConnectionTestWrapper>( | |
58 "callee", &network_thread_, &worker_thread_); | |
59 webrtc::PeerConnectionInterface::IceServer ice_server; | |
60 ice_server.uri = "stun:stun.l.google.com:19302"; | |
61 config_.servers.push_back(ice_server); | |
62 | |
63 #ifdef WEBRTC_ANDROID | |
64 webrtc::InitializeAndroidObjects(); | |
65 #endif | |
66 } | |
67 | |
68 void CreatePcs() { | |
69 CreatePcs(NULL); | |
70 } | |
71 | |
72 void CreatePcs(const MediaConstraintsInterface* pc_constraints) { | |
73 EXPECT_TRUE(caller_->CreatePc(pc_constraints, config_)); | |
74 EXPECT_TRUE(callee_->CreatePc(pc_constraints, config_)); | |
75 PeerConnectionTestWrapper::Connect(caller_.get(), callee_.get()); | |
76 | |
77 caller_->SignalOnDataChannel.connect( | |
78 this, &PeerConnectionEndToEndTest::OnCallerAddedDataChanel); | |
79 callee_->SignalOnDataChannel.connect( | |
80 this, &PeerConnectionEndToEndTest::OnCalleeAddedDataChannel); | |
81 } | |
82 | |
83 void GetAndAddUserMedia() { | |
84 FakeConstraints audio_constraints; | |
85 FakeConstraints video_constraints; | |
86 GetAndAddUserMedia(true, audio_constraints, true, video_constraints); | |
87 } | |
88 | |
89 void GetAndAddUserMedia(bool audio, FakeConstraints audio_constraints, | |
90 bool video, FakeConstraints video_constraints) { | |
91 caller_->GetAndAddUserMedia(audio, audio_constraints, | |
92 video, video_constraints); | |
93 callee_->GetAndAddUserMedia(audio, audio_constraints, | |
94 video, video_constraints); | |
95 } | |
96 | |
97 void Negotiate() { | |
98 caller_->CreateOffer(NULL); | |
99 } | |
100 | |
101 void WaitForCallEstablished() { | |
102 caller_->WaitForCallEstablished(); | |
103 callee_->WaitForCallEstablished(); | |
104 } | |
105 | |
106 void WaitForConnection() { | |
107 caller_->WaitForConnection(); | |
108 callee_->WaitForConnection(); | |
109 } | |
110 | |
111 void OnCallerAddedDataChanel(DataChannelInterface* dc) { | |
112 caller_signaled_data_channels_.push_back(dc); | |
113 } | |
114 | |
115 void OnCalleeAddedDataChannel(DataChannelInterface* dc) { | |
116 callee_signaled_data_channels_.push_back(dc); | |
117 } | |
118 | |
119 // Tests that |dc1| and |dc2| can send to and receive from each other. | |
120 void TestDataChannelSendAndReceive( | |
121 DataChannelInterface* dc1, DataChannelInterface* dc2) { | |
122 std::unique_ptr<webrtc::MockDataChannelObserver> dc1_observer( | |
123 new webrtc::MockDataChannelObserver(dc1)); | |
124 | |
125 std::unique_ptr<webrtc::MockDataChannelObserver> dc2_observer( | |
126 new webrtc::MockDataChannelObserver(dc2)); | |
127 | |
128 static const std::string kDummyData = "abcdefg"; | |
129 webrtc::DataBuffer buffer(kDummyData); | |
130 EXPECT_TRUE(dc1->Send(buffer)); | |
131 EXPECT_EQ_WAIT(kDummyData, dc2_observer->last_message(), kMaxWait); | |
132 | |
133 EXPECT_TRUE(dc2->Send(buffer)); | |
134 EXPECT_EQ_WAIT(kDummyData, dc1_observer->last_message(), kMaxWait); | |
135 | |
136 EXPECT_EQ(1U, dc1_observer->received_message_count()); | |
137 EXPECT_EQ(1U, dc2_observer->received_message_count()); | |
138 } | |
139 | |
140 void WaitForDataChannelsToOpen(DataChannelInterface* local_dc, | |
141 const DataChannelList& remote_dc_list, | |
142 size_t remote_dc_index) { | |
143 EXPECT_EQ_WAIT(DataChannelInterface::kOpen, local_dc->state(), kMaxWait); | |
144 | |
145 EXPECT_TRUE_WAIT(remote_dc_list.size() > remote_dc_index, kMaxWait); | |
146 EXPECT_EQ_WAIT(DataChannelInterface::kOpen, | |
147 remote_dc_list[remote_dc_index]->state(), | |
148 kMaxWait); | |
149 EXPECT_EQ(local_dc->id(), remote_dc_list[remote_dc_index]->id()); | |
150 } | |
151 | |
152 void CloseDataChannels(DataChannelInterface* local_dc, | |
153 const DataChannelList& remote_dc_list, | |
154 size_t remote_dc_index) { | |
155 local_dc->Close(); | |
156 EXPECT_EQ_WAIT(DataChannelInterface::kClosed, local_dc->state(), kMaxWait); | |
157 EXPECT_EQ_WAIT(DataChannelInterface::kClosed, | |
158 remote_dc_list[remote_dc_index]->state(), | |
159 kMaxWait); | |
160 } | |
161 | |
162 protected: | |
163 rtc::Thread network_thread_; | |
164 rtc::Thread worker_thread_; | |
165 rtc::scoped_refptr<PeerConnectionTestWrapper> caller_; | |
166 rtc::scoped_refptr<PeerConnectionTestWrapper> callee_; | |
167 DataChannelList caller_signaled_data_channels_; | |
168 DataChannelList callee_signaled_data_channels_; | |
169 webrtc::PeerConnectionInterface::RTCConfiguration config_; | |
170 }; | |
171 | |
172 // Disabled for TSan v2, see | |
173 // https://bugs.chromium.org/p/webrtc/issues/detail?id=4719 for details. | |
174 // Disabled for Mac, see | |
175 // https://bugs.chromium.org/p/webrtc/issues/detail?id=5231 for details. | |
176 #if !defined(THREAD_SANITIZER) && !defined(WEBRTC_MAC) | |
177 TEST_F(PeerConnectionEndToEndTest, Call) { | |
178 CreatePcs(); | |
179 GetAndAddUserMedia(); | |
180 Negotiate(); | |
181 WaitForCallEstablished(); | |
182 } | |
183 #endif // if !defined(THREAD_SANITIZER) && !defined(WEBRTC_MAC) | |
184 | |
185 #if !defined(ADDRESS_SANITIZER) | |
186 TEST_F(PeerConnectionEndToEndTest, CallWithLegacySdp) { | |
187 FakeConstraints pc_constraints; | |
188 pc_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp, | |
189 false); | |
190 CreatePcs(&pc_constraints); | |
191 GetAndAddUserMedia(); | |
192 Negotiate(); | |
193 WaitForCallEstablished(); | |
194 } | |
195 #endif // !defined(ADDRESS_SANITIZER) | |
196 | |
197 #ifdef HAVE_SCTP | |
198 // Verifies that a DataChannel created before the negotiation can transition to | |
199 // "OPEN" and transfer data. | |
200 TEST_F(PeerConnectionEndToEndTest, CreateDataChannelBeforeNegotiate) { | |
201 MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp); | |
202 | |
203 CreatePcs(); | |
204 | |
205 webrtc::DataChannelInit init; | |
206 rtc::scoped_refptr<DataChannelInterface> caller_dc( | |
207 caller_->CreateDataChannel("data", init)); | |
208 rtc::scoped_refptr<DataChannelInterface> callee_dc( | |
209 callee_->CreateDataChannel("data", init)); | |
210 | |
211 Negotiate(); | |
212 WaitForConnection(); | |
213 | |
214 WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 0); | |
215 WaitForDataChannelsToOpen(callee_dc, caller_signaled_data_channels_, 0); | |
216 | |
217 TestDataChannelSendAndReceive(caller_dc, callee_signaled_data_channels_[0]); | |
218 TestDataChannelSendAndReceive(callee_dc, caller_signaled_data_channels_[0]); | |
219 | |
220 CloseDataChannels(caller_dc, callee_signaled_data_channels_, 0); | |
221 CloseDataChannels(callee_dc, caller_signaled_data_channels_, 0); | |
222 } | |
223 | |
224 // Verifies that a DataChannel created after the negotiation can transition to | |
225 // "OPEN" and transfer data. | |
226 TEST_F(PeerConnectionEndToEndTest, CreateDataChannelAfterNegotiate) { | |
227 MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp); | |
228 | |
229 CreatePcs(); | |
230 | |
231 webrtc::DataChannelInit init; | |
232 | |
233 // This DataChannel is for creating the data content in the negotiation. | |
234 rtc::scoped_refptr<DataChannelInterface> dummy( | |
235 caller_->CreateDataChannel("data", init)); | |
236 Negotiate(); | |
237 WaitForConnection(); | |
238 | |
239 // Wait for the data channel created pre-negotiation to be opened. | |
240 WaitForDataChannelsToOpen(dummy, callee_signaled_data_channels_, 0); | |
241 | |
242 // Create new DataChannels after the negotiation and verify their states. | |
243 rtc::scoped_refptr<DataChannelInterface> caller_dc( | |
244 caller_->CreateDataChannel("hello", init)); | |
245 rtc::scoped_refptr<DataChannelInterface> callee_dc( | |
246 callee_->CreateDataChannel("hello", init)); | |
247 | |
248 WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 1); | |
249 WaitForDataChannelsToOpen(callee_dc, caller_signaled_data_channels_, 0); | |
250 | |
251 TestDataChannelSendAndReceive(caller_dc, callee_signaled_data_channels_[1]); | |
252 TestDataChannelSendAndReceive(callee_dc, caller_signaled_data_channels_[0]); | |
253 | |
254 CloseDataChannels(caller_dc, callee_signaled_data_channels_, 1); | |
255 CloseDataChannels(callee_dc, caller_signaled_data_channels_, 0); | |
256 } | |
257 | |
258 // Verifies that DataChannel IDs are even/odd based on the DTLS roles. | |
259 TEST_F(PeerConnectionEndToEndTest, DataChannelIdAssignment) { | |
260 MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp); | |
261 | |
262 CreatePcs(); | |
263 | |
264 webrtc::DataChannelInit init; | |
265 rtc::scoped_refptr<DataChannelInterface> caller_dc_1( | |
266 caller_->CreateDataChannel("data", init)); | |
267 rtc::scoped_refptr<DataChannelInterface> callee_dc_1( | |
268 callee_->CreateDataChannel("data", init)); | |
269 | |
270 Negotiate(); | |
271 WaitForConnection(); | |
272 | |
273 EXPECT_EQ(1U, caller_dc_1->id() % 2); | |
274 EXPECT_EQ(0U, callee_dc_1->id() % 2); | |
275 | |
276 rtc::scoped_refptr<DataChannelInterface> caller_dc_2( | |
277 caller_->CreateDataChannel("data", init)); | |
278 rtc::scoped_refptr<DataChannelInterface> callee_dc_2( | |
279 callee_->CreateDataChannel("data", init)); | |
280 | |
281 EXPECT_EQ(1U, caller_dc_2->id() % 2); | |
282 EXPECT_EQ(0U, callee_dc_2->id() % 2); | |
283 } | |
284 | |
285 // Verifies that the message is received by the right remote DataChannel when | |
286 // there are multiple DataChannels. | |
287 TEST_F(PeerConnectionEndToEndTest, | |
288 MessageTransferBetweenTwoPairsOfDataChannels) { | |
289 MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp); | |
290 | |
291 CreatePcs(); | |
292 | |
293 webrtc::DataChannelInit init; | |
294 | |
295 rtc::scoped_refptr<DataChannelInterface> caller_dc_1( | |
296 caller_->CreateDataChannel("data", init)); | |
297 rtc::scoped_refptr<DataChannelInterface> caller_dc_2( | |
298 caller_->CreateDataChannel("data", init)); | |
299 | |
300 Negotiate(); | |
301 WaitForConnection(); | |
302 WaitForDataChannelsToOpen(caller_dc_1, callee_signaled_data_channels_, 0); | |
303 WaitForDataChannelsToOpen(caller_dc_2, callee_signaled_data_channels_, 1); | |
304 | |
305 std::unique_ptr<webrtc::MockDataChannelObserver> dc_1_observer( | |
306 new webrtc::MockDataChannelObserver(callee_signaled_data_channels_[0])); | |
307 | |
308 std::unique_ptr<webrtc::MockDataChannelObserver> dc_2_observer( | |
309 new webrtc::MockDataChannelObserver(callee_signaled_data_channels_[1])); | |
310 | |
311 const std::string message_1 = "hello 1"; | |
312 const std::string message_2 = "hello 2"; | |
313 | |
314 caller_dc_1->Send(webrtc::DataBuffer(message_1)); | |
315 EXPECT_EQ_WAIT(message_1, dc_1_observer->last_message(), kMaxWait); | |
316 | |
317 caller_dc_2->Send(webrtc::DataBuffer(message_2)); | |
318 EXPECT_EQ_WAIT(message_2, dc_2_observer->last_message(), kMaxWait); | |
319 | |
320 EXPECT_EQ(1U, dc_1_observer->received_message_count()); | |
321 EXPECT_EQ(1U, dc_2_observer->received_message_count()); | |
322 } | |
323 #endif // HAVE_SCTP | |
324 | |
325 #ifdef HAVE_QUIC | |
326 // Test that QUIC data channels can be used and that messages go to the correct | |
327 // remote data channel when both peers want to use QUIC. It is assumed that the | |
328 // application has externally negotiated the data channel parameters. | |
329 TEST_F(PeerConnectionEndToEndTest, MessageTransferBetweenQuicDataChannels) { | |
330 config_.enable_quic = true; | |
331 CreatePcs(); | |
332 | |
333 webrtc::DataChannelInit init_1; | |
334 init_1.id = 0; | |
335 init_1.ordered = false; | |
336 init_1.reliable = true; | |
337 | |
338 webrtc::DataChannelInit init_2; | |
339 init_2.id = 1; | |
340 init_2.ordered = false; | |
341 init_2.reliable = true; | |
342 | |
343 rtc::scoped_refptr<DataChannelInterface> caller_dc_1( | |
344 caller_->CreateDataChannel("data", init_1)); | |
345 ASSERT_NE(nullptr, caller_dc_1); | |
346 rtc::scoped_refptr<DataChannelInterface> caller_dc_2( | |
347 caller_->CreateDataChannel("data", init_2)); | |
348 ASSERT_NE(nullptr, caller_dc_2); | |
349 rtc::scoped_refptr<DataChannelInterface> callee_dc_1( | |
350 callee_->CreateDataChannel("data", init_1)); | |
351 ASSERT_NE(nullptr, callee_dc_1); | |
352 rtc::scoped_refptr<DataChannelInterface> callee_dc_2( | |
353 callee_->CreateDataChannel("data", init_2)); | |
354 ASSERT_NE(nullptr, callee_dc_2); | |
355 | |
356 Negotiate(); | |
357 WaitForConnection(); | |
358 EXPECT_TRUE_WAIT(caller_dc_1->state() == webrtc::DataChannelInterface::kOpen, | |
359 kMaxWait); | |
360 EXPECT_TRUE_WAIT(callee_dc_1->state() == webrtc::DataChannelInterface::kOpen, | |
361 kMaxWait); | |
362 EXPECT_TRUE_WAIT(caller_dc_2->state() == webrtc::DataChannelInterface::kOpen, | |
363 kMaxWait); | |
364 EXPECT_TRUE_WAIT(callee_dc_2->state() == webrtc::DataChannelInterface::kOpen, | |
365 kMaxWait); | |
366 | |
367 std::unique_ptr<webrtc::MockDataChannelObserver> dc_1_observer( | |
368 new webrtc::MockDataChannelObserver(callee_dc_1.get())); | |
369 | |
370 std::unique_ptr<webrtc::MockDataChannelObserver> dc_2_observer( | |
371 new webrtc::MockDataChannelObserver(callee_dc_2.get())); | |
372 | |
373 const std::string message_1 = "hello 1"; | |
374 const std::string message_2 = "hello 2"; | |
375 | |
376 // Send data from caller to callee. | |
377 caller_dc_1->Send(webrtc::DataBuffer(message_1)); | |
378 EXPECT_EQ_WAIT(message_1, dc_1_observer->last_message(), kMaxWait); | |
379 | |
380 caller_dc_2->Send(webrtc::DataBuffer(message_2)); | |
381 EXPECT_EQ_WAIT(message_2, dc_2_observer->last_message(), kMaxWait); | |
382 | |
383 EXPECT_EQ(1U, dc_1_observer->received_message_count()); | |
384 EXPECT_EQ(1U, dc_2_observer->received_message_count()); | |
385 | |
386 // Send data from callee to caller. | |
387 dc_1_observer.reset(new webrtc::MockDataChannelObserver(caller_dc_1.get())); | |
388 dc_2_observer.reset(new webrtc::MockDataChannelObserver(caller_dc_2.get())); | |
389 | |
390 callee_dc_1->Send(webrtc::DataBuffer(message_1)); | |
391 EXPECT_EQ_WAIT(message_1, dc_1_observer->last_message(), kMaxWait); | |
392 | |
393 callee_dc_2->Send(webrtc::DataBuffer(message_2)); | |
394 EXPECT_EQ_WAIT(message_2, dc_2_observer->last_message(), kMaxWait); | |
395 | |
396 EXPECT_EQ(1U, dc_1_observer->received_message_count()); | |
397 EXPECT_EQ(1U, dc_2_observer->received_message_count()); | |
398 } | |
399 #endif // HAVE_QUIC | |
400 | |
401 #ifdef HAVE_SCTP | |
402 // Verifies that a DataChannel added from an OPEN message functions after | |
403 // a channel has been previously closed (webrtc issue 3778). | |
404 // This previously failed because the new channel re-uses the ID of the closed | |
405 // channel, and the closed channel was incorrectly still assigned to the id. | |
406 // TODO(deadbeef): This is disabled because there's currently a race condition | |
407 // caused by the fact that a data channel signals that it's closed before it | |
408 // really is. Re-enable this test once that's fixed. | |
409 // See: https://bugs.chromium.org/p/webrtc/issues/detail?id=4453 | |
410 TEST_F(PeerConnectionEndToEndTest, | |
411 DISABLED_DataChannelFromOpenWorksAfterClose) { | |
412 MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp); | |
413 | |
414 CreatePcs(); | |
415 | |
416 webrtc::DataChannelInit init; | |
417 rtc::scoped_refptr<DataChannelInterface> caller_dc( | |
418 caller_->CreateDataChannel("data", init)); | |
419 | |
420 Negotiate(); | |
421 WaitForConnection(); | |
422 | |
423 WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 0); | |
424 CloseDataChannels(caller_dc, callee_signaled_data_channels_, 0); | |
425 | |
426 // Create a new channel and ensure it works after closing the previous one. | |
427 caller_dc = caller_->CreateDataChannel("data2", init); | |
428 | |
429 WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 1); | |
430 TestDataChannelSendAndReceive(caller_dc, callee_signaled_data_channels_[1]); | |
431 | |
432 CloseDataChannels(caller_dc, callee_signaled_data_channels_, 1); | |
433 } | |
434 | |
435 // This tests that if a data channel is closed remotely while not referenced | |
436 // by the application (meaning only the PeerConnection contributes to its | |
437 // reference count), no memory access violation will occur. | |
438 // See: https://code.google.com/p/chromium/issues/detail?id=565048 | |
439 TEST_F(PeerConnectionEndToEndTest, CloseDataChannelRemotelyWhileNotReferenced) { | |
440 MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp); | |
441 | |
442 CreatePcs(); | |
443 | |
444 webrtc::DataChannelInit init; | |
445 rtc::scoped_refptr<DataChannelInterface> caller_dc( | |
446 caller_->CreateDataChannel("data", init)); | |
447 | |
448 Negotiate(); | |
449 WaitForConnection(); | |
450 | |
451 WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 0); | |
452 // This removes the reference to the remote data channel that we hold. | |
453 callee_signaled_data_channels_.clear(); | |
454 caller_dc->Close(); | |
455 EXPECT_EQ_WAIT(DataChannelInterface::kClosed, caller_dc->state(), kMaxWait); | |
456 | |
457 // Wait for a bit longer so the remote data channel will receive the | |
458 // close message and be destroyed. | |
459 rtc::Thread::Current()->ProcessMessages(100); | |
460 } | |
461 #endif // HAVE_SCTP | |
OLD | NEW |