net: Remove typedef net::URLRequestJob URLRequestJob;

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 16 matching lines @@
 #include "chrome/common/ref_counted_util.h"
 #include "chrome/common/url_constants.h"
 #include "googleurl/src/url_util.h"
 #include "grit/platform_locale_settings.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #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.
+// URLRequestChromeJob is a net::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(net::URLRequest* request);
 
-  // URLRequestJob implementation.
+  // net::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);
 
   void SetMimeType(const std::string& mime_type) {
     mime_type_ = mime_type;
   }
 
  private:
   virtual ~URLRequestChromeJob();
 
   // Helper for Start(), to let us start asynchronously.
-  // (This pattern is shared by most URLRequestJob implementations.)
+  // (This pattern is shared by most net::URLRequestJob implementations.)
   void StartAsync();
 
   // Do the actual copy from data_ (the data we're serving) into |buf|.
   // Separate from ReadRawData so we can handle async I/O.
   void CompleteRead(net::IOBuffer* buf, int buf_size, int* bytes_read);
 
   // The actual data we're serving.  NULL until it's been fetched.
   scoped_refptr<RefCountedMemory> data_;
   // The current offset into the data that we're handing off to our
   // callers via the Read interfaces.
   int data_offset_;
 
   // For async reads, we keep around a pointer to the buffer that
   // we're reading into.
   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
+// URLRequestChromeFileJob is a net::URLRequestJob that acts like a file:// URL
 class URLRequestChromeFileJob : public URLRequestFileJob {
  public:
   URLRequestChromeFileJob(net::URLRequest* request, const FilePath& path);
 
  private:
   virtual ~URLRequestChromeFileJob();
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestChromeFileJob);
 };
 
@@ skipping 219 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(net::URLRequest* request,
-                                             const std::string& scheme) {
+net::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(net::URLRequest* request)
-    : URLRequestJob(request),
+    : net::URLRequestJob(request),
       data_offset_(0),
       pending_buf_size_(0) {
 }
 
 URLRequestChromeJob::~URLRequestChromeJob() {
   CHECK(!ChromeURLDataManager::GetInstance()->HasPendingJob(this));
 }
 
 void URLRequestChromeJob::Start() {
   // Start reading asynchronously so that all error reporting and data
@@ skipping 71 matching lines @@
                                       net::ERR_INVALID_URL));
   }
 }
 
 URLRequestChromeFileJob::URLRequestChromeFileJob(net::URLRequest* request,
                                                  const FilePath& path)
     : URLRequestFileJob(request, path) {
 }
 
 URLRequestChromeFileJob::~URLRequestChromeFileJob() { }