Introduce rtc::PacketTransportInterface and let cricket::TransportChannel inherit.

webrtc/pc/channel.cc

 /*
  *  Copyright 2004 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.
  */
 
 #include <utility>
 
 #include "webrtc/pc/channel.h"
 
 #include "webrtc/api/call/audio_sink.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/copyonwritebuffer.h"
 #include "webrtc/base/dscp.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/networkroute.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/base/rtputils.h"
+#include "webrtc/p2p/base/packettransport.h"
 #include "webrtc/p2p/base/transportchannel.h"
 #include "webrtc/pc/channelmanager.h"
 
 namespace cricket {
 using rtc::Bind;
 
 namespace {
 // See comment below for why we need to use a pointer to a unique_ptr.
 bool SetRawAudioSink_w(VoiceMediaChannel* channel,
                        uint32_t ssrc,
@@ skipping 483 matching lines @@
       break;
   }
   return channel ? channel->SetOption(opt, value) : -1;
 }
 
 bool BaseChannel::SetCryptoOptions(const rtc::CryptoOptions& crypto_options) {
   crypto_options_ = crypto_options;
   return true;
 }
 
-void BaseChannel::OnWritableState(TransportChannel* channel) {
+void BaseChannel::OnWritableState(rtc::PacketTransport* pt) {
+  TransportChannel* channel = static_cast<TransportChannel*>(pt);
   RTC_DCHECK(channel == transport_channel_ ||
              channel == rtcp_transport_channel_);
   RTC_DCHECK(network_thread_->IsCurrent());
   UpdateWritableState_n();
 }
 
-void BaseChannel::OnChannelRead(TransportChannel* channel,
-                                const char* data, size_t len,
+void BaseChannel::OnChannelRead(rtc::PacketTransport* pt,
+                                const char* data,
+                                size_t len,
                                 const rtc::PacketTime& packet_time,
                                 int flags) {
+  TransportChannel* channel = static_cast<TransportChannel*>(pt);
   TRACE_EVENT0("webrtc", "BaseChannel::OnChannelRead");
   // OnChannelRead gets called from P2PSocket; now pass data to MediaEngine
   RTC_DCHECK(network_thread_->IsCurrent());
 
   // When using RTCP multiplexing we might get RTCP packets on the RTP
   // transport. We feed RTP traffic into the demuxer to determine if it is RTCP.
   bool rtcp = PacketIsRtcp(channel, data, len);
   rtc::CopyOnWriteBuffer packet(data, len);
   HandlePacket(rtcp, &packet, packet_time);
 }
 
-void BaseChannel::OnReadyToSend(TransportChannel* channel) {
+void BaseChannel::OnReadyToSend(rtc::PacketTransport* pt) {
+  TransportChannel* channel = static_cast<TransportChannel*>(pt);
   RTC_DCHECK(channel == transport_channel_ ||
              channel == rtcp_transport_channel_);
   SetTransportChannelReadyToSend(channel == rtcp_transport_channel_, true);
 }
 
 void BaseChannel::OnDtlsState(TransportChannel* channel,
                               DtlsTransportState state) {
   if (!ShouldSetupDtlsSrtp_n()) {
     return;
   }
@@ skipping 875 matching lines @@
   // destructor.
   RTC_DCHECK(network_thread_->IsCurrent());
   rtc::MessageList rtcp_messages;
   network_thread_->Clear(this, MSG_SEND_RTCP_PACKET, &rtcp_messages);
   for (const auto& message : rtcp_messages) {
     network_thread_->Send(RTC_FROM_HERE, this, MSG_SEND_RTCP_PACKET,
                           message.pdata);
   }
 }
 
-void BaseChannel::SignalSentPacket_n(TransportChannel* /* channel */,
+void BaseChannel::SignalSentPacket_n(rtc::PacketTransport* /* pt */,
                                      const rtc::SentPacket& sent_packet) {
   RTC_DCHECK(network_thread_->IsCurrent());
   invoker_.AsyncInvoke<void>(
       RTC_FROM_HERE, worker_thread_,
       rtc::Bind(&BaseChannel::SignalSentPacket_w, this, sent_packet));
 }
 
 void BaseChannel::SignalSentPacket_w(const rtc::SentPacket& sent_packet) {
   RTC_DCHECK(worker_thread_->IsCurrent());
   SignalSentPacket(sent_packet);
@@ skipping 175 matching lines @@
 }
 
 int VoiceChannel::GetOutputLevel_w() {
   return media_channel()->GetOutputLevel();
 }
 
 void VoiceChannel::GetActiveStreams_w(AudioInfo::StreamList* actives) {
   media_channel()->GetActiveStreams(actives);
 }
 
-void VoiceChannel::OnChannelRead(TransportChannel* channel,
-                                 const char* data, size_t len,
+void VoiceChannel::OnChannelRead(rtc::PacketTransport* pt,
+                                 const char* data,
+                                 size_t len,
                                  const rtc::PacketTime& packet_time,
-                                int flags) {
-  BaseChannel::OnChannelRead(channel, data, len, packet_time, flags);
-
+                                 int flags) {
+  BaseChannel::OnChannelRead(pt, data, len, packet_time, flags);
+  TransportChannel* channel = static_cast<TransportChannel*>(pt);
   // Set a flag when we've received an RTP packet. If we're waiting for early
   // media, this will disable the timeout.
   if (!received_media_ && !PacketIsRtcp(channel, data, len)) {
     received_media_ = true;
   }
 }
 
 void BaseChannel::UpdateMediaSendRecvState() {
   RTC_DCHECK(network_thread_->IsCurrent());
   invoker_.AsyncInvoke<void>(
@@ skipping 750 matching lines @@
 }
 
 void DataChannel::OnStreamClosedRemotely(uint32_t sid) {
   rtc::TypedMessageData<uint32_t>* message =
       new rtc::TypedMessageData<uint32_t>(sid);
   signaling_thread()->Post(RTC_FROM_HERE, this, MSG_STREAMCLOSEDREMOTELY,
                            message);
 }
 
 }  // namespace cricket