Rename URLFetcher to be URLFetcherImpl, now that we have the content::URLFetcher interface.

content/common/net/url_fetcher_impl.cc

 // 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.
 
-#include "content/common/net/url_fetcher.h"
+#include "content/common/net/url_fetcher_impl.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util_proxy.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 11 matching lines @@
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_throttler_manager.h"
 
 static const int kBufferSize = 4096;
 
-class URLFetcher::Core
-    : public base::RefCountedThreadSafe<URLFetcher::Core>,
+class URLFetcherImpl::Core
+    : public base::RefCountedThreadSafe<URLFetcherImpl::Core>,
       public net::URLRequest::Delegate {
  public:
   // For POST requests, set |content_type| to the MIME type of the content
   // and set |content| to the data to upload.  |flags| are flags to apply to
   // the load operation--these should be one or more of the LOAD_* flags
   // defined in net/base/load_flags.h.
-  Core(URLFetcher* fetcher,
+  Core(URLFetcherImpl* fetcher,
        const GURL& original_url,
        RequestType request_type,
        content::URLFetcherDelegate* d);
 
   // Starts the load.  It's important that this not happen in the constructor
   // because it causes the IO thread to begin AddRef()ing and Release()ing
   // us.  If our caller hasn't had time to fully construct us and take a
   // reference, the IO thread could interrupt things, run a task, Release()
   // us, and destroy us, leaving the caller with an already-destroyed object
   // when construction finishes.
@@ skipping 12 matching lines @@
   void ReceivedContentWasMalformed();
 
   // Overridden from net::URLRequest::Delegate:
   virtual void OnResponseStarted(net::URLRequest* request);
   virtual void OnReadCompleted(net::URLRequest* request, int bytes_read);
 
   content::URLFetcherDelegate* delegate() const { return delegate_; }
   static void CancelAll();
 
  private:
-  friend class base::RefCountedThreadSafe<URLFetcher::Core>;
+  friend class base::RefCountedThreadSafe<URLFetcherImpl::Core>;
 
   class Registry {
    public:
     Registry();
     ~Registry();
 
     void AddURLFetcherCore(Core* core);
     void RemoveURLFetcherCore(Core* core);
 
     void CancelAll();
@@ skipping 10 matching lines @@
 
   // Class TempFileWriter encapsulates all state involved in writing
   // response bytes to a temporary file. It is only used if
   // |Core::response_destination_| == TEMP_FILE.  Each instance of
   // TempFileWriter is owned by a URLFetcher::Core, which manages
   // its lifetime and never transfers ownership.  While writing to
   // a file, all function calls happen on the IO thread.
   class TempFileWriter {
    public:
     TempFileWriter(
-        URLFetcher::Core* core,
+        URLFetcherImpl::Core* core,
         scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy);
 
     ~TempFileWriter();
     void CreateTempFile();
     void DidCreateTempFile(base::PlatformFileError error_code,
                            base::PassPlatformFile file_handle,
                            FilePath file_path);
 
     // Record |num_bytes_| response bytes in |core_->buffer_| to the file.
     void WriteBuffer(int num_bytes);
@@ skipping 14 matching lines @@
     void RemoveTempFile();
 
     const FilePath& temp_file() const { return temp_file_; }
     int64 total_bytes_written() { return total_bytes_written_; }
     base::PlatformFileError error_code() const { return error_code_; }
 
    private:
     // Callback which gets the result of closing the temp file.
     void DidCloseTempFile(base::PlatformFileError error);
 
-    // The URLFetcher::Core which instantiated this class.
-    URLFetcher::Core* core_;
+    // The URLFetcherImpl::Core which instantiated this class.
+    URLFetcherImpl::Core* core_;
 
     // The last error encountered on a file operation.  base::PLATFORM_FILE_OK
     // if no error occurred.
     base::PlatformFileError error_code_;
 
     // Callbacks are created for use with base::FileUtilProxy.
-    base::WeakPtrFactory<URLFetcher::Core::TempFileWriter> weak_factory_;
+    base::WeakPtrFactory<URLFetcherImpl::Core::TempFileWriter> weak_factory_;
 
     // Message loop on which file operations should happen.
     scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy_;
 
     // Path to the temporary file.  This path is empty when there
     // is no temp file.
     FilePath temp_file_;
 
     // Handle to the temp file.
     base::PlatformFile temp_file_handle_;
@@ skipping 46 matching lines @@
   // returns false, it will post a task that will read more bytes once the
   // write is complete.
   bool WriteBuffer(int num_bytes);
 
   // Read response bytes from the request.
   void ReadResponse();
 
   // Drop ownership of any temp file managed by |temp_file_|.
   void DisownTempFile();
 
-  URLFetcher* fetcher_;              // Corresponding fetcher object
+  URLFetcherImpl* fetcher_;          // Corresponding fetcher object
   GURL original_url_;                // The URL we were asked to fetch
   GURL url_;                         // The URL we eventually wound up at
   RequestType request_type_;         // What type of request is this?
   net::URLRequestStatus status_;     // Status of the request
   content::URLFetcherDelegate* delegate_;  // Object to notify on completion
   scoped_refptr<base::MessageLoopProxy> delegate_loop_proxy_;
                                      // Message loop proxy of the creating
                                      // thread.
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
                                      // The message loop proxy for the thread
@@ skipping 54 matching lines @@
   // re-execute the request, after the back-off delay has expired.
   // true by default.
   bool automatically_retry_on_5xx_;
   // Maximum retries allowed.
   int max_retries_;
   // Back-off time delay. 0 by default.
   base::TimeDelta backoff_delay_;
 
   static base::LazyInstance<Registry> g_registry;
 
-  friend class URLFetcher;
+  friend class URLFetcherImpl;
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
-URLFetcher::Core::Registry::Registry() {}
-URLFetcher::Core::Registry::~Registry() {}
+URLFetcherImpl::Core::Registry::Registry() {}
+URLFetcherImpl::Core::Registry::~Registry() {}
 
-void URLFetcher::Core::Registry::AddURLFetcherCore(Core* core) {
+void URLFetcherImpl::Core::Registry::AddURLFetcherCore(Core* core) {
   DCHECK(!ContainsKey(fetchers_, core));
   fetchers_.insert(core);
 }
 
-void URLFetcher::Core::Registry::RemoveURLFetcherCore(Core* core) {
+void URLFetcherImpl::Core::Registry::RemoveURLFetcherCore(Core* core) {
   DCHECK(ContainsKey(fetchers_, core));
   fetchers_.erase(core);
 }
 
-void URLFetcher::Core::Registry::CancelAll() {
+void URLFetcherImpl::Core::Registry::CancelAll() {
   while (!fetchers_.empty())
     (*fetchers_.begin())->CancelURLRequest();
 }
 
 // static
-base::LazyInstance<URLFetcher::Core::Registry>
-    URLFetcher::Core::g_registry(base::LINKER_INITIALIZED);
+base::LazyInstance<URLFetcherImpl::Core::Registry>
+    URLFetcherImpl::Core::g_registry(base::LINKER_INITIALIZED);
 
-URLFetcher::Core::TempFileWriter::TempFileWriter(
-    URLFetcher::Core* core,
+URLFetcherImpl::Core::TempFileWriter::TempFileWriter(
+    URLFetcherImpl::Core* core,
     scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy)
     : core_(core),
       error_code_(base::PLATFORM_FILE_OK),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       file_message_loop_proxy_(file_message_loop_proxy),
       temp_file_handle_(base::kInvalidPlatformFileValue) {
 }
 
-URLFetcher::Core::TempFileWriter::~TempFileWriter() {
+URLFetcherImpl::Core::TempFileWriter::~TempFileWriter() {
   RemoveTempFile();
 }
 
-void URLFetcher::Core::TempFileWriter::CreateTempFile() {
+void URLFetcherImpl::Core::TempFileWriter::CreateTempFile() {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
   CHECK(file_message_loop_proxy_.get());
   base::FileUtilProxy::CreateTemporary(
       file_message_loop_proxy_,
       0,  // No additional file flags.
-      base::Bind(&URLFetcher::Core::TempFileWriter::DidCreateTempFile,
+      base::Bind(&URLFetcherImpl::Core::TempFileWriter::DidCreateTempFile,
                  weak_factory_.GetWeakPtr()));
 }
 
-void URLFetcher::Core::TempFileWriter::DidCreateTempFile(
+void URLFetcherImpl::Core::TempFileWriter::DidCreateTempFile(
     base::PlatformFileError error_code,
     base::PassPlatformFile file_handle,
     FilePath file_path) {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (base::PLATFORM_FILE_OK != error_code) {
     error_code_ = error_code;
     RemoveTempFile();
     core_->delegate_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(&Core::InformDelegateFetchIsComplete, core_));
     return;
   }
 
   temp_file_ = file_path;
   temp_file_handle_ = file_handle.ReleaseValue();
   total_bytes_written_ = 0;
 
   core_->io_message_loop_proxy_->PostTask(
       FROM_HERE, base::Bind(&Core::StartURLRequestWhenAppropriate, core_));
 }
 
-void URLFetcher::Core::TempFileWriter::WriteBuffer(int num_bytes) {
+void URLFetcherImpl::Core::TempFileWriter::WriteBuffer(int num_bytes) {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
   // Start writing to the temp file by setting the initial state
   // of |pending_bytes_| and |buffer_offset_| to indicate that the
   // entire buffer has not yet been written.
   pending_bytes_ = num_bytes;
   buffer_offset_ = 0;
   ContinueWrite(base::PLATFORM_FILE_OK, 0);
 }
 
-void URLFetcher::Core::TempFileWriter::ContinueWrite(
+void URLFetcherImpl::Core::TempFileWriter::ContinueWrite(
     base::PlatformFileError error_code,
     int bytes_written) {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (base::PLATFORM_FILE_OK != error_code) {
     error_code_ = error_code;
     RemoveTempFile();
     core_->delegate_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(&Core::InformDelegateFetchIsComplete, core_));
     return;
   }
 
   total_bytes_written_ += bytes_written;
   buffer_offset_ += bytes_written;
   pending_bytes_ -= bytes_written;
 
   if (pending_bytes_ > 0) {
     base::FileUtilProxy::Write(
         file_message_loop_proxy_, temp_file_handle_,
         total_bytes_written_,  // Append to the end
         (core_->buffer_->data() + buffer_offset_), pending_bytes_,
-        base::Bind(&URLFetcher::Core::TempFileWriter::ContinueWrite,
+        base::Bind(&URLFetcherImpl::Core::TempFileWriter::ContinueWrite,
                    weak_factory_.GetWeakPtr()));
   } else {
     // Finished writing core_->buffer_ to the file. Read some more.
     core_->ReadResponse();
   }
 }
 
-void URLFetcher::Core::TempFileWriter::DisownTempFile() {
+void URLFetcherImpl::Core::TempFileWriter::DisownTempFile() {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
   // Disowning is done by the delegate's OnURLFetchComplete method.
   // The temp file should be closed by the time that method is called.
   DCHECK(temp_file_handle_ == base::kInvalidPlatformFileValue);
 
   // Forget about any temp file by reseting the path.
   temp_file_ = FilePath();
 }
 
-void URLFetcher::Core::TempFileWriter::CloseTempFileAndCompleteRequest() {
+void URLFetcherImpl::Core::TempFileWriter::CloseTempFileAndCompleteRequest() {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (temp_file_handle_ != base::kInvalidPlatformFileValue) {
     base::FileUtilProxy::Close(
         file_message_loop_proxy_, temp_file_handle_,
-        base::Bind(&URLFetcher::Core::TempFileWriter::DidCloseTempFile,
+        base::Bind(&URLFetcherImpl::Core::TempFileWriter::DidCloseTempFile,
                    weak_factory_.GetWeakPtr()));
     temp_file_handle_ = base::kInvalidPlatformFileValue;
   }
 }
 
-void URLFetcher::Core::TempFileWriter::DidCloseTempFile(
+void URLFetcherImpl::Core::TempFileWriter::DidCloseTempFile(
   base::PlatformFileError error_code) {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (base::PLATFORM_FILE_OK != error_code) {
     error_code_ = error_code;
     RemoveTempFile();
     core_->delegate_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(&Core::InformDelegateFetchIsComplete, core_));
     return;
   }
 
   // If the file was successfully closed, then the URL request is complete.
   core_->RetryOrCompleteUrlFetch();
 }
 
-void URLFetcher::Core::TempFileWriter::RemoveTempFile() {
+void URLFetcherImpl::Core::TempFileWriter::RemoveTempFile() {
   DCHECK(core_->io_message_loop_proxy_->BelongsToCurrentThread());
 
   // Close the temp file if it is open.
   if (temp_file_handle_ != base::kInvalidPlatformFileValue) {
     base::FileUtilProxy::Close(
         file_message_loop_proxy_, temp_file_handle_,
         base::FileUtilProxy::StatusCallback());  // No callback: Ignore errors.
     temp_file_handle_ = base::kInvalidPlatformFileValue;
   }
 
   if (!temp_file_.empty()) {
     base::FileUtilProxy::Delete(
         file_message_loop_proxy_, temp_file_,
         false,  // No need to recurse, as the path is to a file.
         base::FileUtilProxy::StatusCallback());  // No callback: Ignore errors.
     DisownTempFile();
   }
 }
 
 static content::URLFetcherFactory* g_factory = NULL;
 static bool g_interception_enabled = false;
 
 // static
 content::URLFetcher* content::URLFetcher::Create(
     const GURL& url,
     RequestType request_type,
     content::URLFetcherDelegate* d) {
-  return new ::URLFetcher(url, request_type, d);
+  return new URLFetcherImpl(url, request_type, d);
 }
 
 // static
 content::URLFetcher* content::URLFetcher::Create(
     int id,
     const GURL& url,
     RequestType request_type,
     content::URLFetcherDelegate* d) {
   return g_factory ? g_factory->CreateURLFetcher(id, url, request_type, d) :
-                     new ::URLFetcher(url, request_type, d);
+                     new URLFetcherImpl(url, request_type, d);
 }
 
 // static
 void content::URLFetcher::CancelAll() {
-  ::URLFetcher::CancelAll();
+  URLFetcherImpl::CancelAll();
 }
 
 // static
 void content::URLFetcher::SetEnableInterceptionForTests(bool enabled) {
   g_interception_enabled = enabled;
 }
 
 
-URLFetcher::URLFetcher(const GURL& url,
-                       RequestType request_type,
-                       content::URLFetcherDelegate* d)
+URLFetcherImpl::URLFetcherImpl(const GURL& url,
+                               RequestType request_type,
+                               content::URLFetcherDelegate* d)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
       core_(new Core(this, url, request_type, d))) {
 }
 
-URLFetcher::~URLFetcher() {
+URLFetcherImpl::~URLFetcherImpl() {
   core_->Stop();
 }
 
-URLFetcher::Core::Core(URLFetcher* fetcher,
-                       const GURL& original_url,
-                       RequestType request_type,
-                       content::URLFetcherDelegate* d)
+URLFetcherImpl::Core::Core(URLFetcherImpl* fetcher,
+                           const GURL& original_url,
+                           RequestType request_type,
+                           content::URLFetcherDelegate* d)
     : fetcher_(fetcher),
       original_url_(original_url),
       request_type_(request_type),
       delegate_(d),
       delegate_loop_proxy_(
           base::MessageLoopProxy::current()),
       request_(NULL),
       load_flags_(net::LOAD_NORMAL),
       response_code_(RESPONSE_CODE_INVALID),
       buffer_(new net::IOBuffer(kBufferSize)),
       was_fetched_via_proxy_(false),
       is_chunked_upload_(false),
       num_retries_(0),
       was_cancelled_(false),
       response_destination_(STRING),
       automatically_retry_on_5xx_(true),
       max_retries_(0) {
 }
 
-URLFetcher::Core::~Core() {
+URLFetcherImpl::Core::~Core() {
   // |request_| should be NULL.  If not, it's unsafe to delete it here since we
   // may not be on the IO thread.
   DCHECK(!request_.get());
 }
 
-void URLFetcher::Core::Start() {
+void URLFetcherImpl::Core::Start() {
   DCHECK(delegate_loop_proxy_);
   CHECK(request_context_getter_) << "We need an URLRequestContext!";
   if (io_message_loop_proxy_) {
     DCHECK_EQ(io_message_loop_proxy_,
               request_context_getter_->GetIOMessageLoopProxy());
   } else {
     io_message_loop_proxy_ = request_context_getter_->GetIOMessageLoopProxy();
   }
   CHECK(io_message_loop_proxy_.get()) << "We need an IO message loop proxy";
 
   io_message_loop_proxy_->PostTask(
       FROM_HERE, base::Bind(&Core::StartOnIOThread, this));
 }
 
-void URLFetcher::Core::StartOnIOThread() {
+void URLFetcherImpl::Core::StartOnIOThread() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   switch (response_destination_) {
     case STRING:
       StartURLRequestWhenAppropriate();
       break;
 
     case TEMP_FILE:
       DCHECK(file_message_loop_proxy_.get())
         << "Need to set the file message loop proxy.";
 
       temp_file_writer_.reset(
           new TempFileWriter(this, file_message_loop_proxy_));
 
       // If the temp file is successfully created,
       // Core::StartURLRequestWhenAppropriate() will be called.
       temp_file_writer_->CreateTempFile();
       break;
 
     default:
       NOTREACHED();
   }
 }
 
-void URLFetcher::Core::Stop() {
+void URLFetcherImpl::Core::Stop() {
   if (delegate_loop_proxy_) {  // May be NULL in tests.
     DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
   }
   delegate_ = NULL;
   fetcher_ = NULL;
   if (io_message_loop_proxy_.get()) {
     io_message_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(&Core::CancelURLRequest, this));
   }
 }
 
-void URLFetcher::Core::ReceivedContentWasMalformed() {
+void URLFetcherImpl::Core::ReceivedContentWasMalformed() {
   DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
   if (io_message_loop_proxy_.get()) {
     io_message_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(&Core::NotifyMalformedContent, this));
   }
 }
 
-void URLFetcher::Core::CancelAll() {
+void URLFetcherImpl::Core::CancelAll() {
   g_registry.Get().CancelAll();
 }
 
-void URLFetcher::Core::OnResponseStarted(net::URLRequest* request) {
+void URLFetcherImpl::Core::OnResponseStarted(net::URLRequest* request) {
   DCHECK_EQ(request, request_.get());
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   if (request_->status().is_success()) {
     response_code_ = request_->GetResponseCode();
     response_headers_ = request_->response_headers();
     socket_address_ = request_->GetSocketAddress();
     was_fetched_via_proxy_ = request_->was_fetched_via_proxy();
   }
 
   ReadResponse();
 }
 
-void URLFetcher::Core::CompleteAddingUploadDataChunk(
+void URLFetcherImpl::Core::CompleteAddingUploadDataChunk(
     const std::string& content, bool is_last_chunk) {
   DCHECK(is_chunked_upload_);
   DCHECK(request_.get());
   DCHECK(!content.empty());
   request_->AppendChunkToUpload(content.data(),
                                 static_cast<int>(content.length()),
                                 is_last_chunk);
 }
 
-void URLFetcher::Core::AppendChunkToUpload(const std::string& content,
+void URLFetcherImpl::Core::AppendChunkToUpload(const std::string& content,
                                            bool is_last_chunk) {
   DCHECK(delegate_loop_proxy_);
   CHECK(io_message_loop_proxy_.get());
   io_message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&Core::CompleteAddingUploadDataChunk, this, content,
                  is_last_chunk));
 }
 
 // Return true if the write was done and reading may continue.
 // Return false if the write is pending, and the next read will
 // be done later.
-bool URLFetcher::Core::WriteBuffer(int num_bytes) {
+bool URLFetcherImpl::Core::WriteBuffer(int num_bytes) {
   bool write_complete = false;
   switch (response_destination_) {
     case STRING:
       data_.append(buffer_->data(), num_bytes);
       write_complete = true;
       break;
 
     case TEMP_FILE:
       temp_file_writer_->WriteBuffer(num_bytes);
       // WriteBuffer() sends a request the file thread.
       // The write is not done yet.
       write_complete = false;
       break;
 
     default:
       NOTREACHED();
   }
   return write_complete;
 }
 
-void URLFetcher::Core::OnReadCompleted(net::URLRequest* request,
+void URLFetcherImpl::Core::OnReadCompleted(net::URLRequest* request,
                                        int bytes_read) {
   DCHECK(request == request_);
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   url_ = request->url();
   url_throttler_entry_ =
       net::URLRequestThrottlerManager::GetInstance()->RegisterRequestUrl(url_);
 
   bool waiting_on_write = false;
   do {
@@ skipping 24 matching lines @@
       // If the file is open, close it.  After closing the file,
       // RetryOrCompleteUrlFetch() will be called.
       temp_file_writer_->CloseTempFileAndCompleteRequest();
     } else {
       // Otherwise, complete or retry the URL request directly.
       RetryOrCompleteUrlFetch();
     }
   }
 }
 
-void URLFetcher::Core::RetryOrCompleteUrlFetch() {
+void URLFetcherImpl::Core::RetryOrCompleteUrlFetch() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   base::TimeDelta backoff_delay;
 
   // Checks the response from server.
   if (response_code_ >= 500 ||
       status_.error() == net::ERR_TEMPORARILY_THROTTLED) {
     // When encountering a server error, we will send the request again
     // after backoff time.
     ++num_retries_;
 
@@ skipping 15 matching lines @@
   }
   request_context_getter_ = NULL;
   bool posted = delegate_loop_proxy_->PostTask(
       FROM_HERE, base::Bind(&Core::OnCompletedURLRequest, this, backoff_delay));
 
   // If the delegate message loop does not exist any more, then the delegate
   // should be gone too.
   DCHECK(posted || !delegate_);
 }
 
-void URLFetcher::Core::ReadResponse() {
+void URLFetcherImpl::Core::ReadResponse() {
   // Some servers may treat HEAD requests as GET requests.  To free up the
   // network connection as soon as possible, signal that the request has
   // completed immediately, without trying to read any data back (all we care
   // about is the response code and headers, which we already have).
   int bytes_read = 0;
   if (request_->status().is_success() && (request_type_ != HEAD))
     request_->Read(buffer_, kBufferSize, &bytes_read);
   OnReadCompleted(request_.get(), bytes_read);
 }
 
-void URLFetcher::Core::DisownTempFile() {
+void URLFetcherImpl::Core::DisownTempFile() {
   temp_file_writer_->DisownTempFile();
 }
 
-void URLFetcher::Core::StartURLRequest() {
+void URLFetcherImpl::Core::StartURLRequest() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (was_cancelled_) {
     // Since StartURLRequest() is posted as a *delayed* task, it may
     // run after the URLFetcher was already stopped.
     return;
   }
 
   CHECK(request_context_getter_);
   DCHECK(!request_.get());
@@ skipping 42 matching lines @@
   data_.clear();
 
   // If we are writing the response to a file, the only caller
   // of this function should have created it and not written yet.
   CHECK(!temp_file_writer_.get() ||
         temp_file_writer_->total_bytes_written() == 0);
 
   request_->Start();
 }
 
-void URLFetcher::Core::StartURLRequestWhenAppropriate() {
+void URLFetcherImpl::Core::StartURLRequestWhenAppropriate() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (was_cancelled_)
     return;
 
   if (original_url_throttler_entry_ == NULL) {
     original_url_throttler_entry_ =
         net::URLRequestThrottlerManager::GetInstance()->RegisterRequestUrl(
             original_url_);
   }
 
   int64 delay = original_url_throttler_entry_->ReserveSendingTimeForNextRequest(
       GetBackoffReleaseTime());
   if (delay == 0) {
     StartURLRequest();
   } else {
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE, base::Bind(&Core::StartURLRequest, this), delay);
   }
 }
 
-void URLFetcher::Core::CancelURLRequest() {
+void URLFetcherImpl::Core::CancelURLRequest() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (request_.get()) {
     request_->Cancel();
     ReleaseRequest();
   }
   // Release the reference to the request context. There could be multiple
   // references to URLFetcher::Core at this point so it may take a while to
   // delete the object, but we cannot delay the destruction of the request
   // context.
   request_context_getter_ = NULL;
   was_cancelled_ = true;
   temp_file_writer_.reset();
 }
 
-void URLFetcher::Core::OnCompletedURLRequest(
+void URLFetcherImpl::Core::OnCompletedURLRequest(
     base::TimeDelta backoff_delay) {
   DCHECK(delegate_loop_proxy_->BelongsToCurrentThread());
 
   // Save the status and backoff_delay so that delegates can read it.
   if (delegate_) {
     backoff_delay_ = backoff_delay;
     InformDelegateFetchIsComplete();
   }
 }
 
-void URLFetcher::Core::InformDelegateFetchIsComplete() {
+void URLFetcherImpl::Core::InformDelegateFetchIsComplete() {
   CHECK(delegate_loop_proxy_->BelongsToCurrentThread());
   if (delegate_) {
     delegate_->OnURLFetchComplete(fetcher_);
   }
 }
 
-void URLFetcher::Core::NotifyMalformedContent() {
+void URLFetcherImpl::Core::NotifyMalformedContent() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   if (url_throttler_entry_ != NULL) {
     int status_code = response_code_;
     if (status_code == RESPONSE_CODE_INVALID) {
       // The status code will generally be known by the time clients
       // call the |ReceivedContentWasMalformed()| function (which ends up
       // calling the current function) but if it's not, we need to assume
       // the response was successful so that the total failure count
       // used to calculate exponential back-off goes up.
       status_code = 200;
     }
     url_throttler_entry_->ReceivedContentWasMalformed(status_code);
   }
 }
 
-void URLFetcher::Core::ReleaseRequest() {
+void URLFetcherImpl::Core::ReleaseRequest() {
   request_.reset();
   g_registry.Get().RemoveURLFetcherCore(this);
 }
 
-base::TimeTicks URLFetcher::Core::GetBackoffReleaseTime() {
+base::TimeTicks URLFetcherImpl::Core::GetBackoffReleaseTime() {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(original_url_throttler_entry_ != NULL);
 
   base::TimeTicks original_url_backoff =
       original_url_throttler_entry_->GetExponentialBackoffReleaseTime();
   base::TimeTicks destination_url_backoff;
   if (url_throttler_entry_ != NULL &&
       original_url_throttler_entry_ != url_throttler_entry_) {
     destination_url_backoff =
         url_throttler_entry_->GetExponentialBackoffReleaseTime();
   }
 
   return original_url_backoff > destination_url_backoff ?
       original_url_backoff : destination_url_backoff;
 }
 
-void URLFetcher::SetUploadData(const std::string& upload_content_type,
-                               const std::string& upload_content) {
+void URLFetcherImpl::SetUploadData(const std::string& upload_content_type,
+                                   const std::string& upload_content) {
   DCHECK(!core_->is_chunked_upload_);
   core_->upload_content_type_ = upload_content_type;
   core_->upload_content_ = upload_content;
 }
 
-void URLFetcher::SetChunkedUpload(const std::string& content_type) {
+void URLFetcherImpl::SetChunkedUpload(const std::string& content_type) {
   DCHECK(core_->is_chunked_upload_ ||
          (core_->upload_content_type_.empty() &&
           core_->upload_content_.empty()));
   core_->upload_content_type_ = content_type;
   core_->upload_content_.clear();
   core_->is_chunked_upload_ = true;
 }
 
-void URLFetcher::AppendChunkToUpload(const std::string& data,
-                                     bool is_last_chunk) {
+void URLFetcherImpl::AppendChunkToUpload(const std::string& data,
+                                         bool is_last_chunk) {
   DCHECK(data.length());
   core_->AppendChunkToUpload(data, is_last_chunk);
 }
 
-const std::string& URLFetcher::upload_data() const {
+const std::string& URLFetcherImpl::upload_data() const {
   return core_->upload_content_;
 }
 
-void URLFetcher::SetReferrer(const std::string& referrer) {
+void URLFetcherImpl::SetReferrer(const std::string& referrer) {
   core_->referrer_ = referrer;
 }
 
-void URLFetcher::SetLoadFlags(int load_flags) {
+void URLFetcherImpl::SetLoadFlags(int load_flags) {
   core_->load_flags_ = load_flags;
 }
 
-int URLFetcher::GetLoadFlags() const {
+int URLFetcherImpl::GetLoadFlags() const {
   return core_->load_flags_;
 }
 
-void URLFetcher::SetExtraRequestHeaders(
+void URLFetcherImpl::SetExtraRequestHeaders(
     const std::string& extra_request_headers) {
   core_->extra_request_headers_.Clear();
   core_->extra_request_headers_.AddHeadersFromString(extra_request_headers);
 }
 
-void URLFetcher::GetExtraRequestHeaders(net::HttpRequestHeaders* headers) {
+void URLFetcherImpl::GetExtraRequestHeaders(net::HttpRequestHeaders* headers) {
   headers->CopyFrom(core_->extra_request_headers_);
 }
 
-void URLFetcher::SetRequestContext(
+void URLFetcherImpl::SetRequestContext(
     net::URLRequestContextGetter* request_context_getter) {
   DCHECK(!core_->request_context_getter_);
   core_->request_context_getter_ = request_context_getter;
 }
 
-void URLFetcher::SetAutomaticallyRetryOn5xx(bool retry) {
+void URLFetcherImpl::SetAutomaticallyRetryOn5xx(bool retry) {
   core_->automatically_retry_on_5xx_ = retry;
 }
 
-void URLFetcher::SetMaxRetries(int max_retries) {
+void URLFetcherImpl::SetMaxRetries(int max_retries) {
   core_->max_retries_ = max_retries;
 }
 
-int URLFetcher::GetMaxRetries() const {
+int URLFetcherImpl::GetMaxRetries() const {
   return core_->max_retries_;
 }
 
 
-base::TimeDelta URLFetcher::GetBackoffDelay() const {
+base::TimeDelta URLFetcherImpl::GetBackoffDelay() const {
   return core_->backoff_delay_;
 }
 
-void URLFetcher::SaveResponseToTemporaryFile(
+void URLFetcherImpl::SaveResponseToTemporaryFile(
     scoped_refptr<base::MessageLoopProxy> file_message_loop_proxy) {
   core_->file_message_loop_proxy_ = file_message_loop_proxy;
   core_->response_destination_ = TEMP_FILE;
 }
 
-net::HttpResponseHeaders* URLFetcher::GetResponseHeaders() const {
+net::HttpResponseHeaders* URLFetcherImpl::GetResponseHeaders() const {
   return core_->response_headers_;
 }
 
-void URLFetcher::set_response_headers(
+void URLFetcherImpl::set_response_headers(
     scoped_refptr<net::HttpResponseHeaders> headers) {
   core_->response_headers_ = headers;
 }
 
 // TODO(panayiotis): socket_address_ is written in the IO thread,
 // if this is accessed in the UI thread, this could result in a race.
 // Same for response_headers_ above and was_fetched_via_proxy_ below.
-net::HostPortPair URLFetcher::GetSocketAddress() const {
+net::HostPortPair URLFetcherImpl::GetSocketAddress() const {
   return core_->socket_address_;
 }
 
-bool URLFetcher::WasFetchedViaProxy() const {
+bool URLFetcherImpl::WasFetchedViaProxy() const {
   return core_->was_fetched_via_proxy_;
 }
 
-void URLFetcher::set_was_fetched_via_proxy(bool flag) {
+void URLFetcherImpl::set_was_fetched_via_proxy(bool flag) {
   core_->was_fetched_via_proxy_ = flag;
 }
 
-void URLFetcher::Start() {
+void URLFetcherImpl::Start() {
   core_->Start();
 }
 
-void URLFetcher::StartWithRequestContextGetter(
+void URLFetcherImpl::StartWithRequestContextGetter(
     net::URLRequestContextGetter* request_context_getter) {
   SetRequestContext(request_context_getter);
   core_->Start();
 }
 
-const GURL& URLFetcher::GetOriginalUrl() const {
+const GURL& URLFetcherImpl::GetOriginalUrl() const {
   return core_->original_url_;
 }
 
-const GURL& URLFetcher::GetUrl() const {
+const GURL& URLFetcherImpl::GetUrl() const {
   return core_->url_;
 }
 
-const net::URLRequestStatus& URLFetcher::GetStatus() const {
+const net::URLRequestStatus& URLFetcherImpl::GetStatus() const {
   return core_->status_;
 }
 
-int URLFetcher::GetResponseCode() const {
+int URLFetcherImpl::GetResponseCode() const {
   return core_->response_code_;
 }
 
-const net::ResponseCookies& URLFetcher::GetCookies() const {
+const net::ResponseCookies& URLFetcherImpl::GetCookies() const {
   return core_->cookies_;
 }
 
-bool URLFetcher::FileErrorOccurred(
+bool URLFetcherImpl::FileErrorOccurred(
     base::PlatformFileError* out_error_code) const {
 
   // Can't have a file error if no file is being created or written to.
   if (!core_->temp_file_writer_.get()) {
     return false;
   }
 
   base::PlatformFileError error_code = core_->temp_file_writer_->error_code();
   if (error_code == base::PLATFORM_FILE_OK)
     return false;
 
   *out_error_code = error_code;
   return true;
 }
 
-void URLFetcher::ReceivedContentWasMalformed() {
+void URLFetcherImpl::ReceivedContentWasMalformed() {
   core_->ReceivedContentWasMalformed();
 }
 
-bool URLFetcher::GetResponseAsString(std::string* out_response_string) const {
+bool URLFetcherImpl::GetResponseAsString(
+    std::string* out_response_string) const {
   if (core_->response_destination_ != STRING)
     return false;
 
   *out_response_string = core_->data_;
   return true;
 }
 
-bool URLFetcher::GetResponseAsFilePath(bool take_ownership,
-                                       FilePath* out_response_path) const {
+bool URLFetcherImpl::GetResponseAsFilePath(bool take_ownership,
+                                           FilePath* out_response_path) const {
   DCHECK(core_->delegate_loop_proxy_->BelongsToCurrentThread());
   if (core_->response_destination_ != TEMP_FILE ||
       !core_->temp_file_writer_.get())
     return false;
 
   *out_response_path = core_->temp_file_writer_->temp_file();
 
   if (take_ownership) {
     core_->io_message_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(&Core::DisownTempFile, core_.get()));
   }
   return true;
 }
 
 // static
-void URLFetcher::CancelAll() {
+void URLFetcherImpl::CancelAll() {
   Core::CancelAll();
 }
 
 // static
-int URLFetcher::GetNumFetcherCores() {
+int URLFetcherImpl::GetNumFetcherCores() {
   return Core::g_registry.Get().size();
 }
 
-content::URLFetcherDelegate* URLFetcher::delegate() const {
+content::URLFetcherDelegate* URLFetcherImpl::delegate() const {
   return core_->delegate();
 }
 
 // static
-content::URLFetcherFactory* URLFetcher::factory() {
+content::URLFetcherFactory* URLFetcherImpl::factory() {
   return g_factory;
 }
 
 // static
-void URLFetcher::set_factory(content::URLFetcherFactory* factory) {
+void URLFetcherImpl::set_factory(content::URLFetcherFactory* factory) {
   g_factory = factory;
 }