QuicSpdyStream supports receiving trailing headers frames. Flag protected by FLAGS_quic_support_tra…

net/quic/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/quic_spdy_stream.h"
 
 #include "base/logging.h"
 #include "net/quic/quic_spdy_session.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/quic_write_blocked_list.h"
@@ skipping 16 matching lines @@
 // priority in the middle.
 SpdyPriority kDefaultPriority = 3;
 
 }  // namespace
 
 QuicSpdyStream::QuicSpdyStream(QuicStreamId id, QuicSpdySession* spdy_session)
     : ReliableQuicStream(id, spdy_session),
       spdy_session_(spdy_session),
       visitor_(nullptr),
       headers_decompressed_(false),
-      priority_(kDefaultPriority) {
+      priority_(kDefaultPriority),
+      trailers_decompressed_(false) {
   DCHECK_NE(kCryptoStreamId, id);
   // Don't receive any callbacks from the sequencer until headers
   // are complete.
   sequencer()->SetBlockedUntilFlush();
 }
 
 QuicSpdyStream::~QuicSpdyStream() {}
 
 void QuicSpdyStream::CloseWriteSide() {
   if (version() > QUIC_VERSION_28 && !fin_received() && !rst_received() &&
@@ skipping 41 matching lines @@
   DCHECK(FinishedReadingHeaders());
   return sequencer()->GetReadableRegions(iov, iov_len);
 }
 
 void QuicSpdyStream::MarkConsumed(size_t num_bytes) {
   DCHECK(FinishedReadingHeaders());
   return sequencer()->MarkConsumed(num_bytes);
 }
 
 bool QuicSpdyStream::IsDoneReading() const {
-  if (!headers_decompressed_ || !decompressed_headers_.empty()) {
-    return false;
-  }
-  return sequencer()->IsClosed();
+  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 {
-  return !decompressed_headers_.empty() || sequencer()->HasBytesToRead();
+  bool headers_to_read = !decompressed_headers_.empty();
+  bool body_to_read = sequencer()->HasBytesToRead();
+  bool trailers_to_read =
+      (FLAGS_quic_supports_trailers && !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);
+}
+
 void QuicSpdyStream::set_priority(SpdyPriority priority) {
   DCHECK_EQ(0u, stream_bytes_written());
   priority_ = priority;
 }
 
 SpdyPriority QuicSpdyStream::Priority() const {
   return priority();
 }
 
 void QuicSpdyStream::OnStreamHeaders(StringPiece headers_data) {
-  headers_data.AppendToString(&decompressed_headers_);
+  if (!FLAGS_quic_supports_trailers || !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());
   set_priority(priority);
 }
 
 void QuicSpdyStream::OnStreamHeadersComplete(bool fin, size_t frame_len) {
+  if (!FLAGS_quic_supports_trailers || !headers_decompressed_) {
+    OnInitialHeadersComplete(fin, frame_len);
+  } else {
+    OnTrailingHeadersComplete(fin, frame_len);
+  }
+}
+
+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::OnTrailingHeadersComplete(bool fin, size_t /*frame_len*/) {
+  DCHECK(!trailers_decompressed_);
+  if (fin_received()) {
+    DLOG(ERROR) << "Received Trailers after FIN, on stream: " << id();
+    session()->CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA);
+    return;
+  }
+  if (!fin) {
+    DLOG(ERROR) << "Trailers must have FIN set, on stream: " << id();
+    session()->CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA);
+    return;
+  }
+  trailers_decompressed_ = true;
+}
+
 void QuicSpdyStream::OnStreamReset(const QuicRstStreamFrame& frame) {
   if (frame.error_code != QUIC_STREAM_NO_ERROR ||
       version() <= QUIC_VERSION_28) {
     ReliableQuicStream::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();
 
   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);
   }
 }
 
 bool QuicSpdyStream::FinishedReadingHeaders() const {
   return headers_decompressed_ && decompressed_headers_.empty();
 }
 
+bool QuicSpdyStream::FinishedReadingTrailers() const {
+  if (!FLAGS_quic_supports_trailers) {
+    return true;
+  }
+  return trailers_decompressed_ && decompressed_trailers_.empty();
+}
+
 }  // namespace net