Make ResourceHandler::OnWillRead able to complete asynchronously.

content/browser/loader/async_resource_handler.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 "content/browser/loader/async_resource_handler.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 349 matching lines @@
       request()->has_upload()) {
     upload_progress_tracker_ = base::MakeUnique<UploadProgressTracker>(
         FROM_HERE,
         base::BindRepeating(&AsyncResourceHandler::SendUploadProgress,
                             base::Unretained(this)),
         request());
   }
   controller->Resume();
 }
 
-bool AsyncResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
-                                      int* buf_size) {
+void AsyncResourceHandler::OnWillRead(
+    scoped_refptr<net::IOBuffer>* buf,
+    int* buf_size,
+    std::unique_ptr<ResourceController> controller) {
   DCHECK(!has_controller());
 
-  // TODO(mmenke):  Should fail with ERR_INSUFFICIENT_RESOURCES here.
-  if (!CheckForSufficientResource())
-    return false;
+  if (!CheckForSufficientResource()) {
+    controller->CancelWithError(net::ERR_INSUFFICIENT_RESOURCES);
+    return;
+  }
 
   // Return early if InliningHelper allocates the buffer, so that we should
   // inline the data into the IPC message without allocating SharedMemory.
-  if (inlining_helper_->PrepareInlineBufferIfApplicable(buf, buf_size))
-    return true;
+  if (inlining_helper_->PrepareInlineBufferIfApplicable(buf, buf_size)) {
+    controller->Resume();
+    return;
+  }
 
-  if (!EnsureResourceBufferIsInitialized())
-    return false;
+  if (!EnsureResourceBufferIsInitialized()) {
+    controller->CancelWithError(net::ERR_INSUFFICIENT_RESOURCES);
+    return;
+  }
 
   DCHECK(buffer_->CanAllocate());
   char* memory = buffer_->Allocate(&allocation_size_);
   CHECK(memory);
 
   *buf = new DependentIOBuffer(buffer_.get(), memory);
   *buf_size = allocation_size_;
 
-  return true;
+  controller->Resume();
 }
 
 void AsyncResourceHandler::OnReadCompleted(
     int bytes_read,
     std::unique_ptr<ResourceController> controller) {
   DCHECK(!has_controller());
   DCHECK_GE(bytes_read, 0);
 
   if (!bytes_read) {
     controller->Resume();
@@ skipping 216 matching lines @@
 void AsyncResourceHandler::SendUploadProgress(
     const net::UploadProgress& progress) {
   ResourceMessageFilter* filter = GetFilter();
   if (!filter)
     return;
   filter->Send(new ResourceMsg_UploadProgress(
       GetRequestID(), progress.position(), progress.size()));
 }
 
 }  // namespace content