Deletes dead code.

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"
@@ skipping 128 matching lines @@
 }
 
 bool QuicSpdyStream::IsDoneReading() const {
   bool done_reading_headers = FinishedReadingHeaders();
   bool done_reading_body = sequencer()->IsClosed();
   bool done_reading_trailers = FinishedReadingTrailers();
   return done_reading_headers && done_reading_body && done_reading_trailers;
 }
 
 bool QuicSpdyStream::HasBytesToRead() const {
-  bool headers_to_read = !decompressed_headers_.empty();
-  bool body_to_read = sequencer()->HasBytesToRead();
-  bool trailers_to_read = !decompressed_trailers_.empty();
-  return headers_to_read || body_to_read || trailers_to_read;
-}
-
-void QuicSpdyStream::MarkHeadersConsumed(size_t bytes_consumed) {
-  decompressed_headers_.erase(0, bytes_consumed);
-  if (FinishedReadingHeaders()) {
-    sequencer()->SetUnblocked();
-  }
-}
-
-void QuicSpdyStream::MarkTrailersConsumed(size_t bytes_consumed) {
-  decompressed_trailers_.erase(0, bytes_consumed);
+  return sequencer()->HasBytesToRead();
 }
 
 void QuicSpdyStream::MarkTrailersConsumed() {
   trailers_consumed_ = true;
 }
 
 void QuicSpdyStream::ConsumeHeaderList() {
   header_list_.Clear();
   if (FinishedReadingHeaders()) {
     sequencer()->SetUnblocked();
   }
 }
 
 void QuicSpdyStream::SetPriority(SpdyPriority priority) {
   DCHECK_EQ(0u, stream_bytes_written());
   spdy_session_->UpdateStreamPriority(id(), priority);
   priority_ = priority;
 }
 
-void QuicSpdyStream::OnStreamHeaders(StringPiece headers_data) {
-  if (!headers_decompressed_) {
-    headers_data.AppendToString(&decompressed_headers_);
-  } else {
-    DCHECK(!trailers_decompressed_);
-    headers_data.AppendToString(&decompressed_trailers_);
-  }
-}
-
 void QuicSpdyStream::OnStreamHeadersPriority(SpdyPriority priority) {
   DCHECK_EQ(Perspective::IS_SERVER, session()->connection()->perspective());
   SetPriority(priority);
 }
 
-void QuicSpdyStream::OnStreamHeadersComplete(bool fin, size_t frame_len) {
-  if (!headers_decompressed_) {
-    OnInitialHeadersComplete(fin, frame_len);
-  } else {
-    OnTrailingHeadersComplete(fin, frame_len);
-  }
-}
-
 void QuicSpdyStream::OnStreamHeaderList(bool fin,
                                         size_t frame_len,
                                         const QuicHeaderList& header_list) {
   // The headers list avoid infinite buffering by clearing the headers list
   // if the current headers are too large. So if the list is empty here
   // then the headers list must have been too large, and the stream should
   // be reset.
+  // TODO(rch): Use an explicit "headers too large" signal. An empty header list
+  // might be acceptable if it corresponds to a trailing header frame.
   if (FLAGS_quic_limit_uncompressed_headers && header_list.empty()) {
     OnHeadersTooLarge();
     if (IsDoneReading()) {
       return;
     }
   }
   if (!headers_decompressed_) {
     OnInitialHeadersComplete(fin, frame_len, header_list);
   } else {
     OnTrailingHeadersComplete(fin, frame_len, header_list);
   }
 }
 
 void QuicSpdyStream::OnHeadersTooLarge() {
   Reset(QUIC_HEADERS_TOO_LARGE);
 }
 
-void QuicSpdyStream::OnInitialHeadersComplete(bool fin, size_t /*frame_len*/) {
-  headers_decompressed_ = true;
-  if (fin) {
-    OnStreamFrame(QuicStreamFrame(id(), fin, 0, StringPiece()));
-  }
-  if (FinishedReadingHeaders()) {
-    sequencer()->SetUnblocked();
-  }
-}
-
 void QuicSpdyStream::OnInitialHeadersComplete(
     bool fin,
     size_t /*frame_len*/,
     const QuicHeaderList& header_list) {
   headers_decompressed_ = true;
   header_list_ = header_list;
   if (fin) {
     OnStreamFrame(QuicStreamFrame(id(), fin, 0, StringPiece()));
   }
   if (FinishedReadingHeaders()) {
     sequencer()->SetUnblocked();
   }
 }
 
-void QuicSpdyStream::OnPromiseHeaders(StringPiece headers_data) {
-  headers_data.AppendToString(&decompressed_headers_);
-}
-
-void QuicSpdyStream::OnPromiseHeadersComplete(
-    QuicStreamId /* promised_stream_id */,
-    size_t /* frame_len */) {
-  // To be overridden in QuicSpdyClientStream.  Not supported on
-  // server side.
-  session()->connection()->CloseConnection(
-      QUIC_INVALID_HEADERS_STREAM_DATA, "Promise headers received by server",
-      ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-  return;
-}
-
 void QuicSpdyStream::OnPromiseHeaderList(
     QuicStreamId /* promised_id */,
     size_t /* frame_len */,
     const QuicHeaderList& /*header_list */) {
   // To be overridden in QuicSpdyClientStream.  Not supported on
   // server side.
   session()->connection()->CloseConnection(
       QUIC_INVALID_HEADERS_STREAM_DATA, "Promise headers received by server",
       ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
   return;
 }
 
-void QuicSpdyStream::OnTrailingHeadersComplete(bool fin, size_t /*frame_len*/) {
-  DCHECK(!trailers_decompressed_);
-  if (fin_received()) {
-    DLOG(ERROR) << "Received Trailers after FIN, on stream: " << id();
-    session()->connection()->CloseConnection(
-        QUIC_INVALID_HEADERS_STREAM_DATA, "Trailers after fin",
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-    return;
-  }
-  if (!fin) {
-    DLOG(ERROR) << "Trailers must have FIN set, on stream: " << id();
-    session()->connection()->CloseConnection(
-        QUIC_INVALID_HEADERS_STREAM_DATA, "Fin missing from trailers",
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-    return;
-  }
-
-  size_t final_byte_offset = 0;
-  if (!SpdyUtils::ParseTrailers(decompressed_trailers().data(),
-                                decompressed_trailers().length(),
-                                &final_byte_offset, &received_trailers_)) {
-    DLOG(ERROR) << "Trailers are malformed: " << id();
-    session()->connection()->CloseConnection(
-        QUIC_INVALID_HEADERS_STREAM_DATA, "Trailers are malformed",
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-    return;
-  }
-
-  // The data on this stream ends at |final_byte_offset|.
-  DVLOG(1) << "Stream ends at byte offset: " << final_byte_offset
-           << "  currently read: " << stream_bytes_read();
-  trailers_decompressed_ = true;
-  OnStreamFrame(QuicStreamFrame(id(), fin, final_byte_offset, StringPiece()));
-}
-
 void QuicSpdyStream::OnTrailingHeadersComplete(
     bool fin,
     size_t /*frame_len*/,
     const QuicHeaderList& header_list) {
   DCHECK(!trailers_decompressed_);
   if (fin_received()) {
     DLOG(ERROR) << "Received Trailers after FIN, on stream: " << id();
     session()->connection()->CloseConnection(
         QUIC_INVALID_HEADERS_STREAM_DATA, "Trailers after fin",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
@@ skipping 47 matching lines @@
 void QuicSpdyStream::OnCanWrite() {
   ReliableQuicStream::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_ && decompressed_headers_.empty() &&
-         header_list_.empty();
+  return headers_decompressed_ && header_list_.empty();
 }
 
 bool QuicSpdyStream::ParseHeaderStatusCode(const SpdyHeaderBlock& header,
                                            int* status_code) const {
   SpdyHeaderBlock::const_iterator it = header.find(":status");
   if (it == header.end()) {
     return false;
   }
   const StringPiece status(it->second);
   if (status.size() != 3) {
@@ skipping 11 matching lines @@
 }
 
 bool QuicSpdyStream::FinishedReadingTrailers() const {
   // If no further trailing headers are expected, and the decompressed trailers
   // (if any) have been consumed, then reading of trailers is finished.
   if (!fin_received()) {
     return false;
   } else if (!trailers_decompressed_) {
     return true;
   } else {
-    return trailers_consumed_ && decompressed_trailers_.empty();
+    return trailers_consumed_;
   }
 }
 
 SpdyPriority QuicSpdyStream::priority() const {
   return priority_;
 }
 
 void QuicSpdyStream::ClearSession() {
   spdy_session_ = nullptr;
 }
 
 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);
 }
 
 }  // namespace net