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

webrtc/api/quicdatatransport_unittest.cc

 /*
  *  Copyright 2016 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 12 matching lines @@
 #include "webrtc/p2p/quic/quictransportchannel.h"
 #include "webrtc/p2p/quic/reliablequicstream.h"
 
 using webrtc::DataBuffer;
 using webrtc::DataChannelInit;
 using webrtc::DataChannelInterface;
 using webrtc::DataChannelObserver;
 using webrtc::QuicDataChannel;
 using webrtc::QuicDataTransport;
 using cricket::FakeTransportChannel;
+using cricket::FakeTransportController;
 using cricket::QuicTransportChannel;
 using cricket::ReliableQuicStream;
 
 namespace {
 
 // Timeout for asynchronous operations.
 static const int kTimeoutMs = 1000;  // milliseconds
 
 // FakeObserver receives messages from the data channel.
 class FakeObserver : public DataChannelObserver {
@@ skipping 16 matching lines @@
   std::vector<std::string> messages_;
 };
 
 // A peer who uses a QUIC transport channel and fake ICE transport channel to
 // send or receive data.
 class QuicDataTransportPeer {
  public:
   QuicDataTransportPeer()
       : quic_data_transport_(rtc::Thread::Current(),
                              rtc::Thread::Current(),
-                             rtc::Thread::Current()),
+                             rtc::Thread::Current(),
+                             new FakeTransportController()),
         ice_transport_channel_(new FakeTransportChannel("data", 0)),
         quic_transport_channel_(ice_transport_channel_) {
     ice_transport_channel_->SetAsync(true);
   }
 
   void GenerateCertificateAndFingerprint() {
     rtc::scoped_refptr<rtc::RTCCertificate> local_cert =
         rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
             rtc::SSLIdentity::Generate("cert_name", rtc::KT_DEFAULT)));
     quic_transport_channel_.SetLocalCertificate(local_cert);
@@ skipping 253 matching lines @@
     ASSERT_EQ_WAIT(1, observer1.messages_received(), kTimeoutMs);
     EXPECT_EQ("Peer 2 message 1", observer1.messages()[0]);
 
     peer2_data_channel->Send(webrtc::DataBuffer("Peer 2 message 2"));
     ASSERT_EQ_WAIT(2, observer1.messages_received(), kTimeoutMs);
     EXPECT_EQ("Peer 2 message 2", observer1.messages()[1]);
   }
 }
 
 // Tests that SetTransportChannel returns false when setting a NULL transport
-// channel or a transport channel that is not equivalent to the one already set.
+// channel.
 TEST_F(QuicDataTransportTest, SetTransportChannelReturnValue) {
   QuicDataTransport* quic_data_transport = peer1_.quic_data_transport();
   EXPECT_FALSE(quic_data_transport->SetTransportChannel(nullptr));
   QuicTransportChannel* transport_channel = peer1_.quic_transport_channel();
   EXPECT_TRUE(quic_data_transport->SetTransportChannel(transport_channel));
   EXPECT_TRUE(quic_data_transport->SetTransportChannel(transport_channel));
   QuicTransportChannel* other_transport_channel =
       peer2_.quic_transport_channel();
-  EXPECT_FALSE(
+  EXPECT_TRUE(
       quic_data_transport->SetTransportChannel(other_transport_channel));
 }
 
 }  // namespace