Refactor ResourceHandler API.

content/browser/loader/mojo_async_resource_handler.cc

Index: content/browser/loader/mojo_async_resource_handler.cc
diff --git a/content/browser/loader/mojo_async_resource_handler.cc b/content/browser/loader/mojo_async_resource_handler.cc
index 1288fe45136fb67142fa4ca4383a058c83eb14e9..405e86be7f9b14a35b6f8788ee18c4ebebaff030 100644
--- a/content/browser/loader/mojo_async_resource_handler.cc
+++ b/content/browser/loader/mojo_async_resource_handler.cc
@@ -125,16 +125,17 @@ MojoAsyncResourceHandler::~MojoAsyncResourceHandler() {
     rdh_->FinishedWithResourcesForRequest(request());
 }
 
-bool MojoAsyncResourceHandler::OnRequestRedirected(
+void MojoAsyncResourceHandler::OnRequestRedirected(
     const net::RedirectInfo& redirect_info,
     ResourceResponse* response,
-    bool* defer) {
+    std::unique_ptr<ResourceController> controller) {
   // Unlike OnResponseStarted, OnRequestRedirected will NOT be preceded by
   // OnWillRead.
+  DCHECK(!has_controller());
   DCHECK(!shared_writer_);
 
-  *defer = true;
   request()->LogBlockedBy("MojoAsyncResourceHandler");
+  set_controller(std::move(controller));
   did_defer_on_redirect_ = true;
 
   NetLogObserver::PopulateResponseInfo(request(), response);
@@ -146,11 +147,13 @@ bool MojoAsyncResourceHandler::OnRequestRedirected(
   // and hopefully those will eventually all be owned by the browser. It's
   // possible this is still needed while renderer-owned ones exist.
   url_loader_client_->OnReceiveRedirect(redirect_info, response->head);
-  return true;
 }
 
-bool MojoAsyncResourceHandler::OnResponseStarted(ResourceResponse* response,
-                                                 bool* defer) {
+void MojoAsyncResourceHandler::OnResponseStarted(
+    ResourceResponse* response,
+    std::unique_ptr<ResourceController> controller) {
+  DCHECK(!has_controller());
+
   const ResourceRequestInfoImpl* info = GetRequestInfo();
 
   if (rdh_->delegate()) {
@@ -164,11 +167,14 @@ bool MojoAsyncResourceHandler::OnResponseStarted(ResourceResponse* response,
   response->head.response_start = base::TimeTicks::Now();
   sent_received_response_message_ = true;
   url_loader_client_->OnReceiveResponse(response->head);
-  return true;
+
+  controller->Resume();
 }
 
-bool MojoAsyncResourceHandler::OnWillStart(const GURL& url, bool* defer) {
-  return true;
+void MojoAsyncResourceHandler::OnWillStart(
+    const GURL& url,
+    std::unique_ptr<ResourceController> controller) {
+  controller->Resume();
 }
 
 bool MojoAsyncResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
@@ -176,6 +182,7 @@ bool MojoAsyncResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
                                           int min_size) {
   DCHECK_EQ(-1, min_size);
 
+  // TODO(mmenke):  Cancel with net::ERR_INSUFFICIENT_RESOURCES instead.
   if (!CheckForSufficientResource())
     return false;
 
@@ -223,37 +230,56 @@ bool MojoAsyncResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
   return true;
 }
 
-bool MojoAsyncResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
+void MojoAsyncResourceHandler::OnReadCompleted(
+    int bytes_read,
+    std::unique_ptr<ResourceController> controller) {
+  DCHECK(!has_controller());
   DCHECK_GE(bytes_read, 0);
   DCHECK(buffer_);
 
-  if (!bytes_read)
-    return true;
+  if (!bytes_read) {
+    controller->Resume();
+    return;
+  }
 
   if (is_using_io_buffer_not_from_writer_) {
     // Couldn't allocate a buffer on the data pipe in OnWillRead.
     DCHECK_EQ(0u, buffer_bytes_read_);
     buffer_bytes_read_ = bytes_read;
-    if (!CopyReadDataToDataPipe(defer))
-      return false;
-    if (*defer) {
+    bool defer = false;
+    if (!CopyReadDataToDataPipe(&defer)) {
+      controller->Cancel();
+      return;
+    }
+    if (defer) {
       request()->LogBlockedBy("MojoAsyncResourceHandler");
       did_defer_on_writing_ = true;
+      set_controller(std::move(controller));
+      return;
     }
-    return true;
+    controller->Resume();
+    return;
   }
 
-  if (EndWrite(bytes_read) != MOJO_RESULT_OK)
-    return false;
+  if (EndWrite(bytes_read) != MOJO_RESULT_OK) {
+    controller->Cancel();
+    return;
+  }
   // Allocate a buffer for the next OnWillRead call here, because OnWillRead
   // doesn't have |defer| parameter.
-  if (!AllocateWriterIOBuffer(&buffer_, defer))
-    return false;
-  if (*defer) {
+  bool defer = false;
+  if (!AllocateWriterIOBuffer(&buffer_, &defer)) {
+    controller->Cancel();
+    return;
+  }
+  if (defer) {
     request()->LogBlockedBy("MojoAsyncResourceHandler");
     did_defer_on_writing_ = true;
+    set_controller(std::move(controller));
+    return;
   }
-  return true;
+
+  controller->Resume();
 }
 
 void MojoAsyncResourceHandler::OnDataDownloaded(int bytes_downloaded) {
@@ -280,7 +306,7 @@ void MojoAsyncResourceHandler::FollowRedirect() {
   DCHECK(!did_defer_on_writing_);
   did_defer_on_redirect_ = false;
   request()->LogUnblocked();
-  controller()->Resume();
+  Resume();
 }
 
 void MojoAsyncResourceHandler::OnWritableForTesting() {
@@ -306,7 +332,7 @@ MojoResult MojoAsyncResourceHandler::EndWrite(uint32_t written) {
 
 void MojoAsyncResourceHandler::OnResponseCompleted(
     const net::URLRequestStatus& status,
-    bool* defer) {
+    std::unique_ptr<ResourceController> controller) {
   shared_writer_ = nullptr;
   buffer_ = nullptr;
   handle_watcher_.Cancel();
@@ -339,6 +365,7 @@ void MojoAsyncResourceHandler::OnResponseCompleted(
       request()->GetTotalReceivedBytes();
 
   url_loader_client_->OnComplete(request_complete_data);
+  controller->Resume();
 }
 
 bool MojoAsyncResourceHandler::CopyReadDataToDataPipe(bool* defer) {
@@ -394,13 +421,13 @@ bool MojoAsyncResourceHandler::CheckForSufficientResource() {
   if (rdh_->HasSufficientResourcesForRequest(request()))
     return true;
 
-  controller()->CancelWithError(net::ERR_INSUFFICIENT_RESOURCES);
   return false;
 }
 
 void MojoAsyncResourceHandler::OnWritable(MojoResult result) {
   if (!did_defer_on_writing_)
     return;
+  DCHECK(!has_controller());
   DCHECK(!did_defer_on_redirect_);
   did_defer_on_writing_ = false;
 
@@ -409,13 +436,13 @@ void MojoAsyncResourceHandler::OnWritable(MojoResult result) {
     // to the data pipe.
     DCHECK_GT(buffer_bytes_read_, 0u);
     if (!CopyReadDataToDataPipe(&did_defer_on_writing_)) {
-      controller()->CancelWithError(net::ERR_FAILED);
+      CancelWithError(net::ERR_FAILED);
       return;
     }
   } else {
     // Allocate a buffer for the next OnWillRead call here.
     if (!AllocateWriterIOBuffer(&buffer_, &did_defer_on_writing_)) {
-      controller()->CancelWithError(net::ERR_FAILED);
+      CancelWithError(net::ERR_FAILED);
       return;
     }
   }
@@ -425,7 +452,7 @@ void MojoAsyncResourceHandler::OnWritable(MojoResult result) {
     return;
   }
   request()->LogUnblocked();
-  controller()->Resume();
+  Resume();
 }
 
 void MojoAsyncResourceHandler::Cancel() {