Refactor ResourceHandler API.

content/browser/loader/mojo_async_resource_handler.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 "content/browser/loader/mojo_async_resource_handler.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
@@ skipping 107 matching lines @@
   // the callback will never be called after |this| is destroyed.
   binding_.set_connection_error_handler(
       base::Bind(&MojoAsyncResourceHandler::Cancel, base::Unretained(this)));
 }
 
 MojoAsyncResourceHandler::~MojoAsyncResourceHandler() {
   if (has_checked_for_sufficient_resources_)
     rdh_->FinishedWithResourcesForRequest(request());
 }
 
-bool MojoAsyncResourceHandler::OnRequestRedirected(
+void MojoAsyncResourceHandler::OnRequestRedirected(
     const net::RedirectInfo& redirect_info,
     ResourceResponse* response,
-    bool* defer) {
+    bool* defer_or_cancel) {
   // Unlike OnResponseStarted, OnRequestRedirected will NOT be preceded by
   // OnWillRead.
   DCHECK(!shared_writer_);
 
-  *defer = true;
+  *defer_or_cancel = true;
   request()->LogBlockedBy("MojoAsyncResourceHandler");
   did_defer_on_redirect_ = true;
 
   NetLogObserver::PopulateResponseInfo(request(), response);
   response->head.encoded_data_length = request()->GetTotalReceivedBytes();
   response->head.request_start = request()->creation_time();
   response->head.response_start = base::TimeTicks::Now();
   // TODO(davidben): Is it necessary to pass the new first party URL for
   // cookies? The only case where it can change is top-level navigation requests
   // 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,
+                                                 bool* defer_or_cancel) {
   const ResourceRequestInfoImpl* info = GetRequestInfo();
 
   if (rdh_->delegate()) {
     rdh_->delegate()->OnResponseStarted(request(), info->GetContext(),
                                         response);
   }
 
   NetLogObserver::PopulateResponseInfo(request(), response);
 
   response->head.request_start = request()->creation_time();
   response->head.response_start = base::TimeTicks::Now();
   sent_received_response_message_ = true;
   url_loader_client_->OnReceiveResponse(response->head);
-  return true;
 }
 
-bool MojoAsyncResourceHandler::OnWillStart(const GURL& url, bool* defer) {
-  return true;
+void MojoAsyncResourceHandler::OnWillStart(const GURL& url,
+                                           bool* defer_or_cancel) {
+  return;
 }
 
+// TODO(mmenke): The implementation of this method and OnReadComplete is very
+// unwieldy. Allow OnWillRead to complete asynchronously and clean things up.
 bool MojoAsyncResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
                                           int* buf_size,
                                           int min_size) {
   DCHECK_EQ(-1, min_size);
 
   if (!CheckForSufficientResource())
     return false;
 
   if (!shared_writer_) {
     MojoCreateDataPipeOptions options;
@@ skipping 32 matching lines @@
     is_using_io_buffer_not_from_writer_ = true;
     buffer_ = new net::IOBufferWithSize(kMinAllocationSize);
   }
 
   DCHECK_EQ(0u, buffer_offset_);
   *buf = buffer_;
   *buf_size = buffer_->size();
   return true;
 }
 
-bool MojoAsyncResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
+void MojoAsyncResourceHandler::OnReadCompleted(int bytes_read,
+                                               bool* defer_or_cancel) {
   DCHECK_GE(bytes_read, 0);
   DCHECK(buffer_);
 
   if (!bytes_read)
-    return true;
+    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) {
+    if (!CopyReadDataToDataPipe(defer_or_cancel)) {
+      controller()->Cancel();
+      *defer_or_cancel = true;
+      return;
+    }
+    if (*defer_or_cancel) {
       request()->LogBlockedBy("MojoAsyncResourceHandler");
       did_defer_on_writing_ = true;
     }
-    return true;
+    return;
   }
 
-  if (EndWrite(bytes_read) != MOJO_RESULT_OK)
-    return false;
+  if (EndWrite(bytes_read) != MOJO_RESULT_OK) {
+    controller()->Cancel();
+    *defer_or_cancel = true;
+    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) {
+  if (!AllocateWriterIOBuffer(&buffer_, defer_or_cancel)) {
+    controller()->Cancel();
+    *defer_or_cancel = true;
+    return;
+  }
+  if (*defer_or_cancel) {
     request()->LogBlockedBy("MojoAsyncResourceHandler");
     did_defer_on_writing_ = true;
   }
-  return true;
 }
 
 void MojoAsyncResourceHandler::OnDataDownloaded(int bytes_downloaded) {
   int64_t total_received_bytes = request()->GetTotalReceivedBytes();
   int64_t bytes_to_report =
       total_received_bytes - reported_total_received_bytes_;
   reported_total_received_bytes_ = total_received_bytes;
   DCHECK_LE(0, bytes_to_report);
 
   url_loader_client_->OnDataDownloaded(bytes_downloaded, bytes_to_report);
@@ skipping 165 matching lines @@
   const ResourceRequestInfoImpl* info = GetRequestInfo();
   ResourceDispatcherHostImpl::Get()->CancelRequestFromRenderer(
       GlobalRequestID(info->GetChildID(), info->GetRequestID()));
 }
 
 void MojoAsyncResourceHandler::ReportBadMessage(const std::string& error) {
   mojo::ReportBadMessage(error);
 }
 
 }  // namespace content