relnote: Implements OnHeaderFrameStart and OnHeaderFrameEnd in QuicHeadersStream. Not used in produ…

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 "base/strings/string_number_conversions.h"
 #include "net/quic/quic_bug_tracker.h"
 #include "net/quic/quic_spdy_session.h"
@@ skipping 165 matching lines @@
 }
 
 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) {
+  if (!headers_decompressed_) {
+    OnInitialHeadersComplete(fin, frame_len, header_list);
+  } else {
+    OnTrailingHeadersComplete(fin, frame_len, header_list);
+  }
+}
+
 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) {
@@ skipping 17 matching lines @@
   }
 
   // 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();
 
   OnStreamFrame(QuicStreamFrame(id(), fin, final_byte_offset, StringPiece()));
   trailers_decompressed_ = true;
 }
 
+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);
+    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::CopyAndValidateTrailers(header_list, &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;
+  }
+  OnStreamFrame(QuicStreamFrame(id(), fin, final_byte_offset, StringPiece()));
+  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();
+  return headers_decompressed_ && decompressed_headers_.empty() &&
+         header_list_.empty();
 }
 
 bool QuicSpdyStream::ParseHeaderStatusCode(SpdyHeaderBlock* header,
                                            int* status_code) const {
   StringPiece status = (*header)[":status"];
   if (status.size() != 3) {
     return false;
   }
   // First character must be an integer in range [1,5].
   if (status[0] < '1' || status[0] > '5') {
@@ skipping 10 matching lines @@
   // If no further trailing headers are expected, and the decompressed trailers
   // (if any) have been consumed, then reading of trailers is finished.
   bool no_more_trailers = fin_received() || trailers_decompressed_;
   return no_more_trailers && decompressed_trailers_.empty();
 }
 
 SpdyPriority QuicSpdyStream::priority() const {
   return priority_;
 }
 }  // namespace net