net: Remove typedef net::URLRequest URLRequest;

webkit/tools/test_shell/simple_resource_loader_bridge.cc

 // Copyright (c) 2010 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.
 //
 // This file contains an implementation of the ResourceLoaderBridge class.
-// The class is implemented using URLRequest, meaning it is a "simple" version
-// that directly issues requests. The more complicated one used in the
+// The class is implemented using net::URLRequest, meaning it is a "simple"
+// version that directly issues requests. The more complicated one used in the
 // browser uses IPC.
 //
-// Because URLRequest only provides an asynchronous resource loading API, this
-// file makes use of URLRequest from a background IO thread.  Requests for
-// cookies and synchronously loaded resources result in the main thread of the
-// application blocking until the IO thread completes the operation.  (See
+// Because net::URLRequest only provides an asynchronous resource loading API,
+// this file makes use of net::URLRequest from a background IO thread. Requests
+// for cookies and synchronously loaded resources result in the main thread of
+// the application blocking until the IO thread completes the operation.  (See
 // GetCookies and SyncLoad)
 //
 // Main thread                          IO thread
 // -----------                          ---------
 // ResourceLoaderBridge <---o---------> RequestProxy (normal case)
-//                           \            -> URLRequest
+//                           \            -> net::URLRequest
 //                            o-------> SyncRequestProxy (synchronous case)
-//                                        -> URLRequest
+//                                        -> net::URLRequest
 // SetCookie <------------------------> CookieSetter
 //                                        -> net_util::SetCookie
 // GetCookies <-----------------------> CookieGetter
 //                                        -> net_util::GetCookies
 //
 // NOTE: The implementation in this file may be used to have WebKit fetch
 // resources in-process.  For example, it is handy for building a single-
-// process WebKit embedding (e.g., test_shell) that can use URLRequest to
+// process WebKit embedding (e.g., test_shell) that can use net::URLRequest to
 // perform URL loads.  See renderer/resource_dispatcher.h for details on an
 // alternate implementation that defers fetching to another process.
 
 #include "webkit/tools/test_shell/simple_resource_loader_bridge.h"
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
@@ skipping 50 matching lines @@
         cache_mode(in_cache_mode),
         no_proxy(in_no_proxy),
         accept_all_cookies(false) {}
 
   FilePath cache_path;
   net::HttpCache::Mode cache_mode;
   bool no_proxy;
   bool accept_all_cookies;
 };
 
-static URLRequestJob* BlobURLRequestJobFactory(URLRequest* request,
+static URLRequestJob* BlobURLRequestJobFactory(net::URLRequest* request,
                                                const std::string& scheme) {
   webkit_blob::BlobStorageController* blob_storage_controller =
       static_cast<TestShellRequestContext*>(request->context())->
           blob_storage_controller();
   return new webkit_blob::BlobURLRequestJob(
       request,
       blob_storage_controller->GetBlobDataFromUrl(request->url()),
       NULL);
 }
 
@@ skipping 29 matching lines @@
     }
 
     g_request_context->AddRef();
 
     SimpleAppCacheSystem::InitializeOnIOThread(g_request_context);
     SimpleSocketStreamBridge::InitializeOnIOThread(g_request_context);
     SimpleFileWriter::InitializeOnIOThread(g_request_context);
     TestShellWebBlobRegistryImpl::InitializeOnIOThread(
         g_request_context->blob_storage_controller());
 
-    URLRequest::RegisterProtocolFactory("blob", &BlobURLRequestJobFactory);
+    net::URLRequest::RegisterProtocolFactory("blob", &BlobURLRequestJobFactory);
   }
 
   virtual void CleanUp() {
     // In reverse order of initialization.
     TestShellWebBlobRegistryImpl::Cleanup();
     SimpleFileWriter::CleanupOnIOThread();
     SimpleSocketStreamBridge::Cleanup();
     SimpleAppCacheSystem::CleanupOnIOThread();
 
     if (g_request_context) {
@@ skipping 25 matching lines @@
   ResourceType::Type request_type;
   int appcache_host_id;
   bool download_to_file;
   scoped_refptr<net::UploadData> upload;
 };
 
 // The interval for calls to RequestProxy::MaybeUpdateUploadProgress
 static const int kUpdateUploadProgressIntervalMsec = 100;
 
 // The RequestProxy does most of its work on the IO thread.  The Start and
-// Cancel methods are proxied over to the IO thread, where an URLRequest object
-// is instantiated.
-class RequestProxy : public URLRequest::Delegate,
+// Cancel methods are proxied over to the IO thread, where an net::URLRequest
+// object is instantiated.
+class RequestProxy : public net::URLRequest::Delegate,
                      public base::RefCountedThreadSafe<RequestProxy> {
  public:
   // Takes ownership of the params.
   RequestProxy()
       : download_to_file_(false),
         buf_(new net::IOBuffer(kDataSize)),
         last_upload_position_(0) {
   }
 
   void DropPeer() {
@@ skipping 19 matching lines @@
   friend class base::RefCountedThreadSafe<RequestProxy>;
 
   virtual ~RequestProxy() {
     // If we have a request, then we'd better be on the io thread!
     DCHECK(!request_.get() ||
            MessageLoop::current() == g_io_thread->message_loop());
   }
 
   // --------------------------------------------------------------------------
   // The following methods are called on the owner's thread in response to
-  // various URLRequest callbacks.  The event hooks, defined below, trigger
+  // various net::URLRequest callbacks.  The event hooks, defined below, trigger
   // these methods asynchronously.
 
   void NotifyReceivedRedirect(const GURL& new_url,
                               const ResourceResponseInfo& info) {
     bool has_new_first_party_for_cookies = false;
     GURL new_first_party_for_cookies;
     if (peer_ && peer_->OnReceivedRedirect(new_url, info,
                                            &has_new_first_party_for_cookies,
                                            &new_first_party_for_cookies)) {
       g_io_thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
@@ skipping 61 matching lines @@
   // actions performed on the owner's thread.
 
   void AsyncStart(RequestParams* params) {
     // Might need to resolve the blob references in the upload data.
     if (params->upload) {
       static_cast<TestShellRequestContext*>(g_request_context)->
           blob_storage_controller()->ResolveBlobReferencesInUploadData(
               params->upload.get());
     }
 
-    request_.reset(new URLRequest(params->url, this));
+    request_.reset(new net::URLRequest(params->url, this));
     request_->set_method(params->method);
     request_->set_first_party_for_cookies(params->first_party_for_cookies);
     request_->set_referrer(params->referrer.spec());
     net::HttpRequestHeaders headers;
     headers.AddHeadersFromString(params->headers);
     request_->SetExtraRequestHeaders(headers);
     request_->set_load_flags(params->load_flags);
     request_->set_upload(params->upload.get());
     request_->set_context(g_request_context);
     SimpleAppCacheSystem::SetExtraRequestInfo(
@@ skipping 53 matching lines @@
         OnReceivedData(bytes_read);
       } else if (!request_->status().is_io_pending()) {
         Done();
       }  // else wait for OnReadCompleted
     } else {
       Done();
     }
   }
 
   // --------------------------------------------------------------------------
-  // The following methods are event hooks (corresponding to URLRequest
+  // The following methods are event hooks (corresponding to net::URLRequest
   // callbacks) that run on the IO thread.  They are designed to be overridden
   // by the SyncRequestProxy subclass.
 
   virtual void OnReceivedRedirect(
       const GURL& new_url,
       const ResourceResponseInfo& info,
       bool* defer_redirect) {
     *defer_redirect = true;  // See AsyncFollowDeferredRedirect
     owner_loop_->PostTask(FROM_HERE, NewRunnableMethod(
         this, &RequestProxy::NotifyReceivedRedirect, new_url, info));
@@ skipping 25 matching lines @@
       file_stream_.Close();
     owner_loop_->PostTask(FROM_HERE, NewRunnableMethod(
         this,
         &RequestProxy::NotifyCompletedRequest,
         status,
         security_info,
         complete_time));
   }
 
   // --------------------------------------------------------------------------
-  // URLRequest::Delegate implementation:
+  // net::URLRequest::Delegate implementation:
 
-  virtual void OnReceivedRedirect(URLRequest* request,
+  virtual void OnReceivedRedirect(net::URLRequest* request,
                                   const GURL& new_url,
                                   bool* defer_redirect) {
     DCHECK(request->status().is_success());
     ResourceResponseInfo info;
     PopulateResponseInfo(request, &info);
     OnReceivedRedirect(new_url, info, defer_redirect);
   }
 
-  virtual void OnResponseStarted(URLRequest* request) {
+  virtual void OnResponseStarted(net::URLRequest* request) {
     if (request->status().is_success()) {
       ResourceResponseInfo info;
       PopulateResponseInfo(request, &info);
       OnReceivedResponse(info, false);
       AsyncReadData();  // start reading
     } else {
       Done();
     }
   }
 
-  virtual void OnSSLCertificateError(URLRequest* request,
+  virtual void OnSSLCertificateError(net::URLRequest* request,
                                      int cert_error,
                                      net::X509Certificate* cert) {
     // Allow all certificate errors.
     request->ContinueDespiteLastError();
   }
 
-  virtual void OnReadCompleted(URLRequest* request, int bytes_read) {
+  virtual void OnReadCompleted(net::URLRequest* request, int bytes_read) {
     if (request->status().is_success() && bytes_read > 0) {
       OnReceivedData(bytes_read);
     } else {
       Done();
     }
   }
 
   // --------------------------------------------------------------------------
   // Helpers and data:
 
   void Done() {
     if (upload_progress_timer_.IsRunning()) {
       MaybeUpdateUploadProgress();
       upload_progress_timer_.Stop();
     }
     DCHECK(request_.get());
     OnCompletedRequest(request_->status(), std::string(), base::Time());
     request_.reset();  // destroy on the io thread
   }
 
   // Called on the IO thread.
   void MaybeUpdateUploadProgress() {
-    // If a redirect is received upload is cancelled in URLRequest, we should
-    // try to stop the |upload_progress_timer_| timer and return.
+    // If a redirect is received upload is cancelled in net::URLRequest, we
+    // should try to stop the |upload_progress_timer_| timer and return.
     if (!request_->has_upload()) {
       if (upload_progress_timer_.IsRunning())
         upload_progress_timer_.Stop();
       return;
     }
 
     uint64 size = request_->get_upload()->GetContentLength();
     uint64 position = request_->GetUploadProgress();
     if (position == last_upload_position_)
       return;  // no progress made since last time
@@ skipping 11 matching lines @@
     bool too_much_time_passed = time_since_last > kOneSecond;
 
     if (is_finished || enough_new_progress || too_much_time_passed) {
       owner_loop_->PostTask(FROM_HERE, NewRunnableMethod(
           this, &RequestProxy::NotifyUploadProgress, position, size));
       last_upload_ticks_ = base::TimeTicks::Now();
       last_upload_position_ = position;
     }
   }
 
-  void PopulateResponseInfo(URLRequest* request,
+  void PopulateResponseInfo(net::URLRequest* request,
                             ResourceResponseInfo* info) const {
     info->request_time = request->request_time();
     info->response_time = request->response_time();
     info->headers = request->response_headers();
     request->GetMimeType(&info->mime_type);
     request->GetCharset(&info->charset);
     info->content_length = request->GetExpectedContentSize();
     if (downloaded_file_)
       info->download_file_path = downloaded_file_->path();
     SimpleAppCacheSystem::GetExtraResponseInfo(
         request,
         &info->appcache_id,
         &info->appcache_manifest_url);
   }
 
-  scoped_ptr<URLRequest> request_;
+  scoped_ptr<net::URLRequest> request_;
 
   // Support for request.download_to_file behavior.
   bool download_to_file_;
   net::FileStream file_stream_;
   scoped_refptr<DeletableFileReference> downloaded_file_;
 
   // Size of our async IO data buffers
   static const int kDataSize = 16*1024;
 
   // read buffer for async IO
@@ skipping 376 matching lines @@
 
 // static
 scoped_refptr<base::MessageLoopProxy>
     SimpleResourceLoaderBridge::GetIoThread() {
   if (!EnsureIOThread()) {
     LOG(DFATAL) << "Failed to create IO thread.";
     return NULL;
   }
   return g_io_thread->message_loop_proxy();
 }