| 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 |
|---|
Chromium Code Reviews
Issue 2514883002:
Create //webrtc/api:libjingle_peerconnection_api + refactorings. (Closed)
