Add an async ReadBody 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 339 matching lines @@
   // stream to outlive the request_info_'s owner.
   // Only allowed when Read state machine starts. It is safe to reset it at
   // this point since request_info_->upload_data_stream is also not needed
   // anymore.
   request_info_ = nullptr;
 
   // If the stream is already closed, there is no body to read.
   if (!stream_)
     return GetResponseStatus();
 
-  int rv = ReadAvailableData(buf, buf_len);
-  if (rv != ERR_IO_PENDING)
+  int rv = stream_->ReadBody(buf, buf_len,
+                             base::Bind(&QuicHttpStream::OnReadBodyComplete,
+                                        weak_factory_.GetWeakPtr()));
+  if (rv == ERR_IO_PENDING) {
+    callback_ = callback;
+    user_buffer_ = buf;
+    user_buffer_len_ = buf_len;
+    return ERR_IO_PENDING;
+  }
+
+  if (rv < 0)
     return rv;
 
-  callback_ = callback;
-  user_buffer_ = buf;
-  user_buffer_len_ = buf_len;
-  return ERR_IO_PENDING;
+  return HandleReadComplete(rv);
 }
 
 void QuicHttpStream::Close(bool /*not_reusable*/) {
   session_error_ = ERR_ABORTED;
   SaveResponseStatus();
   // Note: the not_reusable flag has no meaning for QUIC streams.
   if (stream_) {
     stream_->ClearDelegate();
     stream_->Reset(QUIC_STREAM_CANCELLED);
   }
@@ skipping 87 matching lines @@
 
   // 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);
   }
 }
 
-void QuicHttpStream::OnDataAvailable() {
-  if (callback_.is_null()) {
-    // Data is available, but can't be delivered
-    return;
-  }
-
-  CHECK(user_buffer_.get());
-  CHECK_NE(0, user_buffer_len_);
-  int rv = ReadAvailableData(user_buffer_.get(), user_buffer_len_);
-  if (rv == ERR_IO_PENDING) {
-    // This was a spurrious notification. Wait for the next one.
-    return;
-  }
-
-  CHECK(!callback_.is_null());
-  user_buffer_ = nullptr;
-  user_buffer_len_ = 0;
-  DoCallback(rv);
-}
-
 void QuicHttpStream::OnClose() {
   quic_connection_error_ = stream_->connection_error();
   quic_stream_error_ = stream_->stream_error();
   SaveResponseStatus();
 
   ResetStream();
   // If already in DoLoop(), |callback_| will be handled when DoLoop() exits.
   if (in_loop_)
     return;
 
@@ skipping 256 matching lines @@
   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();
   return OK;
 }
 
-int QuicHttpStream::ReadAvailableData(IOBuffer* buf, int buf_len) {
-  int rv = stream_->Read(buf, buf_len);
-  // TODO(rtenneti): Temporary fix for crbug.com/585591. Added a check for null
-  // |stream_| to fix crash bug. Delete |stream_| check and histogram after fix
-  // is merged.
-  bool null_stream = stream_ == nullptr;
-  UMA_HISTOGRAM_BOOLEAN("Net.QuicReadAvailableData.NullStream", null_stream);

[xunjieli, 2017/05/12 15:22:22]

Could you mark this histogram as deprecated in histograms.xml?

-  if (null_stream)
-    return rv;
+void QuicHttpStream::OnReadBodyComplete(int rv) {
+  CHECK(callback_);
+  user_buffer_ = nullptr;
+  user_buffer_len_ = 0;
+  rv = HandleReadComplete(rv);
+  DoCallback(rv);
+}
+
+int QuicHttpStream::HandleReadComplete(int rv) {
   if (stream_->IsDoneReading()) {
     stream_->ClearDelegate();
     stream_->OnFinRead();
     SetResponseStatus(OK);
     ResetStream();
   }
   return rv;
 }
 
 void QuicHttpStream::ResetStream() {
@@ skipping 55 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