Revert of Modified PeerConnection and WebRtcSession for end-to-end QuicDataChannel usage.

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, config_));
-    EXPECT_TRUE(callee_->CreatePc(pc_constraints, config_));
+    EXPECT_TRUE(caller_->CreatePc(pc_constraints));
+    EXPECT_TRUE(callee_->CreatePc(pc_constraints));
     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 131 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";
-
-  // Send data from caller to callee.
-  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());
-
-  // Send data from callee to caller.
-  dc_1_observer.reset(new webrtc::MockDataChannelObserver(caller_dc_1.get()));
-  dc_2_observer.reset(new webrtc::MockDataChannelObserver(caller_dc_2.get()));
-
-  callee_dc_1->Send(webrtc::DataBuffer(message_1));
-  EXPECT_EQ_WAIT(message_1, dc_1_observer->last_message(), kMaxWait);
-
-  callee_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());
-}
-#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);
 }