Refactor ResourceHandler API.

content/browser/loader/resource_loader.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/resource_loader.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ skipping 145 matching lines @@
   // as the ResourceHandler may want to inspect the URLRequest and other state.
   handler_.reset();
 }
 
 void ResourceLoader::StartRequest() {
   if (delegate_->HandleExternalProtocol(this, request_->url())) {
     CancelAndIgnore();
     return;
   }
 
-  // Give the handler a chance to delay the URLRequest from being started.
-  bool defer_start = false;
-  if (!handler_->OnWillStart(request_->url(), &defer_start)) {
-    Cancel();
-    return;
-  }
-
   TRACE_EVENT_WITH_FLOW0("loading", "ResourceLoader::StartRequest", this,
                          TRACE_EVENT_FLAG_FLOW_OUT);
-  if (defer_start) {
+
+  // Give the handler a chance to delay the URLRequest from being started.
+  bool defer_or_cancel = false;
+  handler_->OnWillStart(request_->url(), &defer_or_cancel);
+  if (defer_or_cancel) {
     deferred_stage_ = DEFERRED_START;
   } else {
     StartRequestInternal();
   }
 }
 
 void ResourceLoader::CancelRequest(bool from_renderer) {
   TRACE_EVENT_WITH_FLOW0("loading", "ResourceLoader::CancelRequest", this,
                          TRACE_EVENT_FLAG_FLOW_IN);
-  CancelRequestInternal(net::ERR_ABORTED, from_renderer);
-}
-
-void ResourceLoader::CancelAndIgnore() {
-  ResourceRequestInfoImpl* info = GetRequestInfo();
-  info->set_was_ignored_by_handler(true);
-  CancelRequest(false);
-}
-
-void ResourceLoader::CancelWithError(int error_code) {
-  TRACE_EVENT_WITH_FLOW0("loading", "ResourceLoader::CancelWithError", this,
-                         TRACE_EVENT_FLAG_FLOW_IN);
-  CancelRequestInternal(error_code, false);
+  CancelRequestInternal(net::ERR_ABORTED, from_renderer, false);
 }
 
 void ResourceLoader::MarkAsTransferring(
     const base::Closure& on_transfer_complete_callback) {
   CHECK(IsResourceTypeFrame(GetRequestInfo()->GetResourceType()))
       << "Can only transfer for navigations";
   is_transferring_ = true;
   on_transfer_complete_callback_ = on_transfer_complete_callback;
 
   int child_id = GetRequestInfo()->GetChildID();
@@ skipping 68 matching lines @@
 
   if (delegate_->HandleExternalProtocol(this, redirect_info.new_url)) {
     // The request is complete so we can remove it.
     CancelAndIgnore();
     return;
   }
 
   scoped_refptr<ResourceResponse> response = new ResourceResponse();
   PopulateResourceResponse(info, request_.get(), response.get());
   delegate_->DidReceiveRedirect(this, redirect_info.new_url, response.get());
-  if (!handler_->OnRequestRedirected(redirect_info, response.get(), defer)) {
-    Cancel();
-  } else if (*defer) {
+
+  // Cancellations are treated much like defers, so ignore the difference.
+  handler_->OnRequestRedirected(redirect_info, response.get(), defer);
+  if (*defer)
     deferred_stage_ = DEFERRED_REDIRECT;  // Follow redirect when resumed.
-  }
 }
 
 void ResourceLoader::OnAuthRequired(net::URLRequest* unused,
                                     net::AuthChallengeInfo* auth_info) {
   DCHECK_EQ(request_.get(), unused);
 
   ResourceRequestInfoImpl* info = GetRequestInfo();
   if (info->do_not_prompt_for_login()) {
     request_->CancelAuth();
     return;
@@ skipping 168 matching lines @@
     case DEFERRED_FINISH:
       // Delay self-destruction since we don't know how we were reached.
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(&ResourceLoader::CallDidFinishLoading,
                                 weak_ptr_factory_.GetWeakPtr()));
       break;
   }
 }
 
 void ResourceLoader::Cancel() {
-  CancelRequest(false);
+  CancelWithError(net::ERR_ABORTED);
+}
+
+void ResourceLoader::CancelAndIgnore() {
+  CancelRequestInternal(net::ERR_ABORTED, false, true);
+}
+
+void ResourceLoader::CancelWithError(int error_code) {
+  TRACE_EVENT_WITH_FLOW0("loading", "ResourceLoader::CancelWithError", this,
+                         TRACE_EVENT_FLAG_FLOW_IN);
+  CancelRequestInternal(error_code, false, false);
 }
 
 void ResourceLoader::StartRequestInternal() {
   DCHECK(!request_->is_pending());
 
   if (!request_->status().is_success()) {
     return;
   }
 
   started_request_ = true;
   request_->Start();
 
   delegate_->DidStartRequest(this);
 }
 
-void ResourceLoader::CancelRequestInternal(int error, bool from_renderer) {
+void ResourceLoader::CancelRequestInternal(int error,
+                                           bool from_renderer,
+                                           bool ignore) {
   DVLOG(1) << "CancelRequestInternal: " << request_->url().spec();
 
   ResourceRequestInfoImpl* info = GetRequestInfo();
+  if (ignore)
+    info->set_was_ignored_by_handler(true);
 
   // WebKit will send us a cancel for downloads since it no longer handles
   // them.  In this case, ignore the cancel since we handle downloads in the
   // browser.
   if (from_renderer && (info->IsDownload() || info->is_stream()))
     return;
 
   if (from_renderer && info->detachable_handler()) {
     // TODO(davidben): Fix Blink handling of prefetches so they are not
     // cancelled on navigate away and end up in the local cache.
@@ skipping 33 matching lines @@
   ResourceRequestInfoImpl* info = GetRequestInfo();
   scoped_refptr<ResourceResponse> response = new ResourceResponse();
   PopulateResourceResponse(info, request_.get(), response.get());
 
   delegate_->DidReceiveResponse(this);
 
   // TODO(darin): Remove ScopedTracker below once crbug.com/475761 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION("475761 OnResponseStarted()"));
 
-  bool defer = false;
-  if (!handler_->OnResponseStarted(response.get(), &defer)) {
-    Cancel();
-  } else if (defer) {
+  bool defer_or_cancel = false;
+  handler_->OnResponseStarted(response.get(), &defer_or_cancel);
+  if (defer_or_cancel) {
     read_deferral_start_time_ = base::TimeTicks::Now();
     deferred_stage_ = DEFERRED_READ;  // Read first chunk when resumed.
   }
 }
 
 void ResourceLoader::StartReading(bool is_continuation) {
+  TRACE_EVENT_WITH_FLOW0("loading", "ResourceLoader::StartReading", this,
+                         TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT);
+  DCHECK(!is_deferred());
   int bytes_read = 0;
-  ReadMore(&bytes_read);
+
+  // Make sure we track the buffer in at least one place.  This ensures it gets
+  // deleted even in the case the request has already finished its job and
+  // doesn't use the buffer.
+  scoped_refptr<net::IOBuffer> buf;
+  int buf_size;
+  {
+    // TODO(darin): Remove ScopedTracker below once crbug.com/475761 is fixed.
+    tracked_objects::ScopedTracker tracking_profile2(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION("475761 OnWillRead()"));
+
+    if (!handler_->OnWillRead(&buf, &buf_size, -1)) {
+      Cancel();
+      return;
+    }
+  }
+
+  DCHECK(buf.get());
+  DCHECK(buf_size > 0);
+
+  // No need to check the return value here.  Instead, detect errors below by
+  // inspecting the URLRequest's status.
+  request_->Read(buf.get(), buf_size, &bytes_read);
 
   // If IO is pending, wait for the URLRequest to call OnReadCompleted.
   if (request_->status().is_io_pending())
     return;
 
   if (!is_continuation || bytes_read <= 0) {
     OnReadCompleted(request_.get(), bytes_read);
   } else {
     // Else, trigger OnReadCompleted asynchronously to avoid starving the IO
     // thread in case the URLRequest can provide data synchronously.
@@ skipping 12 matching lines @@
                         base::TimeTicks::Now() - read_deferral_start_time_);
     read_deferral_start_time_ = base::TimeTicks();
   }
   if (request_->status().is_success()) {
     StartReading(false);  // Read the next chunk (OK to complete synchronously).
   } else {
     ResponseCompleted();
   }
 }
 
-void ResourceLoader::ReadMore(int* bytes_read) {
-  TRACE_EVENT_WITH_FLOW0("loading", "ResourceLoader::ReadMore", this,
-                         TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT);
-  DCHECK(!is_deferred());
-
-  // Make sure we track the buffer in at least one place.  This ensures it gets
-  // deleted even in the case the request has already finished its job and
-  // doesn't use the buffer.
-  scoped_refptr<net::IOBuffer> buf;
-  int buf_size;
-  {
-    // TODO(darin): Remove ScopedTracker below once crbug.com/475761 is fixed.
-    tracked_objects::ScopedTracker tracking_profile2(
-        FROM_HERE_WITH_EXPLICIT_FUNCTION("475761 OnWillRead()"));
-
-    if (!handler_->OnWillRead(&buf, &buf_size, -1)) {
-      Cancel();
-      return;
-    }
-  }
-
-  DCHECK(buf.get());
-  DCHECK(buf_size > 0);
-
-  request_->Read(buf.get(), buf_size, bytes_read);
-
-  // No need to check the return value here as we'll detect errors by
-  // inspecting the URLRequest's status.
-}
-
 void ResourceLoader::CompleteRead(int bytes_read) {
   TRACE_EVENT_WITH_FLOW0("loading", "ResourceLoader::CompleteRead", this,
                          TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT);
 
   DCHECK(bytes_read >= 0);
   DCHECK(request_->status().is_success());
 
   // TODO(darin): Remove ScopedTracker below once crbug.com/475761 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION("475761 OnReadCompleted()"));
 
-  bool defer = false;
-  if (!handler_->OnReadCompleted(bytes_read, &defer)) {
-    Cancel();
-  } else if (defer) {
+  bool defer_or_cancel = false;
+  handler_->OnReadCompleted(bytes_read, &defer_or_cancel);
+  if (defer_or_cancel) {
     deferred_stage_ =
         bytes_read > 0 ? DEFERRED_READ : DEFERRED_RESPONSE_COMPLETE;
   }
 
   // Note: the request may still have been cancelled while OnReadCompleted
   // returns true if OnReadCompleted caused request to get cancelled
   // out-of-band. (In AwResourceDispatcherHostDelegate::DownloadStarting, for
   // instance.)
 }
 
 void ResourceLoader::ResponseCompleted() {
   TRACE_EVENT_WITH_FLOW0("loading", "ResourceLoader::ResponseCompleted", this,
                          TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT);
 
   DVLOG(1) << "ResponseCompleted: " << request_->url().spec();
   RecordHistograms();
 
   bool defer = false;
   {
     // TODO(darin): Remove ScopedTracker below once crbug.com/475761 is fixed.
     tracked_objects::ScopedTracker tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION("475761 OnResponseCompleted()"));
 
     handler_->OnResponseCompleted(request_->status(), &defer);
   }
   if (defer) {
-    // The handler is not ready to die yet.  We will call DidFinishLoading when
-    // we resume.
+    // The handler is not ready to die yet.  DidFinishLoading will be called on
+    // resume.
     deferred_stage_ = DEFERRED_FINISH;
   } else {
-    // This will result in our destruction.
+    // This will result in destroying |this|.
     CallDidFinishLoading();
   }
 }
 
 void ResourceLoader::CallDidFinishLoading() {
   TRACE_EVENT_WITH_FLOW0("loading", "ResourceLoader::CallDidFinishLoading",
                          this, TRACE_EVENT_FLAG_FLOW_IN);
   delegate_->DidFinishLoading(this);
 }
 
@@ skipping 39 matching lines @@
     }
 
     UMA_HISTOGRAM_ENUMERATION("Net.Prefetch.Pattern", status, STATUS_MAX);
   } else if (request_->response_info().unused_since_prefetch) {
     TimeDelta total_time = base::TimeTicks::Now() - request_->creation_time();
     UMA_HISTOGRAM_TIMES("Net.Prefetch.TimeSpentOnPrefetchHit", total_time);
   }
 }
 
 }  // namespace content