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 278 matching lines @@
         new ResourceMsg_UploadProgress(GetRequestID(),
                                        progress.position(),
                                        progress.size()));
     }
     waiting_for_upload_progress_ack_ = true;
     last_upload_ticks_ = TimeTicks::Now();
     last_upload_position_ = progress.position();
   }
 }
 
-bool AsyncResourceHandler::OnRequestRedirected(
+void AsyncResourceHandler::OnRequestRedirected(
     const net::RedirectInfo& redirect_info,
     ResourceResponse* response,
-    bool* defer) {
+    std::unique_ptr<ResourceController> controller) {
+  DCHECK(!has_controller());
+
   const ResourceRequestInfoImpl* info = GetRequestInfo();
-  if (!info->filter())
-    return false;
-
-  *defer = did_defer_ = true;
-  OnDefer();
+  if (!info->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 info->filter()->Send(new ResourceMsg_ReceivedRedirect(
-      GetRequestID(), redirect_info, response->head));
+  if (!info->filter()->Send(new ResourceMsg_ReceivedRedirect(
+          GetRequestID(), redirect_info, response->head))) {
+    controller->Cancel();
+  } else {
+    did_defer_ = true;
+    OnDefer();
+    set_controller(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();
 
   progress_timer_.Stop();
   const ResourceRequestInfoImpl* info = GetRequestInfo();
-  if (!info->filter())
-    return false;
+  if (!info->filter()) {
+    Cancel();
+    return;
+  }
 
   // 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 (info->is_upload_progress_enabled()) {
     waiting_for_upload_progress_ack_ = false;
     ReportUploadProgress();
   }
 
   if (rdh_->delegate()) {
@@ skipping 20 matching lines @@
 
   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());
     info->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) {
   if (GetRequestInfo()->is_upload_progress_enabled() &&
       request()->has_upload()) {
     ReportUploadProgress();
     progress_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromMilliseconds(kUploadProgressIntervalMsec),
         this,
         &AsyncResourceHandler::ReportUploadProgress);
   }
-  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.

[Randy Smith (Not in Mondays), 2016/12/16 21:37:26]

Is there a reason why CancelWithError() can't be called from here?  (This may be
"haven't gotten to it but plan to in this CL" issue, in which case feel free to
ignore this comment.)

[mmenke, 2016/12/22 16:29:35]

We don't have a ResourceController to call it on.  OnWillRead always completes
synchronously and returns a bool.  I want to make it take a controller like
everything else, but that's well beyond the scope of this CL.  The fact that
this code called cancel and returned false is a bug.

   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();
 
   int encoded_body_length = CalculateEncodedBodyLengthToReport();
   first_chunk_read_ = true;
 
   // Return early if InliningHelper handled the received data.
   if (inlining_helper_->SendInlinedDataIfApplicable(
           bytes_read, encoded_data_length, encoded_body_length, filter,
-          GetRequestID()))
-    return true;
+          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,
                                             encoded_body_length));
   ++pending_data_count_;
 
   if (!buffer_->CanAllocate()) {
-    *defer = did_defer_ = true;
+    did_defer_ = true;
     OnDefer();
+    set_controller(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) {
   const ResourceRequestInfoImpl* info = GetRequestInfo();
-  if (!info->filter())
+  if (!info->filter()) {
+    controller->Resume();
     return;
+  }
 
   // If we crash here, figure out what URL the renderer was requesting.
   // http://crbug.com/107692
   char url_buf[128];
   base::strlcpy(url_buf, request()->url().spec().c_str(), arraysize(url_buf));
   base::debug::Alias(url_buf);
 
   // TODO(gavinp): Remove this CHECK when we figure out the cause of
   // http://crbug.com/124680 . This check mirrors closely check in
   // WebURLLoaderImpl::OnCompletedRequest that routes this message to a WebCore
@@ skipping 16 matching lines @@
   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 = TimeTicks::Now();
   request_complete_data.encoded_data_length =
       request()->GetTotalReceivedBytes();
   info->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;
     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() {
   return TrackDifference(request()->GetTotalReceivedBytes(),
                          &reported_transfer_size_);
 }
 
 int AsyncResourceHandler::CalculateEncodedBodyLengthToReport() {
   return TrackDifference(request()->GetRawBodyBytes(),
@@ skipping 20 matching lines @@
   } else {
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Net.ResourceLoader.ResponseStartToEnd.Over_512kB",
         elapsed_time, 1, 100000, 100);
   }
 
   inlining_helper_->RecordHistogram(elapsed_time);
 }
 
 }  // namespace content