Rename "PacketTransportInterface" to "PacketTransportInternal".

webrtc/pc/channel.h

 /*
  *  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.
  */
 
@@ skipping 13 matching lines @@
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/network.h"
 #include "webrtc/base/sigslot.h"
 #include "webrtc/base/window.h"
 #include "webrtc/media/base/mediachannel.h"
 #include "webrtc/media/base/mediaengine.h"
 #include "webrtc/media/base/streamparams.h"
 #include "webrtc/media/base/videosinkinterface.h"
 #include "webrtc/media/base/videosourceinterface.h"
 #include "webrtc/p2p/base/dtlstransportinternal.h"
-#include "webrtc/p2p/base/packettransportinterface.h"
+#include "webrtc/p2p/base/packettransportinternal.h"
 #include "webrtc/p2p/base/transportcontroller.h"
 #include "webrtc/p2p/client/socketmonitor.h"
 #include "webrtc/pc/audiomonitor.h"
 #include "webrtc/pc/bundlefilter.h"
 #include "webrtc/pc/mediamonitor.h"
 #include "webrtc/pc/mediasession.h"
 #include "webrtc/pc/rtcpmuxfilter.h"
 #include "webrtc/pc/srtpfilter.h"
 
 namespace webrtc {
@@ skipping 33 matching lines @@
   BaseChannel(rtc::Thread* worker_thread,
               rtc::Thread* network_thread,
               rtc::Thread* signaling_thread,
               MediaChannel* channel,
               const std::string& content_name,
               bool rtcp_mux_required,
               bool srtp_required);
   virtual ~BaseChannel();
   bool 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);
   // Deinit may be called multiple times and is simply ignored if it's already
   // done.
   void Deinit();
 
   rtc::Thread* worker_thread() const { return worker_thread_; }
   rtc::Thread* network_thread() const { return network_thread_; }
   const std::string& content_name() const { return content_name_; }
   // TODO(deadbeef): This is redundant; remove this.
   const std::string& transport_name() const { return transport_name_; }
   bool enabled() const { return enabled_; }
 
   // This function returns true if we are using SRTP.
   bool secure() const { return srtp_filter_.IsActive(); }
   // The following function returns true if we are using
   // DTLS-based keying. If you turned off SRTP later, however
   // you could have secure() == false and dtls_secure() == true.
   bool secure_dtls() const { return dtls_keyed_; }
 
   bool writable() const { return writable_; }
 
   // Set the transport(s), and update writability and "ready-to-send" state.
   // |rtp_transport| must be non-null.
   // |rtcp_transport| must be supplied if NeedsRtcpTransport() is true (meaning
   // RTCP muxing is not fully active yet).
   // |rtp_transport| and |rtcp_transport| must share the same transport name as
   // well.
-  // Can not start with "rtc::PacketTransportInterface" and switch to
+  // Can not start with "rtc::PacketTransportInternal" and switch to
   // "DtlsTransportInternal", or vice-versa.
   void SetTransports(DtlsTransportInternal* rtp_dtls_transport,
                      DtlsTransportInternal* rtcp_dtls_transport);
-  void SetTransports(rtc::PacketTransportInterface* rtp_packet_transport,
-                     rtc::PacketTransportInterface* rtcp_packet_transport);
+  void SetTransports(rtc::PacketTransportInternal* rtp_packet_transport,
+                     rtc::PacketTransportInternal* rtcp_packet_transport);
   bool PushdownLocalDescription(const SessionDescription* local_desc,
                                 ContentAction action,
                                 std::string* error_desc);
   bool PushdownRemoteDescription(const SessionDescription* remote_desc,
                                 ContentAction action,
                                 std::string* error_desc);
   // Channel control
   bool SetLocalContent(const MediaContentDescription* content,
                        ContentAction action,
                        std::string* error_desc);
@@ skipping 72 matching lines @@
   bool SetCryptoOptions(const rtc::CryptoOptions& crypto_options);
 
   // This function returns true if we require SRTP for call setup.
   bool srtp_required_for_testing() const { return srtp_required_; }
 
  protected:
   virtual MediaChannel* media_channel() const { return media_channel_; }
 
   void 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);
 
   // This does not update writability or "ready-to-send" state; it just
   // disconnects from the old channel and connects to the new one.
   void SetTransport_n(bool rtcp,
                       DtlsTransportInternal* new_dtls_transport,
-                      rtc::PacketTransportInterface* new_packet_transport);
+                      rtc::PacketTransportInternal* new_packet_transport);
 
   bool was_ever_writable() const { return was_ever_writable_; }
   void set_local_content_direction(MediaContentDirection direction) {
     local_content_direction_ = direction;
   }
   void set_remote_content_direction(MediaContentDirection direction) {
     remote_content_direction_ = direction;
   }
   // These methods verify that:
   // * The required content description directions have been set.
   // * The channel is enabled.
   // * And for sending:
   //   - The SRTP filter is active if it's needed.
   //   - The transport has been writable before, meaning it should be at least
   //     possible to succeed in sending a packet.
   //
   // When any of these properties change, UpdateMediaSendRecvState_w should be
   // called.
   bool IsReadyToReceiveMedia_w() const;
   bool IsReadyToSendMedia_w() const;
   rtc::Thread* signaling_thread() { return signaling_thread_; }
 
   void ConnectToDtlsTransport(DtlsTransportInternal* transport);
   void DisconnectFromDtlsTransport(DtlsTransportInternal* transport);
-  void ConnectToPacketTransport(rtc::PacketTransportInterface* transport);
-  void DisconnectFromPacketTransport(rtc::PacketTransportInterface* transport);
+  void ConnectToPacketTransport(rtc::PacketTransportInternal* transport);
+  void DisconnectFromPacketTransport(rtc::PacketTransportInternal* transport);
 
   void FlushRtcpMessages_n();
 
   // NetworkInterface implementation, called by MediaEngine
   bool SendPacket(rtc::CopyOnWriteBuffer* packet,
                   const rtc::PacketOptions& options) override;
   bool SendRtcp(rtc::CopyOnWriteBuffer* packet,
                 const rtc::PacketOptions& options) override;
 
   // From TransportChannel
-  void OnWritableState(rtc::PacketTransportInterface* transport);
-  virtual void OnPacketRead(rtc::PacketTransportInterface* transport,
+  void OnWritableState(rtc::PacketTransportInternal* transport);
+  virtual void OnPacketRead(rtc::PacketTransportInternal* transport,
                             const char* data,
                             size_t len,
                             const rtc::PacketTime& packet_time,
                             int flags);
-  void OnReadyToSend(rtc::PacketTransportInterface* transport);
+  void OnReadyToSend(rtc::PacketTransportInternal* transport);
 
   void OnDtlsState(DtlsTransportInternal* transport, DtlsTransportState state);
 
   void OnSelectedCandidatePairChanged(
       IceTransportInternal* ice_transport,
       CandidatePairInterface* selected_candidate_pair,
       int last_sent_packet_id,
       bool ready_to_send);
 
-  bool PacketIsRtcp(const rtc::PacketTransportInterface* transport,
+  bool PacketIsRtcp(const rtc::PacketTransportInternal* transport,
                     const char* data,
                     size_t len);
   bool SendPacket(bool rtcp,
                   rtc::CopyOnWriteBuffer* packet,
                   const rtc::PacketOptions& options);
 
   bool WantsPacket(bool rtcp, const rtc::CopyOnWriteBuffer* packet);
   void HandlePacket(bool rtcp, rtc::CopyOnWriteBuffer* packet,
                     const rtc::PacketTime& packet_time);
   void OnPacketReceived(bool rtcp,
@@ skipping 85 matching lines @@
   // Helper function for invoking bool-returning methods on the worker thread.
   template <class FunctorT>
   bool InvokeOnWorker(const rtc::Location& posted_from,
                       const FunctorT& functor) {
     return worker_thread_->Invoke<bool>(posted_from, functor);
   }
 
  private:
   bool 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);
   void DisconnectTransportChannels_n();
-  void SignalSentPacket_n(rtc::PacketTransportInterface* transport,
+  void SignalSentPacket_n(rtc::PacketTransportInternal* transport,
                           const rtc::SentPacket& sent_packet);
   void SignalSentPacket_w(const rtc::SentPacket& sent_packet);
   bool IsReadyToSendMedia_n() const;
   void CacheRtpAbsSendTimeHeaderExtension_n(int rtp_abs_sendtime_extn_id);
   int GetTransportOverheadPerPacket() const;
   void UpdateTransportOverhead();
 
   rtc::Thread* const worker_thread_;
   rtc::Thread* const network_thread_;
   rtc::Thread* const signaling_thread_;
   rtc::AsyncInvoker invoker_;
 
   const std::string content_name_;
   std::unique_ptr<ConnectionMonitor> connection_monitor_;
 
   // Won't be set when using raw packet transports. SDP-specific thing.
   std::string transport_name_;
   // True if RTCP-multiplexing is required. In other words, no standalone RTCP
   // transport will ever be used for this channel.
   const bool rtcp_mux_required_;
 
   // Separate DTLS/non-DTLS pointers to support using BaseChannel without DTLS.
   // Temporary measure until more refactoring is done.
   // If non-null, "X_dtls_transport_" will always equal "X_packet_transport_".
   DtlsTransportInternal* rtp_dtls_transport_ = nullptr;
   DtlsTransportInternal* rtcp_dtls_transport_ = nullptr;
-  rtc::PacketTransportInterface* rtp_packet_transport_ = nullptr;
-  rtc::PacketTransportInterface* rtcp_packet_transport_ = nullptr;
+  rtc::PacketTransportInternal* rtp_packet_transport_ = nullptr;
+  rtc::PacketTransportInternal* rtcp_packet_transport_ = nullptr;
   std::vector<std::pair<rtc::Socket::Option, int> > socket_options_;
   std::vector<std::pair<rtc::Socket::Option, int> > rtcp_socket_options_;
   SrtpFilter srtp_filter_;
   RtcpMuxFilter rtcp_mux_filter_;
   BundleFilter bundle_filter_;
   bool rtp_ready_to_send_ = false;
   bool rtcp_ready_to_send_ = false;
   bool writable_ = false;
   bool was_ever_writable_ = false;
   bool has_received_packet_ = false;
@@ skipping 87 matching lines @@
   void GetActiveStreams_w(AudioInfo::StreamList* actives);
   webrtc::RtpParameters GetRtpSendParameters_w(uint32_t ssrc) const;
   bool SetRtpSendParameters_w(uint32_t ssrc, webrtc::RtpParameters parameters);
   webrtc::RtpParameters GetRtpReceiveParameters_w(uint32_t ssrc) const;
   bool SetRtpReceiveParameters_w(uint32_t ssrc,
                                  webrtc::RtpParameters parameters);
   cricket::MediaType media_type() override { return cricket::MEDIA_TYPE_AUDIO; }
 
  private:
   // overrides from BaseChannel
-  void OnPacketRead(rtc::PacketTransportInterface* transport,
+  void OnPacketRead(rtc::PacketTransportInternal* transport,
                     const char* data,
                     size_t len,
                     const rtc::PacketTime& packet_time,
                     int flags) override;
   void UpdateMediaSendRecvState_w() override;
   const ContentInfo* GetFirstContent(const SessionDescription* sdesc) override;
   bool SetLocalContent_w(const MediaContentDescription* content,
                          ContentAction action,
                          std::string* error_desc) override;
   bool SetRemoteContent_w(const MediaContentDescription* content,
@@ skipping 111 matching lines @@
   RtpDataChannel(rtc::Thread* worker_thread,
                  rtc::Thread* network_thread,
                  rtc::Thread* signaling_thread,
                  DataMediaChannel* channel,
                  const std::string& content_name,
                  bool rtcp_mux_required,
                  bool srtp_required);
   ~RtpDataChannel();
   bool 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);
 
   virtual bool SendData(const SendDataParams& params,
                         const rtc::CopyOnWriteBuffer& payload,
                         SendDataResult* result);
 
   void StartMediaMonitor(int cms);
   void StopMediaMonitor();
 
   // Should be called on the signaling thread only.
   bool ready_to_send_data() const {
@@ skipping 82 matching lines @@
   // SetSendParameters.
   DataSendParameters last_send_params_;
   // Last DataRecvParameters sent down to the media_channel() via
   // SetRecvParameters.
   DataRecvParameters last_recv_params_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_PC_CHANNEL_H_