Modify PeerConnection 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 503 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 && dtls_enabled_) {
+    // Use QUIC instead of DTLS when |enable_quic| is true and encryption is
+    // enabled.
+    data_channel_type_ = cricket::DCT_QUIC;
+    transport_controller_->use_quic();
+    LOG(LS_INFO) << "Using QUIC instead of DTLS";
+  }
+#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 1166 matching lines @@
 
   const cricket::ContentInfo* video = cricket::GetFirstVideoContent(desc);
   if (video && !video->rejected && !video_channel_) {
     if (!CreateVideoChannel(video)) {
       LOG(LS_ERROR) << "Failed to create video channel.";
       return false;
     }
   }
 
   const cricket::ContentInfo* data = cricket::GetFirstDataContent(desc);
-  if (data_channel_type_ != cricket::DCT_NONE &&
-      data && !data->rejected && !data_channel_) {
+  if (data_channel_type_ != cricket::DCT_NONE && data && !data->rejected &&
+      !data_channel_) {
     if (!CreateDataChannel(data)) {
       LOG(LS_ERROR) << "Failed to create data channel.";
       return false;
     }
   }
 
   if (rtcp_mux_policy_ == PeerConnectionInterface::kRtcpMuxPolicyRequire) {
     if (voice_channel()) {
       voice_channel()->ActivateRtcpMux();
     }
@@ skipping 50 matching lines @@
   video_channel_->SignalDtlsSetupFailure.connect(
       this, &WebRtcSession::OnDtlsSetupFailure);
 
   SignalVideoChannelCreated();
   video_channel_->transport_channel()->SignalSentPacket.connect(
       this, &WebRtcSession::OnSentPacket_w);
   return true;
 }
 
 bool WebRtcSession::CreateDataChannel(const cricket::ContentInfo* content) {
-  bool sctp = (data_channel_type_ == cricket::DCT_SCTP);
+#ifdef HAVE_QUIC
+  if (data_channel_type_ == cricket::DCT_QUIC) {
+    // The TransportController may not have a QuicTransportChannel, so force
+    // creation of it.
+    LOG(LS_INFO) << "Getting or creating QuicTransportChannel";
+    RTC_DCHECK(transport_controller_->quic());
+    cricket::TransportChannel* transport_channel =
+        worker_thread_->Invoke<cricket::TransportChannel*>(
+            rtc::Bind(&cricket::TransportController::CreateTransportChannel_w,
+                      transport_controller_.get(), content->name,
+                      cricket::ICE_CANDIDATE_COMPONENT_RTP));
+    if (!transport_channel) {
+      return false;
+    }
+    quic_transport_channel_ =
+        static_cast<cricket::QuicTransportChannel*>(transport_channel);
+    SignalQuicTransportChannelCreated(quic_transport_channel_);
+    return true;
+  }
+#endif  // HAVE_QUIC
+  bool sctp = data_channel_type_ == cricket::DCT_SCTP;
   data_channel_.reset(channel_manager_->CreateDataChannel(
       transport_controller_.get(), content->name, !sctp, data_channel_type_));
   if (!data_channel_) {
     return false;
   }
 
   if (sctp) {
     data_channel_->SignalDataReceived.connect(
         this, &WebRtcSession::OnDataChannelMessageReceived);
   }
@@ skipping 153 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) {
+#ifdef HAVE_QUIC
+    if (data_channel_type_ == cricket::DCT_QUIC && quic_transport_channel_ &&
+        content.name == quic_transport_channel_->transport_name()) {
+      // QUIC data channels do not have a BaseChannel unless bundle is enabled.
+      return transport_controller_->ReadyForRemoteCandidates(
+          quic_transport_channel_->transport_name());
+    }
+#endif  // HAVE_QUIC
     return false;
   }
 
   return transport_controller_->ReadyForRemoteCandidates(
       channel->transport_name());
 }
 
 void WebRtcSession::OnTransportControllerGatheringState(
     cricket::IceGatheringState state) {
   ASSERT(signaling_thread()->IsCurrent());
@@ skipping 123 matching lines @@
   }
 }
 
 void WebRtcSession::OnSentPacket_w(cricket::TransportChannel* channel,
                                    const rtc::SentPacket& sent_packet) {
   RTC_DCHECK(worker_thread()->IsCurrent());
   media_controller_->call_w()->OnSentPacket(sent_packet);
 }
 
 }  // namespace webrtc