Refactor ResourceHandler API.

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 182 matching lines @@
 };
 
 AsyncResourceHandler::AsyncResourceHandler(
     net::URLRequest* request,
     ResourceDispatcherHostImpl* rdh)
     : ResourceHandler(request),
       ResourceMessageDelegate(request),
       rdh_(rdh),
       pending_data_count_(0),
       allocation_size_(0),
-      did_defer_(false),
       has_checked_for_sufficient_resources_(false),
       sent_received_response_msg_(false),
       sent_data_buffer_msg_(false),
       inlining_helper_(new InliningHelper),
       reported_transfer_size_(0) {
   DCHECK(GetRequestInfo()->requester_info()->IsRenderer());
   InitializeResourceBufferConstants();
 }
 
 AsyncResourceHandler::~AsyncResourceHandler() {
@@ skipping 29 matching lines @@
     if (buffer_->CanAllocate())
       ResumeIfDeferred();
   }
 }
 
 void AsyncResourceHandler::OnUploadProgressACK(int request_id) {
   if (upload_progress_tracker_)
     upload_progress_tracker_->OnAckReceived();
 }
 
-bool AsyncResourceHandler::OnRequestRedirected(
+void AsyncResourceHandler::OnRequestRedirected(
     const net::RedirectInfo& redirect_info,
     ResourceResponse* response,
-    bool* defer) {
+    std::unique_ptr<ResourceController> controller) {
   ResourceMessageFilter* filter = GetFilter();
-  if (!filter)
-    return false;
-
-  *defer = did_defer_ = true;
-  OnDefer();
+  if (!filter) {
+    controller->Cancel();
+    return;
+  }
 
   NetLogObserver::PopulateResponseInfo(request(), response);
   response->head.encoded_data_length = request()->GetTotalReceivedBytes();
   reported_transfer_size_ = 0;
   response->head.request_start = request()->creation_time();
   response->head.response_start = 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.
-  return filter->Send(new ResourceMsg_ReceivedRedirect(
-      GetRequestID(), redirect_info, response->head));
+  if (!filter->Send(new ResourceMsg_ReceivedRedirect(
+          GetRequestID(), redirect_info, response->head))) {
+    controller->Cancel();
+  } else {
+    OnDefer();
+    HoldController(std::move(controller));
+  }
 }
 
-bool AsyncResourceHandler::OnResponseStarted(ResourceResponse* response,
-                                             bool* defer) {
+void AsyncResourceHandler::OnResponseStarted(
+    ResourceResponse* response,
+    std::unique_ptr<ResourceController> controller) {
   // For changes to the main frame, inform the renderer of the new URL's
   // per-host settings before the request actually commits.  This way the
   // renderer will be able to set these precisely at the time the
   // request commits, avoiding the possibility of e.g. zooming the old content
   // or of having to layout the new content twice.
+  DCHECK(!has_controller());
 
   response_started_ticks_ = base::TimeTicks::Now();
 
   // We want to send a final upload progress message prior to sending the
   // response complete message even if we're waiting for an ack to to a
   // previous upload progress message.
   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);
   }
 
   ResourceMessageFilter* filter = GetFilter();
-  if (!filter)
-    return false;
+  if (!filter) {
+    controller->Cancel();
+    return;
+  }
 
   NetLogObserver::PopulateResponseInfo(request(), response);
   response->head.encoded_data_length = request()->raw_header_size();
 
   // If the parent handler downloaded the resource to a file, grant the child
   // read permissions on it.
   if (!response->head.download_file_path.empty()) {
     rdh_->RegisterDownloadedTempFile(
         info->GetChildID(), info->GetRequestID(),
         response->head.download_file_path);
   }
 
   response->head.request_start = request()->creation_time();
   response->head.response_start = TimeTicks::Now();
   filter->Send(
       new ResourceMsg_ReceivedResponse(GetRequestID(), response->head));
   sent_received_response_msg_ = true;
 
   if (request()->response_info().metadata.get()) {
     std::vector<char> copy(request()->response_info().metadata->data(),
                            request()->response_info().metadata->data() +
                                request()->response_info().metadata->size());
     filter->Send(new ResourceMsg_ReceivedCachedMetadata(GetRequestID(), copy));
   }
 
   inlining_helper_->OnResponseReceived(*response);
-  return true;
+  controller->Resume();
 }
 
-bool AsyncResourceHandler::OnWillStart(const GURL& url, bool* defer) {
+void AsyncResourceHandler::OnWillStart(
+    const GURL& url,
+    std::unique_ptr<ResourceController> controller) {
   ResourceMessageFilter* filter = GetFilter();
-  if (!filter)
-    return false;
+  if (!filter) {
+    controller->Cancel();
+    return;
+  }
 
   if (GetRequestInfo()->is_upload_progress_enabled() &&
       request()->has_upload()) {
     upload_progress_tracker_ = base::MakeUnique<UploadProgressTracker>(
         FROM_HERE,
         base::BindRepeating(&AsyncResourceHandler::SendUploadProgress,
                             base::Unretained(this)),
         request());
   }
-  return true;
+  controller->Resume();
 }
 
 bool AsyncResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
                                       int* buf_size,
                                       int min_size) {
+  DCHECK(!has_controller());
   DCHECK_EQ(-1, min_size);
 
+  // TODO(mmenke):  Should fail with ERR_INSUFFICIENT_RESOURCES here.
   if (!CheckForSufficientResource())
     return false;
 
   // 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 (!EnsureResourceBufferIsInitialized())
     return false;
 
   DCHECK(buffer_->CanAllocate());
   char* memory = buffer_->Allocate(&allocation_size_);
   CHECK(memory);
 
   *buf = new DependentIOBuffer(buffer_.get(), memory);
   *buf_size = allocation_size_;
 
   return true;
 }
 
-bool AsyncResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
+void AsyncResourceHandler::OnReadCompleted(
+    int bytes_read,
+    std::unique_ptr<ResourceController> controller) {
+  DCHECK(!has_controller());
   DCHECK_GE(bytes_read, 0);
 
-  if (!bytes_read)
-    return true;
+  if (!bytes_read) {
+    controller->Resume();
+    return;
+  }
 
   ResourceMessageFilter* filter = GetFilter();
-  if (!filter)
-    return false;
+  if (!filter) {
+    controller->Cancel();
+    return;
+  }
 
   int encoded_data_length = CalculateEncodedDataLengthToReport();
   if (!first_chunk_read_)
     encoded_data_length -= request()->raw_header_size();
 
   first_chunk_read_ = true;
 
   // Return early if InliningHelper handled the received data.
   if (inlining_helper_->SendInlinedDataIfApplicable(
-          bytes_read, encoded_data_length, filter,
-          GetRequestID()))
-    return true;
+          bytes_read, encoded_data_length, filter, GetRequestID())) {
+    controller->Resume();
+    return;
+  }
 
   buffer_->ShrinkLastAllocation(bytes_read);
 
   if (!sent_data_buffer_msg_) {
     base::SharedMemoryHandle handle = base::SharedMemory::DuplicateHandle(
         buffer_->GetSharedMemory().handle());
-    if (!base::SharedMemory::IsHandleValid(handle))
-      return false;
+    if (!base::SharedMemory::IsHandleValid(handle)) {
+      controller->Cancel();
+      return;
+    }
     filter->Send(new ResourceMsg_SetDataBuffer(
         GetRequestID(), handle, buffer_->GetSharedMemory().mapped_size(),
         filter->peer_pid()));
     sent_data_buffer_msg_ = true;
   }
 
   int data_offset = buffer_->GetLastAllocationOffset();
 
   filter->Send(new ResourceMsg_DataReceived(GetRequestID(), data_offset,
                                             bytes_read, encoded_data_length));
   ++pending_data_count_;
 
   if (!buffer_->CanAllocate()) {
-    *defer = did_defer_ = true;
     OnDefer();
+    HoldController(std::move(controller));
+  } else {
+    controller->Resume();
   }
-
-  return true;
 }
 
 void AsyncResourceHandler::OnDataDownloaded(int bytes_downloaded) {
   int encoded_data_length = CalculateEncodedDataLengthToReport();
 
   ResourceMessageFilter* filter = GetFilter();
   if (filter) {
     filter->Send(new ResourceMsg_DataDownloaded(
         GetRequestID(), bytes_downloaded, encoded_data_length));
   }
 }
 
 void AsyncResourceHandler::OnResponseCompleted(
     const net::URLRequestStatus& status,
-    bool* defer) {
+    std::unique_ptr<ResourceController> controller) {
   ResourceMessageFilter* filter = GetFilter();
-  if (!filter)
+  if (!filter) {
+    controller->Resume();
     return;
+  }
 
   // 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;
   }
 
   // If we crash here, figure out what URL the renderer was requesting.
@@ skipping 26 matching lines @@
   request_complete_data.exists_in_cache = request()->response_info().was_cached;
   request_complete_data.completion_time = TimeTicks::Now();
   request_complete_data.encoded_data_length =
       request()->GetTotalReceivedBytes();
   request_complete_data.encoded_body_length = request()->GetRawBodyBytes();
   filter->Send(
       new ResourceMsg_RequestComplete(GetRequestID(), request_complete_data));
 
   if (status.is_success())
     RecordHistogram();
+  controller->Resume();
 }
 
 bool AsyncResourceHandler::EnsureResourceBufferIsInitialized() {
   DCHECK(has_checked_for_sufficient_resources_);
 
   if (buffer_.get() && buffer_->IsInitialized())
     return true;
 
   buffer_ = new ResourceBuffer();
   return buffer_->Initialize(kBufferSize,
                              kMinAllocationSize,
                              kMaxAllocationSize);
 }
 
 void AsyncResourceHandler::ResumeIfDeferred() {
-  if (did_defer_) {
-    did_defer_ = false;
+  if (has_controller()) {
     request()->LogUnblocked();
-    controller()->Resume();
+    Resume();
   }
 }
 
 void AsyncResourceHandler::OnDefer() {
   request()->LogBlockedBy("AsyncResourceHandler");
 }
 
 bool AsyncResourceHandler::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;
 }
 
 int AsyncResourceHandler::CalculateEncodedDataLengthToReport() {
   const auto transfer_size = request()->GetTotalReceivedBytes();
   const auto difference =  transfer_size - reported_transfer_size_;
   reported_transfer_size_ = transfer_size;
   return difference;
 }
 
@@ skipping 26 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