Landing Recent QUIC changes until 12:43 PM, Nov 5, 2016 UTC+8

net/quic/quartc/quartc_session.cc

 // Copyright (c) 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quartc/quartc_session.h"
 
 #include "base/rand_util.h"
 
 namespace {
 
@@ skipping 144 matching lines @@
     DCHECK(IsCryptoHandshakeConfirmed());
 
     DCHECK(session_delegate_);
     session_delegate_->OnCryptoHandshakeComplete();
   }
 }
 
 void QuartcSession::CloseStream(QuicStreamId stream_id) {
   if (IsClosedStream(stream_id)) {
     // When CloseStream has been called recursively (via
-    // ReliableQuicStream::OnClose), the stream is already closed so return.
+    // QuicStream::OnClose), the stream is already closed so return.
     return;
   }
   write_blocked_streams()->UnregisterStream(stream_id);
   QuicSession::CloseStream(stream_id);
 }
 
 void QuartcSession::OnConnectionClosed(QuicErrorCode error,
                                        const std::string& error_details,
                                        ConnectionCloseSource source) {
   QuicSession::OnConnectionClosed(error, error_details, source);
@@ skipping 79 matching lines @@
 void QuartcSession::SetClientCryptoConfig(
     QuicCryptoClientConfig* client_config) {
   quic_crypto_client_config_.reset(client_config);
 }
 
 void QuartcSession::SetServerCryptoConfig(
     QuicCryptoServerConfig* server_config) {
   quic_crypto_server_config_.reset(server_config);
 }
 
-ReliableQuicStream* QuartcSession::CreateIncomingDynamicStream(
-    QuicStreamId id) {
+QuicStream* QuartcSession::CreateIncomingDynamicStream(QuicStreamId id) {
   QuartcStream* stream = CreateDataStream(id, kDefaultPriority);
   if (stream) {
     DCHECK(session_delegate_);
     session_delegate_->OnIncomingStream(stream);
   }
   return stream;
 }
 
 QuartcStream* QuartcSession::CreateDataStream(QuicStreamId id,
                                               SpdyPriority priority) {
   if (crypto_stream_ == nullptr || !crypto_stream_->encryption_established()) {
     // Encryption not active so no stream created
     return nullptr;
   }
   QuartcStream* stream = new QuartcStream(id, this);
   if (stream) {
     // Make QuicSession take ownership of the stream.
-    ActivateStream(std::unique_ptr<ReliableQuicStream>(stream));
+    ActivateStream(std::unique_ptr<QuicStream>(stream));
     // Register the stream to the QuicWriteBlockedList. |priority| is clamped
     // between 0 and 7, with 0 being the highest priority and 7 the lowest
     // priority.
     write_blocked_streams()->RegisterStream(stream->id(), priority);
   }
   return stream;
 }
 
 }  // namespace net