Avoids the "re-encode HPACK as SPDY3" step.

net/quic/quic_chromium_client_stream.cc

 // Copyright (c) 2012 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_chromium_client_stream.h"
 
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/quic/quic_chromium_client_session.h"
 #include "net/quic/quic_http_utils.h"
 #include "net/quic/quic_spdy_session.h"
 #include "net/quic/quic_write_blocked_list.h"
 #include "net/quic/spdy_utils.h"
+#include "net/spdy/header_coalescer.h"
 
 namespace net {
 
 QuicChromiumClientStream::QuicChromiumClientStream(
     QuicStreamId id,
     QuicClientSessionBase* session,
     const BoundNetLog& net_log)
     : QuicSpdyStream(id, session),
       net_log_(net_log),
       delegate_(nullptr),
@@ skipping 26 matching lines @@
       return;
     }
     MarkHeadersConsumed(headers_len);
     session_->OnInitialHeadersComplete(id(), headers);
 
     // The delegate will read the headers via a posted task.
     NotifyDelegateOfHeadersCompleteLater(headers, frame_len);
   }
 }
 
+void QuicChromiumClientStream::OnStreamHeaderList(
+    bool fin,
+    size_t frame_len,
+    const QuicHeaderList& header_list) {
+  QuicSpdyStream::OnStreamHeaderList(fin, frame_len, header_list);
+
+  if (headers_delivered_) {
+    // The delegate will read the trailers via a posted task.
+    NotifyDelegateOfHeadersCompleteLater(received_trailers(), frame_len);
+  } else {
+    HeaderCoalescer coalescer;
+    for (const auto& header : header_list) {
+      coalescer.OnHeader(header.first, header.second);
+    }
+    ConsumeHeaderList();
+    session_->OnInitialHeadersComplete(id(), coalescer.headers());
+
+    // The delegate will read the headers via a posted task.
+    NotifyDelegateOfHeadersCompleteLater(coalescer.headers(), frame_len);
+  }
+}
+
 void QuicChromiumClientStream::OnPromiseHeadersComplete(
     QuicStreamId promised_id,
     size_t frame_len) {
   size_t headers_len = decompressed_headers().length();
   SpdyHeaderBlock headers;
   SpdyFramer framer(HTTP2);
   if (!framer.ParseHeaderBlockInBuffer(decompressed_headers().data(),
                                        headers_len, &headers)) {
     DLOG(WARNING) << "Invalid headers";
     Reset(QUIC_BAD_APPLICATION_PAYLOAD);
@@ skipping 142 matching lines @@
 }
 
 void QuicChromiumClientStream::NotifyDelegateOfHeadersComplete(
     SpdyHeaderBlock headers,
     size_t frame_len) {
   if (!delegate_)
     return;
   // Only mark trailers consumed when we are about to notify delegate.
   if (headers_delivered_) {
     MarkTrailersConsumed(decompressed_trailers().length());
+    MarkTrailersDelivered();
     net_log_.AddEvent(
         NetLog::TYPE_QUIC_CHROMIUM_CLIENT_STREAM_READ_RESPONSE_TRAILERS,
         base::Bind(&SpdyHeaderBlockNetLogCallback, &headers));
   } else {
     headers_delivered_ = true;
     net_log_.AddEvent(
         NetLog::TYPE_QUIC_CHROMIUM_CLIENT_STREAM_READ_RESPONSE_HEADERS,
         base::Bind(&SpdyHeaderBlockNetLogCallback, &headers));
   }
 
@@ skipping 17 matching lines @@
   } else {
     delegate_tasks_.push_back(closure);
   }
 }
 
 void QuicChromiumClientStream::DisableConnectionMigration() {
   can_migrate_ = false;
 }
 
 }  // namespace net