Make ResourceHandler::OnWillRead able to complete asynchronously.

content/browser/loader/detachable_resource_handler.cc

 // Copyright 2013 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 "content/browser/loader/detachable_resource_handler.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 18 matching lines @@
 class DetachableResourceHandler::Controller : public ResourceController {
  public:
   explicit Controller(DetachableResourceHandler* detachable_handler)
       : detachable_handler_(detachable_handler){};
 
   ~Controller() override {}
 
   // ResourceController implementation:
   void Resume() override {
     MarkAsUsed();
-    detachable_handler_->Resume();
+    detachable_handler_->ResumeInternal();
   }
 
   void Cancel() override {
     MarkAsUsed();
     detachable_handler_->Cancel();
   }
 
   void CancelAndIgnore() override {
     MarkAsUsed();
     detachable_handler_->CancelAndIgnore();
@@ skipping 21 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(Controller);
 };
 
 DetachableResourceHandler::DetachableResourceHandler(
     net::URLRequest* request,
     base::TimeDelta cancel_delay,
     std::unique_ptr<ResourceHandler> next_handler)
     : ResourceHandler(request),
       next_handler_(std::move(next_handler)),
       cancel_delay_(cancel_delay),
+      parent_read_buffer_(nullptr),
+      parent_read_buffer_size_(nullptr),
       is_finished_(false) {
   GetRequestInfo()->set_detachable_handler(this);
 }
 
 DetachableResourceHandler::~DetachableResourceHandler() {
   // Cleanup back-pointer stored on the request info.
   GetRequestInfo()->set_detachable_handler(NULL);
 }
 
 void DetachableResourceHandler::SetDelegate(Delegate* delegate) {
@@ skipping 36 matching lines @@
   detached_timer_->Start(FROM_HERE, cancel_delay_, this,
                          &DetachableResourceHandler::OnTimedOut);
 
   // Resume if necessary. The request may have been deferred, say, waiting on a
   // full buffer in AsyncResourceHandler. Now that it has been detached, resume
   // and drain it.
   if (has_controller()) {
     // The nested ResourceHandler may have logged that it's blocking the
     // request.  Log it as no longer doing so, to avoid a DCHECK on resume.
     request()->LogUnblocked();
+
+    // If in the middle of an OnWillRead call, need to allocate the read buffer
+    // before resuming.
+    if (parent_read_buffer_) {
+      DCHECK(parent_read_buffer_size_);
+
+      scoped_refptr<net::IOBuffer>* parent_read_buffer = parent_read_buffer_;
+      int* parent_read_buffer_size = parent_read_buffer_size_;
+      parent_read_buffer_ = nullptr;
+      parent_read_buffer_size_ = nullptr;
+
+      // Will allocate the buffer and resume the request.
+      OnWillRead(parent_read_buffer, parent_read_buffer_size,
+                 ReleaseController());
+      return;
+    }
+
     Resume();
   }
 }
 
 void DetachableResourceHandler::OnRequestRedirected(
     const net::RedirectInfo& redirect_info,
     ResourceResponse* response,
     std::unique_ptr<ResourceController> controller) {
   DCHECK(!has_controller());
 
@@ skipping 29 matching lines @@
 
   if (!next_handler_) {
     controller->Resume();
     return;
   }
 
   HoldController(std::move(controller));
   next_handler_->OnWillStart(url, base::MakeUnique<Controller>(this));
 }
 
-bool DetachableResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
-                                           int* buf_size) {
+void DetachableResourceHandler::OnWillRead(
+    scoped_refptr<net::IOBuffer>* buf,
+    int* buf_size,
+    std::unique_ptr<ResourceController> controller) {
   if (!next_handler_) {
     if (!read_buffer_.get())
       read_buffer_ = new net::IOBuffer(kReadBufSize);
     *buf = read_buffer_;
     *buf_size = kReadBufSize;
-    return true;
+    controller->Resume();
+    return;
   }
 
-  return next_handler_->OnWillRead(buf, buf_size);
+  parent_read_buffer_ = buf;
+  parent_read_buffer_size_ = buf_size;
+
+  HoldController(std::move(controller));
+  next_handler_->OnWillRead(buf, buf_size, base::MakeUnique<Controller>(this));
 }
 
 void DetachableResourceHandler::OnReadCompleted(
     int bytes_read,
     std::unique_ptr<ResourceController> controller) {
   DCHECK(!has_controller());
 
   if (!next_handler_) {
     controller->Resume();
     return;
@@ skipping 22 matching lines @@
                                      base::MakeUnique<Controller>(this));
 }
 
 void DetachableResourceHandler::OnDataDownloaded(int bytes_downloaded) {
   if (!next_handler_)
     return;
 
   next_handler_->OnDataDownloaded(bytes_downloaded);
 }
 
+void DetachableResourceHandler::ResumeInternal() {
+  parent_read_buffer_ = nullptr;
+  parent_read_buffer_size_ = nullptr;
+  Resume();
+}
+
 void DetachableResourceHandler::OnTimedOut() {
   // Requests are only timed out after being detached, and shouldn't be deferred
   // once detached.
   DCHECK(!next_handler_);
   DCHECK(!has_controller());
 
   OutOfBandCancel(net::ERR_ABORTED, true /* tell_renderer */);
 }
 
 }  // namespace content