Revert of Refactoring of RTCP options in 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.
  */
 
@@ skipping 65 matching lines @@
       public ConnectionStatsGetter {
  public:
   // |rtcp| represents whether or not this channel uses RTCP.
   // 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).
   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 rtcp,
               bool srtp_required);
   virtual ~BaseChannel();
   bool Init_w(TransportChannel* rtp_transport,
               TransportChannel* rtcp_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_; }
   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_; }
 
+  // Activate RTCP mux, regardless of the state so far.  Once
+  // activated, it can not be deactivated, and if the remote
+  // description doesn't support RTCP mux, setting the remote
+  // description will fail.
+  void ActivateRtcpMux();
   bool SetTransport(TransportChannel* rtp_transport,
                     TransportChannel* rtcp_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,
@@ skipping 29 matching lines @@
   sigslot::signal2<BaseChannel*, bool> SignalDtlsSrtpSetupFailure;
   void SignalDtlsSrtpSetupFailure_n(bool rtcp);
   void SignalDtlsSrtpSetupFailure_s(bool rtcp);
 
   // Used for latency measurements.
   sigslot::signal1<BaseChannel*> SignalFirstPacketReceived;
 
   // Forward TransportChannel SignalSentPacket to worker thread.
   sigslot::signal1<const rtc::SentPacket&> SignalSentPacket;
 
-  // Emitted whenever rtcp-mux is fully negotiated and the rtcp-transport can
-  // be destroyed.
-  // Fired on the network thread.
-  sigslot::signal1<const std::string&> SignalRtcpMuxFullyActive;
+  // Emitted whenever the rtcp-mux is active and the rtcp-transport can be
+  // destroyed.
+  sigslot::signal1<const std::string&> SignalDestroyRtcpTransport;
 
   TransportChannel* rtp_transport() const { return rtp_transport_; }
   TransportChannel* rtcp_transport() const { return rtcp_transport_; }
 
   bool NeedsRtcpTransport();
 
   // Made public for easier testing.
   //
   // Updates "ready to send" for an individual channel, and informs the media
   // channel that the transport is ready to send if each channel (in use) is
@@ skipping 151 matching lines @@
   void MaybeCacheRtpAbsSendTimeHeaderExtension_w(
       const std::vector<webrtc::RtpExtension>& extensions);
 
   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_n();
   bool SetRtcpMux_n(bool enable,
                     ContentAction action,
                     ContentSource src,
                     std::string* error_desc);
 
   // From MessageHandler
   void OnMessage(rtc::Message* pmsg) override;
 
   const rtc::CryptoOptions& crypto_options() const {
     return crypto_options_;
@@ skipping 26 matching lines @@
 
   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_;
 
   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_;
+  // 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* rtp_transport_ = nullptr;
   std::vector<std::pair<rtc::Socket::Option, int> > socket_options_;
   TransportChannel* rtcp_transport_ = 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;
@@ skipping 22 matching lines @@
 // 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,
                MediaEngineInterface* media_engine,
                VoiceMediaChannel* channel,
                const std::string& content_name,
-               bool rtcp_mux_required,
+               bool rtcp,
                bool srtp_required);
   ~VoiceChannel();
   bool Init_w(TransportChannel* rtp_transport,
               TransportChannel* rtcp_transport);
 
   // 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,
@@ skipping 98 matching lines @@
 };
 
 // VideoChannel is a specialization for video.
 class VideoChannel : public BaseChannel {
  public:
   VideoChannel(rtc::Thread* worker_thread,
                rtc::Thread* network_thread,
                rtc::Thread* signaling_thread,
                VideoMediaChannel* channel,
                const std::string& content_name,
-               bool rtcp_mux_required,
+               bool rtcp,
                bool srtp_required);
   ~VideoChannel();
   bool Init_w(TransportChannel* rtp_transport,
               TransportChannel* rtcp_transport);
 
   // downcasts a MediaChannel
   VideoMediaChannel* media_channel() const override {
     return static_cast<VideoMediaChannel*>(BaseChannel::media_channel());
   }
 
@@ skipping 59 matching lines @@
 };
 
 // RtpDataChannel is a specialization for data.
 class RtpDataChannel : public BaseChannel {
  public:
   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 rtcp,
                  bool srtp_required);
   ~RtpDataChannel();
   bool Init_w(TransportChannel* rtp_transport,
               TransportChannel* rtcp_transport);
 
   virtual bool SendData(const SendDataParams& params,
                         const rtc::CopyOnWriteBuffer& payload,
                         SendDataResult* result);
 
   void StartMediaMonitor(int cms);
@@ skipping 86 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_