Add an async ReadInitialHeaders 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 295 matching lines @@
 
   return rv > 0 ? OK : rv;
 }
 
 int QuicHttpStream::ReadResponseHeaders(const CompletionCallback& callback) {
   CHECK(callback_.is_null());
   CHECK(!callback.is_null());
 
   if (stream_ == nullptr)
     return GetResponseStatus();
+
+  int rv = stream_->ReadInitialHeaders(
+      &response_header_block_,
+      base::Bind(&QuicHttpStream::OnReadResponseHeadersComplete,
+                 weak_factory_.GetWeakPtr()));
+
+  if (rv == ERR_IO_PENDING) {
+    // Still waiting for the response, return IO_PENDING.
+    CHECK(callback_.is_null());
+    callback_ = callback;
+    return ERR_IO_PENDING;
+  }
+
+  if (rv < 0)
+    return rv;
+
   // Check if we already have the response headers. If so, return synchronously.
   if (response_headers_received_)
     return OK;
 
-  // Still waiting for the response, return IO_PENDING.
-  CHECK(callback_.is_null());
-  callback_ = callback;
-  return ERR_IO_PENDING;
+  headers_bytes_received_ += rv;
+  return ProcessResponseHeaders(response_header_block_);
 }
 
 int QuicHttpStream::ReadResponseBody(IOBuffer* buf,
                                      int buf_len,
                                      const CompletionCallback& callback) {
   CHECK(callback_.is_null());
   CHECK(!callback.is_null());
   CHECK(!user_buffer_.get());
   CHECK_EQ(0, user_buffer_len_);
 
@@ skipping 91 matching lines @@
       ConnectionInfoFromQuicVersion(quic_session()->GetQuicVersion());
   quic_session()->PopulateNetErrorDetails(details);
   if (quic_session()->IsCryptoHandshakeConfirmed())
     details->quic_connection_error = quic_connection_error_;
 }
 
 void QuicHttpStream::SetPriority(RequestPriority priority) {
   priority_ = priority;
 }
 
-void QuicHttpStream::OnInitialHeadersAvailable(const SpdyHeaderBlock& headers,
-                                               size_t frame_len) {
+void QuicHttpStream::OnReadResponseHeadersComplete(int rv) {
+  DCHECK(callback_);
   DCHECK(!response_headers_received_);
-  headers_bytes_received_ += frame_len;
-
-  int rv = ProcessResponseHeaders(headers);
+  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) {
   DCHECK(response_headers_received_);
   headers_bytes_received_ += frame_len;
 
@@ skipping 379 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