Remove the dependency of TransportChannel and TransportChannelImpl.

webrtc/api/webrtcsession.cc

 /*
  *  Copyright 2012 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 17 matching lines @@
 #include "webrtc/base/checks.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/call/call.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/base/videocapturer.h"
 #include "webrtc/media/sctp/sctptransportinternal.h"
 #include "webrtc/p2p/base/portallocator.h"
-#include "webrtc/p2p/base/transportchannel.h"
 #include "webrtc/pc/channel.h"
 #include "webrtc/pc/channelmanager.h"
 #include "webrtc/pc/mediasession.h"
 
 #ifdef HAVE_QUIC
 #include "webrtc/p2p/quic/quictransportchannel.h"
 #endif  // HAVE_QUIC
 
 using cricket::ContentInfo;
 using cricket::ContentInfos;
@@ skipping 1026 matching lines @@
       return true;
     }
 
     std::string old_transport_name = ch->transport_name();
     if (old_transport_name == transport_name) {
       LOG(LS_INFO) << "BUNDLE already enabled for " << ch->content_name()
                    << " on " << transport_name << ".";
       return true;
     }
 
-    cricket::TransportChannel* rtp_transport =
-        transport_controller_->CreateTransportChannel(
+    cricket::DtlsTransportInternal* rtp_dtls_transport =
+        transport_controller_->CreateDtlsTransport(
             transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
-    bool need_rtcp = (ch->rtcp_transport() != nullptr);
-    cricket::TransportChannel* rtcp_transport = nullptr;
+    bool need_rtcp = (ch->rtcp_dtls_transport() != nullptr);
+    cricket::DtlsTransportInternal* rtcp_dtls_transport = nullptr;
     if (need_rtcp) {
-      rtcp_transport = transport_controller_->CreateTransportChannel_n(
+      rtcp_dtls_transport = transport_controller_->CreateDtlsTransport_n(
           transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTCP);
     }
 
-    if (!ch->SetTransport(rtp_transport, rtcp_transport)) {
+    if (!ch->SetTransports(rtp_dtls_transport, rtcp_dtls_transport)) {
       LOG(LS_WARNING) << "Failed to enable BUNDLE for " << ch->content_name();
       return false;
     }
     LOG(LS_INFO) << "Enabled BUNDLE for " << ch->content_name() << " on "
                  << transport_name << ".";
     DestroyTransport(old_transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
     // If the channel needs rtcp, it means that the channel used to have a
     // rtcp transport which needs to be deleted now.
     if (need_rtcp) {
       DestroyTransport(old_transport_name,
@@ skipping 678 matching lines @@
 }
 
 bool WebRtcSession::CreateVoiceChannel(const cricket::ContentInfo* content,
                                        const std::string* bundle_transport) {
   bool require_rtcp_mux =
       rtcp_mux_policy_ == PeerConnectionInterface::kRtcpMuxPolicyRequire;
 
   std::string transport_name =
       bundle_transport ? *bundle_transport : content->name;
 
-  cricket::TransportChannel* rtp_transport =
-      transport_controller_->CreateTransportChannel(
+  cricket::DtlsTransportInternal* rtp_dtls_transport =
+      transport_controller_->CreateDtlsTransport(
           transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
-  cricket::TransportChannel* rtcp_transport = nullptr;
+  cricket::DtlsTransportInternal* rtcp_dtls_transport = nullptr;
   if (!require_rtcp_mux) {
-    rtcp_transport = transport_controller_->CreateTransportChannel(
+    rtcp_dtls_transport = transport_controller_->CreateDtlsTransport(
         transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTCP);
   }
 
   voice_channel_.reset(channel_manager_->CreateVoiceChannel(
-      media_controller_, rtp_transport, rtcp_transport,
+      media_controller_, rtp_dtls_transport, rtcp_dtls_transport,
       transport_controller_->signaling_thread(), content->name,
       bundle_transport, require_rtcp_mux, SrtpRequired(), audio_options_));
   if (!voice_channel_) {
     return false;
   }
 
   voice_channel_->SignalRtcpMuxFullyActive.connect(
       this, &WebRtcSession::DestroyRtcpTransport_n);
   voice_channel_->SignalDtlsSrtpSetupFailure.connect(
       this, &WebRtcSession::OnDtlsSrtpSetupFailure);
 
   SignalVoiceChannelCreated();
   voice_channel_->SignalSentPacket.connect(this,
                                            &WebRtcSession::OnSentPacket_w);
   return true;
 }
 
 bool WebRtcSession::CreateVideoChannel(const cricket::ContentInfo* content,
                                        const std::string* bundle_transport) {
   bool require_rtcp_mux =
       rtcp_mux_policy_ == PeerConnectionInterface::kRtcpMuxPolicyRequire;
 
   std::string transport_name =
       bundle_transport ? *bundle_transport : content->name;
 
-  cricket::TransportChannel* rtp_transport =
-      transport_controller_->CreateTransportChannel(
+  cricket::DtlsTransportInternal* rtp_dtls_transport =
+      transport_controller_->CreateDtlsTransport(
           transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
-  cricket::TransportChannel* rtcp_transport = nullptr;
+  cricket::DtlsTransportInternal* rtcp_dtls_transport = nullptr;
   if (!require_rtcp_mux) {
-    rtcp_transport = transport_controller_->CreateTransportChannel(
+    rtcp_dtls_transport = transport_controller_->CreateDtlsTransport(
         transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTCP);
   }
 
   video_channel_.reset(channel_manager_->CreateVideoChannel(
-      media_controller_, rtp_transport, rtcp_transport,
+      media_controller_, rtp_dtls_transport, rtcp_dtls_transport,
       transport_controller_->signaling_thread(), content->name,
       bundle_transport, require_rtcp_mux, SrtpRequired(), video_options_));
 
   if (!video_channel_) {
     return false;
   }
 
   video_channel_->SignalRtcpMuxFullyActive.connect(
       this, &WebRtcSession::DestroyRtcpTransport_n);
   video_channel_->SignalDtlsSrtpSetupFailure.connect(
       this, &WebRtcSession::OnDtlsSrtpSetupFailure);
 
   SignalVideoChannelCreated();
   video_channel_->SignalSentPacket.connect(this,
                                            &WebRtcSession::OnSentPacket_w);
   return true;
 }
 
 bool WebRtcSession::CreateDataChannel(const cricket::ContentInfo* content,
                                       const std::string* bundle_transport) {
   const std::string transport_name =
       bundle_transport ? *bundle_transport : content->name;
 #ifdef HAVE_QUIC
   if (data_channel_type_ == cricket::DCT_QUIC) {
     RTC_DCHECK(transport_controller_->quic());
-    quic_data_transport_->SetTransport(transport_name);
+    quic_data_transport_->SetTransports(transport_name);
     return true;
   }
 #endif  // HAVE_QUIC
   bool sctp = (data_channel_type_ == cricket::DCT_SCTP);
   if (sctp) {
     if (!sctp_factory_) {
       LOG(LS_ERROR)
           << "Trying to create SCTP transport, but didn't compile with "
              "SCTP support (HAVE_SCTP)";
       return false;
     }
     if (!network_thread_->Invoke<bool>(
             RTC_FROM_HERE, rtc::Bind(&WebRtcSession::CreateSctpTransport_n,
                                      this, content->name, transport_name))) {
       return false;
     };
   } else {
     bool require_rtcp_mux =
         rtcp_mux_policy_ == PeerConnectionInterface::kRtcpMuxPolicyRequire;
 
     std::string transport_name =
         bundle_transport ? *bundle_transport : content->name;
-    cricket::TransportChannel* rtp_transport =
-        transport_controller_->CreateTransportChannel(
+    cricket::DtlsTransportInternal* rtp_dtls_transport =
+        transport_controller_->CreateDtlsTransport(
             transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
-    cricket::TransportChannel* rtcp_transport = nullptr;
+    cricket::DtlsTransportInternal* rtcp_dtls_transport = nullptr;
     if (!require_rtcp_mux) {
-      rtcp_transport = transport_controller_->CreateTransportChannel(
+      rtcp_dtls_transport = transport_controller_->CreateDtlsTransport(
           transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTCP);
     }
 
     rtp_data_channel_.reset(channel_manager_->CreateRtpDataChannel(
-        media_controller_, rtp_transport, rtcp_transport,
+        media_controller_, rtp_dtls_transport, rtcp_dtls_transport,
         transport_controller_->signaling_thread(), content->name,
         bundle_transport, require_rtcp_mux, SrtpRequired()));
 
     if (!rtp_data_channel_) {
       return false;
     }
 
     rtp_data_channel_->SignalRtcpMuxFullyActive.connect(
         this, &WebRtcSession::DestroyRtcpTransport_n);
     rtp_data_channel_->SignalDtlsSrtpSetupFailure.connect(
@@ skipping 26 matching lines @@
           std::move(transport_stats);
     }
   }
   return session_stats;
 }
 
 bool WebRtcSession::CreateSctpTransport_n(const std::string& content_name,
                                           const std::string& transport_name) {
   RTC_DCHECK(network_thread_->IsCurrent());
   RTC_DCHECK(sctp_factory_);
-  cricket::TransportChannel* tc =
-      transport_controller_->CreateTransportChannel_n(
+  cricket::DtlsTransportInternal* tc =
+      transport_controller_->CreateDtlsTransport_n(
           transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
   sctp_transport_ = sctp_factory_->CreateSctpTransport(tc);
   RTC_DCHECK(sctp_transport_);
   sctp_invoker_.reset(new rtc::AsyncInvoker());
   sctp_transport_->SignalReadyToSendData.connect(
       this, &WebRtcSession::OnSctpTransportReadyToSendData_n);
   sctp_transport_->SignalDataReceived.connect(
       this, &WebRtcSession::OnSctpTransportDataReceived_n);
   sctp_transport_->SignalStreamClosedRemotely.connect(
       this, &WebRtcSession::OnSctpStreamClosedRemotely_n);
   sctp_transport_name_ = rtc::Optional<std::string>(transport_name);
   sctp_content_name_ = rtc::Optional<std::string>(content_name);
   return true;
 }
 
 void WebRtcSession::ChangeSctpTransport_n(const std::string& transport_name) {
   RTC_DCHECK(network_thread_->IsCurrent());
   RTC_DCHECK(sctp_transport_);
   RTC_DCHECK(sctp_transport_name_);
   std::string old_sctp_transport_name = *sctp_transport_name_;
   sctp_transport_name_ = rtc::Optional<std::string>(transport_name);
-  cricket::TransportChannel* tc =
-      transport_controller_->CreateTransportChannel_n(
+  cricket::DtlsTransportInternal* tc =
+      transport_controller_->CreateDtlsTransport_n(
           transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
   sctp_transport_->SetTransportChannel(tc);
-  transport_controller_->DestroyTransportChannel_n(
+  transport_controller_->DestroyDtlsTransport_n(
       old_sctp_transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
 }
 
 void WebRtcSession::DestroySctpTransport_n() {
   RTC_DCHECK(network_thread_->IsCurrent());
   sctp_transport_.reset(nullptr);
   sctp_content_name_.reset();
   sctp_transport_name_.reset();
   sctp_invoker_.reset(nullptr);
   sctp_ready_to_send_data_ = false;
@@ skipping 378 matching lines @@
     // Return an empty string if failed to retrieve the transport name.
     return "";
   }
   return channel->transport_name();
 }
 
 void WebRtcSession::DestroyTransport(const std::string& transport_name,
                                      int component) {
   network_thread_->Invoke<void>(
       RTC_FROM_HERE,
-      rtc::Bind(&cricket::TransportController::DestroyTransportChannel_n,
+      rtc::Bind(&cricket::TransportController::DestroyDtlsTransport_n,
                 transport_controller_.get(), transport_name, component));
 }
 
 void WebRtcSession::DestroyRtcpTransport_n(const std::string& transport_name) {
   RTC_DCHECK(network_thread()->IsCurrent());
-  transport_controller_->DestroyTransportChannel_n(
+  transport_controller_->DestroyDtlsTransport_n(
       transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTCP);
 }
 
 void WebRtcSession::DestroyVideoChannel() {
   SignalVideoChannelDestroyed();
-  RTC_DCHECK(video_channel_->rtp_transport());
+  RTC_DCHECK(video_channel_->rtp_dtls_transport());
   std::string transport_name;
-  transport_name = video_channel_->rtp_transport()->transport_name();
-  bool need_to_delete_rtcp = (video_channel_->rtcp_transport() != nullptr);
+  transport_name = video_channel_->rtp_dtls_transport()->transport_name();
+  bool need_to_delete_rtcp = (video_channel_->rtcp_dtls_transport() != nullptr);
   channel_manager_->DestroyVideoChannel(video_channel_.release());
   DestroyTransport(transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
   if (need_to_delete_rtcp) {
     DestroyTransport(transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTCP);
   }
 }
 
 void WebRtcSession::DestroyVoiceChannel() {
   SignalVoiceChannelDestroyed();
-  RTC_DCHECK(voice_channel_->rtp_transport());
+  RTC_DCHECK(voice_channel_->rtp_dtls_transport());
   std::string transport_name;
-  transport_name = voice_channel_->rtp_transport()->transport_name();
-  bool need_to_delete_rtcp = (voice_channel_->rtcp_transport() != nullptr);
+  transport_name = voice_channel_->rtp_dtls_transport()->transport_name();
+  bool need_to_delete_rtcp = (voice_channel_->rtcp_dtls_transport() != nullptr);
   channel_manager_->DestroyVoiceChannel(voice_channel_.release());
   DestroyTransport(transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
   if (need_to_delete_rtcp) {
     DestroyTransport(transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTCP);
   }
 }
 
 void WebRtcSession::DestroyDataChannel() {
   SignalDataChannelDestroyed();
-  RTC_DCHECK(rtp_data_channel_->rtp_transport());
+  RTC_DCHECK(rtp_data_channel_->rtp_dtls_transport());
   std::string transport_name;
-  transport_name = rtp_data_channel_->rtp_transport()->transport_name();
-  bool need_to_delete_rtcp = (rtp_data_channel_->rtcp_transport() != nullptr);
+  transport_name = rtp_data_channel_->rtp_dtls_transport()->transport_name();
+  bool need_to_delete_rtcp =
+      (rtp_data_channel_->rtcp_dtls_transport() != nullptr);
   channel_manager_->DestroyRtpDataChannel(rtp_data_channel_.release());
   DestroyTransport(transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP);
   if (need_to_delete_rtcp) {
     DestroyTransport(transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTCP);
   }
 }
 }  // namespace webrtc