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

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 21 matching lines @@
 #include "webrtc/media/base/videosourceinterface.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 rtc {
+class PacketTransportInterface;
+}
+
 namespace webrtc {
 class AudioSinkInterface;
 }  // namespace webrtc
 
 namespace cricket {
 
 struct CryptoParams;
 class MediaContentDescription;
 
 // BaseChannel contains logic common to voice and video, including enable,
@@ skipping 174 matching lines @@
 
   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(TransportChannel* channel);
-  virtual void OnChannelRead(TransportChannel* channel,
-                             const char* data,
-                             size_t len,
-                             const rtc::PacketTime& packet_time,
-                             int flags);
-  void OnReadyToSend(TransportChannel* channel);
+  void OnWritableState(rtc::PacketTransportInterface* transport);
+  virtual void OnPacketRead(rtc::PacketTransportInterface* transport,
+                            const char* data,
+                            size_t len,
+                            const rtc::PacketTime& packet_time,
+                            int flags);
+  void OnReadyToSend(rtc::PacketTransportInterface* transport);
 
   void OnDtlsState(TransportChannel* channel, DtlsTransportState state);
 
   void OnSelectedCandidatePairChanged(
       TransportChannel* channel,
       CandidatePairInterface* selected_candidate_pair,
       int last_sent_packet_id,
       bool ready_to_send);
 
-  bool PacketIsRtcp(const TransportChannel* channel, const char* data,
+  bool PacketIsRtcp(const rtc::PacketTransportInterface* transport,
+                    const char* data,
                     size_t len);
   bool SendPacket(bool rtcp,
                   rtc::CopyOnWriteBuffer* packet,
                   const rtc::PacketOptions& options);
 
   virtual bool WantsPacket(bool rtcp, const rtc::CopyOnWriteBuffer* packet);
   void HandlePacket(bool rtcp, rtc::CopyOnWriteBuffer* packet,
                     const rtc::PacketTime& packet_time);
   void OnPacketReceived(bool rtcp,
                         const rtc::CopyOnWriteBuffer& packet,
@@ skipping 86 matching lines @@
   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(const std::string* bundle_transport_name);
   void DisconnectTransportChannels_n();
   void DestroyTransportChannels_n();
-  void SignalSentPacket_n(TransportChannel* channel,
+  void SignalSentPacket_n(rtc::PacketTransportInterface* 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);
 
   rtc::Thread* const worker_thread_;
   rtc::Thread* const network_thread_;
   rtc::AsyncInvoker invoker_;
 
   const std::string content_name_;
   std::unique_ptr<ConnectionMonitor> connection_monitor_;
 
   // Transport related members that should be accessed from network thread.
   TransportController* const transport_controller_;
   std::string transport_name_;
   // Is RTCP used at all by this type of channel?
   // Expected to be true (as of typing this) for everything except data
   // channels.
   const bool rtcp_enabled_;
+  // TODO(johan): Replace TransportChannel* with rtc::PacketTransportInterface*.
   TransportChannel* transport_channel_ = nullptr;
   std::vector<std::pair<rtc::Socket::Option, int> > socket_options_;
   TransportChannel* rtcp_transport_channel_ = nullptr;
   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;
@@ skipping 88 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 OnChannelRead(TransportChannel* channel,
-                     const char* data,
-                     size_t len,
-                     const rtc::PacketTime& packet_time,
-                     int flags) override;
+  void OnPacketRead(rtc::PacketTransportInterface* 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,
                           ContentAction action,
                           std::string* error_desc) override;
   void HandleEarlyMediaTimeout();
   bool InsertDtmf_w(uint32_t ssrc, int event, int duration);
@@ skipping 219 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_