Revert of Modified PeerConnection and WebRtcSession for end-to-end QuicDataChannel usage.

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.
  */
 
 #include "webrtc/api/webrtcsession.h"
 
 #include <limits.h>
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "webrtc/api/jsepicecandidate.h"
 #include "webrtc/api/jsepsessiondescription.h"
 #include "webrtc/api/peerconnectioninterface.h"
 #include "webrtc/api/sctputils.h"
 #include "webrtc/api/webrtcsessiondescriptionfactory.h"
 #include "webrtc/audio_sink.h"
 #include "webrtc/base/basictypes.h"
-#include "webrtc/base/bind.h"
 #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.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/base/videocapturer.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;
 using cricket::MediaContentDescription;
 using cricket::SessionDescription;
 using cricket::TransportInfo;
 
 using cricket::LOCAL_PORT_TYPE;
 using cricket::STUN_PORT_TYPE;
 using cricket::RELAY_PORT_TYPE;
 using cricket::PRFLX_PORT_TYPE;
@@ skipping 402 matching lines @@
   return false;
 }
 
 WebRtcSession::WebRtcSession(
     webrtc::MediaControllerInterface* media_controller,
     rtc::Thread* network_thread,
     rtc::Thread* worker_thread,
     rtc::Thread* signaling_thread,
     cricket::PortAllocator* port_allocator,
     std::unique_ptr<cricket::TransportController> transport_controller)
-    : network_thread_(network_thread),
-      worker_thread_(worker_thread),
+    : worker_thread_(worker_thread),
       signaling_thread_(signaling_thread),
       // RFC 3264: The numeric value of the session id and version in the
       // o line MUST be representable with a "64 bit signed integer".
       // Due to this constraint session id |sid_| is max limited to LLONG_MAX.
       sid_(rtc::ToString(rtc::CreateRandomId64() & LLONG_MAX)),
       transport_controller_(std::move(transport_controller)),
       media_controller_(media_controller),
       channel_manager_(media_controller_->channel_manager()),
       ice_observer_(NULL),
       ice_connection_state_(PeerConnectionInterface::kIceConnectionNew),
@@ skipping 24 matching lines @@
     channel_manager_->DestroyVideoChannel(video_channel_.release());
   }
   if (voice_channel_) {
     SignalVoiceChannelDestroyed();
     channel_manager_->DestroyVoiceChannel(voice_channel_.release());
   }
   if (data_channel_) {
     SignalDataChannelDestroyed();
     channel_manager_->DestroyDataChannel(data_channel_.release());
   }
-#ifdef HAVE_QUIC
-  if (quic_data_transport_) {
-    quic_data_transport_.reset();
-  }
-#endif
   SignalDestroyed();
 
   LOG(LS_INFO) << "Session: " << id() << " is destroyed.";
 }
 
 bool WebRtcSession::Initialize(
     const PeerConnectionFactoryInterface::Options& options,
     std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
     const PeerConnectionInterface::RTCConfiguration& rtc_configuration) {
   bundle_policy_ = rtc_configuration.bundle_policy;
@@ skipping 20 matching lines @@
     if (rtc_configuration.enable_dtls_srtp) {
       dtls_enabled_ = *(rtc_configuration.enable_dtls_srtp);
     }
   }
 
   // Enable creation of RTP data channels if the kEnableRtpDataChannels is set.
   // It takes precendence over the disable_sctp_data_channels
   // PeerConnectionFactoryInterface::Options.
   if (rtc_configuration.enable_rtp_data_channel) {
     data_channel_type_ = cricket::DCT_RTP;
-  }
-#ifdef HAVE_QUIC
-  else if (rtc_configuration.enable_quic) {
-    // Use QUIC instead of DTLS when |enable_quic| is true.
-    data_channel_type_ = cricket::DCT_QUIC;
-    transport_controller_->use_quic();
-    if (dtls_enabled_) {
-      LOG(LS_INFO) << "Using QUIC instead of DTLS";
-    }
-    quic_data_transport_.reset(
-        new QuicDataTransport(signaling_thread(), worker_thread(),
-                              network_thread(), transport_controller_.get()));
-  }
-#endif  // HAVE_QUIC
-  else {
+  } else {
     // DTLS has to be enabled to use SCTP.
     if (!options.disable_sctp_data_channels && dtls_enabled_) {
       data_channel_type_ = cricket::DCT_SCTP;
     }
   }
 
   video_options_.screencast_min_bitrate_kbps =
       rtc_configuration.screencast_min_bitrate;
   audio_options_.combined_audio_video_bwe =
       rtc_configuration.combined_audio_video_bwe;
@@ skipping 469 matching lines @@
 
 bool WebRtcSession::EnableBundle(const cricket::ContentGroup& bundle) {
   const std::string* first_content_name = bundle.FirstContentName();
   if (!first_content_name) {
     LOG(LS_WARNING) << "Tried to BUNDLE with no contents.";
     return false;
   }
   const std::string& transport_name = *first_content_name;
   cricket::BaseChannel* first_channel = GetChannel(transport_name);
 
-#ifdef HAVE_QUIC
-  if (quic_data_transport_ &&
-      bundle.HasContentName(quic_data_transport_->content_name()) &&
-      quic_data_transport_->transport_name() != transport_name) {
-    LOG(LS_ERROR) << "Unable to BUNDLE " << quic_data_transport_->content_name()
-                  << " on " << transport_name << "with QUIC.";
-  }
-#endif
-
   auto maybe_set_transport = [this, bundle, transport_name,
                               first_channel](cricket::BaseChannel* ch) {
     if (!ch || !bundle.HasContentName(ch->content_name())) {
       return true;
     }
 
     if (ch->transport_name() == transport_name) {
       LOG(LS_INFO) << "BUNDLE already enabled for " << ch->content_name()
                    << " on " << transport_name << ".";
       return true;
@@ skipping 488 matching lines @@
 
   const cricket::ContentInfo* voice_info =
       cricket::GetFirstAudioContent(desc);
   if ((!voice_info || voice_info->rejected) && voice_channel_) {
     SignalVoiceChannelDestroyed();
     channel_manager_->DestroyVoiceChannel(voice_channel_.release());
   }
 
   const cricket::ContentInfo* data_info =
       cricket::GetFirstDataContent(desc);
-  if (!data_info || data_info->rejected) {
-    if (data_channel_) {
-      SignalDataChannelDestroyed();
-      channel_manager_->DestroyDataChannel(data_channel_.release());
-    }
-#ifdef HAVE_QUIC
-    // Clean up the existing QuicDataTransport and its QuicTransportChannels.
-    if (quic_data_transport_) {
-      quic_data_transport_.reset();
-    }
-#endif
+  if ((!data_info || data_info->rejected) && data_channel_) {
+    SignalDataChannelDestroyed();
+    channel_manager_->DestroyDataChannel(data_channel_.release());
   }
 }
 
 // Returns the name of the transport channel when BUNDLE is enabled, or nullptr
 // if the channel is not part of any bundle.
 const std::string* WebRtcSession::GetBundleTransportName(
     const cricket::ContentInfo* content,
     const cricket::ContentGroup* bundle) {
   if (!bundle) {
     return nullptr;
@@ skipping 93 matching lines @@
       this, &WebRtcSession::OnDtlsSetupFailure);
 
   SignalVideoChannelCreated();
   video_channel_->SignalSentPacket.connect(this,
                                            &WebRtcSession::OnSentPacket_w);
   return true;
 }
 
 bool WebRtcSession::CreateDataChannel(const cricket::ContentInfo* content,
                                       const std::string* bundle_transport) {
-#ifdef HAVE_QUIC
-  if (data_channel_type_ == cricket::DCT_QUIC) {
-    RTC_DCHECK(transport_controller_->quic());
-    const std::string transport_name =
-        bundle_transport ? *bundle_transport : content->name;
-    quic_data_transport_->SetTransport(transport_name);
-    return true;
-  }
-#endif  // HAVE_QUIC
   bool sctp = (data_channel_type_ == cricket::DCT_SCTP);
   bool require_rtcp_mux =
       rtcp_mux_policy_ == PeerConnectionInterface::kRtcpMuxPolicyRequire;
   bool create_rtcp_transport_channel = !sctp && !require_rtcp_mux;
   data_channel_.reset(channel_manager_->CreateDataChannel(
       transport_controller_.get(), content->name, bundle_transport,
       create_rtcp_transport_channel, data_channel_type_));
   if (!data_channel_) {
     return false;
   }
@@ skipping 163 matching lines @@
 
 // We need to check the local/remote description for the Transport instead of
 // the session, because a new Transport added during renegotiation may have
 // them unset while the session has them set from the previous negotiation.
 // Not doing so may trigger the auto generation of transport description and
 // mess up DTLS identity information, ICE credential, etc.
 bool WebRtcSession::ReadyToUseRemoteCandidate(
     const IceCandidateInterface* candidate,
     const SessionDescriptionInterface* remote_desc,
     bool* valid) {
-  *valid = true;
+  *valid = true;;
 
   const SessionDescriptionInterface* current_remote_desc =
       remote_desc ? remote_desc : remote_desc_.get();
 
   if (!current_remote_desc) {
     return false;
   }
 
   size_t mediacontent_index =
       static_cast<size_t>(candidate->sdp_mline_index());
   size_t remote_content_size =
       current_remote_desc->description()->contents().size();
   if (mediacontent_index >= remote_content_size) {
     LOG(LS_ERROR) << "ReadyToUseRemoteCandidate: Invalid candidate media index "
                   << mediacontent_index;
 
     *valid = false;
     return false;
   }
 
   cricket::ContentInfo content =
       current_remote_desc->description()->contents()[mediacontent_index];
-
-  const std::string transport_name = GetTransportName(content.name);
-  if (transport_name.empty()) {
+  cricket::BaseChannel* channel = GetChannel(content.name);
+  if (!channel) {
     return false;
   }
-  return transport_controller_->ReadyForRemoteCandidates(transport_name);
+
+  return transport_controller_->ReadyForRemoteCandidates(
+      channel->transport_name());
 }
 
 void WebRtcSession::OnTransportControllerGatheringState(
     cricket::IceGatheringState state) {
   ASSERT(signaling_thread()->IsCurrent());
   if (state == cricket::kIceGatheringGathering) {
     if (ice_observer_) {
       ice_observer_->OnIceGatheringChange(
           PeerConnectionInterface::kIceGatheringGathering);
     }
@@ skipping 116 matching lines @@
     metrics_observer_->IncrementSparseEnumCounter(ssl_counter_type,
                                                   ssl_cipher_suite);
   }
 }
 
 void WebRtcSession::OnSentPacket_w(const rtc::SentPacket& sent_packet) {
   RTC_DCHECK(worker_thread()->IsCurrent());
   media_controller_->call_w()->OnSentPacket(sent_packet);
 }
 
-const std::string WebRtcSession::GetTransportName(
-    const std::string& content_name) {
-  cricket::BaseChannel* channel = GetChannel(content_name);
-  if (!channel) {
-#ifdef HAVE_QUIC
-    if (data_channel_type_ == cricket::DCT_QUIC && quic_data_transport_ &&
-        content_name == quic_data_transport_->transport_name()) {
-      return quic_data_transport_->transport_name();
-    }
-#endif
-    // Return an empty string if failed to retrieve the transport name.
-    return "";
-  }
-  return channel->transport_name();
-}
 }  // namespace webrtc