Some cleanup in BaseChannel RTCP mux code.

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 151 matching lines @@
                          MediaChannel* media_channel,
                          TransportController* transport_controller,
                          const std::string& content_name,
                          bool rtcp)
     : worker_thread_(worker_thread),
       network_thread_(network_thread),
 
       content_name_(content_name),
 
       transport_controller_(transport_controller),
-      rtcp_transport_enabled_(rtcp),
-      transport_channel_(nullptr),
-      rtcp_transport_channel_(nullptr),
-      rtp_ready_to_send_(false),
-      rtcp_ready_to_send_(false),
-      writable_(false),
-      was_ever_writable_(false),
-      has_received_packet_(false),
-      dtls_keyed_(false),
-      secure_required_(false),
-      rtp_abs_sendtime_extn_id_(-1),
-
-      media_channel_(media_channel),
-      enabled_(false),
-      local_content_direction_(MD_INACTIVE),
-      remote_content_direction_(MD_INACTIVE) {
+      rtcp_enabled_(rtcp),
+      media_channel_(media_channel) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   if (transport_controller) {
     RTC_DCHECK_EQ(network_thread, transport_controller->network_thread());
   }
   LOG(LS_INFO) << "Created channel for " << content_name;
 }
 
 BaseChannel::~BaseChannel() {
   TRACE_EVENT0("webrtc", "BaseChannel::~BaseChannel");
   ASSERT(worker_thread_ == rtc::Thread::Current());
@@ skipping 63 matching lines @@
   RTC_DCHECK(network_thread_->IsCurrent());
   const std::string& transport_name =
       (bundle_transport_name ? *bundle_transport_name : content_name());
   if (!SetTransport_n(transport_name)) {
     return false;
   }
 
   if (!SetDtlsSrtpCryptoSuites_n(transport_channel_, false)) {
     return false;
   }
-  if (rtcp_transport_enabled() &&
+  if (rtcp_transport_channel_ &&
       !SetDtlsSrtpCryptoSuites_n(rtcp_transport_channel_, true)) {
     return false;
   }
   return true;
 }
 
 void BaseChannel::Deinit() {
   RTC_DCHECK(worker_thread_->IsCurrent());
   media_channel_->SetInterface(NULL);
   // Packets arrive on the network thread, processing packets calls virtual
@@ skipping 19 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 the writable_ becomes true again.
     writable_ = false;
     srtp_filter_.ResetParams();
   }
 
-  // TODO(guoweis): Remove this grossness when we remove non-muxed RTCP.
-  if (rtcp_transport_enabled()) {
+  // If this BaseChannel uses RTCP and we haven't fully negotiated RTCP mux,
+  // we need an RTCP channel.
+  if (rtcp_enabled_ && !rtcp_mux_filter_.IsFullyActive()) {
     LOG(LS_INFO) << "Create RTCP TransportChannel for " << content_name()
                  << " on " << transport_name << " transport ";
+    // TODO(deadbeef): Remove this grossness when we remove non-muxed RTCP.
     SetRtcpTransportChannel_n(
         transport_controller_->CreateTransportChannel_n(
             transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTCP),
         false /* update_writablity */);
     if (!rtcp_transport_channel_) {
       return false;
     }
   }
 
   // We're not updating the writablity during the transition state.
   SetTransportChannel_n(transport_controller_->CreateTransportChannel_n(
       transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP));
   if (!transport_channel_) {
     return false;
   }
 
-  // TODO(guoweis): Remove this grossness when we remove non-muxed RTCP.
-  if (rtcp_transport_enabled()) {
+  // TODO(deadbeef): Remove this grossness when we remove non-muxed RTCP.
+  if (rtcp_transport_channel_) {
     // We can only update the RTCP ready to send after set_transport_channel has
     // handled channel writability.
-    SetReadyToSend(
-        true, rtcp_transport_channel_ && rtcp_transport_channel_->writable());
+    SetReadyToSend(true, rtcp_transport_channel_->writable());
   }
   transport_name_ = transport_name;
   return true;
 }
 
 void BaseChannel::SetTransportChannel_n(TransportChannel* new_tc) {
   RTC_DCHECK(network_thread_->IsCurrent());
 
   TransportChannel* old_tc = transport_channel_;
   if (!old_tc && !new_tc) {
@@ skipping 854 matching lines @@
 
 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();
     SetRtcpTransportChannel_n(nullptr, true);
-    rtcp_transport_enabled_ = 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:
       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();
         SetRtcpTransportChannel_n(nullptr, true);
-        rtcp_transport_enabled_ = false;
       }
       break;
     case CA_UPDATE:
       // No RTCP mux info.
       ret = true;
       break;
     default:
       break;
   }
   if (!ret) {
@@ skipping 1188 matching lines @@
 }
 
 void DataChannel::OnStreamClosedRemotely(uint32_t sid) {
   rtc::TypedMessageData<uint32_t>* message =
       new rtc::TypedMessageData<uint32_t>(sid);
   signaling_thread()->Post(RTC_FROM_HERE, this, MSG_STREAMCLOSEDREMOTELY,
                            message);
 }
 
 }  // namespace cricket