Add an async ReadBody method to QuicChromiumClientStream::Handle

net/quic/chromium/quic_chromium_client_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_chromium_client_stream.h"
 
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/log/net_log_event_type.h"
 #include "net/quic/chromium/quic_chromium_client_session.h"
 #include "net/quic/chromium/quic_http_utils.h"
 #include "net/quic/core/quic_spdy_session.h"
 #include "net/quic/core/quic_write_blocked_list.h"
 #include "net/quic/core/spdy_utils.h"
 
 namespace net {
 
 QuicChromiumClientStream::Handle::Handle(QuicChromiumClientStream* stream,
                                          Delegate* delegate)
-    : stream_(stream), delegate_(delegate), read_headers_buffer_(nullptr) {
+    : stream_(stream),
+      delegate_(delegate),
+      read_headers_buffer_(nullptr),
+      read_body_buffer_len_(0) {
   SaveState();
 }
 
 QuicChromiumClientStream::Handle::~Handle() {
   if (stream_) {
     stream_->ClearHandle();
     // TODO(rch): If stream_ is still valid, it should probably be Reset()
     // so that it does not leak.
     // stream_->Reset(QUIC_STREAM_CANCELLED);
   }
@@ skipping 14 matching lines @@
   ResetAndReturn(&read_headers_callback_).Run(rv);
 }
 
 void QuicChromiumClientStream::Handle::OnTrailingHeadersAvailable(
     const SpdyHeaderBlock& headers,
     size_t frame_len) {
   delegate_->OnTrailingHeadersAvailable(headers, frame_len);
 }
 
 void QuicChromiumClientStream::Handle::OnDataAvailable() {
-  delegate_->OnDataAvailable();
+  if (!read_body_callback_)
+    return;  // Wait for ReadBody to be called.
+
+  int rv = stream_->Read(read_body_buffer_, read_body_buffer_len_);
+  if (rv == ERR_IO_PENDING)
+    return;  // Spurrious, likely because of trailers?
+
+  read_body_buffer_ = nullptr;
+  read_body_buffer_len_ = 0;
+  ResetAndReturn(&read_body_callback_).Run(rv);
 }
 
 void QuicChromiumClientStream::Handle::OnClose() {
   if (stream_)
     SaveState();
   stream_ = nullptr;
   if (delegate_) {
     auto* delegate = delegate_;
     delegate_ = nullptr;
     delegate->OnClose();
@@ skipping 19 matching lines @@
 
   int frame_len = 0;
   if (stream_->DeliverInitialHeaders(header_block, &frame_len))
     return frame_len;
 
   read_headers_buffer_ = header_block;
   read_headers_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
+int QuicChromiumClientStream::Handle::ReadBody(
+    IOBuffer* buffer,
+    int buffer_len,
+    const CompletionCallback& callback) {
+  if (!stream_)
+    return ERR_CONNECTION_CLOSED;
+
+  int rv = stream_->Read(buffer, buffer_len);
+  if (rv != ERR_IO_PENDING)
+    return rv;
+
+  read_body_callback_ = callback;
+  read_body_buffer_ = buffer;
+  read_body_buffer_len_ = buffer_len;
+  return ERR_IO_PENDING;
+}
+
 size_t QuicChromiumClientStream::Handle::WriteHeaders(
     SpdyHeaderBlock header_block,
     bool fin,
     QuicReferenceCountedPointer<QuicAckListenerInterface>
         ack_notifier_delegate) {
   if (!stream_)
     return 0;
   return stream_->WriteHeaders(std::move(header_block), fin,
                                ack_notifier_delegate);
 }
@@ skipping 431 matching lines @@
 
 void QuicChromiumClientStream::DisableConnectionMigration() {
   can_migrate_ = false;
 }
 
 bool QuicChromiumClientStream::IsFirstStream() {
   return id() == kHeadersStreamId + 2;
 }
 
 }  // namespace net