Add an async ReadInitialHeaders method to QuicChromiumClientStream::Handle

net/quic/chromium/bidirectional_stream_quic_impl.cc

 // Copyright 2016 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/bidirectional_stream_quic_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 209 matching lines @@
     is_first_stream = stream_->IsFirstStream();
   if (is_first_stream) {
     load_timing_info->socket_reused = false;
     load_timing_info->connect_timing = connect_timing_;
   } else {
     load_timing_info->socket_reused = true;
   }
   return true;
 }
 
-void BidirectionalStreamQuicImpl::OnInitialHeadersAvailable(
-    const SpdyHeaderBlock& headers,
-    size_t frame_len) {
-  headers_bytes_received_ += frame_len;
-  negotiated_protocol_ = kProtoQUIC;
-  connect_timing_ = session_->GetConnectTiming();
-  if (delegate_)
-    delegate_->OnHeadersReceived(headers);
-}
-
 void BidirectionalStreamQuicImpl::OnTrailingHeadersAvailable(
     const SpdyHeaderBlock& headers,
     size_t frame_len) {
   headers_bytes_received_ += frame_len;
   if (delegate_)
     delegate_->OnTrailersReceived(headers);
   // |this| can be destroyed after this point.
 }
 
 void BidirectionalStreamQuicImpl::OnDataAvailable() {
@@ skipping 38 matching lines @@
 void BidirectionalStreamQuicImpl::OnError(int error) {
   NotifyError(error);
 }
 
 void BidirectionalStreamQuicImpl::OnStreamReady(int rv) {
   DCHECK_NE(ERR_IO_PENDING, rv);
   DCHECK(rv == OK || !stream_);
   if (rv == OK) {
     stream_ = session_->ReleaseStream(this);
     NotifyStreamReady();
+
+    rv = stream_->ReadInitialHeaders(
+        &initial_headers_,
+        base::Bind(&BidirectionalStreamQuicImpl::OnReadInitialHeadersComplete,
+                   weak_factory_.GetWeakPtr()));
+    if (rv == ERR_IO_PENDING)
+      return;
+
+    OnReadInitialHeadersComplete(rv);
   } else {
     NotifyError(rv);
   }
 }
 
 void BidirectionalStreamQuicImpl::OnSendDataComplete(int rv) {
   DCHECK(rv == OK || !stream_);
   if (rv == OK) {
     if (delegate_)
       delegate_->OnDataSent();
   } else {
     NotifyError(rv);
   }
 }
 
+void BidirectionalStreamQuicImpl::OnReadInitialHeadersComplete(int rv) {
+  DCHECK_NE(ERR_IO_PENDING, rv);
+  if (rv < 0) {
+    NotifyError(rv);
+    return;
+  }
+
+  headers_bytes_received_ += rv;
+  negotiated_protocol_ = kProtoQUIC;
+  connect_timing_ = session_->GetConnectTiming();
+  if (delegate_)
+    delegate_->OnHeadersReceived(initial_headers_);
+}
+
 void BidirectionalStreamQuicImpl::NotifyError(int error) {
   DCHECK_NE(OK, error);
   DCHECK_NE(ERR_IO_PENDING, error);
 
   ResetStream();
   if (delegate_) {
     response_status_ = error;
     BidirectionalStreamImpl::Delegate* delegate = delegate_;
     delegate_ = nullptr;
     // Cancel any pending callback.
@@ skipping 15 matching lines @@
   if (!stream_)
     return;
   closed_stream_received_bytes_ = stream_->stream_bytes_read();
   closed_stream_sent_bytes_ = stream_->stream_bytes_written();
   closed_is_first_stream_ = stream_->IsFirstStream();
   stream_->ClearDelegate();
   stream_ = nullptr;
 }
 
 }  // namespace net