Modify PeerConnection for end-to-end QuicDataChannel usage

webrtc/p2p/quic/quictransportchannel.cc

 /*
  *  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.
  */
 
@@ skipping 425 matching lines @@
                                      : net::Perspective::IS_SERVER;
   bool owns_writer = false;
   rtc::scoped_ptr<net::QuicConnection> connection(new net::QuicConnection(
       kConnectionId, kConnectionIpEndpoint, &helper_, this, owns_writer,
       perspective, net::QuicSupportedVersions()));
   quic_.reset(new QuicSession(std::move(connection), config_));
   quic_->SignalHandshakeComplete.connect(
       this, &QuicTransportChannel::OnHandshakeComplete);
   quic_->SignalConnectionClosed.connect(
       this, &QuicTransportChannel::OnConnectionClosed);
+  quic_->SignalIncomingStream.connect(this,
+                                      &QuicTransportChannel::OnIncomingStream);
   return true;
 }
 
 bool QuicTransportChannel::StartQuicHandshake() {
   if (*ssl_role_ == rtc::SSL_CLIENT) {
     // Unique identifier for remote peer.
     net::QuicServerId server_id(remote_fingerprint_->value, kQuicServerPort);
     // Perform authentication of remote peer; owned by QuicCryptoClientConfig.
     // TODO(mikescarlett): Actually verify proof.
     net::ProofVerifier* proof_verifier = new InsecureProofVerifier();
@@ skipping 60 matching lines @@
 
 // TODO(mikescarlett): Implement check for whether |channel_| is currently
 // write blocked so that |quic_| does not try to write packet. This is
 // necessary because |channel_| can be writable yet write blocked and
 // channel_->GetError() is not flushed when there is no error.
 bool QuicTransportChannel::IsWriteBlocked() const {
   return !channel_->writable();
 }
 
 void QuicTransportChannel::OnHandshakeComplete() {
+  LOG_J(LS_INFO, this)
+      << "QUIC handshake complete, setting QuicTransportChanel to writable";
   set_quic_state(QUIC_TRANSPORT_CONNECTED);
   set_writable(true);
   // OnReceivingState might have been called before the QUIC channel was
   // connected, in which case the QUIC channel is now receiving.
   if (channel_->receiving()) {
     set_receiving(true);
   }
 }
 
 void QuicTransportChannel::OnConnectionClosed(net::QuicErrorCode error,
                                               bool from_peer) {
   LOG_J(LS_INFO, this) << "Connection closed by "
                        << (from_peer ? "other" : "this") << " peer "
                        << "with QUIC error " << error;
   // TODO(mikescarlett): Allow the QUIC session to be reset when the connection
   // does not close due to failure.
   set_quic_state(QUIC_TRANSPORT_CLOSED);
   set_writable(false);
+  SignalClosed();
 }
 
 void QuicTransportChannel::OnProofValid(
     const net::QuicCryptoClientConfig::CachedState& cached) {
   LOG_J(LS_INFO, this) << "Cached proof marked valid";
 }
 
 void QuicTransportChannel::OnProofVerifyDetailsAvailable(
     const net::ProofVerifyDetails& verify_details) {
   LOG_J(LS_INFO, this) << "Proof verify details available from"
                        << " QuicCryptoClientStream";
 }
 
 bool QuicTransportChannel::HasDataToWrite() const {
   return quic_ && quic_->HasDataToWrite();
 }
 
 void QuicTransportChannel::OnCanWrite() {
   RTC_DCHECK(quic_ != nullptr);
   quic_->connection()->OnCanWrite();
 }
 
 void QuicTransportChannel::set_quic_state(QuicTransportState state) {
   LOG_J(LS_VERBOSE, this) << "set_quic_state from:" << quic_state_ << " to "
                           << state;
   quic_state_ = state;
 }
 
+ReliableQuicStream* QuicTransportChannel::CreateQuicStream() {
+  if (quic_) {
+    net::SpdyPriority priority = 0;  // Priority of the QUIC stream (not used)
+    return quic_->CreateOutgoingDynamicStream(priority);
+  }
+  return nullptr;
+}
+
+void QuicTransportChannel::OnIncomingStream(ReliableQuicStream* stream) {
+  SignalIncomingStream(stream);
+}
+
 }  // namespace cricket