Add QuicTransportChannel methods for QUIC streams

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 78 matching lines @@
 
 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