Allow TransportController to create a QuicTransportChannel

webrtc/p2p/quic/quictransportchannel.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 256 matching lines @@
   return -1;
 }
 
 // The state transition logic here is as follows:
 //     - Before the QUIC handshake is complete, the QUIC channel is unwritable.
 //     - When |channel_| goes writable we start the QUIC handshake.
 //     - Once the QUIC handshake completes, the state is that of the
 //       |channel_| again.
 void QuicTransportChannel::OnWritableState(TransportChannel* channel) {
   ASSERT(rtc::Thread::Current() == worker_thread_);
-  ASSERT(channel == channel_);
+  ASSERT(channel == channel_.get());
   LOG_J(LS_VERBOSE, this)
       << "QuicTransportChannel: channel writable state changed to "
       << channel_->writable();
   switch (quic_state_) {
     case QUIC_TRANSPORT_NEW:
       // Start the QUIC handshake when |channel_| is writable.
       // This will fail if the SSL role or remote fingerprint are not set.
       // Otherwise failure could result from network or QUIC errors.
       MaybeStartQuic();
       break;
@@ skipping 13 matching lines @@
       break;
     case QUIC_TRANSPORT_CLOSED:
       // TODO(mikescarlett): Allow the QUIC connection to be reset if it drops
       // due to a non-failure.
       break;
   }
 }
 
 void QuicTransportChannel::OnReceivingState(TransportChannel* channel) {
   ASSERT(rtc::Thread::Current() == worker_thread_);
-  ASSERT(channel == channel_);
+  ASSERT(channel == channel_.get());
   LOG_J(LS_VERBOSE, this)
       << "QuicTransportChannel: channel receiving state changed to "
       << channel_->receiving();
   if (quic_state_ == QUIC_TRANSPORT_CONNECTED) {
     // Note: SignalReceivingState fired by set_receiving.
     set_receiving(channel_->receiving());
   }
 }
 
 void QuicTransportChannel::OnReadPacket(TransportChannel* channel,
                                         const char* data,
                                         size_t size,
                                         const rtc::PacketTime& packet_time,
                                         int flags) {
   ASSERT(rtc::Thread::Current() == worker_thread_);
-  ASSERT(channel == channel_);
+  ASSERT(channel == channel_.get());
   ASSERT(flags == 0);
 
   switch (quic_state_) {
     case QUIC_TRANSPORT_NEW:
       // This would occur if other peer is ready to start QUIC but this peer
       // hasn't started QUIC.
       LOG_J(LS_INFO, this) << "Dropping packet received before QUIC started.";
       break;
     case QUIC_TRANSPORT_CONNECTING:
     case QUIC_TRANSPORT_CONNECTED:
@@ skipping 26 matching lines @@
   SignalSentPacket(this, sent_packet);
 }
 
 void QuicTransportChannel::OnReadyToSend(TransportChannel* channel) {
   if (writable()) {
     SignalReadyToSend(this);
   }
 }
 
 void QuicTransportChannel::OnGatheringState(TransportChannelImpl* channel) {
-  ASSERT(channel == channel_);
+  ASSERT(channel == channel_.get());
   SignalGatheringState(this);
 }
 
 void QuicTransportChannel::OnCandidateGathered(TransportChannelImpl* channel,
                                                const Candidate& c) {
-  ASSERT(channel == channel_);
+  ASSERT(channel == channel_.get());
   SignalCandidateGathered(this, c);
 }
 
 void QuicTransportChannel::OnRoleConflict(TransportChannelImpl* channel) {
-  ASSERT(channel == channel_);
+  ASSERT(channel == channel_.get());
   SignalRoleConflict(this);
 }
 
 void QuicTransportChannel::OnRouteChange(TransportChannel* channel,
                                          const Candidate& candidate) {
-  ASSERT(channel == channel_);
+  ASSERT(channel == channel_.get());
   SignalRouteChange(this, candidate);
 }
 
 void QuicTransportChannel::OnSelectedCandidatePairChanged(
     TransportChannel* channel,
     CandidatePairInterface* selected_candidate_pair,
     int last_sent_packet_id) {
-  ASSERT(channel == channel_);
+  ASSERT(channel == channel_.get());
   SignalSelectedCandidatePairChanged(this, selected_candidate_pair,
                                      last_sent_packet_id);
 }
 
 void QuicTransportChannel::OnConnectionRemoved(TransportChannelImpl* channel) {
-  ASSERT(channel == channel_);
+  ASSERT(channel == channel_.get());
   SignalConnectionRemoved(this);
 }
 
 bool QuicTransportChannel::MaybeStartQuic() {
   if (!channel_->writable()) {
     LOG_J(LS_ERROR, this) << "Couldn't start QUIC handshake.";
     return false;
   }
   if (!CreateQuicSession() || !StartQuicHandshake()) {
     LOG_J(LS_WARNING, this)
@@ skipping 171 matching lines @@
     return quic_->CreateOutgoingDynamicStream(priority);
   }
   return nullptr;
 }
 
 void QuicTransportChannel::OnIncomingStream(ReliableQuicStream* stream) {
   SignalIncomingStream(stream);
 }
 
 }  // namespace cricket