Remove the dependency of TransportChannel and TransportChannelImpl.

webrtc/pc/channel.cc

Index: webrtc/pc/channel.cc
diff --git a/webrtc/pc/channel.cc b/webrtc/pc/channel.cc
index 1f29261ed2532bdf7422792b5e9878b7a06e3efc..fa4d40e27c415cffa0a725758380f77fc86dfdba 100644
--- a/webrtc/pc/channel.cc
+++ b/webrtc/pc/channel.cc
@@ -343,9 +343,9 @@ bool BaseChannel::SetTransport_n(const std::string& transport_name) {
 }
 
 void BaseChannel::SetTransportChannel_n(bool rtcp,
-                                        TransportChannel* new_channel) {
+                                        DtlsTransportInternal* new_channel) {
   RTC_DCHECK(network_thread_->IsCurrent());
-  TransportChannel*& old_channel =
+  DtlsTransportInternal*& old_channel =
       rtcp ? rtcp_transport_channel_ : transport_channel_;
 
   if (!old_channel && !new_channel) {
@@ -377,28 +377,28 @@ void BaseChannel::SetTransportChannel_n(bool rtcp,
   }
 }
 
-void BaseChannel::ConnectToTransportChannel(TransportChannel* tc) {
+void BaseChannel::ConnectToTransportChannel(DtlsTransportInternal* tc) {
   RTC_DCHECK(network_thread_->IsCurrent());
 
   tc->SignalWritableState.connect(this, &BaseChannel::OnWritableState);
   tc->SignalReadPacket.connect(this, &BaseChannel::OnPacketRead);
   tc->SignalReadyToSend.connect(this, &BaseChannel::OnReadyToSend);
   tc->SignalDtlsState.connect(this, &BaseChannel::OnDtlsState);
-  tc->SignalSelectedCandidatePairChanged.connect(
-      this, &BaseChannel::OnSelectedCandidatePairChanged);
   tc->SignalSentPacket.connect(this, &BaseChannel::SignalSentPacket_n);
+  tc->ice_transport()->SignalSelectedCandidatePairChanged.connect(
+      this, &BaseChannel::OnSelectedCandidatePairChanged);
 }
 
-void BaseChannel::DisconnectFromTransportChannel(TransportChannel* tc) {
+void BaseChannel::DisconnectFromTransportChannel(DtlsTransportInternal* tc) {
   RTC_DCHECK(network_thread_->IsCurrent());
-  OnSelectedCandidatePairChanged(tc, nullptr, -1, false);
+  OnSelectedCandidatePairChanged(tc->ice_transport(), nullptr, -1, false);
 
   tc->SignalWritableState.disconnect(this);
   tc->SignalReadPacket.disconnect(this);
   tc->SignalReadyToSend.disconnect(this);
   tc->SignalDtlsState.disconnect(this);
-  tc->SignalSelectedCandidatePairChanged.disconnect(this);
   tc->SignalSentPacket.disconnect(this);
+  tc->ice_transport()->SignalSelectedCandidatePairChanged.disconnect(this);
 }
 
 bool BaseChannel::Enable(bool enable) {
@@ -468,7 +468,7 @@ void BaseChannel::StopConnectionMonitor() {
 
 bool BaseChannel::GetConnectionStats(ConnectionInfos* infos) {
   RTC_DCHECK(network_thread_->IsCurrent());
-  return transport_channel_->GetStats(infos);
+  return transport_channel_->ice_transport()->GetStats(infos);
 }
 
 bool BaseChannel::IsReadyToReceiveMedia_w() const {
@@ -511,7 +511,7 @@ int BaseChannel::SetOption_n(SocketType type,
                              rtc::Socket::Option opt,
                              int value) {
   RTC_DCHECK(network_thread_->IsCurrent());
-  TransportChannel* channel = nullptr;
+  DtlsTransportInternal* channel = nullptr;
   switch (type) {
     case ST_RTP:
       channel = transport_channel_;
@@ -524,7 +524,7 @@ int BaseChannel::SetOption_n(SocketType type,
           std::pair<rtc::Socket::Option, int>(opt, value));
       break;
   }
-  return channel ? channel->SetOption(opt, value) : -1;
+  return channel ? channel->ice_transport()->SetOption(opt, value) : -1;
 }
 
 bool BaseChannel::SetCryptoOptions(const rtc::CryptoOptions& crypto_options) {
@@ -561,7 +561,7 @@ void BaseChannel::OnReadyToSend(rtc::PacketTransportInterface* transport) {
   SetTransportChannelReadyToSend(transport == rtcp_transport_channel_, true);
 }
 
-void BaseChannel::OnDtlsState(TransportChannel* channel,
+void BaseChannel::OnDtlsState(DtlsTransportInternal* channel,
                               DtlsTransportState state) {
   if (!ShouldSetupDtlsSrtp_n()) {
     return;
@@ -582,8 +582,8 @@ void BaseChannel::OnSelectedCandidatePairChanged(
     CandidatePairInterface* selected_candidate_pair,
     int last_sent_packet_id,
     bool ready_to_send) {
-  RTC_DCHECK(channel == transport_channel_ ||
-             channel == rtcp_transport_channel_);
+  RTC_DCHECK(channel == transport_channel_->ice_transport() ||
+             channel == rtcp_transport_channel_->ice_transport());
   RTC_DCHECK(network_thread_->IsCurrent());
   selected_candidate_pair_ = selected_candidate_pair;
   std::string transport_name = channel->transport_name();
@@ -652,8 +652,9 @@ bool BaseChannel::SendPacket(bool rtcp,
   // packet before doing anything. (We might get RTCP packets that we don't
   // intend to send.) If we've negotiated RTCP mux, send RTCP over the RTP
   // transport.
-  TransportChannel* channel = (!rtcp || rtcp_mux_filter_.IsActive()) ?
-      transport_channel_ : rtcp_transport_channel_;
+  DtlsTransportInternal* channel = (!rtcp || rtcp_mux_filter_.IsActive())
+                                       ? transport_channel_
+                                       : rtcp_transport_channel_;
   if (!channel || !channel->writable()) {
     return false;
   }
@@ -943,7 +944,8 @@ void BaseChannel::SignalDtlsSetupFailure_s(bool rtcp) {
   SignalDtlsSetupFailure(this, rtcp);
 }
 
-bool BaseChannel::SetDtlsSrtpCryptoSuites_n(TransportChannel* tc, bool rtcp) {
+bool BaseChannel::SetDtlsSrtpCryptoSuites_n(DtlsTransportInternal* tc,
+                                            bool rtcp) {
   std::vector<int> crypto_suites;
   // We always use the default SRTP crypto suites for RTCP, but we may use
   // different crypto suites for RTP depending on the media type.
@@ -966,7 +968,7 @@ bool BaseChannel::SetupDtlsSrtp_n(bool rtcp_channel) {
   RTC_DCHECK(network_thread_->IsCurrent());
   bool ret = false;
 
-  TransportChannel* channel =
+  DtlsTransportInternal* channel =
       rtcp_channel ? rtcp_transport_channel_ : transport_channel_;
 
   RTC_DCHECK(channel->IsDtlsActive());