net: Remove typedef net::URLRequestStatus URLRequestStatus;

webkit/glue/weburlloader_impl.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
 // An implementation of WebURLLoader in terms of ResourceLoaderBridge.
 
 #include "webkit/glue/weburlloader_impl.h"
 
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
@@ skipping 127 matching lines @@
       return ResourceType::PREFETCH;
     default:
       NOTREACHED();
       return ResourceType::SUB_RESOURCE;
   }
 }
 
 // Extracts the information from a data: url.
 bool GetInfoFromDataURL(const GURL& url,
                         ResourceResponseInfo* info,
-                        std::string* data, URLRequestStatus* status) {
+                        std::string* data,
+                        net::URLRequestStatus* status) {
   std::string mime_type;
   std::string charset;
   if (net::DataURL::Parse(url, &mime_type, &charset, data)) {
-    *status = URLRequestStatus(URLRequestStatus::SUCCESS, 0);
+    *status = net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0);
     info->request_time = Time::Now();
     info->response_time = Time::Now();
     info->headers = NULL;
     info->mime_type.swap(mime_type);
     info->charset.swap(charset);
     info->security_info.clear();
     info->content_length = -1;
 
     return true;
   }
 
-  *status = URLRequestStatus(URLRequestStatus::FAILED, net::ERR_INVALID_URL);
+  *status = net::URLRequestStatus(net::URLRequestStatus::FAILED,
+                                  net::ERR_INVALID_URL);
   return false;
 }
 
 typedef ResourceDevToolsInfo::HeadersVector HeadersVector;
 
 void PopulateURLResponse(
     const GURL& url,
     const ResourceResponseInfo& info,
     WebURLResponse* response) {
   response->setURL(url);
@@ skipping 111 matching lines @@
   virtual bool OnReceivedRedirect(
       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, bool content_filtered);
   virtual void OnDownloadedData(int len);
   virtual void OnReceivedData(const char* data, int len);
   virtual void OnReceivedCachedMetadata(const char* data, int len);
-  virtual void OnCompletedRequest(
-      const URLRequestStatus& status,
-      const std::string& security_info,
-      const base::Time& completion_time);
+  virtual void OnCompletedRequest(const net::URLRequestStatus& status,
+                                  const std::string& security_info,
+                                  const base::Time& 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();
 
   WebURLLoaderImpl* loader_;
@@ skipping 303 matching lines @@
   }
 }
 
 void WebURLLoaderImpl::Context::OnReceivedCachedMetadata(
     const char* data, int len) {
   if (client_)
     client_->didReceiveCachedMetadata(loader_, data, len);
 }
 
 void WebURLLoaderImpl::Context::OnCompletedRequest(
-    const URLRequestStatus& status,
+    const net::URLRequestStatus& status,
     const std::string& security_info,
     const base::Time& 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() != URLRequestStatus::SUCCESS) {
+    if (status.status() != net::URLRequestStatus::SUCCESS) {
       int error_code;
-      if (status.status() == URLRequestStatus::HANDLED_EXTERNALLY) {
+      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.os_error();
       }
       WebURLError error;
       error.domain = WebString::fromUTF8(net::kErrorDomain);
       error.reason = error_code;
       error.unreachableURL = request_.url();
@@ skipping 30 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;
-  URLRequestStatus status;
+  net::URLRequestStatus status;
   std::string data;
 
   if (GetInfoFromDataURL(request_.url(), &info, &data, &status)) {
     OnReceivedResponse(info, false);
     if (!data.empty())
       OnReceivedData(data.data(), data.size());
   }
 
   OnCompletedRequest(status, info.security_info, base::Time::Now());
 }
@@ skipping 12 matching lines @@
                                          WebURLResponse& response,
                                          WebURLError& error,
                                          WebData& data) {
   ResourceLoaderBridge::SyncLoadResponse sync_load_response;
   context_->Start(request, &sync_load_response);
 
   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 URLRequestStatus::Status& status = sync_load_response.status.status();
-  if (status != URLRequestStatus::SUCCESS &&
-      status != URLRequestStatus::HANDLED_EXTERNALLY) {
+  const net::URLRequestStatus::Status& status =
+      sync_load_response.status.status();
+  if (status != net::URLRequestStatus::SUCCESS &&
+      status != net::URLRequestStatus::HANDLED_EXTERNALLY) {
     response.setURL(final_url);
     error.domain = WebString::fromUTF8(net::kErrorDomain);
     error.reason = sync_load_response.status.os_error();
     error.unreachableURL = final_url;
     return;
   }
 
   PopulateURLResponse(final_url, sync_load_response, &response);
 
   data.assign(sync_load_response.data.data(),
@@ skipping 10 matching lines @@
 
 void WebURLLoaderImpl::cancel() {
   context_->Cancel();
 }
 
 void WebURLLoaderImpl::setDefersLoading(bool value) {
   context_->SetDefersLoading(value);
 }
 
 }  // namespace webkit_glue