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 <algorithm>
 #include <utility>
 #include <vector>
 
@@ skipping 125 matching lines @@
   } else {
     GetRequestInfo()->set_on_transfer(base::Bind(&NotReached));
   }
 }
 
 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) {
+    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");
+  HoldController(std::move(controller));
   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,
+    std::unique_ptr<ResourceController> controller) {
+  DCHECK(!has_controller());
+
   if (upload_progress_tracker_) {
     upload_progress_tracker_->OnUploadCompleted();
     upload_progress_tracker_ = nullptr;
   }
 
   const ResourceRequestInfoImpl* info = GetRequestInfo();
   if (rdh_->delegate()) {
     rdh_->delegate()->OnResponseStarted(request(), info->GetContext(),
                                         response);
   }
@@ skipping 17 matching lines @@
   url_loader_client_->OnReceiveResponse(response->head,
                                         std::move(downloaded_file_ptr));
 
   net::IOBufferWithSize* metadata = GetResponseMetadata(request());
   if (metadata) {
     const uint8_t* data = reinterpret_cast<const uint8_t*>(metadata->data());
 
     url_loader_client_->OnReceiveCachedMetadata(
         std::vector<uint8_t>(data, data + metadata->size()));
   }
-  return true;
+
+  controller->Resume();
 }
 
-bool MojoAsyncResourceHandler::OnWillStart(const GURL& url, bool* defer) {
+void MojoAsyncResourceHandler::OnWillStart(
+    const GURL& url,
+    std::unique_ptr<ResourceController> controller) {
   if (GetRequestInfo()->is_upload_progress_enabled() &&
       request()->has_upload()) {
     upload_progress_tracker_ = CreateUploadProgressTracker(
         FROM_HERE,
         base::BindRepeating(&MojoAsyncResourceHandler::SendUploadProgress,
                             base::Unretained(this)));
   }
 
-  return true;
+  controller->Resume();
 }
 
 bool MojoAsyncResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
                                           int* buf_size,
                                           int min_size) {
   DCHECK_EQ(-1, min_size);
 
+  // TODO(mmenke):  Cancel with net::ERR_INSUFFICIENT_RESOURCES instead.
   if (!CheckForSufficientResource())
     return false;
 
   if (!shared_writer_) {
     MojoCreateDataPipeOptions options;
     options.struct_size = sizeof(MojoCreateDataPipeOptions);
     options.flags = MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE;
     options.element_num_bytes = 1;
     options.capacity_num_bytes = g_allocation_size;
     mojo::DataPipe data_pipe(options);
@@ skipping 26 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,
+    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;
+  }
 
   const ResourceRequestInfoImpl* info = GetRequestInfo();
   if (info->ShouldReportRawHeaders()) {
     auto transfer_size_diff = CalculateRecentlyReceivedBytes();
     if (transfer_size_diff > 0)
       url_loader_client_->OnTransferSizeUpdated(transfer_size_diff);
   }
 
   if (response_body_consumer_handle_.is_valid()) {
     // Send the data pipe on the first OnReadCompleted call.
     url_loader_client_->OnStartLoadingResponseBody(
         std::move(response_body_consumer_handle_));
     response_body_consumer_handle_.reset();
   }
 
   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;
+      HoldController(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;
+    HoldController(std::move(controller));
+    return;
   }
-  return true;
+
+  controller->Resume();
 }
 
 void MojoAsyncResourceHandler::OnDataDownloaded(int bytes_downloaded) {
   url_loader_client_->OnDataDownloaded(bytes_downloaded,
                                        CalculateRecentlyReceivedBytes());
 }
 
 void MojoAsyncResourceHandler::FollowRedirect() {
   if (!request()->status().is_success()) {
     DVLOG(1) << "FollowRedirect for invalid request";
     return;
   }
   if (!did_defer_on_redirect_) {
     DVLOG(1) << "Malformed FollowRedirect request";
     ReportBadMessage("Malformed FollowRedirect request");
     return;
   }
 
   DCHECK(!did_defer_on_writing_);
   did_defer_on_redirect_ = false;
   request()->LogUnblocked();
-  controller()->Resume();
+  Resume();
 }
 
 void MojoAsyncResourceHandler::OnWritableForTesting() {
   OnWritable(MOJO_RESULT_OK);
 }
 
 void MojoAsyncResourceHandler::SetAllocationSizeForTesting(size_t size) {
   g_allocation_size = size;
 }
 
@@ skipping 10 matching lines @@
   return mojo::EndWriteDataRaw(shared_writer_->writer(), written);
 }
 
 net::IOBufferWithSize* MojoAsyncResourceHandler::GetResponseMetadata(
     net::URLRequest* request) {
   return request->response_info().metadata.get();
 }
 
 void MojoAsyncResourceHandler::OnResponseCompleted(
     const net::URLRequestStatus& status,
-    bool* defer) {
+    std::unique_ptr<ResourceController> controller) {
   // Ensure sending the final upload progress message here, since
   // OnResponseCompleted can be called without OnResponseStarted on cancellation
   // or error cases.
   if (upload_progress_tracker_) {
     upload_progress_tracker_->OnUploadCompleted();
     upload_progress_tracker_ = nullptr;
   }
 
   shared_writer_ = nullptr;
   buffer_ = nullptr;
@@ skipping 21 matching lines @@
   ResourceRequestCompletionStatus request_complete_data;
   request_complete_data.error_code = error_code;
   request_complete_data.was_ignored_by_handler = was_ignored_by_handler;
   request_complete_data.exists_in_cache = request()->response_info().was_cached;
   request_complete_data.completion_time = base::TimeTicks::Now();
   request_complete_data.encoded_data_length =
       request()->GetTotalReceivedBytes();
   request_complete_data.encoded_body_length = request()->GetRawBodyBytes();
 
   url_loader_client_->OnComplete(request_complete_data);
+  controller->Resume();
 }
 
 bool MojoAsyncResourceHandler::CopyReadDataToDataPipe(bool* defer) {
   while (true) {
     scoped_refptr<net::IOBufferWithSize> dest;
     if (!AllocateWriterIOBuffer(&dest, defer))
       return false;
     if (*defer)
       return true;
     if (buffer_bytes_read_ == 0) {
@@ skipping 35 matching lines @@
 }
 
 bool MojoAsyncResourceHandler::CheckForSufficientResource() {
   if (has_checked_for_sufficient_resources_)
     return true;
   has_checked_for_sufficient_resources_ = true;
 
   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;
 
   if (is_using_io_buffer_not_from_writer_) {
     // |buffer_| is set to a net::IOBufferWithSize. Write the buffer contents
     // 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;
     }
   }
 
   if (did_defer_on_writing_) {
     // Continue waiting.
     return;
   }
   request()->LogUnblocked();
-  controller()->Resume();
+  Resume();
 }
 
 void MojoAsyncResourceHandler::Cancel() {
   const ResourceRequestInfoImpl* info = GetRequestInfo();
   ResourceDispatcherHostImpl::Get()->CancelRequestFromRenderer(
       GlobalRequestID(info->GetChildID(), info->GetRequestID()));
 }
 
 int64_t MojoAsyncResourceHandler::CalculateRecentlyReceivedBytes() {
   int64_t total_received_bytes = request()->GetTotalReceivedBytes();
@@ skipping 33 matching lines @@
       base::Bind(&MojoAsyncResourceHandler::OnUploadProgressACK,
                  weak_factory_.GetWeakPtr()));
 }
 
 void MojoAsyncResourceHandler::OnUploadProgressACK() {
   if (upload_progress_tracker_)
     upload_progress_tracker_->OnAckReceived();
 }
 
 }  // namespace content