Remove the HANDLED_EXTERNALLY status code.

content/browser/renderer_host/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/renderer_host/resource_loader.h"
 
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/renderer_host/doomed_resource_handler.h"
@@ skipping 64 matching lines @@
   if (ssl_client_auth_handler_)
     ssl_client_auth_handler_->OnRequestCancelled();
 
   // Run ResourceHandler destructor before we tear-down the rest of our state
   // as the ResourceHandler may want to inspect the URLRequest and other state.
   handler_.reset();
 }
 
 void ResourceLoader::StartRequest() {
   if (delegate_->HandleExternalProtocol(this, request_->url())) {
-    CancelRequestInternal(net::ERR_UNKNOWN_URL_SCHEME, false);
+    GetRequestInfo()->set_handled_externally(true);
+    CancelRequestInternal(net::ERR_ABORTED, false);
     return;
   }
 
   // Give the handler a chance to delay the URLRequest from being started.
   bool defer_start = false;
   if (!handler_->OnWillStart(GetRequestInfo()->GetRequestID(), request_->url(),
                              &defer_start)) {
     Cancel();
     return;
   }
 
   if (defer_start) {
     deferred_stage_ = DEFERRED_START;
   } else {
     StartRequestInternal();
   }
 }
 
 void ResourceLoader::CancelRequest(bool from_renderer) {
   CancelRequestInternal(net::ERR_ABORTED, from_renderer);
 }
 
+void ResourceLoader::CancelWithHandledExternally() {
+  GetRequestInfo()->set_handled_externally(true);
+  CancelRequestInternal(net::ERR_ABORTED, false);

[darin (slow to review), 2012/06/25 16:15:32]

another idea, which may be too crazy, is to just get rid of URLRequestStatus
entirely.  since net::ERR_ABORTED implies cancellation at the WebURLLoaderImpl
level, we don't really even need to pass the URLRequestStatus::status() member.

Furthermore (and this is maybe where my proposal gets crazy), since net:: error
codes are all negative, we could use a positive value to indicate "handled
externally".  This is not entirely odd as that is not really an error condition.
 We know that network error codes will never be positive since various network
level interfaces use an integer to pass either byte counts or error codes.

It seems like it might simplify the code if we just had a single int error code
field to pass around and inspect.  Thoughts?

+}
+
 void ResourceLoader::ReportUploadProgress() {
   ResourceRequestInfoImpl* info = GetRequestInfo();
 
   if (waiting_for_upload_progress_ack_)
     return;  // Send one progress event at a time.
 
   uint64 size = info->GetUploadSize();
   if (!size)
     return;  // Nothing to upload.
 
@@ skipping 78 matching lines @@
 
     // Tell the renderer that this request was disallowed.
     Cancel();
     return;
   }
 
   delegate_->DidReceiveRedirect(this, new_url);
 
   if (delegate_->HandleExternalProtocol(this, new_url)) {
     // The request is complete so we can remove it.
-    CancelRequestInternal(net::ERR_UNKNOWN_URL_SCHEME, false);
+    GetRequestInfo()->set_handled_externally(true);
+    CancelRequestInternal(net::ERR_ABORTED, false);
     return;
   }
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse());
   PopulateResourceResponse(request_.get(), response);
 
   if (!handler_->OnRequestRedirected(info->GetRequestID(), new_url, response,
                                      defer)) {
     Cancel();
   }
@@ skipping 423 matching lines @@
   } else {
     OnResponseStarted(request_.get());
   }
 }
 
 void ResourceLoader::CallDidFinishLoading() {
   delegate_->DidFinishLoading(this);
 }
 
 }  // namespace content