net: Remove typedef net::URLRequest URLRequest;

chrome/browser/dom_ui/chrome_url_data_manager.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.
 
 #include "chrome/browser/dom_ui/chrome_url_data_manager.h"
 
 #include "app/l10n_util.h"
 #include "base/file_util.h"
 #include "base/i18n/rtl.h"
 #include "base/message_loop.h"
@@ skipping 23 matching lines @@
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_file_job.h"
 #include "net/url_request/url_request_job.h"
 
 // URLRequestChromeJob is a URLRequestJob that manages running chrome-internal
 // resource requests asynchronously.
 // It hands off URL requests to ChromeURLDataManager, which asynchronously
 // calls back once the data is available.
 class URLRequestChromeJob : public net::URLRequestJob {
  public:
-  explicit URLRequestChromeJob(URLRequest* request);
+  explicit URLRequestChromeJob(net::URLRequest* request);
 
   // URLRequestJob implementation.
   virtual void Start();
   virtual void Kill();
   virtual bool ReadRawData(net::IOBuffer* buf, int buf_size, int *bytes_read);
   virtual bool GetMimeType(std::string* mime_type) const;
 
   // Called by ChromeURLDataManager to notify us that the data blob is ready
   // for us.
   void DataAvailable(RefCountedMemory* bytes);
@@ skipping 24 matching lines @@
   scoped_refptr<net::IOBuffer> pending_buf_;
   int pending_buf_size_;
   std::string mime_type_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestChromeJob);
 };
 
 // URLRequestChromeFileJob is a URLRequestJob that acts like a file:// URL
 class URLRequestChromeFileJob : public URLRequestFileJob {
  public:
-  URLRequestChromeFileJob(URLRequest* request, const FilePath& path);
+  URLRequestChromeFileJob(net::URLRequest* request, const FilePath& path);
 
  private:
   virtual ~URLRequestChromeFileJob();
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestChromeFileJob);
 };
 
 void RegisterURLRequestChromeJob() {
   FilePath inspector_dir;
   if (PathService::Get(chrome::DIR_INSPECTOR, &inspector_dir)) {
     Singleton<ChromeURLDataManager>()->AddFileSource(
         chrome::kChromeUIDevToolsHost, inspector_dir);
   }
 
   SharedResourcesDataSource::Register();
-  URLRequest::RegisterProtocolFactory(chrome::kChromeDevToolsScheme,
-                                      &ChromeURLDataManager::Factory);
-  URLRequest::RegisterProtocolFactory(chrome::kChromeUIScheme,
-                                      &ChromeURLDataManager::Factory);
+  net::URLRequest::RegisterProtocolFactory(chrome::kChromeDevToolsScheme,
+                                           &ChromeURLDataManager::Factory);
+  net::URLRequest::RegisterProtocolFactory(chrome::kChromeUIScheme,
+                                           &ChromeURLDataManager::Factory);
 }
 
 void UnregisterURLRequestChromeJob() {
   FilePath inspector_dir;
   if (PathService::Get(chrome::DIR_INSPECTOR, &inspector_dir)) {
     Singleton<ChromeURLDataManager>()->RemoveFileSource(
         chrome::kChromeUIDevToolsHost);
   }
 }
 
@@ skipping 138 matching lines @@
     if (i->second == job) {
       pending_requests_.erase(i);
       return;
     }
   }
 }
 
 void ChromeURLDataManager::DataAvailable(
     RequestID request_id,
     scoped_refptr<RefCountedMemory> bytes) {
-  // Forward this data on to the pending URLRequest, if it exists.
+  // Forward this data on to the pending net::URLRequest, if it exists.
   PendingRequestMap::iterator i = pending_requests_.find(request_id);
   if (i != pending_requests_.end()) {
     // We acquire a reference to the job so that it doesn't disappear under the
     // feet of any method invoked here (we could trigger a callback).
     scoped_refptr<URLRequestChromeJob> job(i->second);
     pending_requests_.erase(i);
     job->DataAvailable(bytes);
   }
 }
 
@@ skipping 33 matching lines @@
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     web_font_size_id = IDS_WEB_FONT_SIZE_XP;
 #endif
   localized_strings->SetString("fontsize",
       l10n_util::GetStringUTF16(web_font_size_id));
 
   localized_strings->SetString("textdirection",
       base::i18n::IsRTL() ? "rtl" : "ltr");
 }
 
-URLRequestJob* ChromeURLDataManager::Factory(URLRequest* request,
+URLRequestJob* ChromeURLDataManager::Factory(net::URLRequest* request,
                                              const std::string& scheme) {
   // Try first with a file handler
   FilePath path;
   if (ChromeURLDataManager::URLToFilePath(request->url(), &path))
     return new URLRequestChromeFileJob(request, path);
 
   // Next check for chrome://view-http-cache/*, which uses its own job type.
   if (ViewHttpCacheJobFactory::IsSupportedURL(request->url()))
     return ViewHttpCacheJobFactory::CreateJobForRequest(request);
 
   // Next check for chrome://appcache-internals/, which uses its own job type.
   if (ViewAppCacheInternalsJobFactory::IsSupportedURL(request->url()))
     return ViewAppCacheInternalsJobFactory::CreateJobForRequest(request);
 
   // Next check for chrome://blob-internals/, which uses its own job type.
   if (ViewBlobInternalsJobFactory::IsSupportedURL(request->url()))
     return ViewBlobInternalsJobFactory::CreateJobForRequest(request);
 
   // Fall back to using a custom handler
   return new URLRequestChromeJob(request);
 }
 
-URLRequestChromeJob::URLRequestChromeJob(URLRequest* request)
+URLRequestChromeJob::URLRequestChromeJob(net::URLRequest* request)
     : URLRequestJob(request),
       data_offset_(0),
       pending_buf_size_(0) {
 }
 
 URLRequestChromeJob::~URLRequestChromeJob() {
   CHECK(!Singleton<ChromeURLDataManager>()->HasPendingJob(this));
 }
 
 void URLRequestChromeJob::Start() {
@@ skipping 65 matching lines @@
     return;
 
   if (Singleton<ChromeURLDataManager>()->StartRequest(request_->url(), this)) {
     NotifyHeadersComplete();
   } else {
     NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED,
                                       net::ERR_INVALID_URL));
   }
 }
 
-URLRequestChromeFileJob::URLRequestChromeFileJob(URLRequest* request,
+URLRequestChromeFileJob::URLRequestChromeFileJob(net::URLRequest* request,
                                                  const FilePath& path)
     : URLRequestFileJob(request, path) {
 }
 
 URLRequestChromeFileJob::~URLRequestChromeFileJob() { }