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 400 matching lines @@
     return true;
   }
   return false;
 }
 
 WebRtcSession::WebRtcSession(webrtc::MediaControllerInterface* media_controller,
                              rtc::Thread* network_thread,
                              rtc::Thread* worker_thread,
                              rtc::Thread* signaling_thread,
                              cricket::PortAllocator* port_allocator)
-    : worker_thread_(worker_thread),
+    : network_thread_(network_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_(new cricket::TransportController(signaling_thread,
                                                              network_thread,
                                                              port_allocator)),
       media_controller_(media_controller),
       channel_manager_(media_controller_->channel_manager()),
@@ skipping 26 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;
-  } else {
+  }
+#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 {
     // 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
+

[Zhi Huang, 2016/07/25 23:40:36]

If we do not support changing the underneath transport channels, then we may
have to figure out some way to negotiate the bundle.

   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) && data_channel_) {
-    SignalDataChannelDestroyed();
-    channel_manager_->DestroyDataChannel(data_channel_.release());
+  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
   }
 }
 
 // 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);

[Zhi Huang, 2016/07/25 23:40:36]

Is it better to make it

"quic_data_transport_->SetTransport(bundle_transport ? 
                                     *bundle_transport : 
                                      content->name); "
?

[pthatcher1, 2016/07/27 23:21:49]

Why don't we do this:

quic_data_transport_.reset(new QuicDataTransport(..., content->name,
transport_name)); 

?


Then you can simplify the QuicDataTransport code and ignore half my comments
there :)

[Zhi Huang, 2016/08/01 05:12:28]

The original design is that the quic_data_transport_ will be created when
initializing the webrtcsession and the quic_transport_channel will be set when
calling  CreateDataChannel.

Doing this means that we can not create QuicDataChannel(the api one) from
peerconnection before calling CreateDataChannel(the pc one). Are we trying to do
this?  Also it seems that we can not create the quic_data_transport earlier if
we change the constructor because we don't know the transport_name and content
name.

+    quic_data_transport_->set_content_name(content->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];
-  cricket::BaseChannel* channel = GetChannel(content.name);
-  if (!channel) {
+
+  const std::string transport_name = GetTransportName(content.name);
+  if (transport_name.empty()) {
     return false;
   }
-
-  return transport_controller_->ReadyForRemoteCandidates(
-      channel->transport_name());
+  return transport_controller_->ReadyForRemoteCandidates(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