pc/channel.h - src - Git at Google

 /*
  *  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.
  */

 #ifndef PC_CHANNEL_H_
 #define PC_CHANNEL_H_

 #include <stddef.h>
 #include <stdint.h>

 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>

 #include "absl/types/optional.h"
 #include "api/call/audio_sink.h"
 #include "api/crypto/crypto_options.h"
 #include "api/function_view.h"
 #include "api/jsep.h"
 #include "api/media_types.h"
 #include "api/rtp_receiver_interface.h"
 #include "api/rtp_transceiver_direction.h"
 #include "api/scoped_refptr.h"
 #include "api/sequence_checker.h"
 #include "api/video/video_sink_interface.h"
 #include "api/video/video_source_interface.h"
 #include "call/rtp_demuxer.h"
 #include "call/rtp_packet_sink_interface.h"
 #include "media/base/media_channel.h"
 #include "media/base/media_engine.h"
 #include "media/base/stream_params.h"
 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "p2p/base/dtls_transport_internal.h"
 #include "p2p/base/packet_transport_internal.h"
 #include "pc/channel_interface.h"
 #include "pc/dtls_srtp_transport.h"
 #include "pc/media_session.h"
 #include "pc/rtp_transport.h"
 #include "pc/rtp_transport_internal.h"
 #include "pc/session_description.h"
 #include "pc/srtp_transport.h"
 #include "rtc_base/async_packet_socket.h"
 #include "rtc_base/async_udp_socket.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/copy_on_write_buffer.h"
 #include "rtc_base/location.h"
 #include "rtc_base/network.h"
 #include "rtc_base/network/sent_packet.h"
 #include "rtc_base/network_route.h"
 #include "rtc_base/socket.h"
 #include "rtc_base/task_utils/pending_task_safety_flag.h"
 #include "rtc_base/third_party/sigslot/sigslot.h"
 #include "rtc_base/thread.h"
 #include "rtc_base/thread_annotations.h"
 #include "rtc_base/thread_message.h"
 #include "rtc_base/unique_id_generator.h"

 namespace webrtc {
 class AudioSinkInterface;
 }  // namespace webrtc

 namespace cricket {

 struct CryptoParams;

 // BaseChannel contains logic common to voice and video, including enable,
 // marshaling calls to a worker and network threads, and connection and media
 // monitors.
 //
 // BaseChannel assumes signaling and other threads are allowed to make
 // synchronous calls to the worker thread, the worker thread makes synchronous
 // calls only to the network thread, and the network thread can't be blocked by
 // other threads.
 // All methods with _n suffix must be called on network thread,
 //     methods with _w suffix on worker thread
 // and methods with _s suffix on signaling thread.
 // Network and worker threads may be the same thread.
 //
 // WARNING! SUBCLASSES MUST CALL Deinit() IN THEIR DESTRUCTORS!
 // This is required to avoid a data race between the destructor modifying the
 // vtable, and the media channel's thread using BaseChannel as the
 // NetworkInterface.

 class BaseChannel : public ChannelInterface,
                     // TODO(tommi): Remove has_slots inheritance.
                     public sigslot::has_slots<>,
                     // TODO(tommi): Consider implementing these interfaces
                     // via composition.
                     public MediaChannel::NetworkInterface,
                     public webrtc::RtpPacketSinkInterface {
  public:
   // If `srtp_required` is true, the channel will not send or receive any
   // RTP/RTCP packets without using SRTP (either using SDES or DTLS-SRTP).
   // The BaseChannel does not own the UniqueRandomIdGenerator so it is the
   // responsibility of the user to ensure it outlives this object.
   // TODO(zhihuang:) Create a BaseChannel::Config struct for the parameter lists
   // which will make it easier to change the constructor.
   BaseChannel(rtc::Thread* worker_thread,
               rtc::Thread* network_thread,
               rtc::Thread* signaling_thread,
               std::unique_ptr<MediaChannel> media_channel,
               const std::string& content_name,
               bool srtp_required,
               webrtc::CryptoOptions crypto_options,
               rtc::UniqueRandomIdGenerator* ssrc_generator);
   virtual ~BaseChannel();
   virtual void Init_w(webrtc::RtpTransportInternal* rtp_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 override { return content_name_; }
   // TODO(deadbeef): This is redundant; remove this.
   const std::string& transport_name() const override {
     RTC_DCHECK_RUN_ON(network_thread());
     if (rtp_transport_)
       return rtp_transport_->transport_name();
     // TODO(tommi): Delete this variable.
     return transport_name_;
   }

   // This function returns true if using SRTP (DTLS-based keying or SDES).
   bool srtp_active() const {
     RTC_DCHECK_RUN_ON(network_thread());
     return rtp_transport_ && rtp_transport_->IsSrtpActive();
   }

   // Set an RTP level transport which could be an RtpTransport without
   // encryption, an SrtpTransport for SDES or a DtlsSrtpTransport for DTLS-SRTP.
   // This can be called from any thread and it hops to the network thread
   // internally. It would replace the `SetTransports` and its variants.
   bool SetRtpTransport(webrtc::RtpTransportInternal* rtp_transport) override;

   webrtc::RtpTransportInternal* rtp_transport() const {
     RTC_DCHECK_RUN_ON(network_thread());
     return rtp_transport_;
   }

   // Channel control
   bool SetLocalContent(const MediaContentDescription* content,
                        webrtc::SdpType type,
                        std::string* error_desc) override;
   bool SetRemoteContent(const MediaContentDescription* content,
                         webrtc::SdpType type,
                         std::string* error_desc) override;
   // Controls whether this channel will receive packets on the basis of
   // matching payload type alone. This is needed for legacy endpoints that
   // don't signal SSRCs or use MID/RID, but doesn't make sense if there is
   // more than channel of specific media type, As that creates an ambiguity.
   //
   // This method will also remove any existing streams that were bound to this
   // channel on the basis of payload type, since one of these streams might
   // actually belong to a new channel. See: crbug.com/webrtc/11477
   bool SetPayloadTypeDemuxingEnabled(bool enabled) override;

   void Enable(bool enable) override;

   const std::vector<StreamParams>& local_streams() const override {
     return local_streams_;
   }
   const std::vector<StreamParams>& remote_streams() const override {
     return remote_streams_;
   }

   // Used for latency measurements.
   void SetFirstPacketReceivedCallback(std::function<void()> callback) override;

   // From RtpTransport - public for testing only
   void OnTransportReadyToSend(bool ready);

   // Only public for unit tests.  Otherwise, consider protected.
   int SetOption(SocketType type, rtc::Socket::Option o, int val) override;

   // RtpPacketSinkInterface overrides.
   void OnRtpPacket(const webrtc::RtpPacketReceived& packet) override;

   MediaChannel* media_channel() const override {
     return media_channel_.get();
   }

  protected:
   bool was_ever_writable() const {
     RTC_DCHECK_RUN_ON(worker_thread());
     return was_ever_writable_;
   }
   void set_local_content_direction(webrtc::RtpTransceiverDirection direction) {
     RTC_DCHECK_RUN_ON(worker_thread());
     local_content_direction_ = direction;
   }
   void set_remote_content_direction(webrtc::RtpTransceiverDirection direction) {
     RTC_DCHECK_RUN_ON(worker_thread());
     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 RTC_RUN_ON(worker_thread());
   bool IsReadyToSendMedia_w() const RTC_RUN_ON(worker_thread());
   rtc::Thread* signaling_thread() const { return signaling_thread_; }

   // 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 RtpTransportInternal
   void OnWritableState(bool writable);

   void OnNetworkRouteChanged(absl::optional<rtc::NetworkRoute> network_route);

   bool SendPacket(bool rtcp,
                   rtc::CopyOnWriteBuffer* packet,
                   const rtc::PacketOptions& options);

   void EnableMedia_w() RTC_RUN_ON(worker_thread());
   void DisableMedia_w() RTC_RUN_ON(worker_thread());

   // 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() RTC_RUN_ON(network_thread());
   void ChannelWritable_n() RTC_RUN_ON(network_thread());
   void ChannelNotWritable_n() RTC_RUN_ON(network_thread());

   bool AddRecvStream_w(const StreamParams& sp) RTC_RUN_ON(worker_thread());
   bool RemoveRecvStream_w(uint32_t ssrc) RTC_RUN_ON(worker_thread());
   void ResetUnsignaledRecvStream_w() RTC_RUN_ON(worker_thread());
   bool SetPayloadTypeDemuxingEnabled_w(bool enabled)
       RTC_RUN_ON(worker_thread());
   bool AddSendStream_w(const StreamParams& sp) RTC_RUN_ON(worker_thread());
   bool RemoveSendStream_w(uint32_t ssrc) RTC_RUN_ON(worker_thread());

   // Should be called whenever the conditions for
   // IsReadyToReceiveMedia/IsReadyToSendMedia are satisfied (or unsatisfied).
   // Updates the send/recv state of the media channel.
   virtual void UpdateMediaSendRecvState_w() RTC_RUN_ON(worker_thread()) = 0;

   bool UpdateLocalStreams_w(const std::vector<StreamParams>& streams,
                             webrtc::SdpType type,
                             std::string* error_desc)
       RTC_RUN_ON(worker_thread());
   bool UpdateRemoteStreams_w(const std::vector<StreamParams>& streams,
                              webrtc::SdpType type,
                              std::string* error_desc)
       RTC_RUN_ON(worker_thread());
   virtual bool SetLocalContent_w(const MediaContentDescription* content,
                                  webrtc::SdpType type,
                                  std::string* error_desc)
       RTC_RUN_ON(worker_thread()) = 0;
   virtual bool SetRemoteContent_w(const MediaContentDescription* content,
                                   webrtc::SdpType type,
                                   std::string* error_desc)
       RTC_RUN_ON(worker_thread()) = 0;

   // Returns a list of RTP header extensions where any extension URI is unique.
   // Encrypted extensions will be either preferred or discarded, depending on
   // the current crypto_options_.
   RtpHeaderExtensions GetDeduplicatedRtpHeaderExtensions(
       const RtpHeaderExtensions& extensions);

   // Add `payload_type` to `demuxer_criteria_` if payload type demuxing is
   // enabled.
   void MaybeAddHandledPayloadType(int payload_type) RTC_RUN_ON(worker_thread());

   void ClearHandledPayloadTypes() RTC_RUN_ON(worker_thread());

   void UpdateRtpHeaderExtensionMap(
       const RtpHeaderExtensions& header_extensions);

   bool RegisterRtpDemuxerSink_w() RTC_RUN_ON(worker_thread());

   // Return description of media channel to facilitate logging
   std::string ToString() const;

  private:
   bool ConnectToRtpTransport() RTC_RUN_ON(network_thread());
   void DisconnectFromRtpTransport() RTC_RUN_ON(network_thread());
   void SignalSentPacket_n(const rtc::SentPacket& sent_packet);

   rtc::Thread* const worker_thread_;
   rtc::Thread* const network_thread_;
   rtc::Thread* const signaling_thread_;
   rtc::scoped_refptr<webrtc::PendingTaskSafetyFlag> alive_;

   const std::string content_name_;

   std::function<void()> on_first_packet_received_
       RTC_GUARDED_BY(network_thread());

   // Won't be set when using raw packet transports. SDP-specific thing.
   // TODO(bugs.webrtc.org/12230): Written on network thread, read on
   // worker thread (at least).
   // TODO(tommi): Remove this variable and instead use rtp_transport_ to
   // return the transport name. This variable is currently required for
   // "for_test" methods.
   std::string transport_name_;

   webrtc::RtpTransportInternal* rtp_transport_
       RTC_GUARDED_BY(network_thread()) = nullptr;

   std::vector<std::pair<rtc::Socket::Option, int> > socket_options_
       RTC_GUARDED_BY(network_thread());
   std::vector<std::pair<rtc::Socket::Option, int> > rtcp_socket_options_
       RTC_GUARDED_BY(network_thread());
   bool writable_ RTC_GUARDED_BY(network_thread()) = false;
   bool was_ever_writable_n_ RTC_GUARDED_BY(network_thread()) = false;
   bool was_ever_writable_ RTC_GUARDED_BY(worker_thread()) = false;
   const bool srtp_required_ = true;

   // TODO(tommi): This field shouldn't be necessary. It's a copy of
   // PeerConnection::GetCryptoOptions(), which is const state. It's also only
   // used to filter header extensions when calling
   // `rtp_transport_->UpdateRtpHeaderExtensionMap()` when the local/remote
   // content description is updated. Since the transport is actually owned
   // by the transport controller that also gets updated whenever the content
   // description changes, it seems we have two paths into the transports, along
   // with several thread hops via various classes (such as the Channel classes)
   // that only serve as additional layers and store duplicate state. The Jsep*
   // family of classes already apply session description updates on the network
   // thread every time it changes.
   // For the Channel classes, we should be able to get rid of:
   // * crypto_options (and fewer construction parameters)_
   // * UpdateRtpHeaderExtensionMap
   // * GetFilteredRtpHeaderExtensions
   // * Blocking thread hop to the network thread for every call to set
   //   local/remote content is updated.
   const webrtc::CryptoOptions crypto_options_;

   // MediaChannel related members that should be accessed from the worker
   // thread.
   const std::unique_ptr<MediaChannel> media_channel_;
   // Currently the `enabled_` flag is accessed from the signaling thread as
   // well, but it can be changed only when signaling thread does a synchronous
   // call to the worker thread, so it should be safe.
   bool enabled_ RTC_GUARDED_BY(worker_thread()) = false;
   bool enabled_s_ RTC_GUARDED_BY(signaling_thread()) = false;
   bool payload_type_demuxing_enabled_ RTC_GUARDED_BY(worker_thread()) = true;
   std::vector<StreamParams> local_streams_ RTC_GUARDED_BY(worker_thread());
   std::vector<StreamParams> remote_streams_ RTC_GUARDED_BY(worker_thread());
   // TODO(bugs.webrtc.org/12230): local_content_direction and
   // remote_content_direction are set on the worker thread, but accessed on the
   // network thread.
   webrtc::RtpTransceiverDirection local_content_direction_ =
       webrtc::RtpTransceiverDirection::kInactive;
   webrtc::RtpTransceiverDirection remote_content_direction_ =
       webrtc::RtpTransceiverDirection::kInactive;

   // Cached list of payload types, used if payload type demuxing is re-enabled.
   std::set<uint8_t> payload_types_ RTC_GUARDED_BY(worker_thread());
   // TODO(bugs.webrtc.org/12239): Modified on worker thread, accessed
   // on network thread in RegisterRtpDemuxerSink_n (called from Init_w)
   webrtc::RtpDemuxerCriteria demuxer_criteria_;
   // Accessed on the worker thread, modified on the network thread from
   // RegisterRtpDemuxerSink_w's Invoke.
   webrtc::RtpDemuxerCriteria previous_demuxer_criteria_;
   // This generator is used to generate SSRCs for local streams.
   // This is needed in cases where SSRCs are not negotiated or set explicitly
   // like in Simulcast.
   // This object is not owned by the channel so it must outlive it.
   rtc::UniqueRandomIdGenerator* const ssrc_generator_;
 };

 // VoiceChannel is a specialization that adds support for early media, DTMF,
 // and input/output level monitoring.
 class VoiceChannel : public BaseChannel {
  public:
   VoiceChannel(rtc::Thread* worker_thread,
                rtc::Thread* network_thread,
                rtc::Thread* signaling_thread,
                std::unique_ptr<VoiceMediaChannel> channel,
                const std::string& content_name,
                bool srtp_required,
                webrtc::CryptoOptions crypto_options,
                rtc::UniqueRandomIdGenerator* ssrc_generator);
   ~VoiceChannel();

   // downcasts a MediaChannel
   VoiceMediaChannel* media_channel() const override {
     return static_cast<VoiceMediaChannel*>(BaseChannel::media_channel());
   }

   cricket::MediaType media_type() const override {
     return cricket::MEDIA_TYPE_AUDIO;
   }

  private:
   // overrides from BaseChannel
   void UpdateMediaSendRecvState_w() override;
   bool SetLocalContent_w(const MediaContentDescription* content,
                          webrtc::SdpType type,
                          std::string* error_desc) override;
   bool SetRemoteContent_w(const MediaContentDescription* content,
                           webrtc::SdpType type,
                           std::string* error_desc) override;

   // Last AudioSendParameters sent down to the media_channel() via
   // SetSendParameters.
   AudioSendParameters last_send_params_;
   // Last AudioRecvParameters sent down to the media_channel() via
   // SetRecvParameters.
   AudioRecvParameters last_recv_params_;
 };

 // VideoChannel is a specialization for video.
 class VideoChannel : public BaseChannel {
  public:
   VideoChannel(rtc::Thread* worker_thread,
                rtc::Thread* network_thread,
                rtc::Thread* signaling_thread,
                std::unique_ptr<VideoMediaChannel> media_channel,
                const std::string& content_name,
                bool srtp_required,
                webrtc::CryptoOptions crypto_options,
                rtc::UniqueRandomIdGenerator* ssrc_generator);
   ~VideoChannel();

   // downcasts a MediaChannel
   VideoMediaChannel* media_channel() const override {
     return static_cast<VideoMediaChannel*>(BaseChannel::media_channel());
   }

   void FillBitrateInfo(BandwidthEstimationInfo* bwe_info);

   cricket::MediaType media_type() const override {
     return cricket::MEDIA_TYPE_VIDEO;
   }

  private:
   // overrides from BaseChannel
   void UpdateMediaSendRecvState_w() override;
   bool SetLocalContent_w(const MediaContentDescription* content,
                          webrtc::SdpType type,
                          std::string* error_desc) override;
   bool SetRemoteContent_w(const MediaContentDescription* content,
                           webrtc::SdpType type,
                           std::string* error_desc) override;

   // Last VideoSendParameters sent down to the media_channel() via
   // SetSendParameters.
   VideoSendParameters last_send_params_;
   // Last VideoRecvParameters sent down to the media_channel() via
   // SetRecvParameters.
   VideoRecvParameters last_recv_params_;
 };

 }  // namespace cricket

 #endif  // 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.
	*/

	#ifndef PC_CHANNEL_H_
	#define PC_CHANNEL_H_

	#include <stddef.h>
	#include <stdint.h>

	#include <map>
	#include <memory>
	#include <set>
	#include <string>
	#include <utility>
	#include <vector>

	#include "absl/types/optional.h"
	#include "api/call/audio_sink.h"
	#include "api/crypto/crypto_options.h"
	#include "api/function_view.h"
	#include "api/jsep.h"
	#include "api/media_types.h"
	#include "api/rtp_receiver_interface.h"
	#include "api/rtp_transceiver_direction.h"
	#include "api/scoped_refptr.h"
	#include "api/sequence_checker.h"
	#include "api/video/video_sink_interface.h"
	#include "api/video/video_source_interface.h"
	#include "call/rtp_demuxer.h"
	#include "call/rtp_packet_sink_interface.h"
	#include "media/base/media_channel.h"
	#include "media/base/media_engine.h"
	#include "media/base/stream_params.h"
	#include "modules/rtp_rtcp/source/rtp_packet_received.h"
	#include "p2p/base/dtls_transport_internal.h"
	#include "p2p/base/packet_transport_internal.h"
	#include "pc/channel_interface.h"
	#include "pc/dtls_srtp_transport.h"
	#include "pc/media_session.h"
	#include "pc/rtp_transport.h"
	#include "pc/rtp_transport_internal.h"
	#include "pc/session_description.h"
	#include "pc/srtp_transport.h"
	#include "rtc_base/async_packet_socket.h"
	#include "rtc_base/async_udp_socket.h"
	#include "rtc_base/checks.h"
	#include "rtc_base/copy_on_write_buffer.h"
	#include "rtc_base/location.h"
	#include "rtc_base/network.h"
	#include "rtc_base/network/sent_packet.h"
	#include "rtc_base/network_route.h"
	#include "rtc_base/socket.h"
	#include "rtc_base/task_utils/pending_task_safety_flag.h"
	#include "rtc_base/third_party/sigslot/sigslot.h"
	#include "rtc_base/thread.h"
	#include "rtc_base/thread_annotations.h"
	#include "rtc_base/thread_message.h"
	#include "rtc_base/unique_id_generator.h"

	namespace webrtc {
	class AudioSinkInterface;
	} // namespace webrtc

	namespace cricket {

	struct CryptoParams;

	// BaseChannel contains logic common to voice and video, including enable,
	// marshaling calls to a worker and network threads, and connection and media
	// monitors.
	//
	// BaseChannel assumes signaling and other threads are allowed to make
	// synchronous calls to the worker thread, the worker thread makes synchronous
	// calls only to the network thread, and the network thread can't be blocked by
	// other threads.
	// All methods with _n suffix must be called on network thread,
	// methods with _w suffix on worker thread
	// and methods with _s suffix on signaling thread.
	// Network and worker threads may be the same thread.
	//
	// WARNING! SUBCLASSES MUST CALL Deinit() IN THEIR DESTRUCTORS!
	// This is required to avoid a data race between the destructor modifying the
	// vtable, and the media channel's thread using BaseChannel as the
	// NetworkInterface.

	class BaseChannel : public ChannelInterface,
	// TODO(tommi): Remove has_slots inheritance.
	public sigslot::has_slots<>,
	// TODO(tommi): Consider implementing these interfaces
	// via composition.
	public MediaChannel::NetworkInterface,
	public webrtc::RtpPacketSinkInterface {
	public:
	// If `srtp_required` is true, the channel will not send or receive any
	// RTP/RTCP packets without using SRTP (either using SDES or DTLS-SRTP).
	// The BaseChannel does not own the UniqueRandomIdGenerator so it is the
	// responsibility of the user to ensure it outlives this object.
	// TODO(zhihuang:) Create a BaseChannel::Config struct for the parameter lists
	// which will make it easier to change the constructor.
	BaseChannel(rtc::Thread* worker_thread,
	rtc::Thread* network_thread,
	rtc::Thread* signaling_thread,
	std::unique_ptr<MediaChannel> media_channel,
	const std::string& content_name,
	bool srtp_required,
	webrtc::CryptoOptions crypto_options,
	rtc::UniqueRandomIdGenerator* ssrc_generator);
	virtual ~BaseChannel();
	virtual void Init_w(webrtc::RtpTransportInternal* rtp_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 override { return content_name_; }
	// TODO(deadbeef): This is redundant; remove this.
	const std::string& transport_name() const override {
	RTC_DCHECK_RUN_ON(network_thread());
	if (rtp_transport_)
	return rtp_transport_->transport_name();
	// TODO(tommi): Delete this variable.
	return transport_name_;
	}

	// This function returns true if using SRTP (DTLS-based keying or SDES).
	bool srtp_active() const {
	RTC_DCHECK_RUN_ON(network_thread());
	return rtp_transport_ && rtp_transport_->IsSrtpActive();
	}

	// Set an RTP level transport which could be an RtpTransport without
	// encryption, an SrtpTransport for SDES or a DtlsSrtpTransport for DTLS-SRTP.
	// This can be called from any thread and it hops to the network thread
	// internally. It would replace the `SetTransports` and its variants.
	bool SetRtpTransport(webrtc::RtpTransportInternal* rtp_transport) override;

	webrtc::RtpTransportInternal* rtp_transport() const {
	RTC_DCHECK_RUN_ON(network_thread());
	return rtp_transport_;
	}

	// Channel control
	bool SetLocalContent(const MediaContentDescription* content,
	webrtc::SdpType type,
	std::string* error_desc) override;
	bool SetRemoteContent(const MediaContentDescription* content,
	webrtc::SdpType type,
	std::string* error_desc) override;
	// Controls whether this channel will receive packets on the basis of
	// matching payload type alone. This is needed for legacy endpoints that
	// don't signal SSRCs or use MID/RID, but doesn't make sense if there is
	// more than channel of specific media type, As that creates an ambiguity.
	//
	// This method will also remove any existing streams that were bound to this
	// channel on the basis of payload type, since one of these streams might
	// actually belong to a new channel. See: crbug.com/webrtc/11477
	bool SetPayloadTypeDemuxingEnabled(bool enabled) override;

	void Enable(bool enable) override;

	const std::vector<StreamParams>& local_streams() const override {
	return local_streams_;
	}
	const std::vector<StreamParams>& remote_streams() const override {
	return remote_streams_;
	}

	// Used for latency measurements.
	void SetFirstPacketReceivedCallback(std::function<void()> callback) override;

	// From RtpTransport - public for testing only
	void OnTransportReadyToSend(bool ready);

	// Only public for unit tests. Otherwise, consider protected.
	int SetOption(SocketType type, rtc::Socket::Option o, int val) override;

	// RtpPacketSinkInterface overrides.
	void OnRtpPacket(const webrtc::RtpPacketReceived& packet) override;

	MediaChannel* media_channel() const override {
	return media_channel_.get();
	}

	protected:
	bool was_ever_writable() const {
	RTC_DCHECK_RUN_ON(worker_thread());
	return was_ever_writable_;
	}
	void set_local_content_direction(webrtc::RtpTransceiverDirection direction) {
	RTC_DCHECK_RUN_ON(worker_thread());
	local_content_direction_ = direction;
	}
	void set_remote_content_direction(webrtc::RtpTransceiverDirection direction) {
	RTC_DCHECK_RUN_ON(worker_thread());
	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 RTC_RUN_ON(worker_thread());
	bool IsReadyToSendMedia_w() const RTC_RUN_ON(worker_thread());
	rtc::Thread* signaling_thread() const { return signaling_thread_; }

	// 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 RtpTransportInternal
	void OnWritableState(bool writable);

	void OnNetworkRouteChanged(absl::optional<rtc::NetworkRoute> network_route);

	bool SendPacket(bool rtcp,
	rtc::CopyOnWriteBuffer* packet,
	const rtc::PacketOptions& options);

	void EnableMedia_w() RTC_RUN_ON(worker_thread());
	void DisableMedia_w() RTC_RUN_ON(worker_thread());

	// 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() RTC_RUN_ON(network_thread());
	void ChannelWritable_n() RTC_RUN_ON(network_thread());
	void ChannelNotWritable_n() RTC_RUN_ON(network_thread());

	bool AddRecvStream_w(const StreamParams& sp) RTC_RUN_ON(worker_thread());
	bool RemoveRecvStream_w(uint32_t ssrc) RTC_RUN_ON(worker_thread());
	void ResetUnsignaledRecvStream_w() RTC_RUN_ON(worker_thread());
	bool SetPayloadTypeDemuxingEnabled_w(bool enabled)
	RTC_RUN_ON(worker_thread());
	bool AddSendStream_w(const StreamParams& sp) RTC_RUN_ON(worker_thread());
	bool RemoveSendStream_w(uint32_t ssrc) RTC_RUN_ON(worker_thread());

	// Should be called whenever the conditions for
	// IsReadyToReceiveMedia/IsReadyToSendMedia are satisfied (or unsatisfied).
	// Updates the send/recv state of the media channel.
	virtual void UpdateMediaSendRecvState_w() RTC_RUN_ON(worker_thread()) = 0;

	bool UpdateLocalStreams_w(const std::vector<StreamParams>& streams,
	webrtc::SdpType type,
	std::string* error_desc)
	RTC_RUN_ON(worker_thread());
	bool UpdateRemoteStreams_w(const std::vector<StreamParams>& streams,
	webrtc::SdpType type,
	std::string* error_desc)
	RTC_RUN_ON(worker_thread());
	virtual bool SetLocalContent_w(const MediaContentDescription* content,
	webrtc::SdpType type,
	std::string* error_desc)
	RTC_RUN_ON(worker_thread()) = 0;
	virtual bool SetRemoteContent_w(const MediaContentDescription* content,
	webrtc::SdpType type,
	std::string* error_desc)
	RTC_RUN_ON(worker_thread()) = 0;

	// Returns a list of RTP header extensions where any extension URI is unique.
	// Encrypted extensions will be either preferred or discarded, depending on
	// the current crypto_options_.
	RtpHeaderExtensions GetDeduplicatedRtpHeaderExtensions(
	const RtpHeaderExtensions& extensions);

	// Add `payload_type` to `demuxer_criteria_` if payload type demuxing is
	// enabled.
	void MaybeAddHandledPayloadType(int payload_type) RTC_RUN_ON(worker_thread());

	void ClearHandledPayloadTypes() RTC_RUN_ON(worker_thread());

	void UpdateRtpHeaderExtensionMap(
	const RtpHeaderExtensions& header_extensions);

	bool RegisterRtpDemuxerSink_w() RTC_RUN_ON(worker_thread());

	// Return description of media channel to facilitate logging
	std::string ToString() const;

	private:
	bool ConnectToRtpTransport() RTC_RUN_ON(network_thread());
	void DisconnectFromRtpTransport() RTC_RUN_ON(network_thread());
	void SignalSentPacket_n(const rtc::SentPacket& sent_packet);

	rtc::Thread* const worker_thread_;
	rtc::Thread* const network_thread_;
	rtc::Thread* const signaling_thread_;
	rtc::scoped_refptr<webrtc::PendingTaskSafetyFlag> alive_;

	const std::string content_name_;

	std::function<void()> on_first_packet_received_
	RTC_GUARDED_BY(network_thread());

	// Won't be set when using raw packet transports. SDP-specific thing.
	// TODO(bugs.webrtc.org/12230): Written on network thread, read on
	// worker thread (at least).
	// TODO(tommi): Remove this variable and instead use rtp_transport_ to
	// return the transport name. This variable is currently required for
	// "for_test" methods.
	std::string transport_name_;

	webrtc::RtpTransportInternal* rtp_transport_
	RTC_GUARDED_BY(network_thread()) = nullptr;

	std::vector<std::pair<rtc::Socket::Option, int> > socket_options_
	RTC_GUARDED_BY(network_thread());
	std::vector<std::pair<rtc::Socket::Option, int> > rtcp_socket_options_
	RTC_GUARDED_BY(network_thread());
	bool writable_ RTC_GUARDED_BY(network_thread()) = false;
	bool was_ever_writable_n_ RTC_GUARDED_BY(network_thread()) = false;
	bool was_ever_writable_ RTC_GUARDED_BY(worker_thread()) = false;
	const bool srtp_required_ = true;

	// TODO(tommi): This field shouldn't be necessary. It's a copy of
	// PeerConnection::GetCryptoOptions(), which is const state. It's also only
	// used to filter header extensions when calling
	// `rtp_transport_->UpdateRtpHeaderExtensionMap()` when the local/remote
	// content description is updated. Since the transport is actually owned
	// by the transport controller that also gets updated whenever the content
	// description changes, it seems we have two paths into the transports, along
	// with several thread hops via various classes (such as the Channel classes)
	// that only serve as additional layers and store duplicate state. The Jsep*
	// family of classes already apply session description updates on the network
	// thread every time it changes.
	// For the Channel classes, we should be able to get rid of:
	// * crypto_options (and fewer construction parameters)_
	// * UpdateRtpHeaderExtensionMap
	// * GetFilteredRtpHeaderExtensions
	// * Blocking thread hop to the network thread for every call to set
	// local/remote content is updated.
	const webrtc::CryptoOptions crypto_options_;

	// MediaChannel related members that should be accessed from the worker
	// thread.
	const std::unique_ptr<MediaChannel> media_channel_;
	// Currently the `enabled_` flag is accessed from the signaling thread as
	// well, but it can be changed only when signaling thread does a synchronous
	// call to the worker thread, so it should be safe.
	bool enabled_ RTC_GUARDED_BY(worker_thread()) = false;
	bool enabled_s_ RTC_GUARDED_BY(signaling_thread()) = false;
	bool payload_type_demuxing_enabled_ RTC_GUARDED_BY(worker_thread()) = true;
	std::vector<StreamParams> local_streams_ RTC_GUARDED_BY(worker_thread());
	std::vector<StreamParams> remote_streams_ RTC_GUARDED_BY(worker_thread());
	// TODO(bugs.webrtc.org/12230): local_content_direction and
	// remote_content_direction are set on the worker thread, but accessed on the
	// network thread.
	webrtc::RtpTransceiverDirection local_content_direction_ =
	webrtc::RtpTransceiverDirection::kInactive;
	webrtc::RtpTransceiverDirection remote_content_direction_ =
	webrtc::RtpTransceiverDirection::kInactive;

	// Cached list of payload types, used if payload type demuxing is re-enabled.
	std::set<uint8_t> payload_types_ RTC_GUARDED_BY(worker_thread());
	// TODO(bugs.webrtc.org/12239): Modified on worker thread, accessed
	// on network thread in RegisterRtpDemuxerSink_n (called from Init_w)
	webrtc::RtpDemuxerCriteria demuxer_criteria_;
	// Accessed on the worker thread, modified on the network thread from
	// RegisterRtpDemuxerSink_w's Invoke.
	webrtc::RtpDemuxerCriteria previous_demuxer_criteria_;
	// This generator is used to generate SSRCs for local streams.
	// This is needed in cases where SSRCs are not negotiated or set explicitly
	// like in Simulcast.
	// This object is not owned by the channel so it must outlive it.
	rtc::UniqueRandomIdGenerator* const ssrc_generator_;
	};

	// VoiceChannel is a specialization that adds support for early media, DTMF,
	// and input/output level monitoring.
	class VoiceChannel : public BaseChannel {
	public:
	VoiceChannel(rtc::Thread* worker_thread,
	rtc::Thread* network_thread,
	rtc::Thread* signaling_thread,
	std::unique_ptr<VoiceMediaChannel> channel,
	const std::string& content_name,
	bool srtp_required,
	webrtc::CryptoOptions crypto_options,
	rtc::UniqueRandomIdGenerator* ssrc_generator);
	~VoiceChannel();

	// downcasts a MediaChannel
	VoiceMediaChannel* media_channel() const override {
	return static_cast<VoiceMediaChannel*>(BaseChannel::media_channel());
	}

	cricket::MediaType media_type() const override {
	return cricket::MEDIA_TYPE_AUDIO;
	}

	private:
	// overrides from BaseChannel
	void UpdateMediaSendRecvState_w() override;
	bool SetLocalContent_w(const MediaContentDescription* content,
	webrtc::SdpType type,
	std::string* error_desc) override;
	bool SetRemoteContent_w(const MediaContentDescription* content,
	webrtc::SdpType type,
	std::string* error_desc) override;

	// Last AudioSendParameters sent down to the media_channel() via
	// SetSendParameters.
	AudioSendParameters last_send_params_;
	// Last AudioRecvParameters sent down to the media_channel() via
	// SetRecvParameters.
	AudioRecvParameters last_recv_params_;
	};

	// VideoChannel is a specialization for video.
	class VideoChannel : public BaseChannel {
	public:
	VideoChannel(rtc::Thread* worker_thread,
	rtc::Thread* network_thread,
	rtc::Thread* signaling_thread,
	std::unique_ptr<VideoMediaChannel> media_channel,
	const std::string& content_name,
	bool srtp_required,
	webrtc::CryptoOptions crypto_options,
	rtc::UniqueRandomIdGenerator* ssrc_generator);
	~VideoChannel();

	// downcasts a MediaChannel
	VideoMediaChannel* media_channel() const override {
	return static_cast<VideoMediaChannel*>(BaseChannel::media_channel());
	}

	void FillBitrateInfo(BandwidthEstimationInfo* bwe_info);

	cricket::MediaType media_type() const override {
	return cricket::MEDIA_TYPE_VIDEO;
	}

	private:
	// overrides from BaseChannel
	void UpdateMediaSendRecvState_w() override;
	bool SetLocalContent_w(const MediaContentDescription* content,
	webrtc::SdpType type,
	std::string* error_desc) override;
	bool SetRemoteContent_w(const MediaContentDescription* content,
	webrtc::SdpType type,
	std::string* error_desc) override;

	// Last VideoSendParameters sent down to the media_channel() via
	// SetSendParameters.
	VideoSendParameters last_send_params_;
	// Last VideoRecvParameters sent down to the media_channel() via
	// SetRecvParameters.
	VideoRecvParameters last_recv_params_;
	};

	} // namespace cricket

	#endif // PC_CHANNEL_H_