Move RTP/RTCP demuxing logic from BaseChannel to RtpTransport.

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 18 matching lines @@
 #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/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/rtptransport.h"
 #include "webrtc/pc/srtpfilter.h"
 
 namespace webrtc {
 class AudioSinkInterface;
 }  // namespace webrtc
 
@@ skipping 92 matching lines @@
   bool RemoveRecvStream(uint32_t ssrc);
   bool AddSendStream(const StreamParams& sp);
   bool RemoveSendStream(uint32_t ssrc);
 
   // Monitoring
   void StartConnectionMonitor(int cms);
   void StopConnectionMonitor();
   // For ConnectionStatsGetter, used by ConnectionMonitor
   bool GetConnectionStats(ConnectionInfos* infos) override;
 
-  BundleFilter* bundle_filter() { return &bundle_filter_; }
-
   const std::vector<StreamParams>& local_streams() const {
     return local_streams_;
   }
   const std::vector<StreamParams>& remote_streams() const {
     return remote_streams_;
   }
 
   sigslot::signal2<BaseChannel*, bool> SignalDtlsSrtpSetupFailure;
   void SignalDtlsSrtpSetupFailure_n(bool rtcp);
   void SignalDtlsSrtpSetupFailure_s(bool rtcp);
@@ skipping 27 matching lines @@
       override;
   int SetOption_n(SocketType type, rtc::Socket::Option o, int val);
 
   SrtpFilter* srtp_filter() { return &srtp_filter_; }
 
   virtual cricket::MediaType media_type() = 0;
 
   // This function returns true if we require SRTP for call setup.
   bool srtp_required_for_testing() const { return srtp_required_; }
 
+  // Public for testing.
+  // TODO(zstein): Remove this once channels register themselves with
+  // an RtpTransport in a more explicit way.
+  bool HandlesPayloadType(int payload_type) const;
+
  protected:
   virtual MediaChannel* media_channel() const { return media_channel_; }
 
   void SetTransports_n(DtlsTransportInternal* rtp_dtls_transport,
                        DtlsTransportInternal* rtcp_dtls_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.
@@ skipping 30 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(rtc::PacketTransportInternal* transport);
-  virtual void OnPacketRead(rtc::PacketTransportInternal* transport,
-                            const char* data,
-                            size_t len,
-                            const rtc::PacketTime& packet_time,
-                            int flags);
 
   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::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,
-                        const rtc::CopyOnWriteBuffer& packet,
-                        const rtc::PacketTime& packet_time);
+  // TODO(zstein): packet can be const once the RtpTransport handles protection.
+  virtual void OnPacketReceived(bool rtcp,
+                                rtc::CopyOnWriteBuffer& packet,
+                                const rtc::PacketTime& packet_time);
+  void ProcessPacket(bool rtcp,
+                     const rtc::CopyOnWriteBuffer& packet,
+                     const rtc::PacketTime& packet_time);
 
   void EnableMedia_w();
   void DisableMedia_w();
 
   // Performs actions if the RTP/RTCP writable state changed. This should
   // be called whenever a channel's writable state changes or when RTCP muxing
   // becomes active/inactive.
   void UpdateWritableState_n();
   void ChannelWritable_n();
   void ChannelNotWritable_n();
@@ skipping 62 matching lines @@
   virtual void OnConnectionMonitorUpdate(ConnectionMonitor* monitor,
       const std::vector<ConnectionInfo>& infos) = 0;
 
   // 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);
   }
 
+  void AddHandledPayloadType(int payload_type);
+
  private:
   bool InitNetwork_n(DtlsTransportInternal* rtp_dtls_transport,
                      DtlsTransportInternal* rtcp_dtls_transport,
                      rtc::PacketTransportInternal* rtp_packet_transport,
                      rtc::PacketTransportInternal* rtcp_packet_transport);
   void DisconnectTransportChannels_n();
   void SignalSentPacket_n(rtc::PacketTransportInternal* transport,
                           const rtc::SentPacket& sent_packet);
   void SignalSentPacket_w(const rtc::SentPacket& sent_packet);
   bool IsReadyToSendMedia_n() const;
@@ skipping 17 matching lines @@
   // 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;
   webrtc::RtpTransport rtp_transport_;
   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 writable_ = false;
   bool was_ever_writable_ = false;
   bool has_received_packet_ = false;
   bool dtls_keyed_ = false;
   const bool srtp_required_ = true;
   int rtp_abs_sendtime_extn_id_ = -1;
 
   // MediaChannel related members that should be accessed from the worker
   // thread.
   MediaChannel* const media_channel_;
@@ skipping 81 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::PacketTransportInternal* transport,
-                    const char* data,
-                    size_t len,
-                    const rtc::PacketTime& packet_time,
-                    int flags) override;
+  void OnPacketReceived(bool rtcp,
+                        rtc::CopyOnWriteBuffer& packet,
+                        const rtc::PacketTime& packet_time) 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 207 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_