Remove the HANDLED_EXTERNALLY status code.

webkit/glue/weburlloader_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.
 
 // An implementation of WebURLLoader in terms of ResourceLoaderBridge.
 
 #include "webkit/glue/weburlloader_impl.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
@@ skipping 281 matching lines @@
       const ResourceResponseInfo& info,
       bool* has_new_first_party_for_cookies,
       GURL* new_first_party_for_cookies);
   virtual void OnReceivedResponse(const ResourceResponseInfo& info);
   virtual void OnDownloadedData(int len);
   virtual void OnReceivedData(const char* data,
                               int data_length,
                               int encoded_data_length);
   virtual void OnReceivedCachedMetadata(const char* data, int len);
   virtual void OnCompletedRequest(const net::URLRequestStatus& status,
+                                  bool handled_externally,
                                   const std::string& security_info,
                                   const base::TimeTicks& completion_time);
 
  private:
   friend class base::RefCounted<Context>;
   ~Context() {}
 
   // We can optimize the handling of data URLs in most cases.
   bool CanHandleDataURL(const GURL& url) const;
   void HandleDataURL();
@@ skipping 305 matching lines @@
 }
 
 void WebURLLoaderImpl::Context::OnReceivedCachedMetadata(
     const char* data, int len) {
   if (client_)
     client_->didReceiveCachedMetadata(loader_, data, len);
 }
 
 void WebURLLoaderImpl::Context::OnCompletedRequest(
     const net::URLRequestStatus& status,
+    bool handled_externally,
     const std::string& security_info,
     const base::TimeTicks& completion_time) {
   if (ftp_listing_delegate_.get()) {
     ftp_listing_delegate_->OnCompletedRequest();
     ftp_listing_delegate_.reset(NULL);
   } else if (multipart_delegate_.get()) {
     multipart_delegate_->OnCompletedRequest();
     multipart_delegate_.reset(NULL);
   }
 
   // Prevent any further IPC to the browser now that we're complete, but
   // don't delete it to keep any downloaded temp files alive.
   DCHECK(!completed_bridge_.get());
   completed_bridge_.swap(bridge_);
 
   if (client_) {
     if (status.status() != net::URLRequestStatus::SUCCESS) {
-      int error_code;
-      if (status.status() == net::URLRequestStatus::HANDLED_EXTERNALLY) {
-        // By marking this request as aborted we insure that we don't navigate
-        // to an error page.
-        error_code = net::ERR_ABORTED;
-      } else {
-        error_code = status.error();
-      }
       WebURLError error;
-      if (error_code == net::ERR_ABORTED) {
+      if (status.error() == net::ERR_ABORTED) {
         error.isCancellation = true;
-      } else if (error_code == net::ERR_TEMPORARILY_THROTTLED) {
+      } else if (status.error() == net::ERR_TEMPORARILY_THROTTLED) {
         error.localizedDescription = WebString::fromUTF8(
             kThrottledErrorDescription);
       }
-      error.domain = WebString::fromUTF8(net::kErrorDomain);
-      error.reason = error_code;
+      error.domain = WebString::fromUTF8(
+          handled_externally ? "ext" : net::kErrorDomain);
+      error.reason = status.error();
       error.unreachableURL = request_.url();
       client_->didFail(loader_, error);
     } else {
       client_->didFinishLoading(
           loader_, (completion_time - TimeTicks()).InSecondsF());
     }
   }
 
   // We are done with the bridge now, and so we need to release the reference
   // to ourselves that we took on behalf of the bridge.  This may cause our
@@ skipping 35 matching lines @@
   ResourceResponseInfo info;
   net::URLRequestStatus status;
   std::string data;
 
   if (GetInfoFromDataURL(request_.url(), &info, &data, &status)) {
     OnReceivedResponse(info);
     if (!data.empty())
       OnReceivedData(data.data(), data.size(), 0);
   }
 
-  OnCompletedRequest(status, info.security_info, base::TimeTicks::Now());
+  OnCompletedRequest(status, false, info.security_info,
+                     base::TimeTicks::Now());
 }
 
 // WebURLLoaderImpl -----------------------------------------------------------
 
 WebURLLoaderImpl::WebURLLoaderImpl(WebKitPlatformSupportImpl* platform)
     : ALLOW_THIS_IN_INITIALIZER_LIST(context_(new Context(this))),
       platform_(platform) {
 }
 
 WebURLLoaderImpl::~WebURLLoaderImpl() {
   cancel();
 }
 
 void WebURLLoaderImpl::loadSynchronously(const WebURLRequest& request,
                                          WebURLResponse& response,
                                          WebURLError& error,
                                          WebData& data) {
   ResourceLoaderBridge::SyncLoadResponse sync_load_response;
   context_->Start(request, &sync_load_response, platform_);
 
   const GURL& final_url = sync_load_response.url;
 
   // TODO(tc): For file loads, we may want to include a more descriptive
   // status code or status text.
   const net::URLRequestStatus::Status& status =
       sync_load_response.status.status();
-  if (status != net::URLRequestStatus::SUCCESS &&
-      status != net::URLRequestStatus::HANDLED_EXTERNALLY) {
+  if (status != net::URLRequestStatus::SUCCESS) {
     response.setURL(final_url);
-    error.domain = WebString::fromUTF8(net::kErrorDomain);
+    error.domain = WebString::fromUTF8(
+        sync_load_response.handled_externally ? "ext" : net::kErrorDomain);
     error.reason = sync_load_response.status.error();
     error.unreachableURL = final_url;
     return;
   }
 
   PopulateURLResponse(final_url, sync_load_response, &response);
 
   data.assign(sync_load_response.data.data(),
               sync_load_response.data.size());
 }
 
 void WebURLLoaderImpl::loadAsynchronously(const WebURLRequest& request,
                                           WebURLLoaderClient* client) {
   DCHECK(!context_->client());
 
   context_->set_client(client);
   context_->Start(request, NULL, platform_);
 }
 
 void WebURLLoaderImpl::cancel() {
   context_->Cancel();
 }
 
 void WebURLLoaderImpl::setDefersLoading(bool value) {
   context_->SetDefersLoading(value);
 }
 
 }  // namespace webkit_glue