Set isCancelling flag on WebURLError when request has net::ERR_ABORTED as an error_code

content/browser/renderer_host/resource_dispatcher_host.cc

 // Copyright (c) 2011 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.h"
 
 #include <set>
 #include <vector>
@@ skipping 126 matching lines @@
     // Tell the renderer that this request was disallowed.
     filter->Send(new ResourceMsg_RequestComplete(
         route_id,
         request_id,
         status,
         std::string(),   // No security info needed, connection was not
         base::Time()));  // established.
   }
 }
 
+// Aborts a request before an URLRequest has actually been created.
+void CancelRequestBeforeItStarts(ResourceMessageFilter* filter,

[gavinp, 2011/06/15 15:31:23]

Instead of writing this function, add a bool or enumerated parameter to
AbortRequestBeforeItStarts, and maybe rename it to something more general.

+                                IPC::Message* sync_result,
+                                int route_id,
+                                int request_id) {
+  net::URLRequestStatus status(net::URLRequestStatus::CANCELED,
+                               net::ERR_ABORTED);
+  if (sync_result) {
+    SyncLoadResult result;
+    result.status = status;
+    ResourceHostMsg_SyncLoad::WriteReplyParams(sync_result, result);
+    filter->Send(sync_result);
+  } else {
+    // Tell the renderer that this request was disallowed.
+    filter->Send(new ResourceMsg_RequestComplete(
+        route_id,
+        request_id,
+        status,
+        std::string(),   // No security info needed, connection was not
+        base::Time()));  // established.
+  }
+}
+
 GURL MaybeStripReferrer(const GURL& possible_referrer) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kNoReferrers))
     return GURL();
   return possible_referrer;
 }
 
 // Consults the RendererSecurity policy to determine whether the
 // ResourceDispatcherHost should service this request.  A request might be
 // disallowed if the renderer is not authorized to retrieve the request URL or
 // if the renderer is attempting to upload an unauthorized file.
@@ skipping 233 matching lines @@
     return;
   }
 
   const GURL referrer = MaybeStripReferrer(request_data.referrer);
 
   // Allow the observer to block/handle the request.
   if (delegate_ && !delegate_->ShouldBeginRequest(child_id, route_id,
                                                   request_data,
                                                   resource_context,
                                                   referrer)) {
-    AbortRequestBeforeItStarts(filter_, sync_result, route_id, request_id);
+    CancelRequestBeforeItStarts(filter_, sync_result, route_id, request_id);
     return;
   }
 
   // Construct the event handler.
   scoped_refptr<ResourceHandler> handler;
   if (sync_result) {
     handler = new SyncResourceHandler(
         filter_, request_data.url, sync_result, this);
   } else {
     handler = new AsyncResourceHandler(
@@ skipping 1596 matching lines @@
 
 bool ResourceDispatcherHost::allow_cross_origin_auth_prompt() {
   return allow_cross_origin_auth_prompt_;
 }
 
 void ResourceDispatcherHost::set_allow_cross_origin_auth_prompt(bool value) {
   allow_cross_origin_auth_prompt_ = value;
 }