Refactoring on QUIC

webrtc/api/peerconnectionendtoend_unittest.cc

 /*
  *  Copyright 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 38 matching lines @@
   typedef std::vector<rtc::scoped_refptr<DataChannelInterface> >
       DataChannelList;
 
   PeerConnectionEndToEndTest() {
     RTC_CHECK(network_thread_.Start());
     RTC_CHECK(worker_thread_.Start());
     caller_ = new rtc::RefCountedObject<PeerConnectionTestWrapper>(
         "caller", &network_thread_, &worker_thread_);
     callee_ = new rtc::RefCountedObject<PeerConnectionTestWrapper>(
         "callee", &network_thread_, &worker_thread_);
+    webrtc::PeerConnectionInterface::IceServer ice_server;
+    ice_server.uri = "stun:stun.l.google.com:19302";
+    config_.servers.push_back(ice_server);
+
 #ifdef WEBRTC_ANDROID
     webrtc::InitializeAndroidObjects();
 #endif
   }
 
   void CreatePcs() {
     CreatePcs(NULL);
   }
 
   void CreatePcs(const MediaConstraintsInterface* pc_constraints) {
-    EXPECT_TRUE(caller_->CreatePc(pc_constraints));
-    EXPECT_TRUE(callee_->CreatePc(pc_constraints));
+    EXPECT_TRUE(caller_->CreatePc(pc_constraints, config_));
+    EXPECT_TRUE(callee_->CreatePc(pc_constraints, config_));
     PeerConnectionTestWrapper::Connect(caller_.get(), callee_.get());
 
     caller_->SignalOnDataChannel.connect(
         this, &PeerConnectionEndToEndTest::OnCallerAddedDataChanel);
     callee_->SignalOnDataChannel.connect(
         this, &PeerConnectionEndToEndTest::OnCalleeAddedDataChannel);
   }
 
   void GetAndAddUserMedia() {
     FakeConstraints audio_constraints;
@@ skipping 74 matching lines @@
                    kMaxWait);
   }
 
  protected:
   rtc::Thread network_thread_;
   rtc::Thread worker_thread_;
   rtc::scoped_refptr<PeerConnectionTestWrapper> caller_;
   rtc::scoped_refptr<PeerConnectionTestWrapper> callee_;
   DataChannelList caller_signaled_data_channels_;
   DataChannelList callee_signaled_data_channels_;
+  webrtc::PeerConnectionInterface::RTCConfiguration config_;
 };
 
 // Disabled for TSan v2, see
 // https://bugs.chromium.org/p/webrtc/issues/detail?id=4719 for details.
 // Disabled for Mac, see
 // https://bugs.chromium.org/p/webrtc/issues/detail?id=5231 for details.
 #if !defined(THREAD_SANITIZER) && !defined(WEBRTC_MAC)
 TEST_F(PeerConnectionEndToEndTest, Call) {
   CreatePcs();
   GetAndAddUserMedia();
@@ skipping 135 matching lines @@
   caller_dc_1->Send(webrtc::DataBuffer(message_1));
   EXPECT_EQ_WAIT(message_1, dc_1_observer->last_message(), kMaxWait);
 
   caller_dc_2->Send(webrtc::DataBuffer(message_2));
   EXPECT_EQ_WAIT(message_2, dc_2_observer->last_message(), kMaxWait);
 
   EXPECT_EQ(1U, dc_1_observer->received_message_count());
   EXPECT_EQ(1U, dc_2_observer->received_message_count());
 }
 
+#ifdef HAVE_QUIC
+// Test that QUIC data channels can be used and that messages go to the correct
+// remote data channel when both peers want to use QUIC. It is assumed that the
+// application has externally negotiated the data channel parameters.
+TEST_F(PeerConnectionEndToEndTest, MessageTransferBetweenQuicDataChannels) {
+  config_.enable_quic = true;
+  CreatePcs();
+
+  webrtc::DataChannelInit init_1;
+  init_1.id = 0;
+  init_1.ordered = false;
+  init_1.reliable = true;
+
+  webrtc::DataChannelInit init_2;
+  init_2.id = 1;
+  init_2.ordered = false;
+  init_2.reliable = true;
+
+  rtc::scoped_refptr<DataChannelInterface> caller_dc_1(
+      caller_->CreateDataChannel("data", init_1));
+  ASSERT_NE(nullptr, caller_dc_1);
+  rtc::scoped_refptr<DataChannelInterface> caller_dc_2(
+      caller_->CreateDataChannel("data", init_2));
+  ASSERT_NE(nullptr, caller_dc_2);
+  rtc::scoped_refptr<DataChannelInterface> callee_dc_1(
+      callee_->CreateDataChannel("data", init_1));
+  ASSERT_NE(nullptr, callee_dc_1);
+  rtc::scoped_refptr<DataChannelInterface> callee_dc_2(
+      callee_->CreateDataChannel("data", init_2));
+  ASSERT_NE(nullptr, callee_dc_2);
+
+  Negotiate();
+  WaitForConnection();
+  EXPECT_TRUE_WAIT(caller_dc_1->state() == webrtc::DataChannelInterface::kOpen,
+                   kMaxWait);
+  EXPECT_TRUE_WAIT(callee_dc_1->state() == webrtc::DataChannelInterface::kOpen,
+                   kMaxWait);
+  EXPECT_TRUE_WAIT(caller_dc_2->state() == webrtc::DataChannelInterface::kOpen,
+                   kMaxWait);
+  EXPECT_TRUE_WAIT(callee_dc_2->state() == webrtc::DataChannelInterface::kOpen,
+                   kMaxWait);
+
+  std::unique_ptr<webrtc::MockDataChannelObserver> dc_1_observer(
+      new webrtc::MockDataChannelObserver(callee_dc_1.get()));
+
+  std::unique_ptr<webrtc::MockDataChannelObserver> dc_2_observer(
+      new webrtc::MockDataChannelObserver(callee_dc_2.get()));
+
+  const std::string message_1 = "hello 1";
+  const std::string message_2 = "hello 2";
+
+  caller_dc_1->Send(webrtc::DataBuffer(message_1));
+  EXPECT_EQ_WAIT(message_1, dc_1_observer->last_message(), kMaxWait);
+
+  caller_dc_2->Send(webrtc::DataBuffer(message_2));
+  EXPECT_EQ_WAIT(message_2, dc_2_observer->last_message(), kMaxWait);

[Taylor Brandstetter, 2016/06/29 17:50:04]

Should we also test data sent in the reverse direction (callee to caller)?

+
+  EXPECT_EQ(1U, dc_1_observer->received_message_count());
+  EXPECT_EQ(1U, dc_2_observer->received_message_count());
+}
+#endif  // HAVE_QUIC
+
 // Verifies that a DataChannel added from an OPEN message functions after
 // a channel has been previously closed (webrtc issue 3778).
 // This previously failed because the new channel re-uses the ID of the closed
 // channel, and the closed channel was incorrectly still assigned to the id.
 // TODO(deadbeef): This is disabled because there's currently a race condition
 // caused by the fact that a data channel signals that it's closed before it
 // really is. Re-enable this test once that's fixed.
 TEST_F(PeerConnectionEndToEndTest,
        DISABLED_DataChannelFromOpenWorksAfterClose) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
@@ skipping 38 matching lines @@
   WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 0);
   // This removes the reference to the remote data channel that we hold.
   callee_signaled_data_channels_.clear();
   caller_dc->Close();
   EXPECT_EQ_WAIT(DataChannelInterface::kClosed, caller_dc->state(), kMaxWait);
 
   // Wait for a bit longer so the remote data channel will receive the
   // close message and be destroyed.
   rtc::Thread::Current()->ProcessMessages(100);
 }