Make BaseChannel::rtp_transport_ a unique_ptr.

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.
  */
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
 #include "webrtc/pc/channel.h"
 
 #include "webrtc/api/call/audio_sink.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/base/rtputils.h"
 #include "webrtc/rtc_base/bind.h"
 #include "webrtc/rtc_base/byteorder.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/copyonwritebuffer.h"
 #include "webrtc/rtc_base/dscp.h"
 #include "webrtc/rtc_base/logging.h"
 #include "webrtc/rtc_base/networkroute.h"
+#include "webrtc/rtc_base/ptr_util.h"
 #include "webrtc/rtc_base/trace_event.h"
 // Adding 'nogncheck' to disable the gn include headers check to support modular
 // WebRTC build targets.
 #include "webrtc/media/engine/webrtcvoiceengine.h"  // nogncheck
 #include "webrtc/p2p/base/packettransportinternal.h"
 #include "webrtc/pc/channelmanager.h"
 
 namespace cricket {
 using rtc::Bind;
 
@@ skipping 111 matching lines @@
                          rtc::Thread* signaling_thread,
                          MediaChannel* media_channel,
                          const std::string& content_name,
                          bool rtcp_mux_required,
                          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),
-      rtp_transport_(rtcp_mux_required),
+      rtp_transport_(rtc::MakeUnique<webrtc::RtpTransport>(rtcp_mux_required)),
       srtp_required_(srtp_required),
       media_channel_(media_channel),
       selected_candidate_pair_(nullptr) {
   RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
 #if defined(ENABLE_EXTERNAL_AUTH)
   srtp_filter_.EnableExternalAuth();
 #endif
-  rtp_transport_.SignalReadyToSend.connect(
+  rtp_transport_->SignalReadyToSend.connect(
       this, &BaseChannel::OnTransportReadyToSend);
   // TODO(zstein):  RtpTransport::SignalPacketReceived will probably be replaced
   // with a callback interface later so that the demuxer can select which
   // channel to signal.
-  rtp_transport_.SignalPacketReceived.connect(this,
+  rtp_transport_->SignalPacketReceived.connect(this,
                                               &BaseChannel::OnPacketReceived);
   LOG(LS_INFO) << "Created channel for " << content_name;
 }
 
 BaseChannel::~BaseChannel() {
   TRACE_EVENT0("webrtc", "BaseChannel::~BaseChannel");
   RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
   Deinit();
   StopConnectionMonitor();
   // Eats any outstanding messages or packets.
   worker_thread_->Clear(&invoker_);
   worker_thread_->Clear(this);
   // We must destroy the media channel before the transport channel, otherwise
   // the media channel may try to send on the dead transport channel. NULLing
   // is not an effective strategy since the sends will come on another thread.
   delete media_channel_;
   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_) {
     DisconnectFromDtlsTransport(rtp_dtls_transport_);
-  } else if (rtp_transport_.rtp_packet_transport()) {
-    DisconnectFromPacketTransport(rtp_transport_.rtp_packet_transport());
+  } else if (rtp_transport_->rtp_packet_transport()) {
+    DisconnectFromPacketTransport(rtp_transport_->rtp_packet_transport());
   }
   if (rtcp_dtls_transport_) {
     DisconnectFromDtlsTransport(rtcp_dtls_transport_);
-  } else if (rtp_transport_.rtcp_packet_transport()) {
-    DisconnectFromPacketTransport(rtp_transport_.rtcp_packet_transport());
+  } else if (rtp_transport_->rtcp_packet_transport()) {
+    DisconnectFromPacketTransport(rtp_transport_->rtcp_packet_transport());
   }
 
-  rtp_transport_.SetRtpPacketTransport(nullptr);
-  rtp_transport_.SetRtcpPacketTransport(nullptr);
+  rtp_transport_->SetRtpPacketTransport(nullptr);
+  rtp_transport_->SetRtcpPacketTransport(nullptr);
 
   // 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,
                          rtc::PacketTransportInternal* rtp_packet_transport,
                          rtc::PacketTransportInternal* rtcp_packet_transport) {
@@ skipping 58 matching lines @@
     rtc::PacketTransportInternal* rtcp_packet_transport) {
   RTC_DCHECK(network_thread_->IsCurrent());
   // 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_transport_.rtp_packet_transport() || rtp_dtls_transport_);
+    RTC_DCHECK(!rtp_transport_->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());
   }
   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_transport_.rtp_packet_transport()) {
+  if (rtp_packet_transport == rtp_transport_->rtp_packet_transport()) {
     // Nothing to do if transport isn't changing.
     return;
   }
 
   // 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.
@@ skipping 19 matching lines @@
 }
 
 void BaseChannel::SetTransport_n(
     bool rtcp,
     DtlsTransportInternal* new_dtls_transport,
     rtc::PacketTransportInternal* new_packet_transport) {
   RTC_DCHECK(network_thread_->IsCurrent());
   DtlsTransportInternal*& old_dtls_transport =
       rtcp ? rtcp_dtls_transport_ : rtp_dtls_transport_;
   rtc::PacketTransportInternal* old_packet_transport =
-      rtcp ? rtp_transport_.rtcp_packet_transport()
-           : rtp_transport_.rtp_packet_transport();
+      rtcp ? rtp_transport_->rtcp_packet_transport()
+           : rtp_transport_->rtp_packet_transport();
 
   if (!old_packet_transport && !new_packet_transport) {
     // Nothing to do.
     return;
   }
 
   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);
   }
 
   if (rtcp) {
-    rtp_transport_.SetRtcpPacketTransport(new_packet_transport);
+    rtp_transport_->SetRtcpPacketTransport(new_packet_transport);
   } else {
-    rtp_transport_.SetRtpPacketTransport(new_packet_transport);
+    rtp_transport_->SetRtpPacketTransport(new_packet_transport);
   }
   old_dtls_transport = new_dtls_transport;
 
   // 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()))
@@ skipping 168 matching lines @@
       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());
   rtc::PacketTransportInternal* transport = nullptr;
   switch (type) {
     case ST_RTP:
-      transport = rtp_transport_.rtp_packet_transport();
+      transport = rtp_transport_->rtp_packet_transport();
       socket_options_.push_back(
           std::pair<rtc::Socket::Option, int>(opt, value));
       break;
     case ST_RTCP:
-      transport = rtp_transport_.rtcp_packet_transport();
+      transport = rtp_transport_->rtcp_packet_transport();
       rtcp_socket_options_.push_back(
           std::pair<rtc::Socket::Option, int>(opt, value));
       break;
   }
   return transport ? transport->SetOption(opt, value) : -1;
 }
 
 void BaseChannel::OnWritableState(rtc::PacketTransportInternal* transport) {
-  RTC_DCHECK(transport == rtp_transport_.rtp_packet_transport() ||
-             transport == rtp_transport_.rtcp_packet_transport());
+  RTC_DCHECK(transport == rtp_transport_->rtp_packet_transport() ||
+             transport == rtp_transport_->rtcp_packet_transport());
   RTC_DCHECK(network_thread_->IsCurrent());
   UpdateWritableState_n();
 }
 
 void BaseChannel::OnDtlsState(DtlsTransportInternal* transport,
                               DtlsTransportState state) {
   if (!ShouldSetupDtlsSrtp_n()) {
     return;
   }
 
@@ skipping 58 matching lines @@
     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.
-  if (!rtp_transport_.IsWritable(rtcp)) {
+  if (!rtp_transport_->IsWritable(rtcp)) {
     return false;
   }
 
   // Protect ourselves against crazy data.
   if (!ValidPacket(rtcp, packet)) {
     LOG(LS_ERROR) << "Dropping outgoing " << content_name_ << " "
                   << RtpRtcpStringLiteral(rtcp)
                   << " packet: wrong size=" << packet->size();
     return false;
   }
@@ skipping 75 matching lines @@
     // However, there shouldn't be any RTP packets sent before SRTP is set up
     // (and SetSend(true) is called).
     LOG(LS_ERROR) << "Can't send outgoing RTP packet when SRTP is inactive"
                   << " and crypto is required";
     RTC_NOTREACHED();
     return false;
   }
 
   // Bon voyage.
   int flags = (secure() && secure_dtls()) ? PF_SRTP_BYPASS : PF_NORMAL;
-  return rtp_transport_.SendPacket(rtcp, packet, updated_options, flags);
+  return rtp_transport_->SendPacket(rtcp, packet, updated_options, flags);
 }
 
 bool BaseChannel::HandlesPayloadType(int packet_type) const {
-  return rtp_transport_.HandlesPayloadType(packet_type);
+  return rtp_transport_->HandlesPayloadType(packet_type);
 }
 
 void BaseChannel::OnPacketReceived(bool rtcp,
                                    rtc::CopyOnWriteBuffer& packet,
                                    const rtc::PacketTime& packet_time) {
   if (!has_received_packet_ && !rtcp) {
     has_received_packet_ = true;
     signaling_thread()->Post(RTC_FROM_HERE, this, MSG_FIRSTPACKETRECEIVED);
   }
 
@@ skipping 107 matching lines @@
   if (!enabled_)
     return;
 
   LOG(LS_INFO) << "Channel disabled";
   enabled_ = false;
   UpdateMediaSendRecvState_w();
 }
 
 void BaseChannel::UpdateWritableState_n() {
   rtc::PacketTransportInternal* rtp_packet_transport =
-      rtp_transport_.rtp_packet_transport();
+      rtp_transport_->rtp_packet_transport();
   rtc::PacketTransportInternal* rtcp_packet_transport =
-      rtp_transport_.rtcp_packet_transport();
+      rtp_transport_->rtcp_packet_transport();
   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());
@@ skipping 308 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 permanently activated RTCP muxing; signal that we no longer need
         // the RTCP transport.
         std::string debug_name =
             transport_name_.empty()
-                ? rtp_transport_.rtp_packet_transport()->debug_name()
+                ? rtp_transport_->rtp_packet_transport()->debug_name()
                 : transport_name_;
         ;
         LOG(LS_INFO) << "Enabling rtcp-mux for " << content_name()
                      << "; no longer need RTCP transport for " << debug_name;
-        if (rtp_transport_.rtcp_packet_transport()) {
+        if (rtp_transport_->rtcp_packet_transport()) {
           SetTransport_n(true, nullptr, nullptr);
           SignalRtcpMuxFullyActive(transport_name_);
         }
         UpdateWritableState_n();
       }
       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;
   }
-  rtp_transport_.SetRtcpMuxEnabled(rtcp_mux_filter_.IsActive());
+  rtp_transport_->SetRtcpMuxEnabled(rtcp_mux_filter_.IsActive());
   // |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_transport_.rtp_packet_transport()->writable()) {
+    if (rtp_transport_->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 205 matching lines @@
       break;
     }
     case MSG_FIRSTPACKETRECEIVED: {
       SignalFirstPacketReceived(this);
       break;
     }
   }
 }
 
 void BaseChannel::AddHandledPayloadType(int payload_type) {
-  rtp_transport_.AddHandledPayloadType(payload_type);
+  rtp_transport_->AddHandledPayloadType(payload_type);
 }
 
 void BaseChannel::FlushRtcpMessages_n() {
   // Flush all remaining RTCP messages. This should only be called in
   // destructor.
   RTC_DCHECK(network_thread_->IsCurrent());
   rtc::MessageList rtcp_messages;
   network_thread_->Clear(this, MSG_SEND_RTCP_PACKET, &rtcp_messages);
   for (const auto& message : rtcp_messages) {
     network_thread_->Send(RTC_FROM_HERE, this, MSG_SEND_RTCP_PACKET,
@@ skipping 976 matching lines @@
 
 void RtpDataChannel::OnDataChannelReadyToSend(bool writable) {
   // This is usded for congestion control to indicate that the stream is ready
   // to send by the MediaChannel, as opposed to OnReadyToSend, which indicates
   // that the transport channel is ready.
   signaling_thread()->Post(RTC_FROM_HERE, this, MSG_READYTOSENDDATA,
                            new DataChannelReadyToSendMessageData(writable));
 }
 
 }  // namespace cricket