Downloads: replace BrowserThread::FILE with task scheduler.

content/browser/download/base_file.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 "content/browser/download/base_file.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 #include "content/browser/download/download_interrupt_reasons_impl.h"
 #include "content/browser/download/download_net_log_parameters.h"
 #include "content/browser/download/download_stats.h"
 #include "content/public/browser/browser_thread.h"

[gab, 2017/07/20 16:54:31]

We can remove browser_thread.h in many of these I assume (i.e. all of those that
don't still tie into BrowserThread::UI or IO).

[Sigurður Ásgeirsson, 2017/07/20 17:23:21]

Done for those where the shoe fits - not that many, alas.

 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/quarantine.h"
 #include "crypto/secure_hash.h"
 #include "net/base/net_errors.h"
 #include "net/log/net_log.h"
 #include "net/log/net_log_event_type.h"
 
 namespace content {
 
-BaseFile::BaseFile(const net::NetLogWithSource& net_log) : net_log_(net_log) {}
+BaseFile::BaseFile(const net::NetLogWithSource& net_log) : net_log_(net_log) {
+  DETACH_FROM_SEQUENCE(sequence_checker_);
+}
 
 BaseFile::~BaseFile() {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (detached_)
     Close();
   else
     Cancel();  // Will delete the file.
 }
 
 DownloadInterruptReason BaseFile::Initialize(
     const base::FilePath& full_path,
     const base::FilePath& default_directory,
     base::File file,
     int64_t bytes_so_far,
     const std::string& hash_so_far,
     std::unique_ptr<crypto::SecureHash> hash_state,
     bool is_sparse_file) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!detached_);
 
   if (full_path.empty()) {
     base::FilePath initial_directory(default_directory);
     base::FilePath temp_file;
     if (initial_directory.empty()) {
       initial_directory =
           GetContentClient()->browser()->GetDefaultDownloadDirectory();
     }
     // |initial_directory| can still be empty if ContentBrowserClient returned
@@ skipping 60 matching lines @@
   net_log_.EndEvent(net::NetLogEventType::DOWNLOAD_FILE_WRITTEN,
                     net::NetLog::Int64Callback("bytes", data_len));
 
   if (secure_hash_)
     secure_hash_->Update(data, data_len);
 
   return DOWNLOAD_INTERRUPT_REASON_NONE;
 }
 
 DownloadInterruptReason BaseFile::Rename(const base::FilePath& new_path) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DownloadInterruptReason rename_result = DOWNLOAD_INTERRUPT_REASON_NONE;
 
   // If the new path is same as the old one, there is no need to perform the
   // following renaming logic.
   if (new_path == full_path_)
     return DOWNLOAD_INTERRUPT_REASON_NONE;
 
   // Save the information whether the download is in progress because
   // it will be overwritten by closing the file.
   bool was_in_progress = in_progress();
@@ skipping 24 matching lines @@
   return rename_result == DOWNLOAD_INTERRUPT_REASON_NONE ? open_result
                                                          : rename_result;
 }
 
 void BaseFile::Detach() {
   detached_ = true;
   net_log_.AddEvent(net::NetLogEventType::DOWNLOAD_FILE_DETACHED);
 }
 
 void BaseFile::Cancel() {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!detached_);
 
   net_log_.AddEvent(net::NetLogEventType::CANCELLED);
 
   Close();
 
   if (!full_path_.empty()) {
     net_log_.AddEvent(net::NetLogEventType::DOWNLOAD_FILE_DELETED);
     base::DeleteFile(full_path_, false);
   }
 
   Detach();
 }
 
 std::unique_ptr<crypto::SecureHash> BaseFile::Finish() {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // TODO(qinmin): verify that all the holes have been filled.
   if (is_sparse_file_)
     CalculatePartialHash(std::string());
   Close();
   return std::move(secure_hash_);
 }
 
 std::string BaseFile::DebugString() const {
   return base::StringPrintf(
@@ skipping 67 matching lines @@
       return LogInterruptReason("Verifying prefix hash",
                                 0,
                                 DOWNLOAD_INTERRUPT_REASON_FILE_HASH_MISMATCH);
     }
   }
 
   return DOWNLOAD_INTERRUPT_REASON_NONE;
 }
 
 DownloadInterruptReason BaseFile::Open(const std::string& hash_so_far) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!detached_);
   DCHECK(!full_path_.empty());
 
   // Create a new file if it is not provided.
   if (!file_.IsValid()) {
     file_.Initialize(full_path_,
                      base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE |
                          base::File::FLAG_READ);
     if (!file_.IsValid()) {
       return LogNetError("Open/Initialize File",
@@ skipping 42 matching lines @@
     // The file is shorter than we expected.  Our hashes won't be valid.
     ClearFile();
     return LogInterruptReason("Unable to seek to last written point", 0,
                               DOWNLOAD_INTERRUPT_REASON_FILE_TOO_SHORT);
   }
 
   return DOWNLOAD_INTERRUPT_REASON_NONE;
 }
 
 void BaseFile::Close() {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (file_.IsValid()) {
     // Currently we don't really care about the return value, since if it fails
     // theres not much we can do.  But we might in the future.
     file_.Flush();
     ClearFile();
   }
 }
 
 void BaseFile::ClearFile() {
@@ skipping 66 matching lines @@
 
   return GURL();
 }
 
 }  // namespace
 
 DownloadInterruptReason BaseFile::AnnotateWithSourceInformation(
     const std::string& client_guid,
     const GURL& source_url,
     const GURL& referrer_url) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!detached_);
   DCHECK(!full_path_.empty());
 
   net_log_.BeginEvent(net::NetLogEventType::DOWNLOAD_FILE_ANNOTATED);
   QuarantineFileResult result = QuarantineFile(
       full_path_, GetEffectiveAuthorityURL(source_url, referrer_url),
       referrer_url, client_guid);
   net_log_.EndEvent(net::NetLogEventType::DOWNLOAD_FILE_ANNOTATED);
   switch (result) {
     case QuarantineFileResult::OK:
@@ skipping 33 matching lines @@
 #else  // !OS_WIN && !OS_MACOSX && !OS_LINUX
 DownloadInterruptReason BaseFile::AnnotateWithSourceInformation(
     const std::string& client_guid,
     const GURL& source_url,
     const GURL& referrer_url) {
   return DOWNLOAD_INTERRUPT_REASON_NONE;
 }
 #endif
 
 }  // namespace content