Revert of Refactoring of RTCP options in BaseChannel.

webrtc/pc/channel.cc

 /*
  *  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 145 matching lines @@
     RtpSendParameters<Codec>* send_params) {
   RtpParametersFromMediaDescription(desc, send_params);
   send_params->max_bandwidth_bps = desc->bandwidth();
 }
 
 BaseChannel::BaseChannel(rtc::Thread* worker_thread,
                          rtc::Thread* network_thread,
                          rtc::Thread* signaling_thread,
                          MediaChannel* media_channel,
                          const std::string& content_name,
-                         bool rtcp_mux_required,
+                         bool rtcp,
                          bool srtp_required)
     : worker_thread_(worker_thread),
       network_thread_(network_thread),
       signaling_thread_(signaling_thread),
       content_name_(content_name),
-      rtcp_mux_required_(rtcp_mux_required),
+      rtcp_enabled_(rtcp),
       srtp_required_(srtp_required),
       media_channel_(media_channel),
       selected_candidate_pair_(nullptr) {
   RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
   LOG(LS_INFO) << "Created channel for " << content_name;
 }
 
 BaseChannel::~BaseChannel() {
   TRACE_EVENT0("webrtc", "BaseChannel::~BaseChannel");
   RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
@@ skipping 50 matching lines @@
   if (!SetTransport_n(rtp_transport, rtcp_transport)) {
     return false;
   }
 
   if (!SetDtlsSrtpCryptoSuites_n(rtp_transport_, false)) {
     return false;
   }
   if (rtcp_transport_ && !SetDtlsSrtpCryptoSuites_n(rtcp_transport_, true)) {
     return false;
   }
-  if (rtcp_mux_required_) {
-    rtcp_mux_filter_.SetActive();
-  }
   return true;
 }
 
 void BaseChannel::Deinit() {
   RTC_DCHECK(worker_thread_->IsCurrent());
   media_channel_->SetInterface(NULL);
   // Packets arrive on the network thread, processing packets calls virtual
   // functions, so need to stop this process in Deinit that is called in
   // derived classes destructor.
   network_thread_->Invoke<void>(
@@ skipping 31 matching lines @@
   // When using DTLS-SRTP, we must reset the SrtpFilter every time the transport
   // changes and wait until the DTLS handshake is complete to set the newly
   // negotiated parameters.
   if (ShouldSetupDtlsSrtp_n()) {
     // Set |writable_| to false such that UpdateWritableState_w can set up
     // DTLS-SRTP when |writable_| becomes true again.
     writable_ = false;
     srtp_filter_.ResetParams();
   }
 
-  // If this BaseChannel doesn't require RTCP mux and we haven't fully
-  // negotiated RTCP mux, we need an RTCP transport.
+  // If this BaseChannel uses RTCP and we haven't fully negotiated RTCP mux,
+  // we need an RTCP channel.
   if (NeedsRtcpTransport()) {
     LOG(LS_INFO) << "Setting RTCP Transport for " << content_name() << " on "
                  << transport_name() << " transport " << rtcp_transport;
     SetTransportChannel_n(true, rtcp_transport);
     if (!rtcp_transport_) {
       return false;
     }
   }
 
   LOG(LS_INFO) << "Setting non-RTCP Transport for " << content_name() << " on "
@@ skipping 139 matching lines @@
     connection_monitor_.reset();
   }
 }
 
 bool BaseChannel::GetConnectionStats(ConnectionInfos* infos) {
   RTC_DCHECK(network_thread_->IsCurrent());
   return rtp_transport_->GetStats(infos);
 }
 
 bool BaseChannel::NeedsRtcpTransport() {
-  // If this BaseChannel doesn't require RTCP mux and we haven't fully
-  // negotiated RTCP mux, we need an RTCP transport.
-  return !rtcp_mux_required_ && !rtcp_mux_filter_.IsFullyActive();
+  return rtcp_enabled_ && !rtcp_mux_filter_.IsFullyActive();
 }
 
 bool BaseChannel::IsReadyToReceiveMedia_w() const {
   // Receive data if we are enabled and have local content,
   return enabled() && IsReceiveContentDirection(local_content_direction_);
 }
 
 bool BaseChannel::IsReadyToSendMedia_w() const {
   // Need to access some state updated on the network thread.
   return network_thread_->Invoke<bool>(
@@ skipping 684 matching lines @@
     default:
       break;
   }
   if (!ret) {
     SafeSetError("Failed to setup SRTP filter.", error_desc);
     return false;
   }
   return true;
 }
 
+void BaseChannel::ActivateRtcpMux() {
+  network_thread_->Invoke<void>(RTC_FROM_HERE,
+                                Bind(&BaseChannel::ActivateRtcpMux_n, this));
+}
+
+void BaseChannel::ActivateRtcpMux_n() {
+  if (!rtcp_mux_filter_.IsActive()) {
+    rtcp_mux_filter_.SetActive();
+    bool need_to_delete_rtcp = (rtcp_transport() != nullptr);
+    SetTransportChannel_n(true, nullptr);
+    if (need_to_delete_rtcp) {
+      SignalDestroyRtcpTransport(rtp_transport()->transport_name());
+    }
+    // Update aggregate writable/ready-to-send state between RTP and RTCP upon
+    // removing channel.
+    UpdateWritableState_n();
+    SetTransportChannelReadyToSend(true, false);
+  }
+}
+
 bool BaseChannel::SetRtcpMux_n(bool enable,
                                ContentAction action,
                                ContentSource src,
                                std::string* error_desc) {
   bool ret = false;
   switch (action) {
     case CA_OFFER:
       ret = rtcp_mux_filter_.SetOffer(enable, src);
       break;
     case CA_PRANSWER:
       // This may activate RTCP muxing, but we don't yet destroy the channel
       // because the final answer may deactivate it.
       ret = rtcp_mux_filter_.SetProvisionalAnswer(enable, src);
       break;
     case CA_ANSWER:
       ret = rtcp_mux_filter_.SetAnswer(enable, src);
       if (ret && rtcp_mux_filter_.IsActive()) {
         // We activated RTCP mux, close down the RTCP transport.
         LOG(LS_INFO) << "Enabling rtcp-mux for " << content_name()
                      << " by destroying RTCP transport channel for "
                      << transport_name();
-        if (rtcp_transport()) {
-          SetTransportChannel_n(true, nullptr);
-          SignalRtcpMuxFullyActive(rtp_transport()->transport_name());
+        bool need_to_delete_rtcp = (rtcp_transport() != nullptr);
+        SetTransportChannel_n(true, nullptr);
+        if (need_to_delete_rtcp) {
+          SignalDestroyRtcpTransport(rtp_transport()->transport_name());
         }
         UpdateWritableState_n();
         SetTransportChannelReadyToSend(true, false);
       }
       break;
     case CA_UPDATE:
       // No RTCP mux info.
       ret = true;
       break;
     default:
@@ skipping 240 matching lines @@
   RTC_DCHECK(worker_thread_->IsCurrent());
   SignalSentPacket(sent_packet);
 }
 
 VoiceChannel::VoiceChannel(rtc::Thread* worker_thread,
                            rtc::Thread* network_thread,
                            rtc::Thread* signaling_thread,
                            MediaEngineInterface* media_engine,
                            VoiceMediaChannel* media_channel,
                            const std::string& content_name,
-                           bool rtcp_mux_required,
+                           bool rtcp,
                            bool srtp_required)
     : BaseChannel(worker_thread,
                   network_thread,
                   signaling_thread,
                   media_channel,
                   content_name,
-                  rtcp_mux_required,
+                  rtcp,
                   srtp_required),
       media_engine_(media_engine),
       received_media_(false) {}
 
 VoiceChannel::~VoiceChannel() {
   TRACE_EVENT0("webrtc", "VoiceChannel::~VoiceChannel");
   StopAudioMonitor();
   StopMediaMonitor();
   // this can't be done in the base class, since it calls a virtual
   DisableMedia_w();
@@ skipping 385 matching lines @@
 void VoiceChannel::GetSrtpCryptoSuites_n(
     std::vector<int>* crypto_suites) const {
   GetSupportedAudioCryptoSuites(crypto_options(), crypto_suites);
 }
 
 VideoChannel::VideoChannel(rtc::Thread* worker_thread,
                            rtc::Thread* network_thread,
                            rtc::Thread* signaling_thread,
                            VideoMediaChannel* media_channel,
                            const std::string& content_name,
-                           bool rtcp_mux_required,
+                           bool rtcp,
                            bool srtp_required)
     : BaseChannel(worker_thread,
                   network_thread,
                   signaling_thread,
                   media_channel,
                   content_name,
-                  rtcp_mux_required,
+                  rtcp,
                   srtp_required) {}
 
 bool VideoChannel::Init_w(TransportChannel* rtp_transport,
                           TransportChannel* rtcp_transport) {
   return BaseChannel::Init_w(rtp_transport, rtcp_transport);
 }
 
 VideoChannel::~VideoChannel() {
   TRACE_EVENT0("webrtc", "VideoChannel::~VideoChannel");
   StopMediaMonitor();
@@ skipping 233 matching lines @@
 void VideoChannel::GetSrtpCryptoSuites_n(
     std::vector<int>* crypto_suites) const {
   GetSupportedVideoCryptoSuites(crypto_options(), crypto_suites);
 }
 
 RtpDataChannel::RtpDataChannel(rtc::Thread* worker_thread,
                                rtc::Thread* network_thread,
                                rtc::Thread* signaling_thread,
                                DataMediaChannel* media_channel,
                                const std::string& content_name,
-                               bool rtcp_mux_required,
+                               bool rtcp,
                                bool srtp_required)
     : BaseChannel(worker_thread,
                   network_thread,
                   signaling_thread,
                   media_channel,
                   content_name,
-                  rtcp_mux_required,
+                  rtcp,
                   srtp_required) {}
 
 RtpDataChannel::~RtpDataChannel() {
   TRACE_EVENT0("webrtc", "RtpDataChannel::~RtpDataChannel");
   StopMediaMonitor();
   // this can't be done in the base class, since it calls a virtual
   DisableMedia_w();
 
   Deinit();
 }
@@ skipping 239 matching lines @@
   signaling_thread()->Post(RTC_FROM_HERE, this, MSG_READYTOSENDDATA,
                            new DataChannelReadyToSendMessageData(writable));
 }
 
 void RtpDataChannel::GetSrtpCryptoSuites_n(
     std::vector<int>* crypto_suites) const {
   GetSupportedDataCryptoSuites(crypto_options(), crypto_suites);
 }
 
 }  // namespace cricket