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 10 matching lines @@
 #include "webkit/appcache/appcache_interceptor.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace content {
 namespace {
 
 void PopulateResourceResponse(net::URLRequest* request,
                               ResourceResponse* response) {
-  response->head.status = request->status();
+  response->head.error_code = request->status().error();
   response->head.request_time = request->request_time();
   response->head.response_time = request->response_time();
   response->head.headers = request->response_headers();
   request->GetCharset(&response->head.charset);
   response->head.content_length = request->GetExpectedContentSize();
   request->GetMimeType(&response->head.mime_type);
   net::HttpResponseInfo response_info = request->response_info();
   response->head.was_fetched_via_spdy = response_info.was_fetched_via_spdy;
   response->head.was_npn_negotiated = response_info.was_npn_negotiated;
   response->head.npn_negotiated_protocol =
@@ skipping 28 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);
+    HandledExternally();
     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::CancelWithError(int error) {
+  CancelRequestInternal(error, false);
+}
+
+void ResourceLoader::HandledExternally() {
+  ResourceRequestInfoImpl* info = GetRequestInfo();
+  info->set_handled_externally(true);
+  CancelRequest(false);
+}
+
 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 83 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);
+    HandledExternally();
     return;
   }
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse());
   PopulateResourceResponse(request_.get(), response);
 
   if (!handler_->OnRequestRedirected(info->GetRequestID(), new_url, response,
                                      defer)) {
     Cancel();
   } else if (*defer) {
@@ skipping 340 matching lines @@
     // we resume.
     deferred_stage_ = DEFERRED_FINISH;
   }
 }
 
 void ResourceLoader::CallDidFinishLoading() {
   delegate_->DidFinishLoading(this);
 }
 
 }  // namespace content