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 446 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_)

[xunjieli, 2017/05/26 15:53:06]

Is the null check needed? I thought the handle is never null-ed.

[Ryan Hamilton, 2017/05/26 22:35:50]

It's still null out in ResetStream, as of this CL. But in the follow up I remove
OnClose and OnError and no longer null it out. Stay tuned! :)

[xunjieli, 2017/05/29 14:06:08]

Acknowledged.

+    return;
+
+  int rv = stream_->ReadTrailingHeaders(
+      &trailing_header_block_,
+      base::Bind(&QuicHttpStream::OnReadTrailingHeadersComplete,
+                 weak_factory_.GetWeakPtr()));
+
+  OnReadTrailingHeadersComplete(rv);

[xunjieli, 2017/05/26 15:53:05]

Should we test (rv != ERR_IO_PENDING) before calling
OnReadTrailingHeadersComplete(rv) here?

[Ryan Hamilton, 2017/05/26 22:35:50]

Good point. Amusingly, OnReadTrailingHeadersComplete is a no-op if rv ==
ERR_IO_PENDING, so there's no "bug" currently, but yeah, it's totally wrong!

Done.

+}
+
+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 67 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