Implement a ResourceThrottle for URL overriding in Chrome on Android.

content/browser/renderer_host/resource_dispatcher_host_impl.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/renderer_host/resource_dispatcher_host_impl.h"
 
 #include <set>
 #include <vector>
@@ skipping 1393 matching lines @@
 
   DCHECK(request->status().is_success());
 
   if (info->process_type() != PROCESS_TYPE_PLUGIN &&
       !ChildProcessSecurityPolicyImpl::GetInstance()->
           CanRequestURL(info->GetChildID(), new_url)) {
     VLOG(1) << "Denied unauthorized request for "
             << new_url.possibly_invalid_spec();
 
     // Tell the renderer that this request was disallowed.
-    CancelRequestInternal(request, false);
+    CancelRequestInternal(request, false, false);
     return;
   }
 
   NotifyReceivedRedirect(request, info->GetChildID(), new_url);
 
   if (HandleExternalProtocol(info->GetRequestID(), info->GetChildID(),
                              info->GetRouteID(), new_url,
                              info->GetResourceType(),
                              *request->context()->job_factory(),
                              info->resource_handler())) {
     // The request is complete so we can remove it.
     RemovePendingRequest(info->GetChildID(), info->GetRequestID());
     return;
   }
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
   PopulateResourceResponse(request, response);
   if (!info->resource_handler()->OnRequestRedirected(info->GetRequestID(),
                                                      new_url,
                                                      response, defer_redirect))
-    CancelRequestInternal(request, false);
+    CancelRequestInternal(request, false, false);
 }
 
 void ResourceDispatcherHostImpl::OnAuthRequired(
     net::URLRequest* request,
     net::AuthChallengeInfo* auth_info) {
   if (request->load_flags() & net::LOAD_DO_NOT_PROMPT_FOR_LOGIN) {
     request->CancelAuth();
     return;
   }
 
@@ skipping 86 matching lines @@
       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.
     info->set_waiting_for_upload_progress_ack(false);
     MaybeUpdateUploadProgress(info, request);
 
     if (!CompleteResponseStarted(request)) {
-      CancelRequestInternal(request, false);
+      CancelRequestInternal(request, false, false);
     } else {
       // Check if the handler paused the request in their OnResponseStarted.
       if (PauseRequestIfNeeded(info)) {
         VLOG(1) << "OnResponseStarted pausing2: " << request->url().spec();
         return;
       }
 
       StartReading(request);
     }
   } else {
@@ skipping 34 matching lines @@
 
   if (defer)
     PauseRequest(info->GetChildID(), info->GetRequestID(), true);
 
   return true;
 }
 
 void ResourceDispatcherHostImpl::CancelRequest(int child_id,
                                                int request_id,
                                                bool from_renderer) {
+  CancelRequestWorker(child_id, request_id, from_renderer, false);
+}
+
+void ResourceDispatcherHostImpl::CancelRequestWithHandledExternallyStatus(
+    int child_id, int request_id) {
+  CancelRequestWorker(child_id, request_id, false, true);
+}
+
+void ResourceDispatcherHostImpl::CancelRequestWorker(int child_id,
+                                                     int request_id,
+                                                     bool from_renderer,
+                                                     bool handled_externally) {
+  // The renderer will only ever ask us to perform a regular cancel.
+  DCHECK(!(handled_externally && from_renderer));
   GlobalRequestID id(child_id, request_id);
   if (from_renderer) {
     // When the old renderer dies, it sends a message to us to cancel its
     // requests.
     if (transferred_navigations_.find(id) != transferred_navigations_.end())
       return;
   }
 
   PendingRequestList::iterator i = pending_requests_.find(id);
   if (i == pending_requests_.end()) {
     // We probably want to remove this warning eventually, but I wanted to be
     // able to notice when this happens during initial development since it
     // should be rare and may indicate a bug.
     DVLOG(1) << "Canceling a request that wasn't found";
     return;
   }
   net::URLRequest* request = i->second;
 
   bool started_before_cancel = request->is_pending();
-  if (CancelRequestInternal(request, from_renderer) &&
+  if (CancelRequestInternal(request, from_renderer, handled_externally) &&
       !started_before_cancel) {
     // If the request isn't in flight, then we won't get an asynchronous
     // notification from the request, so we have to signal ourselves to finish
     // this request.
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ResourceDispatcherHostImpl::CallResponseCompleted,
                    base::Unretained(this),
                    child_id,
                    request_id));
   }
 }
 
-bool ResourceDispatcherHostImpl::CancelRequestInternal(net::URLRequest* request,
-                                                       bool from_renderer) {
+bool ResourceDispatcherHostImpl::CancelRequestInternal(
+    net::URLRequest* request,
+    bool from_renderer,
+    bool handled_externally) {
   VLOG(1) << "CancelRequest: " << request->url().spec();
 
   // 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.
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request);
   if (!from_renderer || !info->is_download()) {
     if (info->login_delegate()) {
       info->login_delegate()->OnRequestCancelled();
       info->set_login_delegate(NULL);
     }
     if (info->ssl_client_auth_handler()) {
       info->ssl_client_auth_handler()->OnRequestCancelled();
       info->set_ssl_client_auth_handler(NULL);
     }
-    request->Cancel();
+    if (handled_externally)
+      request->CancelWithHandledExternallyStatus();
+    else
+      request->Cancel();
     // Our callers assume |request| is valid after we return.
     DCHECK(IsValidRequest(request));
     return true;
   }
 
   // Do not remove from the pending requests, as the request will still
   // call AllDataReceived, and may even have more data before it does
   // that.
   return false;
 }
@@ skipping 86 matching lines @@
   //       of whether |defer_start| was set).
   //   (2) If |defer_start| was set to true, then the request is not added
   //       into the resource queue, and will only be started in response to
   //       calling StartDeferredRequest().
   //   (3) If |defer_start| is not set, then the request is inserted into
   //       the resource_queue_ (which may pause it further, or start it).
   bool defer_start = false;
   if (!info->resource_handler()->OnWillStart(
           info->GetRequestID(), request->url(),
           &defer_start)) {
-    CancelRequestInternal(request, false);
+    CancelRequestInternal(request, false, false);
     return;
   }
 
   if (!defer_start)
     StartRequest(request);
 }
 
 void ResourceDispatcherHostImpl::StartRequest(net::URLRequest* request) {
   request->Start();
 
@@ skipping 182 matching lines @@
   if (!request || !request->status().is_success()) {
     NOTREACHED();
     return false;
   }
 
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request);
 
   bool defer = false;
   if (!info->resource_handler()->OnReadCompleted(info->GetRequestID(),
                                                  bytes_read, &defer)) {
-    CancelRequestInternal(request, false);
+    CancelRequestInternal(request, false, false);
     return false;
   }
 
   if (defer)
     PauseRequest(info->GetChildID(), info->GetRequestID(), true);
 
   return *bytes_read != 0;
 }
 
 void ResourceDispatcherHostImpl::ResponseCompleted(net::URLRequest* request) {
@@ skipping 394 matching lines @@
   return allow_cross_origin_auth_prompt_;
 }
 
 bool ResourceDispatcherHostImpl::IsTransferredNavigation(
     const GlobalRequestID& transferred_request_id) const {
   return transferred_navigations_.find(transferred_request_id) !=
       transferred_navigations_.end();
 }
 
 }  // namespace content