Make P2PTransportChannel inherit from IceTransportInternal.

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 32 matching lines @@
     return false;
   }
   const uint8_t* u = reinterpret_cast<const uint8_t*>(data);
   return len > 17 && u[0] == 22 && u[13] == 1;
 }
 static bool IsRtpPacket(const char* data, size_t len) {
   const uint8_t* u = reinterpret_cast<const uint8_t*>(data);
   return (len >= kMinRtpPacketLen && (u[0] & 0xC0) == 0x80);
 }
 
-StreamInterfaceChannel::StreamInterfaceChannel(TransportChannel* channel)
+StreamInterfaceChannel::StreamInterfaceChannel(IceTransportInternal* channel)
     : channel_(channel),
       state_(rtc::SS_OPEN),
-      packets_(kMaxPendingPackets, kMaxDtlsPacketLen) {
-}
+      packets_(kMaxPendingPackets, kMaxDtlsPacketLen) {}
 
 rtc::StreamResult StreamInterfaceChannel::Read(void* buffer,
                                                      size_t buffer_len,
                                                      size_t* read,
                                                      int* error) {
   if (state_ == rtc::SS_CLOSED)
     return rtc::SR_EOS;
   if (state_ == rtc::SS_OPENING)
     return rtc::SR_BLOCK;
 
@@ skipping 28 matching lines @@
   }
   return ret;
 }
 
 void StreamInterfaceChannel::Close() {
   packets_.Clear();
   state_ = rtc::SS_CLOSED;
 }
 
 DtlsTransportChannelWrapper::DtlsTransportChannelWrapper(
-    TransportChannelImpl* channel)
+    IceTransportInternal* channel)
     : TransportChannelImpl(channel->transport_name(), 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);
@@ skipping 560 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) {
+    IceTransportInternal* channel) {
   ASSERT(channel == channel_);
   SignalGatheringState(this);
 }
 
 void DtlsTransportChannelWrapper::OnCandidateGathered(
-    TransportChannelImpl* channel,
+    IceTransportInternal* channel,
     const Candidate& c) {
   ASSERT(channel == channel_);
   SignalCandidateGathered(this, c);
 }
 
 void DtlsTransportChannelWrapper::OnCandidatesRemoved(
-    TransportChannelImpl* channel,
+    IceTransportInternal* channel,
     const Candidates& candidates) {
   ASSERT(channel == channel_);
   SignalCandidatesRemoved(this, candidates);
 }
 
 void DtlsTransportChannelWrapper::OnRoleConflict(
-    TransportChannelImpl* channel) {
+    IceTransportInternal* channel) {
   ASSERT(channel == channel_);
   SignalRoleConflict(this);
 }
 
-void DtlsTransportChannelWrapper::OnRouteChange(
-    TransportChannel* channel, const Candidate& candidate) {
+void DtlsTransportChannelWrapper::OnRouteChange(IceTransportInternal* channel,
+                                                const Candidate& candidate) {
   ASSERT(channel == channel_);
   SignalRouteChange(this, candidate);
 }
 
 void DtlsTransportChannelWrapper::OnSelectedCandidatePairChanged(
-    TransportChannel* channel,
+    IceTransportInternal* 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) {
+    IceTransportInternal* channel) {
   ASSERT(channel == channel_);
   SignalStateChanged(this);
 }
 
 void DtlsTransportChannelWrapper::OnDtlsHandshakeError(
     rtc::SSLHandshakeError error) {
   SignalDtlsHandshakeError(error);
 }
 
 }  // namespace cricket