More minor improvements to BaseChannel/transport 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 210 matching lines @@
   // Both RTP and RTCP channels are set, we can call SetInterface on
   // media channel and it can set network options.
   RTC_DCHECK(worker_thread_->IsCurrent());
   media_channel_->SetInterface(this);
   return true;
 }
 
 bool BaseChannel::InitNetwork_n(TransportChannel* rtp_transport,
                                 TransportChannel* rtcp_transport) {
   RTC_DCHECK(network_thread_->IsCurrent());
-  //  const std::string& transport_name =
-  //      (bundle_transport_name ? *bundle_transport_name : content_name());
-  if (!SetTransport_n(rtp_transport, rtcp_transport)) {
-    return false;
-  }
+  SetTransport_n(rtp_transport, rtcp_transport);
 
   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>(
       RTC_FROM_HERE, Bind(&BaseChannel::DisconnectTransportChannels_n, this));
 }
 
-bool BaseChannel::SetTransport(TransportChannel* rtp_transport,
+void BaseChannel::SetTransports(TransportChannel* rtp_transport,
                                TransportChannel* rtcp_transport) {
-  return network_thread_->Invoke<bool>(
+  network_thread_->Invoke<void>(
       RTC_FROM_HERE,
       Bind(&BaseChannel::SetTransport_n, this, rtp_transport, rtcp_transport));
 }
 
-bool BaseChannel::SetTransport_n(TransportChannel* rtp_transport,
+void BaseChannel::SetTransport_n(TransportChannel* rtp_transport,
                                  TransportChannel* rtcp_transport) {
   RTC_DCHECK(network_thread_->IsCurrent());
-  if (!rtp_transport && !rtcp_transport) {
-    LOG(LS_ERROR) << "Setting nullptr to RTP Transport and RTCP Transport.";
-    return false;
-  }
-
+  // Verify some assumptions (as described in the comment above SetTransport).
+  RTC_DCHECK(rtp_transport);
+  RTC_DCHECK(NeedsRtcpTransport() == (rtcp_transport != nullptr));
   if (rtcp_transport) {
     RTC_DCHECK(rtp_transport->transport_name() ==
                rtcp_transport->transport_name());
-    RTC_DCHECK(NeedsRtcpTransport());
   }
 
   if (rtp_transport->transport_name() == transport_name_) {
     // Nothing to do if transport name isn't changing.
-    return true;
+    return;
   }
 
   transport_name_ = rtp_transport->transport_name();
 
   // 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 (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;
-    }
+    RTC_DCHECK(rtcp_transport_);
   }
 
   LOG(LS_INFO) << "Setting non-RTCP Transport for " << content_name() << " on "
                << transport_name() << " transport " << rtp_transport;
   SetTransportChannel_n(false, rtp_transport);
-  if (!rtp_transport_) {
-    return false;
-  }
+  RTC_DCHECK(rtp_transport_);
 
   // Update aggregate writable/ready-to-send state between RTP and RTCP upon
   // setting new transport channels.
   UpdateWritableState_n();
   // We can only update ready-to-send after updating writability.
   //
   // On setting a new channel, assume it's ready to send if it's writable,
   // because we have no way of knowing otherwise (the channel doesn't give us
   // "was last send successful?").
   //
   // This won't always be accurate (the last SendPacket call from another
   // BaseChannel could have resulted in an error), but even so, we'll just
   // encounter the error again and update "ready to send" accordingly.
   SetTransportChannelReadyToSend(false,
                                  rtp_transport_ && rtp_transport_->writable());
   SetTransportChannelReadyToSend(
       true, rtcp_transport_ && rtcp_transport_->writable());
-  return true;
 }
 
 void BaseChannel::SetTransportChannel_n(bool rtcp,
                                         TransportChannel* new_transport) {
   RTC_DCHECK(network_thread_->IsCurrent());
   TransportChannel*& old_transport = rtcp ? rtcp_transport_ : rtp_transport_;
   if (!old_transport && !new_transport) {
     // Nothing to do.
     return;
   }
@@ skipping 2047 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