Remove the dependency of TransportChannel and TransportChannelImpl.

webrtc/p2p/base/dtlstransportchannel.cc

 /*
  *  Copyright 2011 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 86 matching lines @@
   return ret;
 }
 
 void StreamInterfaceChannel::Close() {
   packets_.Clear();
   state_ = rtc::SS_CLOSED;
 }
 
 DtlsTransportChannelWrapper::DtlsTransportChannelWrapper(
     TransportChannelImpl* channel)
-    : TransportChannelImpl(channel->transport_name(), channel->component()),
+    : transport_name_(channel->transport_name()),
+      component_(channel->component()),
       network_thread_(rtc::Thread::Current()),
       channel_(channel),
       downward_(NULL),
       ssl_role_(rtc::SSL_CLIENT),
       ssl_max_version_(rtc::SSL_PROTOCOL_DTLS_12) {
   channel_->SignalWritableState.connect(this,
       &DtlsTransportChannelWrapper::OnWritableState);
   channel_->SignalReadPacket.connect(this,
       &DtlsTransportChannelWrapper::OnReadPacket);
   channel_->SignalSentPacket.connect(
       this, &DtlsTransportChannelWrapper::OnSentPacket);
   channel_->SignalReadyToSend.connect(this,
       &DtlsTransportChannelWrapper::OnReadyToSend);
-  channel_->SignalGatheringState.connect(
-      this, &DtlsTransportChannelWrapper::OnGatheringState);
-  channel_->SignalCandidateGathered.connect(
-      this, &DtlsTransportChannelWrapper::OnCandidateGathered);
-  channel_->SignalCandidatesRemoved.connect(
-      this, &DtlsTransportChannelWrapper::OnCandidatesRemoved);
-  channel_->SignalRoleConflict.connect(this,
-      &DtlsTransportChannelWrapper::OnRoleConflict);
-  channel_->SignalRouteChange.connect(this,
-      &DtlsTransportChannelWrapper::OnRouteChange);
-  channel_->SignalSelectedCandidatePairChanged.connect(
-      this, &DtlsTransportChannelWrapper::OnSelectedCandidatePairChanged);
-  channel_->SignalStateChanged.connect(
-      this, &DtlsTransportChannelWrapper::OnChannelStateChanged);
   channel_->SignalReceivingState.connect(this,
       &DtlsTransportChannelWrapper::OnReceivingState);
 }
 
 DtlsTransportChannelWrapper::~DtlsTransportChannelWrapper() {
 }
 
 bool DtlsTransportChannelWrapper::SetLocalCertificate(
     const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) {
   if (dtls_active_) {
@@ skipping 531 matching lines @@
 
     tmp_data += record_len + kDtlsRecordHeaderLen;
     tmp_size -= record_len + kDtlsRecordHeaderLen;
   }
 
   // Looks good. Pass to the SIC which ends up being passed to
   // the DTLS stack.
   return downward_->OnPacketReceived(data, size);
 }
 
-void DtlsTransportChannelWrapper::OnGatheringState(
-    TransportChannelImpl* channel) {
-  ASSERT(channel == channel_);
-  SignalGatheringState(this);
-}
-
-void DtlsTransportChannelWrapper::OnCandidateGathered(
-    TransportChannelImpl* channel,
-    const Candidate& c) {
-  ASSERT(channel == channel_);
-  SignalCandidateGathered(this, c);
-}
-
-void DtlsTransportChannelWrapper::OnCandidatesRemoved(
-    TransportChannelImpl* channel,
-    const Candidates& candidates) {
-  ASSERT(channel == channel_);
-  SignalCandidatesRemoved(this, candidates);
-}
-
-void DtlsTransportChannelWrapper::OnRoleConflict(
-    TransportChannelImpl* channel) {
-  ASSERT(channel == channel_);
-  SignalRoleConflict(this);
-}
-
-void DtlsTransportChannelWrapper::OnRouteChange(
-    TransportChannel* channel, const Candidate& candidate) {
-  ASSERT(channel == channel_);
-  SignalRouteChange(this, candidate);
-}
-
-void DtlsTransportChannelWrapper::OnSelectedCandidatePairChanged(
-    TransportChannel* channel,
-    CandidatePairInterface* selected_candidate_pair,
-    int last_sent_packet_id,
-    bool ready_to_send) {
-  ASSERT(channel == channel_);
-  SignalSelectedCandidatePairChanged(this, selected_candidate_pair,
-                                     last_sent_packet_id, ready_to_send);
-}
-
-void DtlsTransportChannelWrapper::OnChannelStateChanged(
-    TransportChannelImpl* channel) {
-  ASSERT(channel == channel_);
-  SignalStateChanged(this);
-}
-
 void DtlsTransportChannelWrapper::OnDtlsHandshakeError(
     rtc::SSLHandshakeError error) {
   SignalDtlsHandshakeError(error);
 }
 
+void DtlsTransportChannelWrapper::set_receiving(bool receiving) {
+  if (receiving_ == receiving) {
+    return;
+  }
+  receiving_ = receiving;
+  SignalReceivingState(this);
+}
+
+void DtlsTransportChannelWrapper::set_writable(bool writable) {
+  if (writable_ == writable) {
+    return;
+  }
+  LOG_J(LS_VERBOSE, this) << "set_writable from:" << writable_ << " to "
+                          << writable;
+  writable_ = writable;
+  if (writable_) {
+    SignalReadyToSend(this);
+  }
+  SignalWritableState(this);
+}
+
+void DtlsTransportChannelWrapper::set_dtls_state(DtlsTransportState state) {
+  if (dtls_state_ == state) {
+    return;
+  }
+  LOG_J(LS_VERBOSE, this) << "set_dtls_state from:" << dtls_state_ << " to "
+                          << state;
+  dtls_state_ = state;
+  SignalDtlsState(this, state);
+}
+
 }  // namespace cricket