Add QuicDataChannel and QuicDataTransport classes

webrtc/api/quicdatatransport.cc

Index: webrtc/api/quicdatatransport.cc
diff --git a/webrtc/api/quicdatatransport.cc b/webrtc/api/quicdatatransport.cc
new file mode 100644
index 0000000000000000000000000000000000000000..70ad03dbfdde6ddb79b946bb5db567d74490b788
--- /dev/null
+++ b/webrtc/api/quicdatatransport.cc
@@ -0,0 +1,146 @@
+/*
+ *  Copyright 2016 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/quicdatatransport.h"
+
+#include "webrtc/base/logging.h"
+#include "webrtc/p2p/quic/quictransportchannel.h"
+#include "webrtc/p2p/quic/reliablequicstream.h"
+
+namespace webrtc {
+
+QuicDataTransport::QuicDataTransport(rtc::Thread* signaling_thread,
+                                     rtc::Thread* worker_thread)
+    : signaling_thread_(signaling_thread), worker_thread_(worker_thread) {
+  RTC_DCHECK(signaling_thread_);
+  RTC_DCHECK(worker_thread_);
+}
+
+QuicDataTransport::~QuicDataTransport() {}
+
+bool QuicDataTransport::SetTransportChannel(
+    cricket::QuicTransportChannel* channel) {
+  if (!channel) {
+    LOG(LS_ERROR) << "|channel| is NULL. Cannot set transport channel.";
+    return false;
+  }
+  if (quic_transport_channel_) {
+    if (channel == quic_transport_channel_) {
+      LOG(LS_WARNING) << "Ignoring duplicate transport channel.";
+      return true;
+    }
+    LOG(LS_ERROR) << "|channel| does not match existing transport channel.";
+    return false;
+  }
+
+  LOG(LS_INFO) << "Setting QuicTransportChannel for QuicDataTransport";
+  quic_transport_channel_ = channel;
+  quic_transport_channel_->SignalIncomingStream.connect(
+      this, &QuicDataTransport::OnIncomingStream);
+
+  bool success = true;
+  for (const auto& kv : data_channel_by_id_) {
+    rtc::scoped_refptr<QuicDataChannel> data_channel = kv.second;
+    if (!data_channel->SetTransportChannel(quic_transport_channel_)) {
+      LOG(LS_ERROR)
+          << "Cannot set QUIC transport channel for QUIC data channel "
+          << kv.first;
+      success = false;
+    }
+  }
+  return success;
+}
+
+rtc::scoped_refptr<DataChannelInterface> QuicDataTransport::CreateDataChannel(
+    const std::string& label,
+    const DataChannelInit* config) {
+  if (config == nullptr) {
+    return nullptr;
+  }
+  if (data_channel_by_id_.find(config->id) != data_channel_by_id_.end()) {
+    LOG(LS_ERROR) << "QUIC data channel already exists with id " << config->id;
+    return nullptr;
+  }
+  rtc::scoped_refptr<QuicDataChannel> data_channel(
+      new QuicDataChannel(signaling_thread_, worker_thread_, label, *config));
+  if (quic_transport_channel_) {
+    if (!data_channel->SetTransportChannel(quic_transport_channel_)) {
+      LOG(LS_ERROR)
+          << "Cannot set QUIC transport channel for QUIC data channel "
+          << config->id;
+    }
+  }
+
+  data_channel_by_id_[data_channel->id()] = data_channel;
+  return data_channel;
+}
+
+void QuicDataTransport::DestroyDataChannel(int id) {
+  data_channel_by_id_.erase(id);
+}
+
+bool QuicDataTransport::HasDataChannel(int id) const {
+  return data_channel_by_id_.find(id) != data_channel_by_id_.end();
+}
+
+bool QuicDataTransport::HasDataChannels() const {
+  return !data_channel_by_id_.empty();
+}
+
+// Called when a QUIC stream is created for incoming data.
+void QuicDataTransport::OnIncomingStream(cricket::ReliableQuicStream* stream) {
+  RTC_DCHECK(stream != nullptr);
+  quic_stream_by_id_[stream->id()] = stream;
+  stream->SignalDataReceived.connect(this, &QuicDataTransport::OnDataReceived);
+}
+
+// Called when the first QUIC stream frame is received for incoming data.
+void QuicDataTransport::OnDataReceived(net::QuicStreamId id,
+                                       const char* data,
+                                       size_t len) {
+  const auto& quic_stream_kv = quic_stream_by_id_.find(id);
+  if (quic_stream_kv == quic_stream_by_id_.end()) {
+    RTC_DCHECK(false);
+    return;
+  }
+  cricket::ReliableQuicStream* stream = quic_stream_kv->second;
+  stream->SignalDataReceived.disconnect(this);
+  quic_stream_by_id_.erase(id);
+  // Read the data channel ID and message ID.
+  int data_channel_id;
+  uint64_t message_id;
+  size_t bytes_read;
+  if (!ParseQuicDataMessageHeader(data, len, &data_channel_id, &message_id,
+                                  &bytes_read)) {
+    LOG(LS_ERROR) << "Could not read QUIC message header from QUIC stream "
+                  << id;
+    return;
+  }
+  data += bytes_read;
+  len -= bytes_read;
+  // Retrieve the data channel which will handle the message.
+  const auto& data_channel_kv = data_channel_by_id_.find(data_channel_id);
+  if (data_channel_kv == data_channel_by_id_.end()) {
+    // TODO(mikescarlett): Implement OPEN message to create a new
+    // QuicDataChannel when messages are received for a nonexistent ID.
+    LOG(LS_ERROR) << "Data was received for QUIC data channel "
+                  << data_channel_id
+                  << " but it is not registered to the QuicDataTransport.";
+    return;
+  }
+  QuicDataChannel* data_channel = data_channel_kv->second;
+  QuicDataChannel::Message message;
+  message.id = message_id;
+  message.buffer = rtc::CopyOnWriteBuffer(data, len);
+  message.stream = stream;
+  data_channel->OnIncomingMessage(std::move(message));
+}
+
+}  // namespace webrtc