Rename "PacketTransportInterface" to "PacketTransportInternal".

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/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/packettransportinterface.h"
+#include "webrtc/p2p/base/packettransportinternal.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,
                        std::unique_ptr<webrtc::AudioSinkInterface>* sink) {
@@ skipping 170 matching lines @@
     DisconnectFromPacketTransport(rtcp_packet_transport_);
   }
 
   // Clear pending read packets/messages.
   network_thread_->Clear(&invoker_);
   network_thread_->Clear(this);
 }
 
 bool BaseChannel::Init_w(DtlsTransportInternal* rtp_dtls_transport,
                          DtlsTransportInternal* rtcp_dtls_transport,
-                         rtc::PacketTransportInterface* rtp_packet_transport,
-                         rtc::PacketTransportInterface* rtcp_packet_transport) {
+                         rtc::PacketTransportInternal* rtp_packet_transport,
+                         rtc::PacketTransportInternal* rtcp_packet_transport) {
   if (!network_thread_->Invoke<bool>(
           RTC_FROM_HERE, Bind(&BaseChannel::InitNetwork_n, this,
                               rtp_dtls_transport, rtcp_dtls_transport,
                               rtp_packet_transport, rtcp_packet_transport))) {
     return false;
   }
   // Both RTP and RTCP channels should be set, we can call SetInterface on
   // the media channel and it can set network options.
   RTC_DCHECK_RUN_ON(worker_thread_);
   media_channel_->SetInterface(this);
   return true;
 }
 
 bool BaseChannel::InitNetwork_n(
     DtlsTransportInternal* rtp_dtls_transport,
     DtlsTransportInternal* rtcp_dtls_transport,
-    rtc::PacketTransportInterface* rtp_packet_transport,
-    rtc::PacketTransportInterface* rtcp_packet_transport) {
+    rtc::PacketTransportInternal* rtp_packet_transport,
+    rtc::PacketTransportInternal* rtcp_packet_transport) {
   RTC_DCHECK(network_thread_->IsCurrent());
   SetTransports_n(rtp_dtls_transport, rtcp_dtls_transport, rtp_packet_transport,
                   rtcp_packet_transport);
 
   if (rtp_dtls_transport_ &&
       !SetDtlsSrtpCryptoSuites_n(rtp_dtls_transport_, false)) {
     return false;
   }
   if (rtcp_dtls_transport_ &&
       !SetDtlsSrtpCryptoSuites_n(rtcp_dtls_transport_, true)) {
@@ skipping 17 matching lines @@
 
 void BaseChannel::SetTransports(DtlsTransportInternal* rtp_dtls_transport,
                                 DtlsTransportInternal* rtcp_dtls_transport) {
   network_thread_->Invoke<void>(
       RTC_FROM_HERE,
       Bind(&BaseChannel::SetTransports_n, this, rtp_dtls_transport,
            rtcp_dtls_transport, rtp_dtls_transport, rtcp_dtls_transport));
 }
 
 void BaseChannel::SetTransports(
-    rtc::PacketTransportInterface* rtp_packet_transport,
-    rtc::PacketTransportInterface* rtcp_packet_transport) {
+    rtc::PacketTransportInternal* rtp_packet_transport,
+    rtc::PacketTransportInternal* rtcp_packet_transport) {
   network_thread_->Invoke<void>(
       RTC_FROM_HERE, Bind(&BaseChannel::SetTransports_n, this, nullptr, nullptr,
                           rtp_packet_transport, rtcp_packet_transport));
 }
 
 void BaseChannel::SetTransports_n(
     DtlsTransportInternal* rtp_dtls_transport,
     DtlsTransportInternal* rtcp_dtls_transport,
-    rtc::PacketTransportInterface* rtp_packet_transport,
-    rtc::PacketTransportInterface* rtcp_packet_transport) {
+    rtc::PacketTransportInternal* rtp_packet_transport,
+    rtc::PacketTransportInternal* rtcp_packet_transport) {
   RTC_DCHECK(network_thread_->IsCurrent());
   // Validate some assertions about the input.
   RTC_DCHECK(rtp_packet_transport);
   RTC_DCHECK_EQ(NeedsRtcpTransport(), rtcp_packet_transport != nullptr);
   if (rtp_dtls_transport || rtcp_dtls_transport) {
     // DTLS/non-DTLS pointers should be to the same object.
     RTC_DCHECK(rtp_dtls_transport == rtp_packet_transport);
     RTC_DCHECK(rtcp_dtls_transport == rtcp_packet_transport);
     // Can't go from non-DTLS to DTLS.
     RTC_DCHECK(!rtp_packet_transport_ || rtp_dtls_transport_);
@@ skipping 54 matching lines @@
   // encounter the error again and update "ready to send" accordingly.
   SetTransportChannelReadyToSend(
       false, rtp_packet_transport_ && rtp_packet_transport_->writable());
   SetTransportChannelReadyToSend(
       true, rtcp_packet_transport_ && rtcp_packet_transport_->writable());
 }
 
 void BaseChannel::SetTransport_n(
     bool rtcp,
     DtlsTransportInternal* new_dtls_transport,
-    rtc::PacketTransportInterface* new_packet_transport) {
+    rtc::PacketTransportInternal* new_packet_transport) {
   RTC_DCHECK(network_thread_->IsCurrent());
   DtlsTransportInternal*& old_dtls_transport =
       rtcp ? rtcp_dtls_transport_ : rtp_dtls_transport_;
-  rtc::PacketTransportInterface*& old_packet_transport =
+  rtc::PacketTransportInternal*& old_packet_transport =
       rtcp ? rtcp_packet_transport_ : rtp_packet_transport_;
 
   if (!old_packet_transport && !new_packet_transport) {
     // Nothing to do.
     return;
   }
 
   RTC_DCHECK(old_packet_transport != new_packet_transport);
   if (old_dtls_transport) {
     DisconnectFromDtlsTransport(old_dtls_transport);
@@ skipping 46 matching lines @@
   transport->SignalWritableState.disconnect(this);
   transport->SignalReadPacket.disconnect(this);
   transport->SignalReadyToSend.disconnect(this);
   transport->SignalDtlsState.disconnect(this);
   transport->SignalSentPacket.disconnect(this);
   transport->ice_transport()->SignalSelectedCandidatePairChanged.disconnect(
       this);
 }
 
 void BaseChannel::ConnectToPacketTransport(
-    rtc::PacketTransportInterface* transport) {
+    rtc::PacketTransportInternal* transport) {
   RTC_DCHECK_RUN_ON(network_thread_);
   transport->SignalWritableState.connect(this, &BaseChannel::OnWritableState);
   transport->SignalReadPacket.connect(this, &BaseChannel::OnPacketRead);
   transport->SignalReadyToSend.connect(this, &BaseChannel::OnReadyToSend);
   transport->SignalSentPacket.connect(this, &BaseChannel::SignalSentPacket_n);
 }
 
 void BaseChannel::DisconnectFromPacketTransport(
-    rtc::PacketTransportInterface* transport) {
+    rtc::PacketTransportInternal* transport) {
   RTC_DCHECK_RUN_ON(network_thread_);
   transport->SignalWritableState.disconnect(this);
   transport->SignalReadPacket.disconnect(this);
   transport->SignalReadyToSend.disconnect(this);
   transport->SignalSentPacket.disconnect(this);
 }
 
 bool BaseChannel::Enable(bool enable) {
   worker_thread_->Invoke<void>(
       RTC_FROM_HERE,
@@ skipping 106 matching lines @@
 int BaseChannel::SetOption(SocketType type, rtc::Socket::Option opt,
                            int value) {
   return network_thread_->Invoke<int>(
       RTC_FROM_HERE, Bind(&BaseChannel::SetOption_n, this, type, opt, value));
 }
 
 int BaseChannel::SetOption_n(SocketType type,
                              rtc::Socket::Option opt,
                              int value) {
   RTC_DCHECK(network_thread_->IsCurrent());
-  rtc::PacketTransportInterface* transport = nullptr;
+  rtc::PacketTransportInternal* transport = nullptr;
   switch (type) {
     case ST_RTP:
       transport = rtp_packet_transport_;
       socket_options_.push_back(
           std::pair<rtc::Socket::Option, int>(opt, value));
       break;
     case ST_RTCP:
       transport = rtcp_packet_transport_;
       rtcp_socket_options_.push_back(
           std::pair<rtc::Socket::Option, int>(opt, value));
       break;
   }
   return transport ? transport->SetOption(opt, value) : -1;
 }
 
 bool BaseChannel::SetCryptoOptions(const rtc::CryptoOptions& crypto_options) {
   crypto_options_ = crypto_options;
   return true;
 }
 
-void BaseChannel::OnWritableState(rtc::PacketTransportInterface* transport) {
+void BaseChannel::OnWritableState(rtc::PacketTransportInternal* transport) {
   RTC_DCHECK(transport == rtp_packet_transport_ ||
              transport == rtcp_packet_transport_);
   RTC_DCHECK(network_thread_->IsCurrent());
   UpdateWritableState_n();
 }
 
-void BaseChannel::OnPacketRead(rtc::PacketTransportInterface* transport,
+void BaseChannel::OnPacketRead(rtc::PacketTransportInternal* transport,
                                const char* data,
                                size_t len,
                                const rtc::PacketTime& packet_time,
                                int flags) {
   TRACE_EVENT0("webrtc", "BaseChannel::OnPacketRead");
   // OnPacketRead 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(transport, data, len);
   rtc::CopyOnWriteBuffer packet(data, len);
   HandlePacket(rtcp, &packet, packet_time);
 }
 
-void BaseChannel::OnReadyToSend(rtc::PacketTransportInterface* transport) {
+void BaseChannel::OnReadyToSend(rtc::PacketTransportInternal* transport) {
   RTC_DCHECK(transport == rtp_packet_transport_ ||
              transport == rtcp_packet_transport_);
   SetTransportChannelReadyToSend(transport == rtcp_packet_transport_, true);
 }
 
 void BaseChannel::OnDtlsState(DtlsTransportInternal* transport,
                               DtlsTransportState state) {
   if (!ShouldSetupDtlsSrtp_n()) {
     return;
   }
@@ skipping 46 matching lines @@
   bool ready_to_send =
       (rtp_ready_to_send_ &&
        // In the case of rtcp mux |rtcp_packet_transport_| will be null.
        (rtcp_ready_to_send_ || !rtcp_packet_transport_));
 
   invoker_.AsyncInvoke<void>(
       RTC_FROM_HERE, worker_thread_,
       Bind(&MediaChannel::OnReadyToSend, media_channel_, ready_to_send));
 }
 
-bool BaseChannel::PacketIsRtcp(const rtc::PacketTransportInterface* transport,
+bool BaseChannel::PacketIsRtcp(const rtc::PacketTransportInternal* transport,
                                const char* data,
                                size_t len) {
   return (transport == rtcp_packet_transport_ ||
           rtcp_mux_filter_.DemuxRtcp(data, static_cast<int>(len)));
 }
 
 bool BaseChannel::SendPacket(bool rtcp,
                              rtc::CopyOnWriteBuffer* packet,
                              const rtc::PacketOptions& options) {
   // SendPacket gets called from MediaEngine, on a pacer or an encoder thread.
@@ skipping 11 matching lines @@
     data->options = options;
     network_thread_->Post(RTC_FROM_HERE, this, message_id, data);
     return true;
   }
   TRACE_EVENT0("webrtc", "BaseChannel::SendPacket");
 
   // Now that we are on the correct thread, ensure we have a place to send this
   // 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.
-  rtc::PacketTransportInterface* transport =
+  rtc::PacketTransportInternal* transport =
       (!rtcp || rtcp_mux_filter_.IsActive()) ? rtp_packet_transport_
                                              : rtcp_packet_transport_;
   if (!transport || !transport->writable()) {
     return false;
   }
 
   // Protect ourselves against crazy data.
   if (!ValidPacket(rtcp, packet)) {
     LOG(LS_ERROR) << "Dropping outgoing " << content_name_ << " "
                   << PacketType(rtcp)
@@ skipping 778 matching lines @@
   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(
-    rtc::PacketTransportInterface* /* transport */,
+    rtc::PacketTransportInternal* /* transport */,
     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 170 matching lines @@
 }
 
 int VoiceChannel::GetOutputLevel_w() {
   return media_channel()->GetOutputLevel();
 }
 
 void VoiceChannel::GetActiveStreams_w(AudioInfo::StreamList* actives) {
   media_channel()->GetActiveStreams(actives);
 }
 
-void VoiceChannel::OnPacketRead(rtc::PacketTransportInterface* transport,
+void VoiceChannel::OnPacketRead(rtc::PacketTransportInternal* transport,
                                 const char* data,
                                 size_t len,
                                 const rtc::PacketTime& packet_time,
                                 int flags) {
   BaseChannel::OnPacketRead(transport, data, len, packet_time, flags);
   // 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(transport, data, len)) {
     received_media_ = true;
   }
@@ skipping 493 matching lines @@
   StopMediaMonitor();
   // this can't be done in the base class, since it calls a virtual
   DisableMedia_w();
 
   Deinit();
 }
 
 bool RtpDataChannel::Init_w(
     DtlsTransportInternal* rtp_dtls_transport,
     DtlsTransportInternal* rtcp_dtls_transport,
-    rtc::PacketTransportInterface* rtp_packet_transport,
-    rtc::PacketTransportInterface* rtcp_packet_transport) {
+    rtc::PacketTransportInternal* rtp_packet_transport,
+    rtc::PacketTransportInternal* rtcp_packet_transport) {
   if (!BaseChannel::Init_w(rtp_dtls_transport, rtcp_dtls_transport,
                            rtp_packet_transport, rtcp_packet_transport)) {
     return false;
   }
   media_channel()->SignalDataReceived.connect(this,
                                               &RtpDataChannel::OnDataReceived);
   media_channel()->SignalReadyToSend.connect(
       this, &RtpDataChannel::OnDataChannelReadyToSend);
   return true;
 }
@@ skipping 227 matching lines @@
   signaling_thread()->Post(RTC_FROM_HERE, this, MSG_READYTOSENDDATA,
                            new DataChannelReadyToSendMessageData(writable));
 }
 
 void RtpDataChannel::GetSrtpCryptoSuites_n(
     std::vector<int>* crypto_suites) const {
   GetSupportedDataCryptoSuites(crypto_options(), crypto_suites);
 }
 
 }  // namespace cricket