Allow TransportController to create a QuicTransportChannel

webrtc/p2p/quic/quictransportchannel_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 76 matching lines @@
 };
 
 // Peer who establishes a handshake using a QuicTransportChannel, which wraps
 // a FailableTransportChannel to simulate network connectivity and ICE
 // negotiation.
 class QuicTestPeer : public sigslot::has_slots<> {
  public:
   explicit QuicTestPeer(const std::string& name)
       : name_(name),
         bytes_sent_(0),
-        ice_channel_(name_, 0),
-        quic_channel_(&ice_channel_),
+        ice_channel_(new FailableTransportChannel(name_, 0)),
+        quic_channel_(ice_channel_),
         incoming_stream_count_(0) {
     quic_channel_.SignalReadPacket.connect(
         this, &QuicTestPeer::OnTransportChannelReadPacket);
     quic_channel_.SignalIncomingStream.connect(this,
                                                &QuicTestPeer::OnIncomingStream);
     quic_channel_.SignalClosed.connect(this, &QuicTestPeer::OnClosed);
-    ice_channel_.SetAsync(true);
+    ice_channel_->SetAsync(true);
     rtc::scoped_refptr<rtc::RTCCertificate> local_cert =
         rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
             rtc::SSLIdentity::Generate(name_, rtc::KT_DEFAULT)));
     quic_channel_.SetLocalCertificate(local_cert);
     local_fingerprint_.reset(CreateFingerprint(local_cert.get()));
   }
 
   // Connects |ice_channel_| to that of the other peer.
   void Connect(QuicTestPeer* other_peer) {
-    ice_channel_.Connect();
-    other_peer->ice_channel_.Connect();
-    ice_channel_.SetDestination(&other_peer->ice_channel_);
+    ice_channel_->Connect();
+    other_peer->ice_channel_->Connect();
+    ice_channel_->SetDestination(other_peer->ice_channel_);
   }
 
   // Disconnects |ice_channel_|.
-  void Disconnect() { ice_channel_.SetDestination(nullptr); }
+  void Disconnect() { ice_channel_->SetDestination(nullptr); }
 
   // Generates ICE credentials and passes them to |quic_channel_|.
   void SetIceParameters(IceRole local_ice_role,
                         ConnectionRole local_connection_role,
                         ConnectionRole remote_connection_role,
                         rtc::SSLFingerprint* remote_fingerprint) {
     quic_channel_.SetIceRole(local_ice_role);
     quic_channel_.SetIceTiebreaker(
         (local_ice_role == cricket::ICEROLE_CONTROLLING) ? 1 : 2);
 
@@ skipping 50 matching lines @@
     char packet[kPacketSize];
     packet[0] = 0x80;  // Make the packet header look like RTP.
     return quic_channel_.SendPacket(&packet[0], kPacketSize,
                                     rtc::PacketOptions(), 0);
   }
 
   void ClearBytesSent() { bytes_sent_ = 0; }
 
   void ClearBytesReceived() { bytes_received_ = 0; }
 
-  void SetWriteError(int error) { ice_channel_.SetError(error); }
+  void SetWriteError(int error) { ice_channel_->SetError(error); }
 
   size_t bytes_received() const { return bytes_received_; }
 
   size_t bytes_sent() const { return bytes_sent_; }
 
-  FailableTransportChannel* ice_channel() { return &ice_channel_; }
+  FailableTransportChannel* ice_channel() { return ice_channel_; }
 
   QuicTransportChannel* quic_channel() { return &quic_channel_; }
 
   std::unique_ptr<rtc::SSLFingerprint>& local_fingerprint() {
     return local_fingerprint_;
   }
 
   ReliableQuicStream* incoming_quic_stream() { return incoming_quic_stream_; }
 
   size_t incoming_stream_count() const { return incoming_stream_count_; }
@@ skipping 14 matching lines @@
   }
   void OnIncomingStream(ReliableQuicStream* stream) {
     incoming_quic_stream_ = stream;
     ++incoming_stream_count_;
   }
   void OnClosed() { signal_closed_emitted_ = true; }
 
   std::string name_;                      // Channel name.
   size_t bytes_sent_;                     // Bytes sent by QUIC channel.
   size_t bytes_received_;                 // Bytes received by QUIC channel.
-  FailableTransportChannel ice_channel_;  // Simulates an ICE channel.
+  FailableTransportChannel* ice_channel_;  // Simulates an ICE channel.
   QuicTransportChannel quic_channel_;     // QUIC channel to test.
   std::unique_ptr<rtc::SSLFingerprint> local_fingerprint_;
   ReliableQuicStream* incoming_quic_stream_ = nullptr;
   size_t incoming_stream_count_;
   bool signal_closed_emitted_ = false;
 };
 
 class QuicTransportChannelTest : public testing::Test {
  public:
   QuicTransportChannelTest() : peer1_("P1"), peer2_("P2") {}
@@ skipping 303 matching lines @@
   Connect();
   ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
   ASSERT_FALSE(peer1_.signal_closed_emitted());
   ReliableQuicStream* stream = peer1_.quic_channel()->CreateQuicStream();
   ASSERT_NE(nullptr, stream);
   stream->CloseConnectionWithDetails(net::QuicErrorCode::QUIC_NO_ERROR,
                                      "Closing QUIC for testing");
   EXPECT_TRUE(peer1_.signal_closed_emitted());
   EXPECT_TRUE_WAIT(peer2_.signal_closed_emitted(), kTimeoutMs);
 }