URLFetcher uses a TaskRunner instead of a message loop.

net/url_request/url_fetcher_core.cc

 // Copyright (c) 2012 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 "net/url_request/url_fetcher_core.h"
 
 #include "base/bind.h"
 #include "base/file_util_proxy.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 38 matching lines @@
 void URLFetcherCore::Registry::CancelAll() {
   while (!fetchers_.empty())
     (*fetchers_.begin())->CancelURLRequest();
 }
 
 
 // URLFetcherCore::FileWriter -------------------------------------------------
 
 URLFetcherCore::FileWriter::FileWriter(
     URLFetcherCore* core,
-    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner)
+    scoped_refptr<base::TaskRunner> file_task_runner)
     : core_(core),
       error_code_(base::PLATFORM_FILE_OK),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       file_task_runner_(file_task_runner),
       file_handle_(base::kInvalidPlatformFileValue) {
 }
 
 URLFetcherCore::FileWriter::~FileWriter() {
-  RemoveFile();
+  CloseAndDeleteFile();
 }
 
 void URLFetcherCore::FileWriter::CreateFileAtPath(
     const FilePath& file_path) {
   DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
   DCHECK(file_task_runner_.get());
   base::FileUtilProxy::CreateOrOpen(
       file_task_runner_,
       file_path,
       base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_WRITE,
@@ skipping 38 matching lines @@
 
   // Every code path that resets |core_->request_| should reset
   // |core->file_writer_| or cause the file writer to disown the file.  In the
   // former case, this callback can not be called, because the weak pointer to
   // |this| will be NULL. In the latter case, the check of |file_handle_| at the
   // start of this method ensures that we can not reach this point.
   CHECK(core_->request_.get());
 
   if (base::PLATFORM_FILE_OK != error_code) {
     error_code_ = error_code;
-    RemoveFile();
+    CloseAndDeleteFile();
     core_->delegate_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&URLFetcherCore::InformDelegateFetchIsComplete, core_));
     return;
   }
 
   total_bytes_written_ += bytes_written;
   buffer_offset_ += bytes_written;
   pending_bytes_ -= bytes_written;
 
@@ skipping 26 matching lines @@
 
   if (file_handle_ != base::kInvalidPlatformFileValue) {
     base::FileUtilProxy::Close(
         file_task_runner_, file_handle_,
         base::Bind(&URLFetcherCore::FileWriter::DidCloseFile,
                    weak_factory_.GetWeakPtr()));
     file_handle_ = base::kInvalidPlatformFileValue;
   }
 }
 
-void URLFetcherCore::FileWriter::RemoveFile() {
+void URLFetcherCore::FileWriter::CloseAndDeleteFile() {
   DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
 
+  if (file_handle_ == base::kInvalidPlatformFileValue) {
+    DeleteFile(base::PLATFORM_FILE_OK);
+    return;
+  }
   // Close the file if it is open.
-  if (file_handle_ != base::kInvalidPlatformFileValue) {
-    base::FileUtilProxy::Close(
-        file_task_runner_, file_handle_,
-        base::FileUtilProxy::StatusCallback());  // No callback: Ignore errors.
-    file_handle_ = base::kInvalidPlatformFileValue;
-  }
+  base::FileUtilProxy::Close(
+      file_task_runner_, file_handle_,
+      base::Bind(&URLFetcherCore::FileWriter::DeleteFile,
+                 weak_factory_.GetWeakPtr()));
+  file_handle_ = base::kInvalidPlatformFileValue;
+}
 
-  if (!file_path_.empty()) {
-    base::FileUtilProxy::Delete(
-        file_task_runner_, file_path_,
-        false,  // No need to recurse, as the path is to a file.
-        base::FileUtilProxy::StatusCallback());  // No callback: Ignore errors.
-    DisownFile();
-  }
+void URLFetcherCore::FileWriter::DeleteFile(
+    base::PlatformFileError error_code) {
+  DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
+  if (file_path_.empty())
+    return;
+
+  base::FileUtilProxy::Delete(
+      file_task_runner_, file_path_,
+      false,  // No need to recurse, as the path is to a file.
+      base::FileUtilProxy::StatusCallback());
+  DisownFile();
 }
 
 void URLFetcherCore::FileWriter::DidCreateFile(
     const FilePath& file_path,
     base::PlatformFileError error_code,
     base::PassPlatformFile file_handle,
     bool created) {
   DidCreateFileInternal(file_path, error_code, file_handle);
 }
 
 void URLFetcherCore::FileWriter::DidCreateTempFile(
     base::PlatformFileError error_code,
     base::PassPlatformFile file_handle,
     const FilePath& file_path) {
   DidCreateFileInternal(file_path, error_code, file_handle);
 }
 
 void URLFetcherCore::FileWriter::DidCreateFileInternal(
     const FilePath& file_path,
     base::PlatformFileError error_code,
     base::PassPlatformFile file_handle) {
   DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
 
   if (base::PLATFORM_FILE_OK != error_code) {
     error_code_ = error_code;
-    RemoveFile();
+    CloseAndDeleteFile();
     core_->delegate_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&URLFetcherCore::InformDelegateFetchIsComplete, core_));
     return;
   }
 
   file_path_ = file_path;
   file_handle_ = file_handle.ReleaseValue();
   total_bytes_written_ = 0;
 
   core_->network_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&URLFetcherCore::StartURLRequestWhenAppropriate, core_));
 }
 
 void URLFetcherCore::FileWriter::DidCloseFile(
     base::PlatformFileError error_code) {
   DCHECK(core_->network_task_runner_->BelongsToCurrentThread());
 
   if (base::PLATFORM_FILE_OK != error_code) {
     error_code_ = error_code;
-    RemoveFile();
+    CloseAndDeleteFile();
     core_->delegate_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&URLFetcherCore::InformDelegateFetchIsComplete, core_));
     return;
   }
 
   // If the file was successfully closed, then the URL request is complete.
   core_->RetryOrCompleteUrlFetch();
 }
 
@@ skipping 155 matching lines @@
 int URLFetcherCore::GetMaxRetries() const {
   return max_retries_;
 }
 
 base::TimeDelta URLFetcherCore::GetBackoffDelay() const {
   return backoff_delay_;
 }
 
 void URLFetcherCore::SaveResponseToFileAtPath(
     const FilePath& file_path,
-    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner) {
+    scoped_refptr<base::TaskRunner> file_task_runner) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   file_task_runner_ = file_task_runner;
   response_destination_ = URLFetcherCore::PERMANENT_FILE;
   response_destination_file_path_ = file_path;
 }
 
 void URLFetcherCore::SaveResponseToTemporaryFile(
-    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner) {
+    scoped_refptr<base::TaskRunner> file_task_runner) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   file_task_runner_ = file_task_runner;
   response_destination_ = URLFetcherCore::TEMP_FILE;
 }
 
 HttpResponseHeaders* URLFetcherCore::GetResponseHeaders() const {
   return response_headers_;
 }
 
 // TODO(panayiotis): socket_address_ is written in the IO thread,
@@ skipping 562 matching lines @@
 }
 
 void URLFetcherCore::InformDelegateDownloadDataInDelegateThread(
     scoped_ptr<std::string> download_data) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchDownloadData(fetcher_, download_data.Pass());
 }
 
 }  // namespace net