Modify PeerConnection for end-to-end QuicDataChannel usage

webrtc/api/peerconnection.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 815 matching lines @@
 PeerConnectionInterface::IceGatheringState
 PeerConnection::ice_gathering_state() {
   return ice_gathering_state_;
 }
 
 rtc::scoped_refptr<DataChannelInterface>
 PeerConnection::CreateDataChannel(
     const std::string& label,
     const DataChannelInit* config) {
   TRACE_EVENT0("webrtc", "PeerConnection::CreateDataChannel");
+#ifdef USE_QUIC
+  // TODO(mikescarlett): Handle case when CreateDataChannel() is called
+  // before QUIC is specified in the session description.

[Taylor Brandstetter, 2016/04/01 23:23:41]

Can't "use quic" be a parameter in RTCConfiguration, at the PeerConnection
initialization time? Or maybe it could be a parameter in the DataChannelInit.

[mikescarlett, 2016/04/05 19:58:49]

This seems necessary since QUIC won't be negotiated.

+  if (session_->data_channel_type() == cricket::DCT_QUIC) {
+    cricket::QuicTransportChannel* quic_transport_channel =
+        session_->quic_transport_channel();
+    RTC_DCHECK(quic_transport_channel != nullptr);

[Taylor Brandstetter, 2016/04/01 23:23:41]

It should be possible to create a data channel even if the underlying QUIC
transport channel doesn't exist.

[mikescarlett, 2016/04/05 19:58:48]

Fixed.

+    rtc::scoped_refptr<QuicDataChannel> channel(new QuicDataChannel(
+        quic_transport_channel, session_->signaling_thread(),
+        session_->worker_thread(), label, config));
+    quic_data_channels_.push_back(channel);
+    if (!quic_transport_) {
+      quic_transport_.reset(new QuicTransport(quic_transport_channel));
+    }

[pthatcher1, 2016/03/30 20:34:47]

It seems like this should logically go a few lines up, just before "new
QuicDataChannel".

+    quic_transport_->RegisterDataChannel(channel);
+    return channel;
+  }
+#endif  // USE_QUIC
+
   bool first_datachannel = !HasDataChannels();
 
   rtc::scoped_ptr<InternalDataChannelInit> internal_config;
   if (config) {
     internal_config.reset(new InternalDataChannelInit(*config));
   }
   rtc::scoped_refptr<DataChannelInterface> channel(
       InternalCreateDataChannel(label, internal_config.get()));
   if (!channel.get()) {
     return nullptr;
@@ skipping 177 matching lines @@
 
   const cricket::ContentInfo* data_content =
       GetFirstDataContent(desc->description());
   if (data_content) {
     const cricket::DataContentDescription* data_desc =
         static_cast<const cricket::DataContentDescription*>(
             data_content->description);
     if (rtc::starts_with(data_desc->protocol().data(),
                          cricket::kMediaProtocolRtpPrefix)) {
       UpdateLocalRtpDataChannels(data_desc->streams());
     }

[pthatcher, 2016/03/30 22:59:48]

An alternative to the TransportChannel storing a transport channel:

quic_transport_channel =
static_cast<QuicDataChannel>(session_->data_channel()->transport_channel());
quic_data_transport_->SetTransportChannel(quic_transport_channel);
for (auto dc : quic_data_channels_) {
  dc->SetTransportChannel(quic_transport_channel);
}

   }
 
   SetSessionDescriptionMsg* msg = new SetSessionDescriptionMsg(observer);
   signaling_thread()->Post(this, MSG_SET_SESSIONDESCRIPTION_SUCCESS, msg);
 
   // MaybeStartGathering needs to be called after posting
   // MSG_SET_SESSIONDESCRIPTION_SUCCESS, so that we don't signal any candidates
   // before signaling that SetLocalDescription completed.
   session_->MaybeStartGathering();
 }
@@ skipping 870 matching lines @@
     RTC_DCHECK(channel->data_channel_type() == cricket::DCT_SCTP);
     sctp_data_channels_.push_back(channel);
     channel->SignalClosed.connect(this,
                                   &PeerConnection::OnSctpDataChannelClosed);
   }
 
   return channel;
 }
 
 bool PeerConnection::HasDataChannels() const {
   return !rtp_data_channels_.empty() || !sctp_data_channels_.empty();

[Taylor Brandstetter, 2016/04/01 23:23:41]

|| !quic_data_channels_.empty()

This is used so that a data m= section is offered if there's at least one data
channel.

[mikescarlett, 2016/04/05 19:58:49]

Done.

 }
 
 void PeerConnection::AllocateSctpSids(rtc::SSLRole role) {
   for (const auto& channel : sctp_data_channels_) {
     if (channel->id() < 0) {
       int sid;
       if (!sid_allocator_.AllocateSid(role, &sid)) {
         LOG(LS_ERROR) << "Failed to allocate SCTP sid.";
         continue;
       }
@@ skipping 123 matching lines @@
 DataChannel* PeerConnection::FindDataChannelBySid(int sid) const {
   for (const auto& channel : sctp_data_channels_) {
     if (channel->id() == sid) {
       return channel;
     }
   }
   return nullptr;
 }
 
 }  // namespace webrtc