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

net/quic/quic_headers_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_headers_stream.h"
 
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "net/quic/quic_bug_tracker.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_headers_stream.h"
+#include "net/quic/quic_header_list.h"
 #include "net/quic/quic_spdy_session.h"
 #include "net/quic/quic_time.h"
 
 using base::StringPiece;
 using net::HTTP2;
 using net::SpdyFrameType;
 using std::string;
 
 namespace net {
 
@@ skipping 45 matching lines @@
   void OnStreamEnd(SpdyStreamId stream_id) override {
     // The framer invokes OnStreamEnd after processing a SYN_STREAM
     // or SYN_REPLY frame that had the fin bit set.
   }
 
   void OnStreamPadding(SpdyStreamId stream_id, size_t len) override {
     CloseConnection("SPDY frame padding received.");
   }
 
   SpdyHeadersHandlerInterface* OnHeaderFrameStart(
-      SpdyStreamId stream_id) override {
-    LOG(FATAL);
-    return nullptr;
+      SpdyStreamId /* stream_id */) override {
+    return &header_list_;
   }
 
-  void OnHeaderFrameEnd(SpdyStreamId stream_id, bool end_headers) override {
-    LOG(FATAL);
+  void OnHeaderFrameEnd(SpdyStreamId /* stream_id */,
+                        bool end_headers) override {
+    if (end_headers) {
+      if (stream_->IsConnected()) {
+        stream_->OnHeaderList(header_list_);
+      }
+      header_list_.Clear();
+    }
   }
 
   void OnError(SpdyFramer* framer) override {
     CloseConnection(base::StringPrintf(
         "SPDY framing error: %s",
         SpdyFramer::ErrorCodeToString(framer->error_code())));
   }
 
   void OnDataFrameHeader(SpdyStreamId stream_id,
                          size_t length,
@@ skipping 82 matching lines @@
  private:
   void CloseConnection(const string& details) {
     if (stream_->IsConnected()) {
       stream_->CloseConnectionWithDetails(QUIC_INVALID_HEADERS_STREAM_DATA,
                                           details);
     }
   }
 
  private:
   QuicHeadersStream* stream_;
+  QuicHeaderList header_list_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyFramerVisitor);
 };
 
 QuicHeadersStream::QuicHeadersStream(QuicSpdySession* session)
     : ReliableQuicStream(kHeadersStreamId, session),
       spdy_session_(session),
       stream_id_(kInvalidStreamId),
       promised_stream_id_(kInvalidStreamId),
       fin_(false),
@@ skipping 152 matching lines @@
   } else {
     if (promised_stream_id_ == kInvalidStreamId) {
       spdy_session_->OnStreamHeaders(stream_id_, StringPiece(header_data, len));
     } else {
       spdy_session_->OnPromiseHeaders(stream_id_,
                                       StringPiece(header_data, len));
     }
   }
 }
 
+void QuicHeadersStream::OnHeaderList(const QuicHeaderList& header_list) {
+  if (measure_headers_hol_blocking_time_) {
+    if (prev_max_timestamp_ > cur_max_timestamp_) {
+      // prev_max_timestamp_ > cur_max_timestamp_ implies that
+      // headers from lower numbered streams actually came off the
+      // wire after headers for the current stream, hence there was
+      // HOL blocking.
+      QuicTime::Delta delta = prev_max_timestamp_.Subtract(cur_max_timestamp_);
+      DVLOG(1) << "stream " << stream_id_
+                 << ": Net.QuicSession.HeadersHOLBlockedTime "

[ramant (doing other things), 2016/04/11 18:11:57]

nit: indentation for lines 375-376.

[Zhongyi Shi, 2016/04/11 18:27:31]

it's already fixed in Final.

+                 << delta.ToMilliseconds();
+      spdy_session_->OnHeadersHeadOfLineBlocking(delta);
+    }
+    prev_max_timestamp_ = std::max(prev_max_timestamp_, cur_max_timestamp_);
+    cur_max_timestamp_ = QuicTime::Zero();
+  }
+  if (promised_stream_id_ == kInvalidStreamId) {
+    spdy_session_->OnStreamHeaderList(stream_id_, fin_, frame_len_,
+                                      header_list);
+  } else {
+    spdy_session_->OnPromiseHeaderList(stream_id_, promised_stream_id_,
+                                       frame_len_, header_list);
+  }
+  // Reset state for the next frame.
+  promised_stream_id_ = kInvalidStreamId;
+  stream_id_ = kInvalidStreamId;
+  fin_ = false;
+  frame_len_ = 0;
+}
+
 void QuicHeadersStream::OnCompressedFrameSize(size_t frame_len) {
   frame_len_ += frame_len;
 }
 
 bool QuicHeadersStream::IsConnected() {
   return session()->connection()->connected();
 }
 
 void QuicHeadersStream::DisableHpackDynamicTable() {
   spdy_framer_.UpdateHeaderEncoderTableSize(0);
 }
 
 }  // namespace net