Downloads: replace BrowserThread::FILE with task scheduler.

content/browser/download/download_item_impl.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.
 
 // File method ordering: Methods in this file are in the same order as
 // in download_item_impl.h, with the following exception: The public
 // interface Start is placed in chronological order with the other
 // (private) routines that together define a DownloadItem's state
 // transitions as the download progresses.  See "Download progression
 // cascade" later in this file.
@@ skipping 18 matching lines @@
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/task_runner_util.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/download_file.h"
 #include "content/browser/download/download_interrupt_reasons_impl.h"
 #include "content/browser/download/download_item_impl_delegate.h"
 #include "content/browser/download/download_job_factory.h"
 #include "content/browser/download/download_job_impl.h"
 #include "content/browser/download/download_net_log_parameters.h"
 #include "content/browser/download/download_request_handle.h"
 #include "content/browser/download/download_stats.h"
+#include "content/browser/download/download_task_runner.h"
 #include "content/browser/download/parallel_download_utils.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/download_danger_type.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_url_parameters.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/referrer.h"
 #include "net/http/http_response_headers.h"
 #include "net/log/net_log.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_parameters_callback.h"
 #include "net/log/net_log_source.h"
 #include "net/traffic_annotation/network_traffic_annotation.h"
 
 namespace content {
 
 namespace {
 
 bool DeleteDownloadedFile(const base::FilePath& path) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(GetDownloadTaskRunner()->RunsTasksInCurrentSequence());
 
   // Make sure we only delete files.
   if (base::DirectoryExists(path))
     return true;
   return base::DeleteFile(path, false);
 }
 
 void DeleteDownloadedFileDone(
     base::WeakPtr<DownloadItemImpl> item,
     const base::Callback<void(bool)>& callback,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (success && item.get())
     item->OnDownloadedFileRemoved();
   callback.Run(success);
 }
 
 // Wrapper around DownloadFile::Detach and DownloadFile::Cancel that
 // takes ownership of the DownloadFile and hence implicitly destroys it
 // at the end of the function.
 static base::FilePath DownloadFileDetach(
     std::unique_ptr<DownloadFile> download_file) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(GetDownloadTaskRunner()->RunsTasksInCurrentSequence());
   base::FilePath full_path = download_file->FullPath();
   download_file->Detach();
   return full_path;
 }
 
 static base::FilePath MakeCopyOfDownloadFile(DownloadFile* download_file) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(GetDownloadTaskRunner()->RunsTasksInCurrentSequence());
   base::FilePath temp_file_path;
   if (base::CreateTemporaryFile(&temp_file_path) &&
       base::CopyFile(download_file->FullPath(), temp_file_path)) {
     return temp_file_path;
   } else {
     // Deletes the file at |temp_file_path|.
     if (!base::DirectoryExists(temp_file_path))
       base::DeleteFile(temp_file_path, false);
     temp_file_path.clear();
     return base::FilePath();
   }
 }
 
 static void DownloadFileCancel(std::unique_ptr<DownloadFile> download_file) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(GetDownloadTaskRunner()->RunsTasksInCurrentSequence());
   download_file->Cancel();
 }
 
 // Most of the cancellation pathways behave the same whether the cancellation
 // was initiated by ther user (CANCELED) or initiated due to browser context
 // shutdown (SHUTDOWN).
 bool IsCancellation(DownloadInterruptReason reason) {
   return reason == DOWNLOAD_INTERRUPT_REASON_USER_SHUTDOWN ||
          reason == DOWNLOAD_INTERRUPT_REASON_USER_CANCELED;
 }
@@ skipping 274 matching lines @@
 void DownloadItemImpl::StealDangerousDownload(
     bool delete_file_afterward,
     const AcquireFileCallback& callback) {
   DVLOG(20) << __func__ << "() download = " << DebugString(true);
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(IsDangerous());
   DCHECK(AllDataSaved());
 
   if (delete_file_afterward) {
     if (download_file_) {
-      BrowserThread::PostTaskAndReplyWithResult(
-          BrowserThread::FILE, FROM_HERE,
+      PostTaskAndReplyWithResult(
+          GetDownloadTaskRunner().get(), FROM_HERE,
           base::Bind(&DownloadFileDetach, base::Passed(&download_file_)),
           callback);
     } else {
       callback.Run(GetFullPath());
     }
     destination_info_.current_path.clear();
     Remove();
     // Download item has now been deleted.
   } else if (download_file_) {
-    BrowserThread::PostTaskAndReplyWithResult(
-        BrowserThread::FILE, FROM_HERE,
+    PostTaskAndReplyWithResult(
+        GetDownloadTaskRunner().get(), FROM_HERE,
         base::Bind(&MakeCopyOfDownloadFile, download_file_.get()), callback);
   } else {
     callback.Run(GetFullPath());
   }
 }
 
 void DownloadItemImpl::Pause() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Ignore irrelevant states.
@@ skipping 14 matching lines @@
       // associated with this DII. When a request is assigned (due to a
       // resumption, for example) we can honor the |DownloadJob::is_paused_|
       // setting.
       return;
 
     case IN_PROGRESS_INTERNAL:
     case TARGET_PENDING_INTERNAL:
       job_->Pause();
       UpdateObservers();
       if (download_file_) {
-        BrowserThread::PostTask(
-            BrowserThread::FILE, FROM_HERE,
+        GetDownloadTaskRunner()->PostTask(
+            FROM_HERE,
             base::Bind(&DownloadFile::WasPaused,
                        // Safe because we control download file lifetime.
                        base::Unretained(download_file_.get())));
       }
       return;
 
     case MAX_DOWNLOAD_INTERNAL_STATE:
     case TARGET_RESOLVED_INTERNAL:
       NOTREACHED();
   }
@@ skipping 286 matching lines @@
     return;
   }
   if (GetFullPath().empty() || file_externally_removed_) {
     // Pass a null WeakPtr so it doesn't call OnDownloadedFileRemoved.
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&DeleteDownloadedFileDone,
                    base::WeakPtr<DownloadItemImpl>(), callback, true));
     return;
   }
-  BrowserThread::PostTaskAndReplyWithResult(
-      BrowserThread::FILE, FROM_HERE,
+  PostTaskAndReplyWithResult(
+      GetDownloadTaskRunner().get(), FROM_HERE,
       base::Bind(&DeleteDownloadedFile, GetFullPath()),
       base::Bind(&DeleteDownloadedFileDone, weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 bool DownloadItemImpl::IsDangerous() const {
   return (danger_type_ == DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE ||
           danger_type_ == DOWNLOAD_DANGER_TYPE_DANGEROUS_URL ||
           danger_type_ == DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT ||
           danger_type_ == DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT ||
@@ skipping 708 matching lines @@
 
   // Rename to intermediate name.
   // TODO(asanka): Skip this rename if AllDataSaved() is true. This avoids a
   //               spurious rename when we can just rename to the final
   //               filename. Unnecessary renames may cause bugs like
   //               http://crbug.com/74187.
   DCHECK(!IsSavePackageDownload());
   DownloadFile::RenameCompletionCallback callback =
       base::Bind(&DownloadItemImpl::OnDownloadRenamedToIntermediateName,
                  weak_ptr_factory_.GetWeakPtr());
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(&DownloadFile::RenameAndUniquify,
-                 // Safe because we control download file lifetime.
-                 base::Unretained(download_file_.get()),
-                 intermediate_path, callback));
+  GetDownloadTaskRunner()->PostTask(
+      FROM_HERE, base::Bind(&DownloadFile::RenameAndUniquify,
+                            // Safe because we control download file lifetime.
+                            base::Unretained(download_file_.get()),
+                            intermediate_path, callback));
 }
 
 void DownloadItemImpl::OnDownloadRenamedToIntermediateName(
     DownloadInterruptReason reason,
     const base::FilePath& full_path) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(state_ == TARGET_PENDING_INTERNAL ||
          state_ == INTERRUPTED_TARGET_PENDING_INTERNAL);
   DCHECK(download_file_);
   DVLOG(20) << __func__ << "() download=" << DebugString(true);
@@ skipping 85 matching lines @@
   DVLOG(20) << __func__ << "() " << DebugString(true);
   DCHECK(!GetTargetFilePath().empty());
   DCHECK(!IsDangerous());
 
   DCHECK(download_file_.get());
   // Unilaterally rename; even if it already has the right name,
   // we need theannotation.
   DownloadFile::RenameCompletionCallback callback =
       base::Bind(&DownloadItemImpl::OnDownloadRenamedToFinalName,
                  weak_ptr_factory_.GetWeakPtr());
-  BrowserThread::PostTask(
-      BrowserThread::FILE,
+  GetDownloadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&DownloadFile::RenameAndAnnotate,
-                 base::Unretained(download_file_.get()),
-                 GetTargetFilePath(),
-                 delegate_->GetApplicationClientIdForFileScanning(),
-                 GetURL(),
-                 GetReferrerUrl(),
-                 callback));
+                 base::Unretained(download_file_.get()), GetTargetFilePath(),
+                 delegate_->GetApplicationClientIdForFileScanning(), GetURL(),
+                 GetReferrerUrl(), callback));
 }
 
 void DownloadItemImpl::OnDownloadRenamedToFinalName(
     DownloadInterruptReason reason,
     const base::FilePath& full_path) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!IsSavePackageDownload());
 
   // If a cancel or interrupt hit, we'll cancel the DownloadFile, which
   // will result in deleting the file on the file thread.  So we don't
@@ skipping 161 matching lines @@
       // The first non-cancel interrupt reason wins in cases where multiple
       // things go wrong.
       if (!IsCancellation(reason))
         return;
 
       last_reason_ = reason;
       if (!GetFullPath().empty()) {
         // There is no download file and this is transitioning from INTERRUPTED
         // to CANCELLED. The intermediate file is no longer usable, and should
         // be deleted.
-        BrowserThread::PostTask(
-            BrowserThread::FILE, FROM_HERE,
-            base::Bind(base::IgnoreResult(&DeleteDownloadedFile),
-                       GetFullPath()));
+        GetDownloadTaskRunner()->PostTask(
+            FROM_HERE, base::Bind(base::IgnoreResult(&DeleteDownloadedFile),
+                                  GetFullPath()));
         destination_info_.current_path.clear();
       }
       break;
   }
 
   // Reset all data saved, as even if we did save all the data we're going to go
   // through another round of downloading when we resume. There's a potential
   // problem here in the abstract, as if we did download all the data and then
   // run into a continuable error, on resumption we won't download any more
   // data.  However, a) there are currently no continuable errors that can occur
@@ skipping 76 matching lines @@
   std::vector<char> hash_value(clone_of_hash_state->GetHashLength());
   clone_of_hash_state->Finish(&hash_value.front(), hash_value.size());
   destination_info_.hash.assign(hash_value.begin(), hash_value.end());
 }
 
 void DownloadItemImpl::ReleaseDownloadFile(bool destroy_file) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DVLOG(20) << __func__ << "() destroy_file:" << destroy_file;
 
   if (destroy_file) {
-    BrowserThread::PostTask(
-        BrowserThread::FILE, FROM_HERE,
+    GetDownloadTaskRunner()->PostTask(
+        FROM_HERE,
         // Will be deleted at end of task execution.
         base::Bind(&DownloadFileCancel, base::Passed(&download_file_)));
     // Avoid attempting to reuse the intermediate file by clearing out
     // current_path_ and received slices.
     destination_info_.current_path.clear();
     received_slices_.clear();
   } else {
-    BrowserThread::PostTask(
-        BrowserThread::FILE,
-        FROM_HERE,
-        base::Bind(base::IgnoreResult(&DownloadFileDetach),
-                   // Will be deleted at end of task execution.
-                   base::Passed(&download_file_)));
+    GetDownloadTaskRunner()->PostTask(
+        FROM_HERE, base::Bind(base::IgnoreResult(&DownloadFileDetach),
+                              // Will be deleted at end of task execution.
+                              base::Passed(&download_file_)));
   }
   // Don't accept any more messages from the DownloadFile, and null
   // out any previous "all data received".  This also breaks links to
   // other entities we've given out weak pointers to.
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 bool DownloadItemImpl::IsDownloadReadyForCompletion(
     const base::Closure& state_change_notification) {
   // If the download hasn't progressed to the IN_PROGRESS state, then it's not
@@ skipping 446 matching lines @@
     case RESUME_MODE_USER_CONTINUE:
       return "USER_CONTINUE";
     case RESUME_MODE_USER_RESTART:
       return "USER_RESTART";
   }
   NOTREACHED() << "Unknown resume mode " << mode;
   return "unknown";
 }
 
 }  // namespace content