Add an async ReadBody 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 94 matching lines @@
 }
 
 int BidirectionalStreamQuicImpl::ReadData(IOBuffer* buffer, int buffer_len) {
   DCHECK(buffer);
   DCHECK(buffer_len);
 
   if (!stream_) {
     // If the stream is already closed, there is no body to read.
     return response_status_;
   }
-  int rv = stream_->Read(buffer, buffer_len);
-  if (rv != ERR_IO_PENDING) {
-    if (stream_->IsDoneReading()) {
-      // If the write side is closed, OnFinRead() will call
-      // BidirectionalStreamQuicImpl::OnClose().
-      stream_->OnFinRead();
-    }
+  int rv = stream_->ReadBody(
+      buffer, buffer_len,
+      base::Bind(&BidirectionalStreamQuicImpl::OnReadDataComplete,
+                 weak_factory_.GetWeakPtr()));
+  if (rv == ERR_IO_PENDING) {
+    // Read will complete asynchronously and Delegate::OnReadCompleted will be
+    // called upon completion.

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

nit: Could you remove this old comment (line 120 to 121)? 
I think the new API is much easier to understand, so the comment is no longer
needed.

[Ryan Hamilton, 2017/05/12 17:26:24]

Great! Done.

+    read_buffer_ = buffer;
+    read_buffer_len_ = buffer_len;
+    return ERR_IO_PENDING;
+  }
+
+  if (rv < 0)
     return rv;
+
+  if (stream_->IsDoneReading()) {
+    // If the write side is closed, OnFinRead() will call
+    // BidirectionalStreamQuicImpl::OnClose().
+    stream_->OnFinRead();
   }
-  // Read will complete asynchronously and Delegate::OnReadCompleted will be
-  // called upon completion.
-  read_buffer_ = buffer;
-  read_buffer_len_ = buffer_len;
-  return ERR_IO_PENDING;
+  return rv;
 }
 
 void BidirectionalStreamQuicImpl::SendData(const scoped_refptr<IOBuffer>& data,
                                            int length,
                                            bool end_stream) {
   DCHECK(length > 0 || (length == 0 && end_stream));
   if (!stream_) {
     LOG(ERROR) << "Trying to send data after stream has been destroyed.";
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&BidirectionalStreamQuicImpl::NotifyError,
@@ skipping 90 matching lines @@
 
 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() {
-  // Return early if ReadData has not been called.
-  if (!read_buffer_)
-    return;
-
-  int rv = ReadData(read_buffer_.get(), read_buffer_len_);
-  if (rv == ERR_IO_PENDING) {
-    // Spurrious notification. Wait for the next one.
-    return;
-  }
-  read_buffer_ = nullptr;
-  read_buffer_len_ = 0;
-  if (delegate_)
-    delegate_->OnDataRead(rv);
-}
-
 void BidirectionalStreamQuicImpl::OnClose() {
   DCHECK(stream_);
 
   if (stream_->connection_error() != QUIC_NO_ERROR ||
       stream_->stream_error() != QUIC_STREAM_NO_ERROR) {
     NotifyError(session_->IsCryptoHandshakeConfirmed()
                     ? ERR_QUIC_PROTOCOL_ERROR
                     : ERR_QUIC_HANDSHAKE_FAILED);
     return;
   }
@@ skipping 51 matching lines @@
     return;
   }
 
   headers_bytes_received_ += rv;
   negotiated_protocol_ = kProtoQUIC;
   connect_timing_ = session_->GetConnectTiming();
   if (delegate_)
     delegate_->OnHeadersReceived(initial_headers_);
 }
 
+void BidirectionalStreamQuicImpl::OnReadDataComplete(int rv) {
+  DCHECK_GE(rv, 0);
+  read_buffer_ = nullptr;
+  read_buffer_len_ = 0;
+  if (delegate_)
+    delegate_->OnDataRead(rv);
+}
+
 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