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

net/quic/core/quic_spdy_stream.cc

 // Copyright 2013 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/core/quic_spdy_stream.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/core/quic_bug_tracker.h"
 #include "net/quic/core/quic_spdy_session.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/core/quic_write_blocked_list.h"
 #include "net/quic/core/spdy_utils.h"
 
 using base::IntToString;
 using base::StringPiece;
 using std::min;
 using std::string;
 
 namespace net {
 
 #define ENDPOINT                                                               \
   (session()->perspective() == Perspective::IS_SERVER ? "Server: " : "Client:" \
                                                                      " ")
 
 QuicSpdyStream::QuicSpdyStream(QuicStreamId id, QuicSpdySession* spdy_session)
-    : ReliableQuicStream(id, spdy_session),
+    : QuicStream(id, spdy_session),
       spdy_session_(spdy_session),
       visitor_(nullptr),
       allow_bidirectional_data_(false),
       headers_decompressed_(false),
       priority_(kDefaultPriority),
       trailers_decompressed_(false),
       trailers_consumed_(false) {
   DCHECK_NE(kCryptoStreamId, id);
   // Don't receive any callbacks from the sequencer until headers
   // are complete.
   sequencer()->SetBlockedUntilFlush();
   spdy_session_->RegisterStreamPriority(id, priority_);
 }
 
 QuicSpdyStream::~QuicSpdyStream() {
   if (spdy_session_ != nullptr) {
     spdy_session_->UnregisterStreamPriority(id());
   }
 }
 
 void QuicSpdyStream::CloseWriteSide() {
   if (!fin_received() && !rst_received() && sequencer()->ignore_read_data() &&
       !rst_sent()) {
     DCHECK(fin_sent());
     // Tell the peer to stop sending further data.
     DVLOG(1) << ENDPOINT << "Send QUIC_STREAM_NO_ERROR on stream " << id();
     Reset(QUIC_STREAM_NO_ERROR);
   }
 
-  ReliableQuicStream::CloseWriteSide();
+  QuicStream::CloseWriteSide();
 }
 
 void QuicSpdyStream::StopReading() {
   if (!fin_received() && !rst_received() && write_side_closed() &&
       !rst_sent()) {
     DCHECK(fin_sent());
     // Tell the peer to stop sending further data.
     DVLOG(1) << ENDPOINT << "Send QUIC_STREAM_NO_ERROR on stream " << id();
     Reset(QUIC_STREAM_NO_ERROR);
   }
-  ReliableQuicStream::StopReading();
+  QuicStream::StopReading();
 }
 
 size_t QuicSpdyStream::WriteHeaders(
     SpdyHeaderBlock header_block,
     bool fin,
     QuicAckListenerInterface* ack_notifier_delegate) {
   size_t bytes_written = spdy_session_->WriteHeaders(
       id(), std::move(header_block), fin, priority_, ack_notifier_delegate);
   if (fin) {
     // TODO(rch): Add test to ensure fin_sent_ is set whenever a fin is sent.
@@ skipping 170 matching lines @@
         QUIC_INVALID_HEADERS_STREAM_DATA, "Trailers are malformed",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return;
   }
   trailers_decompressed_ = true;
   OnStreamFrame(QuicStreamFrame(id(), fin, final_byte_offset, StringPiece()));
 }
 
 void QuicSpdyStream::OnStreamReset(const QuicRstStreamFrame& frame) {
   if (frame.error_code != QUIC_STREAM_NO_ERROR) {
-    ReliableQuicStream::OnStreamReset(frame);
+    QuicStream::OnStreamReset(frame);
     return;
   }
   DVLOG(1) << "Received QUIC_STREAM_NO_ERROR, not discarding response";
   set_rst_received(true);
   MaybeIncreaseHighestReceivedOffset(frame.byte_offset);
   set_stream_error(frame.error_code);
   CloseWriteSide();
 }
 
 void QuicSpdyStream::OnClose() {
-  ReliableQuicStream::OnClose();
+  QuicStream::OnClose();
 
   if (visitor_) {
     Visitor* visitor = visitor_;
     // Calling Visitor::OnClose() may result the destruction of the visitor,
     // so we need to ensure we don't call it again.
     visitor_ = nullptr;
     visitor->OnClose(this);
   }
 }
 
 void QuicSpdyStream::OnCanWrite() {
-  ReliableQuicStream::OnCanWrite();
+  QuicStream::OnCanWrite();
 
   // Trailers (and hence a FIN) may have been sent ahead of queued body bytes.
   if (!HasBufferedData() && fin_sent()) {
     CloseWriteSide();
   }
 }
 
 bool QuicSpdyStream::FinishedReadingHeaders() const {
   return headers_decompressed_ && header_list_.empty();
 }
@@ skipping 42 matching lines @@
 QuicConsumedData QuicSpdyStream::WritevDataInner(
     QuicIOVector iov,
     QuicStreamOffset offset,
     bool fin,
     QuicAckListenerInterface* ack_notifier_delegate) {
   if (spdy_session_->headers_stream() != nullptr &&
       spdy_session_->force_hol_blocking()) {
     return spdy_session_->headers_stream()->WritevStreamData(
         id(), iov, offset, fin, ack_notifier_delegate);
   }
-  return ReliableQuicStream::WritevDataInner(iov, offset, fin,
-                                             ack_notifier_delegate);
+  return QuicStream::WritevDataInner(iov, offset, fin, ack_notifier_delegate);
 }
 
 }  // namespace net