Adding ability for BaseChannel to use PacketTransportInterface.

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 180 matching lines @@
   LOG(LS_INFO) << "Destroyed channel: " << content_name_;
 }
 
 void BaseChannel::DisconnectTransportChannels_n() {
   // Send any outstanding RTCP packets.
   FlushRtcpMessages_n();
 
   // Stop signals from transport channels, but keep them alive because
   // media_channel may use them from a different thread.
   if (rtp_dtls_transport_) {
-    DisconnectFromTransport(rtp_dtls_transport_);
+    DisconnectFromDtlsTransport(rtp_dtls_transport_);
+  } else if (rtp_packet_transport_) {
+    DisconnectFromPacketTransport(rtp_packet_transport_);
   }
   if (rtcp_dtls_transport_) {
-    DisconnectFromTransport(rtcp_dtls_transport_);
+    DisconnectFromDtlsTransport(rtcp_dtls_transport_);
+  } else if (rtcp_packet_transport_) {
+    DisconnectFromPacketTransport(rtcp_packet_transport_);
   }
 
   // Clear pending read packets/messages.
   network_thread_->Clear(&invoker_);
   network_thread_->Clear(this);
 }
 
 bool BaseChannel::Init_w(DtlsTransportInternal* rtp_dtls_transport,
-                         DtlsTransportInternal* rtcp_dtls_transport) {
+                         DtlsTransportInternal* rtcp_dtls_transport,
+                         rtc::PacketTransportInterface* rtp_packet_transport,
+                         rtc::PacketTransportInterface* rtcp_packet_transport) {
   if (!network_thread_->Invoke<bool>(
           RTC_FROM_HERE, Bind(&BaseChannel::InitNetwork_n, this,
-                              rtp_dtls_transport, rtcp_dtls_transport))) {
+                              rtp_dtls_transport, rtcp_dtls_transport,
+                              rtp_packet_transport, rtcp_packet_transport))) {
     return false;
   }
-
-  // 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());
+  // Both RTP and RTCP channels should be set, we can call SetInterface on
+  // the media channel and it can set network options.
+  RTC_DCHECK_RUN_ON(worker_thread_);
   media_channel_->SetInterface(this);
   return true;
 }
 
-bool BaseChannel::InitNetwork_n(DtlsTransportInternal* rtp_dtls_transport,
-                                DtlsTransportInternal* rtcp_dtls_transport) {
+bool BaseChannel::InitNetwork_n(
+    DtlsTransportInternal* rtp_dtls_transport,
+    DtlsTransportInternal* rtcp_dtls_transport,
+    rtc::PacketTransportInterface* rtp_packet_transport,
+    rtc::PacketTransportInterface* rtcp_packet_transport) {
   RTC_DCHECK(network_thread_->IsCurrent());
-  SetTransports_n(rtp_dtls_transport, rtcp_dtls_transport);
+  SetTransports_n(rtp_dtls_transport, rtcp_dtls_transport, rtp_packet_transport,
+                  rtcp_packet_transport);
 
-  if (!SetDtlsSrtpCryptoSuites_n(rtp_dtls_transport_, false)) {
+  if (rtp_dtls_transport_ &&
+      !SetDtlsSrtpCryptoSuites_n(rtp_dtls_transport_, false)) {
     return false;
   }
   if (rtcp_dtls_transport_ &&
       !SetDtlsSrtpCryptoSuites_n(rtcp_dtls_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));
 }
 
 void BaseChannel::SetTransports(DtlsTransportInternal* rtp_dtls_transport,
                                 DtlsTransportInternal* rtcp_dtls_transport) {
-  network_thread_->Invoke<void>(RTC_FROM_HERE,
-                                Bind(&BaseChannel::SetTransports_n, this,
-                                     rtp_dtls_transport, rtcp_dtls_transport));
+  network_thread_->Invoke<void>(
+      RTC_FROM_HERE,
+      Bind(&BaseChannel::SetTransports_n, this, rtp_dtls_transport,
+           rtcp_dtls_transport, rtp_dtls_transport, rtcp_dtls_transport));
 }
 
-void BaseChannel::SetTransports_n(DtlsTransportInternal* rtp_dtls_transport,
-                                  DtlsTransportInternal* rtcp_dtls_transport) {
+void BaseChannel::SetTransports(
+    rtc::PacketTransportInterface* rtp_packet_transport,
+    rtc::PacketTransportInterface* rtcp_packet_transport) {
+  network_thread_->Invoke<void>(
+      RTC_FROM_HERE, Bind(&BaseChannel::SetTransports_n, this, nullptr, nullptr,
+                          rtp_packet_transport, rtcp_packet_transport));
+}
+
+void BaseChannel::SetTransports_n(
+    DtlsTransportInternal* rtp_dtls_transport,
+    DtlsTransportInternal* rtcp_dtls_transport,
+    rtc::PacketTransportInterface* rtp_packet_transport,
+    rtc::PacketTransportInterface* rtcp_packet_transport) {
   RTC_DCHECK(network_thread_->IsCurrent());
-  if (!rtp_dtls_transport && !rtcp_dtls_transport) {
-    LOG(LS_ERROR) << "Setting nullptr to RTP Transport and RTCP Transport.";
-    return;
+  // Validate some assertions about the input.
+  RTC_DCHECK(rtp_packet_transport);
+  RTC_DCHECK_EQ(NeedsRtcpTransport(), rtcp_packet_transport != nullptr);
+  if (rtp_dtls_transport || rtcp_dtls_transport) {
+    // DTLS/non-DTLS pointers should be to the same object.
+    RTC_DCHECK(rtp_dtls_transport == rtp_packet_transport);
+    RTC_DCHECK(rtcp_dtls_transport == rtcp_packet_transport);
+    // Can't go from non-DTLS to DTLS.
+    RTC_DCHECK(!rtp_packet_transport_ || rtp_dtls_transport_);
+  } else {
+    // Can't go from DTLS to non-DTLS.
+    RTC_DCHECK(!rtp_dtls_transport_);
   }
-
+  // Transport names should be the same.
   if (rtp_dtls_transport && rtcp_dtls_transport) {
     RTC_DCHECK(rtp_dtls_transport->transport_name() ==
                rtcp_dtls_transport->transport_name());
-    RTC_DCHECK(NeedsRtcpTransport());
   }
-
-  std::string transport_name = rtp_dtls_transport
-                                   ? rtp_dtls_transport->transport_name()
-                                   : rtcp_dtls_transport->transport_name();
-  if (transport_name == transport_name_) {
-    // Nothing to do if transport name isn't changing.
+  std::string debug_name;
+  if (rtp_dtls_transport) {
+    transport_name_ = rtp_dtls_transport->transport_name();
+    debug_name = transport_name_;
+  } else {
+    debug_name = rtp_packet_transport->debug_name();
+  }
+  if (rtp_packet_transport == rtp_packet_transport_) {
+    // Nothing to do if transport isn't changing.
     return;
   }
 
-  transport_name_ = 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()) {
+  if (rtcp_packet_transport) {
     LOG(LS_INFO) << "Setting RTCP Transport for " << content_name() << " on "
-                 << transport_name << " transport " << rtcp_dtls_transport;
-    SetTransport_n(true, rtcp_dtls_transport);
-    RTC_DCHECK(rtcp_dtls_transport_);
+                 << debug_name << " transport " << rtcp_packet_transport;
+    SetTransport_n(true, rtcp_dtls_transport, rtcp_packet_transport);
   }
 
-  LOG(LS_INFO) << "Setting non-RTCP Transport for " << content_name() << " on "
-               << transport_name << " transport " << rtp_dtls_transport;
-  SetTransport_n(false, rtp_dtls_transport);
-  RTC_DCHECK(rtp_dtls_transport_);
+  LOG(LS_INFO) << "Setting RTP Transport for " << content_name() << " on "
+               << debug_name << " transport " << rtp_packet_transport;
+  SetTransport_n(false, rtp_dtls_transport, rtp_packet_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_dtls_transport_ && rtp_dtls_transport_->writable());
+      false, rtp_packet_transport_ && rtp_packet_transport_->writable());
   SetTransportChannelReadyToSend(
-      true, rtcp_dtls_transport_ && rtcp_dtls_transport_->writable());
+      true, rtcp_packet_transport_ && rtcp_packet_transport_->writable());
 }
 
-void BaseChannel::SetTransport_n(bool rtcp,
-                                 DtlsTransportInternal* new_transport) {
+void BaseChannel::SetTransport_n(
+    bool rtcp,
+    DtlsTransportInternal* new_dtls_transport,
+    rtc::PacketTransportInterface* new_packet_transport) {
   RTC_DCHECK(network_thread_->IsCurrent());
-  DtlsTransportInternal*& old_transport =
+  DtlsTransportInternal*& old_dtls_transport =
       rtcp ? rtcp_dtls_transport_ : rtp_dtls_transport_;
+  rtc::PacketTransportInterface*& old_packet_transport =
+      rtcp ? rtcp_packet_transport_ : rtp_packet_transport_;
 
-  if (!old_transport && !new_transport) {
+  if (!old_packet_transport && !new_packet_transport) {
     // Nothing to do.
     return;
   }
 
-  RTC_DCHECK(old_transport != new_transport);
-  if (old_transport) {
-    DisconnectFromTransport(old_transport);
+  RTC_DCHECK(old_packet_transport != new_packet_transport);
+  if (old_dtls_transport) {
+    DisconnectFromDtlsTransport(old_dtls_transport);
+  } else if (old_packet_transport) {
+    DisconnectFromPacketTransport(old_packet_transport);
   }
 
-  old_transport = new_transport;
+  old_packet_transport = new_packet_transport;
+  old_dtls_transport = new_dtls_transport;
 
-  if (new_transport) {
-    if (rtcp) {
-      RTC_CHECK(!(ShouldSetupDtlsSrtp_n() && srtp_filter_.IsActive()))
-          << "Setting RTCP for DTLS/SRTP after SrtpFilter is active "
-          << "should never happen.";
-    }
-    ConnectToTransport(new_transport);
-    auto& socket_options = rtcp ? rtcp_socket_options_ : socket_options_;
-    for (const auto& pair : socket_options) {
-      new_transport->SetOption(pair.first, pair.second);
-    }
+  // If there's no new transport, we're done after disconnecting from old one.
+  if (!new_packet_transport) {
+    return;
+  }
+
+  if (rtcp && new_dtls_transport) {
+    RTC_CHECK(!(ShouldSetupDtlsSrtp_n() && srtp_filter_.IsActive()))
+        << "Setting RTCP for DTLS/SRTP after SrtpFilter is active "
+        << "should never happen.";
+  }
+  if (new_dtls_transport) {
+    ConnectToDtlsTransport(new_dtls_transport);
+  } else {
+    ConnectToPacketTransport(new_packet_transport);
+  }
+  auto& socket_options = rtcp ? rtcp_socket_options_ : socket_options_;
+  for (const auto& pair : socket_options) {
+    new_packet_transport->SetOption(pair.first, pair.second);
   }
 }
 
-void BaseChannel::ConnectToTransport(DtlsTransportInternal* transport) {
+void BaseChannel::ConnectToDtlsTransport(DtlsTransportInternal* transport) {
   RTC_DCHECK(network_thread_->IsCurrent());
 
   transport->SignalWritableState.connect(this, &BaseChannel::OnWritableState);
   transport->SignalReadPacket.connect(this, &BaseChannel::OnPacketRead);
   transport->SignalReadyToSend.connect(this, &BaseChannel::OnReadyToSend);
   transport->SignalDtlsState.connect(this, &BaseChannel::OnDtlsState);
   transport->SignalSentPacket.connect(this, &BaseChannel::SignalSentPacket_n);
   transport->ice_transport()->SignalSelectedCandidatePairChanged.connect(
       this, &BaseChannel::OnSelectedCandidatePairChanged);
 }
 
-void BaseChannel::DisconnectFromTransport(DtlsTransportInternal* transport) {
+void BaseChannel::DisconnectFromDtlsTransport(
+    DtlsTransportInternal* transport) {
   RTC_DCHECK(network_thread_->IsCurrent());
   OnSelectedCandidatePairChanged(transport->ice_transport(), nullptr, -1,
                                  false);
 
   transport->SignalWritableState.disconnect(this);
   transport->SignalReadPacket.disconnect(this);
   transport->SignalReadyToSend.disconnect(this);
   transport->SignalDtlsState.disconnect(this);
   transport->SignalSentPacket.disconnect(this);
   transport->ice_transport()->SignalSelectedCandidatePairChanged.disconnect(
       this);
 }
 
+void BaseChannel::ConnectToPacketTransport(
+    rtc::PacketTransportInterface* transport) {
+  RTC_DCHECK_RUN_ON(network_thread_);
+  transport->SignalWritableState.connect(this, &BaseChannel::OnWritableState);
+  transport->SignalReadPacket.connect(this, &BaseChannel::OnPacketRead);
+  transport->SignalReadyToSend.connect(this, &BaseChannel::OnReadyToSend);
+  transport->SignalSentPacket.connect(this, &BaseChannel::SignalSentPacket_n);
+}
+
+void BaseChannel::DisconnectFromPacketTransport(
+    rtc::PacketTransportInterface* transport) {
+  RTC_DCHECK_RUN_ON(network_thread_);
+  transport->SignalWritableState.disconnect(this);
+  transport->SignalReadPacket.disconnect(this);
+  transport->SignalReadyToSend.disconnect(this);
+  transport->SignalSentPacket.disconnect(this);
+}
+
 bool BaseChannel::Enable(bool enable) {
   worker_thread_->Invoke<void>(
       RTC_FROM_HERE,
       Bind(enable ? &BaseChannel::EnableMedia_w : &BaseChannel::DisableMedia_w,
            this));
   return true;
 }
 
 bool BaseChannel::AddRecvStream(const StreamParams& sp) {
   return InvokeOnWorker(RTC_FROM_HERE,
@@ skipping 47 matching lines @@
 
 void BaseChannel::StopConnectionMonitor() {
   if (connection_monitor_) {
     connection_monitor_->Stop();
     connection_monitor_.reset();
   }
 }
 
 bool BaseChannel::GetConnectionStats(ConnectionInfos* infos) {
   RTC_DCHECK(network_thread_->IsCurrent());
+  if (!rtp_dtls_transport_) {
+    return false;
+  }
   return rtp_dtls_transport_->ice_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();
 }
 
 bool BaseChannel::IsReadyToReceiveMedia_w() const {
@@ skipping 29 matching lines @@
 int BaseChannel::SetOption(SocketType type, rtc::Socket::Option opt,
                            int value) {
   return network_thread_->Invoke<int>(
       RTC_FROM_HERE, Bind(&BaseChannel::SetOption_n, this, type, opt, value));
 }
 
 int BaseChannel::SetOption_n(SocketType type,
                              rtc::Socket::Option opt,
                              int value) {
   RTC_DCHECK(network_thread_->IsCurrent());
-  DtlsTransportInternal* transport = nullptr;
+  rtc::PacketTransportInterface* transport = nullptr;
   switch (type) {
     case ST_RTP:
-      transport = rtp_dtls_transport_;
+      transport = rtp_packet_transport_;
       socket_options_.push_back(
           std::pair<rtc::Socket::Option, int>(opt, value));
       break;
     case ST_RTCP:
-      transport = rtcp_dtls_transport_;
+      transport = rtcp_packet_transport_;
       rtcp_socket_options_.push_back(
           std::pair<rtc::Socket::Option, int>(opt, value));
       break;
   }
-  return transport ? transport->ice_transport()->SetOption(opt, value) : -1;
+  return transport ? transport->SetOption(opt, value) : -1;
 }
 
 bool BaseChannel::SetCryptoOptions(const rtc::CryptoOptions& crypto_options) {
   crypto_options_ = crypto_options;
   return true;
 }
 
 void BaseChannel::OnWritableState(rtc::PacketTransportInterface* transport) {
-  RTC_DCHECK(transport == rtp_dtls_transport_ ||
-             transport == rtcp_dtls_transport_);
+  RTC_DCHECK(transport == rtp_packet_transport_ ||
+             transport == rtcp_packet_transport_);
   RTC_DCHECK(network_thread_->IsCurrent());
   UpdateWritableState_n();
 }
 
 void BaseChannel::OnPacketRead(rtc::PacketTransportInterface* transport,
                                const char* data,
                                size_t len,
                                const rtc::PacketTime& packet_time,
                                int flags) {
   TRACE_EVENT0("webrtc", "BaseChannel::OnPacketRead");
   // OnPacketRead gets called from P2PSocket; now pass data to MediaEngine
   RTC_DCHECK(network_thread_->IsCurrent());
 
   // When using RTCP multiplexing we might get RTCP packets on the RTP
   // transport. We feed RTP traffic into the demuxer to determine if it is RTCP.
   bool rtcp = PacketIsRtcp(transport, data, len);
   rtc::CopyOnWriteBuffer packet(data, len);
   HandlePacket(rtcp, &packet, packet_time);
 }
 
 void BaseChannel::OnReadyToSend(rtc::PacketTransportInterface* transport) {
-  RTC_DCHECK(transport == rtp_dtls_transport_ ||
-             transport == rtcp_dtls_transport_);
-  SetTransportChannelReadyToSend(transport == rtcp_dtls_transport_, true);
+  RTC_DCHECK(transport == rtp_packet_transport_ ||
+             transport == rtcp_packet_transport_);
+  SetTransportChannelReadyToSend(transport == rtcp_packet_transport_, true);
 }
 
 void BaseChannel::OnDtlsState(DtlsTransportInternal* transport,
                               DtlsTransportState state) {
   if (!ShouldSetupDtlsSrtp_n()) {
     return;
   }
 
   // Reset the srtp filter if it's not the CONNECTED state. For the CONNECTED
   // state, setting up DTLS-SRTP context is deferred to ChannelWritable_w to
   // cover other scenarios like the whole transport is writable (not just this
   // TransportChannel) or when TransportChannel is attached after DTLS is
   // negotiated.
   if (state != DTLS_TRANSPORT_CONNECTED) {
     srtp_filter_.ResetParams();
   }
 }
 
 void BaseChannel::OnSelectedCandidatePairChanged(
     IceTransportInternal* ice_transport,
     CandidatePairInterface* selected_candidate_pair,
     int last_sent_packet_id,
     bool ready_to_send) {
-  RTC_DCHECK(ice_transport == rtp_dtls_transport_->ice_transport() ||
-             ice_transport == rtcp_dtls_transport_->ice_transport());
+  RTC_DCHECK((rtp_dtls_transport_ &&
+              ice_transport == rtp_dtls_transport_->ice_transport()) ||
+             (rtcp_dtls_transport_ &&
+              ice_transport == rtcp_dtls_transport_->ice_transport()));
   RTC_DCHECK(network_thread_->IsCurrent());
   selected_candidate_pair_ = selected_candidate_pair;
   std::string transport_name = ice_transport->transport_name();
   rtc::NetworkRoute network_route;
   if (selected_candidate_pair) {
     network_route = rtc::NetworkRoute(
         ready_to_send, selected_candidate_pair->local_candidate().network_id(),
         selected_candidate_pair->remote_candidate().network_id(),
         last_sent_packet_id);
 
     UpdateTransportOverhead();
   }
   invoker_.AsyncInvoke<void>(
       RTC_FROM_HERE, worker_thread_,
       Bind(&MediaChannel::OnNetworkRouteChanged, media_channel_, transport_name,
            network_route));
 }
 
 void BaseChannel::SetTransportChannelReadyToSend(bool rtcp, bool ready) {
   RTC_DCHECK(network_thread_->IsCurrent());
   if (rtcp) {
     rtcp_ready_to_send_ = ready;
   } else {
     rtp_ready_to_send_ = ready;
   }
 
   bool ready_to_send =
       (rtp_ready_to_send_ &&
-       // In the case of rtcp mux |rtcp_dtls_transport_| will be null.
-       (rtcp_ready_to_send_ || !rtcp_dtls_transport_));
+       // In the case of rtcp mux |rtcp_packet_transport_| will be null.
+       (rtcp_ready_to_send_ || !rtcp_packet_transport_));
 
   invoker_.AsyncInvoke<void>(
       RTC_FROM_HERE, worker_thread_,
       Bind(&MediaChannel::OnReadyToSend, media_channel_, ready_to_send));
 }
 
 bool BaseChannel::PacketIsRtcp(const rtc::PacketTransportInterface* transport,
                                const char* data,
                                size_t len) {
-  return (transport == rtcp_dtls_transport_ ||
+  return (transport == rtcp_packet_transport_ ||
           rtcp_mux_filter_.DemuxRtcp(data, static_cast<int>(len)));
 }
 
 bool BaseChannel::SendPacket(bool rtcp,
                              rtc::CopyOnWriteBuffer* packet,
                              const rtc::PacketOptions& options) {
   // SendPacket gets called from MediaEngine, on a pacer or an encoder thread.
   // If the thread is not our network thread, we will post to our network
   // so that the real work happens on our network. This avoids us having to
   // synchronize access to all the pieces of the send path, including
   // SRTP and the inner workings of the transport channels.
   // The only downside is that we can't return a proper failure code if
   // needed. Since UDP is unreliable anyway, this should be a non-issue.
   if (!network_thread_->IsCurrent()) {
     // Avoid a copy by transferring the ownership of the packet data.
     int message_id = rtcp ? MSG_SEND_RTCP_PACKET : MSG_SEND_RTP_PACKET;
     SendPacketMessageData* data = new SendPacketMessageData;
     data->packet = std::move(*packet);
     data->options = options;
     network_thread_->Post(RTC_FROM_HERE, this, message_id, data);
     return true;
   }
   TRACE_EVENT0("webrtc", "BaseChannel::SendPacket");
 
   // Now that we are on the correct thread, ensure we have a place to send this
   // packet before doing anything. (We might get RTCP packets that we don't
   // intend to send.) If we've negotiated RTCP mux, send RTCP over the RTP
   // transport.
-  DtlsTransportInternal* transport = (!rtcp || rtcp_mux_filter_.IsActive())
-                                         ? rtp_dtls_transport_
-                                         : rtcp_dtls_transport_;
+  rtc::PacketTransportInterface* transport =
+      (!rtcp || rtcp_mux_filter_.IsActive()) ? rtp_packet_transport_
+                                             : rtcp_packet_transport_;
   if (!transport || !transport->writable()) {
     return false;
   }
 
   // Protect ourselves against crazy data.
   if (!ValidPacket(rtcp, packet)) {
     LOG(LS_ERROR) << "Dropping outgoing " << content_name_ << " "
                   << PacketType(rtcp)
                   << " packet: wrong size=" << packet->size();
     return false;
@@ skipping 228 matching lines @@
   RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
   if (!enabled_)
     return;
 
   LOG(LS_INFO) << "Channel disabled";
   enabled_ = false;
   UpdateMediaSendRecvState_w();
 }
 
 void BaseChannel::UpdateWritableState_n() {
-  if (rtp_dtls_transport_ && rtp_dtls_transport_->writable() &&
-      (!rtcp_dtls_transport_ || rtcp_dtls_transport_->writable())) {
+  if (rtp_packet_transport_ && rtp_packet_transport_->writable() &&
+      (!rtcp_packet_transport_ || rtcp_packet_transport_->writable())) {
     ChannelWritable_n();
   } else {
     ChannelNotWritable_n();
   }
 }
 
 void BaseChannel::ChannelWritable_n() {
   RTC_DCHECK(network_thread_->IsCurrent());
   if (writable_) {
     return;
@@ skipping 46 matching lines @@
 }
 
 // This function returns true if either DTLS-SRTP is not in use
 // *or* DTLS-SRTP is successfully set up.
 bool BaseChannel::SetupDtlsSrtp_n(bool rtcp) {
   RTC_DCHECK(network_thread_->IsCurrent());
   bool ret = false;
 
   DtlsTransportInternal* transport =
       rtcp ? rtcp_dtls_transport_ : rtp_dtls_transport_;
-
+  RTC_DCHECK(transport);
   RTC_DCHECK(transport->IsDtlsActive());
 
   int selected_crypto_suite;
 
   if (!transport->GetSrtpCryptoSuite(&selected_crypto_suite)) {
     LOG(LS_ERROR) << "No DTLS-SRTP selected crypto suite";
     return false;
   }
 
   LOG(LS_INFO) << "Installing keys from DTLS-SRTP on " << content_name() << " "
@@ skipping 130 matching lines @@
   }
 
   return true;
 }
 
 // |dtls| will be set to true if DTLS is active for transport and crypto is
 // empty.
 bool BaseChannel::CheckSrtpConfig_n(const std::vector<CryptoParams>& cryptos,
                                     bool* dtls,
                                     std::string* error_desc) {
-  *dtls = rtp_dtls_transport_->IsDtlsActive();
+  *dtls = rtp_dtls_transport_ && rtp_dtls_transport_->IsDtlsActive();
   if (*dtls && !cryptos.empty()) {
     SafeSetError("Cryptos must be empty when DTLS is active.", error_desc);
     return false;
   }
   return true;
 }
 
 bool BaseChannel::SetSrtp_n(const std::vector<CryptoParams>& cryptos,
                             ContentAction action,
                             ContentSource src,
@@ skipping 64 matching lines @@
       // 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 for "
                      << transport_name();
-        if (rtcp_dtls_transport()) {
-          SetTransport_n(true, nullptr);
-          SignalRtcpMuxFullyActive(rtp_dtls_transport()->transport_name());
+        if (rtcp_packet_transport_) {
+          SetTransport_n(true, nullptr, nullptr);
+          SignalRtcpMuxFullyActive(transport_name_);
         }
         UpdateWritableState_n();
         SetTransportChannelReadyToSend(true, false);
       }
       break;
     case CA_UPDATE:
       // No RTCP mux info.
       ret = true;
       break;
     default:
       break;
   }
   if (!ret) {
     SafeSetError("Failed to setup RTCP mux filter.", error_desc);
     return false;
   }
   // |rtcp_mux_filter_| can be active if |action| is CA_PRANSWER or
   // CA_ANSWER, but we only want to tear down the RTCP transport if we received
   // a final answer.
   if (rtcp_mux_filter_.IsActive()) {
     // If the RTP transport is already writable, then so are we.
-    if (rtp_dtls_transport_->writable()) {
+    if (rtp_packet_transport_->writable()) {
       ChannelWritable_n();
     }
   }
 
   return true;
 }
 
 bool BaseChannel::AddRecvStream_w(const StreamParams& sp) {
   RTC_DCHECK(worker_thread() == rtc::Thread::Current());
   return media_channel()->AddRecvStream(sp);
@@ skipping 239 matching lines @@
 
 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();
   Deinit();
 }
 
-bool VoiceChannel::Init_w(DtlsTransportInternal* rtp_dtls_transport,
-                          DtlsTransportInternal* rtcp_dtls_transport) {
-  return BaseChannel::Init_w(rtp_dtls_transport, rtcp_dtls_transport);
-}
-
 bool VoiceChannel::SetAudioSend(uint32_t ssrc,
                                 bool enable,
                                 const AudioOptions* options,
                                 AudioSource* source) {
   return InvokeOnWorker(RTC_FROM_HERE,
                         Bind(&VoiceMediaChannel::SetAudioSend, media_channel(),
                              ssrc, enable, options, source));
 }
 
 // TODO(juberti): Handle early media the right way. We should get an explicit
@@ skipping 377 matching lines @@
                            bool rtcp_mux_required,
                            bool srtp_required)
     : BaseChannel(worker_thread,
                   network_thread,
                   signaling_thread,
                   media_channel,
                   content_name,
                   rtcp_mux_required,
                   srtp_required) {}
 
-bool VideoChannel::Init_w(DtlsTransportInternal* rtp_dtls_transport,
-                          DtlsTransportInternal* rtcp_dtls_transport) {
-  return BaseChannel::Init_w(rtp_dtls_transport, rtcp_dtls_transport);
-}
-
 VideoChannel::~VideoChannel() {
   TRACE_EVENT0("webrtc", "VideoChannel::~VideoChannel");
   StopMediaMonitor();
   // this can't be done in the base class, since it calls a virtual
   DisableMedia_w();
 
   Deinit();
 }
 
 bool VideoChannel::SetSink(uint32_t ssrc,
@@ skipping 245 matching lines @@
 
 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();
 }
 
-bool RtpDataChannel::Init_w(DtlsTransportInternal* rtp_dtls_transport,
-                            DtlsTransportInternal* rtcp_dtls_transport) {
-  if (!BaseChannel::Init_w(rtp_dtls_transport, rtcp_dtls_transport)) {
+bool RtpDataChannel::Init_w(
+    DtlsTransportInternal* rtp_dtls_transport,
+    DtlsTransportInternal* rtcp_dtls_transport,
+    rtc::PacketTransportInterface* rtp_packet_transport,
+    rtc::PacketTransportInterface* rtcp_packet_transport) {
+  if (!BaseChannel::Init_w(rtp_dtls_transport, rtcp_dtls_transport,
+                           rtp_packet_transport, rtcp_packet_transport)) {
     return false;
   }
   media_channel()->SignalDataReceived.connect(this,
                                               &RtpDataChannel::OnDataReceived);
   media_channel()->SignalReadyToSend.connect(
       this, &RtpDataChannel::OnDataChannelReadyToSend);
   return true;
 }
 
 bool RtpDataChannel::SendData(const SendDataParams& params,
@@ skipping 225 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