Refactoring on QUIC

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 66 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_) {

[pthatcher1, 2016/06/28 22:39:03]

I don't think we need to check for 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";

[pthatcher1, 2016/06/28 22:39:03]

We could log this if dtls_enabled_.  But otherwise, I don't think we need to.

+  }
+#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 1237 matching lines @@
       this, &WebRtcSession::OnChannelFirstPacketReceived);
 
   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) {
+    // 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 =
+        network_thread_->Invoke<cricket::TransportChannel*>(
+            RTC_FROM_HERE,
+            rtc::Bind(&cricket::TransportController::CreateTransportChannel_n,
+                      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

[Taylor Brandstetter, 2016/06/29 17:50:04]

I think this needs to be rethought. This design means that when using QUIC,
WebRtcSession creates the transport channel instead of BaseChannel. But that
means WebRtcSession should be doing the same stuff that happens when using
BaseChannels, such as:

* If BUNDLE is negotiated, may need to switch which TransportChannel is used for
data
* If a media description is rejected, the TransportChannel should be destroyed.

It may be easier to just use BaseChannel, and signal when its TransportChannel
is changed and when it's created/destroyed. For example, when bundling is
negotiated, the PeerConnection's QuicDataTransport should start using the
QuicTransportChannel negotiated for bundling data.

Or, QuicDataTransport could just be a subclass of BaseChannel. Then there are
much less wires to hook up.

It's probably a good idea to have a whiteboard discussion when Peter is here.

[pthatcher1, 2016/06/29 18:35:28]

Yeah, we can discuss it in person.  This was the design Michael and I came up
with while he was here.  I was trying to avoid the complexity of BaseChannel by
requiring that QUIC only be used with max-bundle, at least in the early version
of support for QUIC.

Similarly, this CL doesn't do any negotiation.  It just assumes you will do QUIC
and won't reject QUIC (kind of a like a max-quic setting would be).  Doing
negotiation can come in a later CL (at which point, we may need to do something
with BaseChannel, but there are actually harder things to whiteboard and figure
out around offering either DTLS or QUIC and then reacting to whichever comes
back either on the signaling or media path).

   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 178 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 122 matching lines @@
                                                   ssl_cipher_suite);
   }
 }
 
 void WebRtcSession::OnSentPacket_w(const rtc::SentPacket& sent_packet) {
   RTC_DCHECK(worker_thread()->IsCurrent());
   media_controller_->call_w()->OnSentPacket(sent_packet);
 }
 
 }  // namespace webrtc