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 104 matching lines @@
  private:
   int load_flags_;
   std::string buffer_;
   bool has_accept_header_;
 };
 
 // Extracts the information from a data: url.
 bool GetInfoFromDataURL(const GURL& url,
                         ResourceResponseInfo* info,
                         std::string* data,
-                        net::URLRequestStatus* status) {
+                        int* error_code) {
   std::string mime_type;
   std::string charset;
   if (net::DataURL::Parse(url, &mime_type, &charset, data)) {
-    *status = net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0);
+    *error_code = net::OK;
     // Assure same time for all time fields of data: URLs.
     Time now = Time::Now();
     info->load_timing.base_time = now;
     info->load_timing.base_ticks = TimeTicks::Now();
     info->request_time = now;
     info->response_time = now;
     info->headers = NULL;
     info->mime_type.swap(mime_type);
     info->charset.swap(charset);
     info->security_info.clear();
     info->content_length = data->length();
     info->encoded_data_length = 0;
 
     return true;
   }
 
-  *status = net::URLRequestStatus(net::URLRequestStatus::FAILED,
-                                  net::ERR_INVALID_URL);
+  *error_code = net::ERR_INVALID_URL;
   return false;
 }
 
 typedef ResourceDevToolsInfo::HeadersVector HeadersVector;
 
 void PopulateURLResponse(
     const GURL& url,
     const ResourceResponseInfo& info,
     WebURLResponse* response) {
   response->setURL(url);
@@ skipping 133 matching lines @@
       const GURL& new_url,
       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,
+  virtual void OnCompletedRequest(int error_code,
+                                  bool is_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 44 matching lines @@
   request_ = request;  // Save the request.
 
   GURL url = request.url();
   if (url.SchemeIs("data") && CanHandleDataURL(url)) {
     if (sync_load_response) {
       // This is a sync load. Do the work now.
       sync_load_response->url = url;
       std::string data;
       GetInfoFromDataURL(sync_load_response->url, sync_load_response,
                          &sync_load_response->data,
-                         &sync_load_response->status);
+                         &sync_load_response->error_code);
     } else {
       AddRef();  // Balanced in OnCompletedRequest
       MessageLoop::current()->PostTask(FROM_HERE,
           base::Bind(&Context::HandleDataURL, this));
     }
     return;
   }
 
   GURL referrer_url(
       request.httpHeaderField(WebString::fromUTF8("Referer")).utf8());
@@ skipping 239 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,
+    int error_code,
+    bool is_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();
-      }
+    if (!net::IsSuccess(error_code) || is_handled_externally) {

[darin (slow to review), 2012/08/10 18:03:02]

I think you should just compare error_code against net::OK here since we don't
support positive error codes in this context.

[mkosiba (inactive), 2012/08/29 15:53:01]

Positive error codes support was dropped in one of the previous iterations
(there is no net::OK anymore).

       WebURLError error;
       if (error_code == net::ERR_ABORTED) {
         error.isCancellation = true;
       } else if (error_code == net::ERR_TEMPORARILY_THROTTLED) {
         error.localizedDescription = WebString::fromUTF8(
             kThrottledErrorDescription);
       }
       error.domain = WebString::fromUTF8(net::kErrorDomain);
       error.reason = error_code;
       error.unreachableURL = request_.url();
@@ skipping 35 matching lines @@
   std::string mime_type, unused_charset;
   if (net::DataURL::Parse(url, &mime_type, &unused_charset, NULL) &&
       net::IsSupportedMimeType(mime_type))
     return true;
 
   return false;
 }
 
 void WebURLLoaderImpl::Context::HandleDataURL() {
   ResourceResponseInfo info;
-  net::URLRequestStatus status;
+  int error_code;
   std::string data;
 
-  if (GetInfoFromDataURL(request_.url(), &info, &data, &status)) {
+  if (GetInfoFromDataURL(request_.url(), &info, &data, &error_code)) {
     OnReceivedResponse(info);
     if (!data.empty())
       OnReceivedData(data.data(), data.size(), 0);
   }
 
-  OnCompletedRequest(status, info.security_info, base::TimeTicks::Now());
+  OnCompletedRequest(error_code, 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) {
+  int error_code = sync_load_response.error_code;
+  if (!net::IsSuccess(error_code)) {
     response.setURL(final_url);
     error.domain = WebString::fromUTF8(net::kErrorDomain);
-    error.reason = sync_load_response.status.error();
+    error.reason = error_code;
     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