Add an async ReadTrailers method to QuicChromiumClientStream::Handle

net/quic/chromium/quic_http_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/chromium/quic_http_stream.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/callback_helpers.h"
@@ skipping 38 matching lines @@
     : MultiplexedHttpStream(std::move(session)),
       next_state_(STATE_NONE),
       stream_(nullptr),
       request_info_(nullptr),
       request_body_stream_(nullptr),
       priority_(MINIMUM_PRIORITY),
       response_info_(nullptr),
       has_response_status_(false),
       response_status_(ERR_UNEXPECTED),
       response_headers_received_(false),
+      trailing_headers_received_(false),
       headers_bytes_received_(0),
       headers_bytes_sent_(0),
       closed_stream_received_bytes_(0),
       closed_stream_sent_bytes_(0),
       closed_is_first_stream_(false),
       user_buffer_len_(0),
       session_error_(ERR_UNEXPECTED),
       quic_connection_error_(QUIC_NO_ERROR),
       quic_stream_error_(QUIC_STREAM_NO_ERROR),
       found_promise_(false),
@@ skipping 388 matching lines @@
   DCHECK(!response_headers_received_);
   if (rv > 0) {
     headers_bytes_received_ += rv;
     rv = ProcessResponseHeaders(response_header_block_);
   }
   if (rv != ERR_IO_PENDING && !callback_.is_null()) {
     DoCallback(rv);
   }
 }
 
-void QuicHttpStream::OnTrailingHeadersAvailable(const SpdyHeaderBlock& headers,
-                                                size_t frame_len) {
+void QuicHttpStream::ReadTrailingHeaders() {
+  if (!stream_)
+    return;
+
+  int rv = stream_->ReadTrailingHeaders(
+      &trailing_header_block_,
+      base::Bind(&QuicHttpStream::OnReadTrailingHeadersComplete,
+                 weak_factory_.GetWeakPtr()));
+
+  if (rv != ERR_IO_PENDING)
+    OnReadTrailingHeadersComplete(rv);
+}
+
+void QuicHttpStream::OnReadTrailingHeadersComplete(int rv) {
   DCHECK(response_headers_received_);
-  headers_bytes_received_ += frame_len;
+  if (rv > 0)
+    headers_bytes_received_ += rv;
 
   // QuicHttpStream ignores trailers.
   if (stream_->IsDoneReading()) {
     // Close the read side. If the write side has been closed, this will
     // invoke QuicHttpStream::OnClose to reset the stream.
     stream_->OnFinRead();
     SetResponseStatus(OK);
   }
 }
 
@@ skipping 263 matching lines @@
   response_info_->was_alpn_negotiated = true;
   response_info_->alpn_negotiated_protocol =
       HttpResponseInfo::ConnectionInfoToString(response_info_->connection_info);
   response_info_->response_time = base::Time::Now();
   response_info_->request_time = request_time_;
   response_headers_received_ = true;
 
   // Populate |connect_timing_| when response headers are received. This should
   // take care of 0-RTT where request is sent before handshake is confirmed.
   connect_timing_ = quic_session()->GetConnectTiming();
+
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&QuicHttpStream::ReadTrailingHeaders,
+                            weak_factory_.GetWeakPtr()));
+
   return OK;
 }
 
 void QuicHttpStream::OnReadBodyComplete(int rv) {
   CHECK(callback_);
   user_buffer_ = nullptr;
   user_buffer_len_ = 0;
   rv = HandleReadComplete(rv);
   DoCallback(rv);
 }
@@ skipping 68 matching lines @@
       quic_stream_error_ != QUIC_STREAM_CONNECTION_ERROR) {
     return ERR_QUIC_PROTOCOL_ERROR;
   }
 
   DCHECK_NE(QUIC_HANDSHAKE_TIMEOUT, quic_connection_error_);
 
   return ERR_QUIC_PROTOCOL_ERROR;
 }
 
 }  // namespace net