Added network thread to rtc::BaseChannel

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.
  */
 
 #ifndef WEBRTC_PC_CHANNEL_H_
 #define WEBRTC_PC_CHANNEL_H_
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "webrtc/audio_sink.h"
+#include "webrtc/base/asyncinvoker.h"
 #include "webrtc/base/asyncudpsocket.h"
 #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/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 {
 class AudioSinkInterface;
 }  // namespace webrtc
 
 namespace cricket {
 
 struct CryptoParams;
 class MediaContentDescription;
 
-enum SinkType {
-  SINK_PRE_CRYPTO,  // Sink packets before encryption or after decryption.
-  SINK_POST_CRYPTO  // Sink packets after encryption or before decryption.
-};
-
 // BaseChannel contains logic common to voice and video, including
-// enable, marshaling calls to a worker thread, and
+// 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 rtc::MessageHandler, public sigslot::has_slots<>,
       public MediaChannel::NetworkInterface,
       public ConnectionStatsGetter {
  public:
-  BaseChannel(rtc::Thread* thread,
+  BaseChannel(rtc::Thread* worker_thread,
+              rtc::Thread* network_thread,
               MediaChannel* channel,
               TransportController* transport_controller,
               const std::string& content_name,
               bool rtcp);
   virtual ~BaseChannel();
-  bool Init();
-  // Deinit may be called multiple times and is simply ignored if it's alreay
+  bool Init_w();
+  // 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_; }
   const std::string& transport_name() const { return transport_name_; }
-  TransportChannel* transport_channel() const {
-    return transport_channel_;
-  }
-  TransportChannel* rtcp_transport_channel() const {
-    return rtcp_transport_channel_;
-  }
   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_; }
   // This function returns true if we require secure channel for call setup.
   bool secure_required() const { return secure_required_; }
@@ skipping 37 matching lines @@
   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> SignalDtlsSetupFailure;
-  void SignalDtlsSetupFailure_w(bool rtcp);
+  void SignalDtlsSetupFailure_n(bool rtcp);
   void SignalDtlsSetupFailure_s(bool rtcp);
 
   // Used for latency measurements.
   sigslot::signal1<BaseChannel*> SignalFirstPacketReceived;
 
+  // Forward TransportChannel SignalSentPacket to worker thread.
+  sigslot::signal1<const rtc::SentPacket&> SignalSentPacket;
+
+  // Only public for unit tests.  Otherwise, consider private.
+  TransportChannel* transport_channel() const { return transport_channel_; }
+  TransportChannel* rtcp_transport_channel() const {
+    return rtcp_transport_channel_;
+  }
+
   // Made public for easier testing.
   void SetReadyToSend(bool rtcp, bool ready);
 
   // Only public for unit tests.  Otherwise, consider protected.
   int SetOption(SocketType type, rtc::Socket::Option o, int val)
       override;
+  int SetOption_n(SocketType type, rtc::Socket::Option o, int val);
 
   SrtpFilter* srtp_filter() { return &srtp_filter_; }
 
  protected:
   virtual MediaChannel* media_channel() const { return media_channel_; }
   // Sets the |transport_channel_| (and |rtcp_transport_channel_|, if |rtcp_| is
   // true). Gets the transport channels from |transport_controller_|.
-  bool SetTransport_w(const std::string& transport_name);
+  bool SetTransport_n(const std::string& transport_name);
 
-  void set_transport_channel(TransportChannel* transport);
-  void set_rtcp_transport_channel(TransportChannel* transport,
-                                  bool update_writablity);
+  void SetTransportChannel_n(TransportChannel* transport);
+  void SetRtcpTransportChannel_n(TransportChannel* transport,
+                                 bool update_writablity);
 
   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;
   }
   void set_secure_required(bool secure_required) {
     secure_required_ = secure_required;
   }
-  bool IsReadyToReceive() const;
-  bool IsReadyToSend() const;
+  bool IsReadyToReceive_w() const;
+  bool IsReadyToSend_w() const;
   rtc::Thread* signaling_thread() {
     return transport_controller_->signaling_thread();
   }
   bool rtcp_transport_enabled() const { return rtcp_transport_enabled_; }
 
   void ConnectToTransportChannel(TransportChannel* tc);
   void DisconnectFromTransportChannel(TransportChannel* tc);
 
-  void FlushRtcpMessages();
+  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 OnDtlsState(TransportChannel* channel, DtlsTransportState state);
 
   void OnSelectedCandidatePairChanged(
       TransportChannel* channel,
       CandidatePairInterface* selected_candidate_pair,
       int last_sent_packet_id);
 
   bool PacketIsRtcp(const TransportChannel* channel, 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,
+                        const rtc::PacketTime& packet_time);
 
   void EnableMedia_w();
   void DisableMedia_w();
-  void UpdateWritableState_w();
-  void ChannelWritable_w();
-  void ChannelNotWritable_w();
+  void UpdateWritableState_n();
+  void ChannelWritable_n();
+  void ChannelNotWritable_n();
   bool AddRecvStream_w(const StreamParams& sp);
   bool RemoveRecvStream_w(uint32_t ssrc);
   bool AddSendStream_w(const StreamParams& sp);
   bool RemoveSendStream_w(uint32_t ssrc);
-  virtual bool ShouldSetupDtlsSrtp() const;
+  virtual bool ShouldSetupDtlsSrtp_n() const;
   // Do the DTLS key expansion and impose it on the SRTP/SRTCP filters.
   // |rtcp_channel| indicates whether to set up the RTP or RTCP filter.
-  bool SetupDtlsSrtp(bool rtcp_channel);
-  void MaybeSetupDtlsSrtp_w();
+  bool SetupDtlsSrtp_n(bool rtcp_channel);
+  void MaybeSetupDtlsSrtp_n();
   // Set the DTLS-SRTP cipher policy on this channel as appropriate.
-  bool SetDtlsSrtpCryptoSuites(TransportChannel* tc, bool rtcp);
+  bool SetDtlsSrtpCryptoSuites_n(TransportChannel* tc, bool rtcp);
 
-  virtual void ChangeState() = 0;
+  void ChangeState();
+  virtual void ChangeState_w() = 0;
 
   // Gets the content info appropriate to the channel (audio or video).
   virtual const ContentInfo* GetFirstContent(
       const SessionDescription* sdesc) = 0;
   bool UpdateLocalStreams_w(const std::vector<StreamParams>& streams,
                             ContentAction action,
                             std::string* error_desc);
   bool UpdateRemoteStreams_w(const std::vector<StreamParams>& streams,
                              ContentAction action,
                              std::string* error_desc);
   virtual bool SetLocalContent_w(const MediaContentDescription* content,
                                  ContentAction action,
                                  std::string* error_desc) = 0;
   virtual bool SetRemoteContent_w(const MediaContentDescription* content,
                                   ContentAction action,
                                   std::string* error_desc) = 0;
-  bool SetRtpTransportParameters_w(const MediaContentDescription* content,
+  bool SetRtpTransportParameters(const MediaContentDescription* content,
+                                 ContentAction action,
+                                 ContentSource src,
+                                 std::string* error_desc);
+  bool SetRtpTransportParameters_n(const MediaContentDescription* content,
                                    ContentAction action,
                                    ContentSource src,
                                    std::string* error_desc);
 
   // Helper method to get RTP Absoulute SendTime extension header id if
   // present in remote supported extensions list.
-  void MaybeCacheRtpAbsSendTimeHeaderExtension(
+  void MaybeCacheRtpAbsSendTimeHeaderExtension_w(
       const std::vector<RtpHeaderExtension>& extensions);
 
-  bool CheckSrtpConfig(const std::vector<CryptoParams>& cryptos,
-                       bool* dtls,
-                       std::string* error_desc);
-  bool SetSrtp_w(const std::vector<CryptoParams>& params,
+  bool CheckSrtpConfig_n(const std::vector<CryptoParams>& cryptos,
+                         bool* dtls,
+                         std::string* error_desc);
+  bool SetSrtp_n(const std::vector<CryptoParams>& params,
                  ContentAction action,
                  ContentSource src,
                  std::string* error_desc);
-  void ActivateRtcpMux_w();
-  bool SetRtcpMux_w(bool enable,
+  void ActivateRtcpMux_n();
+  bool SetRtcpMux_n(bool enable,
                     ContentAction action,
                     ContentSource src,
                     std::string* error_desc);
 
   // From MessageHandler
   void OnMessage(rtc::Message* pmsg) override;
 
   // Handled in derived classes
   // Get the SRTP crypto suites to use for RTP media
-  virtual void GetSrtpCryptoSuites(std::vector<int>* crypto_suites) const = 0;
+  virtual void GetSrtpCryptoSuites_n(std::vector<int>* crypto_suites) const = 0;
   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 FunctorT& functor) {
     return worker_thread_->Invoke<bool>(functor);
   }
 
  private:
-  rtc::Thread* worker_thread_;
-  TransportController* transport_controller_;
-  MediaChannel* media_channel_;
-  std::vector<StreamParams> local_streams_;
-  std::vector<StreamParams> remote_streams_;
+  bool InitNetwork_n();
+  void DeinitNetwork_n();
+  void SignalSentPacket_n(TransportChannel* channel,
+                          const rtc::SentPacket& sent_packet);
+  void SignalSentPacket_w(const rtc::SentPacket& sent_packet);
+  bool IsTransportReadyToSend_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_;
   bool rtcp_transport_enabled_;
   TransportChannel* transport_channel_;
   std::vector<std::pair<rtc::Socket::Option, int> > socket_options_;
   TransportChannel* rtcp_transport_channel_;
   std::vector<std::pair<rtc::Socket::Option, int> > rtcp_socket_options_;
   SrtpFilter srtp_filter_;
   RtcpMuxFilter rtcp_mux_filter_;
   BundleFilter bundle_filter_;
-  std::unique_ptr<ConnectionMonitor> connection_monitor_;
-  bool enabled_;
-  bool writable_;
   bool rtp_ready_to_send_;
   bool rtcp_ready_to_send_;
+  bool writable_;
   bool was_ever_writable_;
-  MediaContentDirection local_content_direction_;
-  MediaContentDirection remote_content_direction_;
   bool has_received_packet_;
   bool dtls_keyed_;
   bool secure_required_;
   int rtp_abs_sendtime_extn_id_;
+
+  // MediaChannel related members that should be access from worker thread.
+  MediaChannel* const media_channel_;
+  // Currently enabled_ flag accessed from signaling thread too, but it can
+  // be changed only when signaling thread does sunchronious call to worker
+  // thread, so it should be safe.
+  bool enabled_;
+  std::vector<StreamParams> local_streams_;
+  std::vector<StreamParams> remote_streams_;
+  MediaContentDirection local_content_direction_;
+  MediaContentDirection remote_content_direction_;
 };
 
 // VoiceChannel is a specialization that adds support for early media, DTMF,
 // and input/output level monitoring.
 class VoiceChannel : public BaseChannel {
  public:
-  VoiceChannel(rtc::Thread* thread,
+  VoiceChannel(rtc::Thread* worker_thread,
+               rtc::Thread* network_thread,
                MediaEngineInterface* media_engine,
                VoiceMediaChannel* channel,
                TransportController* transport_controller,
                const std::string& content_name,
                bool rtcp);
   ~VoiceChannel();
-  bool Init();
+  bool Init_w();
 
   // Configure sending media on the stream with SSRC |ssrc|
   // If there is only one sending stream SSRC 0 can be used.
   bool SetAudioSend(uint32_t ssrc,
                     bool enable,
                     const AudioOptions* options,
                     AudioSource* source);
 
   // downcasts a MediaChannel
-  virtual VoiceMediaChannel* media_channel() const {
+  VoiceMediaChannel* media_channel() const override {
     return static_cast<VoiceMediaChannel*>(BaseChannel::media_channel());
   }
 
   void SetEarlyMedia(bool enable);
   // This signal is emitted when we have gone a period of time without
   // receiving early media. When received, a UI should start playing its
   // own ringing sound
   sigslot::signal1<VoiceChannel*> SignalEarlyMediaTimeout;
 
   // Returns if the telephone-event has been negotiated.
@@ skipping 27 matching lines @@
   sigslot::signal2<VoiceChannel*, const AudioInfo&> SignalAudioMonitor;
 
   int GetInputLevel_w();
   int GetOutputLevel_w();
   void GetActiveStreams_w(AudioInfo::StreamList* actives);
   webrtc::RtpParameters GetRtpParameters_w(uint32_t ssrc) const;
   bool SetRtpParameters_w(uint32_t ssrc, webrtc::RtpParameters parameters);
 
  private:
   // overrides from BaseChannel
-  virtual void OnChannelRead(TransportChannel* channel,
-                             const char* data, size_t len,
-                             const rtc::PacketTime& packet_time,
-                             int flags);
-  virtual void ChangeState();
-  virtual const ContentInfo* GetFirstContent(const SessionDescription* sdesc);
-  virtual bool SetLocalContent_w(const MediaContentDescription* content,
-                                 ContentAction action,
-                                 std::string* error_desc);
-  virtual bool SetRemoteContent_w(const MediaContentDescription* content,
-                                  ContentAction action,
-                                  std::string* error_desc);
+  void OnChannelRead(TransportChannel* channel,
+                     const char* data,
+                     size_t len,
+                     const rtc::PacketTime& packet_time,
+                     int flags) override;
+  void ChangeState_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);
   bool SetOutputVolume_w(uint32_t ssrc, double volume);
   bool GetStats_w(VoiceMediaInfo* stats);
 
-  virtual void OnMessage(rtc::Message* pmsg);
-  virtual void GetSrtpCryptoSuites(std::vector<int>* crypto_suites) const;
-  virtual void OnConnectionMonitorUpdate(
-      ConnectionMonitor* monitor, const std::vector<ConnectionInfo>& infos);
-  virtual void OnMediaMonitorUpdate(
-      VoiceMediaChannel* media_channel, const VoiceMediaInfo& info);
+  void OnMessage(rtc::Message* pmsg) override;
+  void GetSrtpCryptoSuites_n(std::vector<int>* crypto_suites) const override;
+  void OnConnectionMonitorUpdate(
+      ConnectionMonitor* monitor,
+      const std::vector<ConnectionInfo>& infos) override;
+  void OnMediaMonitorUpdate(VoiceMediaChannel* media_channel,
+                            const VoiceMediaInfo& info);
   void OnAudioMonitorUpdate(AudioMonitor* monitor, const AudioInfo& info);
 
   static const int kEarlyMediaTimeout = 1000;
   MediaEngineInterface* media_engine_;
   bool received_media_;
   std::unique_ptr<VoiceMediaMonitor> media_monitor_;
   std::unique_ptr<AudioMonitor> audio_monitor_;
 
   // 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* thread,
+  VideoChannel(rtc::Thread* worker_thread,
+               rtc::Thread* netwokr_thread,
                VideoMediaChannel* channel,
                TransportController* transport_controller,
                const std::string& content_name,
                bool rtcp);
   ~VideoChannel();
-  bool Init();
+  bool Init_w();
 
   // downcasts a MediaChannel
-  virtual VideoMediaChannel* media_channel() const {
+  VideoMediaChannel* media_channel() const override {
     return static_cast<VideoMediaChannel*>(BaseChannel::media_channel());
   }
 
   bool SetSink(uint32_t ssrc, rtc::VideoSinkInterface<VideoFrame>* sink);
   // Register a source. The |ssrc| must correspond to a registered
   // send stream.
   void SetSource(uint32_t ssrc,
                  rtc::VideoSourceInterface<cricket::VideoFrame>* source);
   // Get statistics about the current media session.
   bool GetStats(VideoMediaInfo* stats);
 
   sigslot::signal2<VideoChannel*, const std::vector<ConnectionInfo>&>
       SignalConnectionMonitor;
 
   void StartMediaMonitor(int cms);
   void StopMediaMonitor();
   sigslot::signal2<VideoChannel*, const VideoMediaInfo&> SignalMediaMonitor;
 
   bool SetVideoSend(uint32_t ssrc, bool enable, const VideoOptions* options);
   webrtc::RtpParameters GetRtpParameters(uint32_t ssrc) const;
   bool SetRtpParameters(uint32_t ssrc, const webrtc::RtpParameters& parameters);
 
  private:
   // overrides from BaseChannel
-  virtual void ChangeState();
-  virtual const ContentInfo* GetFirstContent(const SessionDescription* sdesc);
-  virtual bool SetLocalContent_w(const MediaContentDescription* content,
-                                 ContentAction action,
-                                 std::string* error_desc);
-  virtual bool SetRemoteContent_w(const MediaContentDescription* content,
-                                  ContentAction action,
-                                  std::string* error_desc);
+  void ChangeState_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;
   bool GetStats_w(VideoMediaInfo* stats);
   webrtc::RtpParameters GetRtpParameters_w(uint32_t ssrc) const;
   bool SetRtpParameters_w(uint32_t ssrc, webrtc::RtpParameters parameters);
 
-  virtual void OnMessage(rtc::Message* pmsg);
-  virtual void GetSrtpCryptoSuites(std::vector<int>* crypto_suites) const;
-  virtual void OnConnectionMonitorUpdate(
-      ConnectionMonitor* monitor, const std::vector<ConnectionInfo>& infos);
-  virtual void OnMediaMonitorUpdate(
-      VideoMediaChannel* media_channel, const VideoMediaInfo& info);
+  void OnMessage(rtc::Message* pmsg) override;
+  void GetSrtpCryptoSuites_n(std::vector<int>* crypto_suites) const override;
+  void OnConnectionMonitorUpdate(
+      ConnectionMonitor* monitor,
+      const std::vector<ConnectionInfo>& infos) override;
+  void OnMediaMonitorUpdate(VideoMediaChannel* media_channel,
+                            const VideoMediaInfo& info);
 
   std::unique_ptr<VideoMediaMonitor> media_monitor_;
 
   // 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_;
 };
 
 // DataChannel is a specialization for data.
 class DataChannel : public BaseChannel {
  public:
-  DataChannel(rtc::Thread* thread,
+  DataChannel(rtc::Thread* worker_thread,
+              rtc::Thread* network_thread,
               DataMediaChannel* media_channel,
               TransportController* transport_controller,
               const std::string& content_name,
               bool rtcp);
   ~DataChannel();
-  bool Init();
+  bool Init_w();
 
   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 {
     return ready_to_send_data_;
   }
 
   sigslot::signal2<DataChannel*, const DataMediaInfo&> SignalMediaMonitor;
   sigslot::signal2<DataChannel*, const std::vector<ConnectionInfo>&>
       SignalConnectionMonitor;
   sigslot::signal3<DataChannel*, const ReceiveDataParams&,
       const rtc::CopyOnWriteBuffer&> SignalDataReceived;
   // Signal for notifying when the channel becomes ready to send data.
   // That occurs when the channel is enabled, the transport is writable,
   // both local and remote descriptions are set, and the channel is unblocked.
   sigslot::signal1<bool> SignalReadyToSendData;
   // Signal for notifying that the remote side has closed the DataChannel.
   sigslot::signal1<uint32_t> SignalStreamClosedRemotely;
 
  protected:
   // downcasts a MediaChannel.
-  virtual DataMediaChannel* media_channel() const {
+  DataMediaChannel* media_channel() const override {
     return static_cast<DataMediaChannel*>(BaseChannel::media_channel());
   }
 
  private:
   struct SendDataMessageData : public rtc::MessageData {
     SendDataMessageData(const SendDataParams& params,
                         const rtc::CopyOnWriteBuffer* payload,
                         SendDataResult* result)
         : params(params),
           payload(payload),
@@ skipping 16 matching lines @@
         : params(params),
           payload(data, len) {
     }
     const ReceiveDataParams params;
     const rtc::CopyOnWriteBuffer payload;
   };
 
   typedef rtc::TypedMessageData<bool> DataChannelReadyToSendMessageData;
 
   // overrides from BaseChannel
-  virtual const ContentInfo* GetFirstContent(const SessionDescription* sdesc);
+  const ContentInfo* GetFirstContent(const SessionDescription* sdesc) override;
   // If data_channel_type_ is DCT_NONE, set it.  Otherwise, check that
   // it's the same as what was set previously.  Returns false if it's
   // set to one type one type and changed to another type later.
   bool SetDataChannelType(DataChannelType new_data_channel_type,
                           std::string* error_desc);
   // Same as SetDataChannelType, but extracts the type from the
   // DataContentDescription.
   bool SetDataChannelTypeFromContent(const DataContentDescription* content,
                                      std::string* error_desc);
-  virtual bool SetLocalContent_w(const MediaContentDescription* content,
-                                 ContentAction action,
-                                 std::string* error_desc);
-  virtual bool SetRemoteContent_w(const MediaContentDescription* content,
-                                  ContentAction action,
-                                  std::string* error_desc);
-  virtual void ChangeState();
-  virtual bool WantsPacket(bool rtcp, const rtc::CopyOnWriteBuffer* packet);
+  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 ChangeState_w() override;
+  bool WantsPacket(bool rtcp, const rtc::CopyOnWriteBuffer* packet) override;
 
-  virtual void OnMessage(rtc::Message* pmsg);
-  virtual void GetSrtpCryptoSuites(std::vector<int>* crypto_suites) const;
-  virtual void OnConnectionMonitorUpdate(
-      ConnectionMonitor* monitor, const std::vector<ConnectionInfo>& infos);
-  virtual void OnMediaMonitorUpdate(
-      DataMediaChannel* media_channel, const DataMediaInfo& info);
-  virtual bool ShouldSetupDtlsSrtp() const;
+  void OnMessage(rtc::Message* pmsg) override;
+  void GetSrtpCryptoSuites_n(std::vector<int>* crypto_suites) const override;
+  void OnConnectionMonitorUpdate(
+      ConnectionMonitor* monitor,
+      const std::vector<ConnectionInfo>& infos) override;
+  void OnMediaMonitorUpdate(DataMediaChannel* media_channel,
+                            const DataMediaInfo& info);
+  bool ShouldSetupDtlsSrtp_n() const override;
   void OnDataReceived(
       const ReceiveDataParams& params, const char* data, size_t len);
   void OnDataChannelError(uint32_t ssrc, DataMediaChannel::Error error);
   void OnDataChannelReadyToSend(bool writable);
   void OnStreamClosedRemotely(uint32_t sid);
 
   std::unique_ptr<DataMediaMonitor> media_monitor_;
   // TODO(pthatcher): Make a separate SctpDataChannel and
   // RtpDataChannel instead of using this.
   DataChannelType data_channel_type_;
   bool ready_to_send_data_;
 
   // Last DataSendParameters sent down to the media_channel() via
   // 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_