Rename TaskRunner::RunsTasksOnCurrentThread() in //components

components/update_client/component.cc

 // Copyright 2017 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 "components/update_client/component.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 51 matching lines @@
 using InstallOnBlockingTaskRunnerCompleteCallback =
     base::Callback<void(int error_category, int error_code, int extra_code1)>;
 
 CrxInstaller::Result DoInstallOnBlockingTaskRunner(
     const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
     const scoped_refptr<base::SequencedTaskRunner>& blocking_task_runner,
     const base::FilePath& unpack_path,
     const std::string& fingerprint,
     const scoped_refptr<CrxInstaller>& installer,
     InstallOnBlockingTaskRunnerCompleteCallback callback) {
-  DCHECK(blocking_task_runner->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner->RunsTasksInCurrentSequence());
 
   if (static_cast<int>(fingerprint.size()) !=
       base::WriteFile(
           unpack_path.Append(FILE_PATH_LITERAL("manifest.fingerprint")),
           fingerprint.c_str(), base::checked_cast<int>(fingerprint.size()))) {
     return CrxInstaller::Result(InstallError::FINGERPRINT_WRITE_FAILED);
   }
 
   std::unique_ptr<base::DictionaryValue> manifest = ReadManifest(unpack_path);
   if (!manifest)
     return CrxInstaller::Result(InstallError::BAD_MANIFEST);
 
   return installer->Install(*manifest, unpack_path);
 }
 
 void InstallOnBlockingTaskRunner(
     const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
     const scoped_refptr<base::SequencedTaskRunner>& blocking_task_runner,
     const base::FilePath& unpack_path,
     const std::string& fingerprint,
     const scoped_refptr<CrxInstaller>& installer,
     InstallOnBlockingTaskRunnerCompleteCallback callback) {
-  DCHECK(blocking_task_runner->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner->RunsTasksInCurrentSequence());
 
   const auto result = DoInstallOnBlockingTaskRunner(
       main_task_runner, blocking_task_runner, unpack_path, fingerprint,
       installer, callback);
 
   const ErrorCategory error_category =
       result.error ? ErrorCategory::kInstallError : ErrorCategory::kErrorNone;
   main_task_runner->PostTask(
       FROM_HERE,
       base::Bind(callback, static_cast<int>(error_category),
                  static_cast<int>(result.error), result.extended_error));
 }
 
 void UnpackCompleteOnBlockingTaskRunner(
     const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
     const scoped_refptr<base::SequencedTaskRunner>& blocking_task_runner,
     const base::FilePath& crx_path,
     const std::string& fingerprint,
     const scoped_refptr<CrxInstaller>& installer,
     InstallOnBlockingTaskRunnerCompleteCallback callback,
     const ComponentUnpacker::Result& result) {
-  DCHECK(blocking_task_runner->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner->RunsTasksInCurrentSequence());
 
   update_client::DeleteFileAndEmptyParentDirectory(crx_path);
 
   if (result.error != UnpackerError::kNone) {
     main_task_runner->PostTask(
         FROM_HERE,
         base::Bind(callback, static_cast<int>(ErrorCategory::kUnpackError),
                    static_cast<int>(result.error), result.extended_error));
     return;
   }
 
   blocking_task_runner->PostTask(
       FROM_HERE, base::Bind(&InstallOnBlockingTaskRunner, main_task_runner,
                             blocking_task_runner, result.unpack_path,
                             fingerprint, installer, callback));
 }
 
 void StartInstallOnBlockingTaskRunner(
     const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
     const scoped_refptr<base::SequencedTaskRunner>& blocking_task_runner,
     const std::vector<uint8_t>& pk_hash,
     const base::FilePath& crx_path,
     const std::string& fingerprint,
     const scoped_refptr<CrxInstaller>& installer,
     const scoped_refptr<OutOfProcessPatcher>& oop_patcher,
     InstallOnBlockingTaskRunnerCompleteCallback callback) {
-  DCHECK(blocking_task_runner->RunsTasksOnCurrentThread());
+  DCHECK(blocking_task_runner->RunsTasksInCurrentSequence());
 
   auto unpacker = base::MakeShared<ComponentUnpacker>(
       pk_hash, crx_path, installer, oop_patcher, blocking_task_runner);
 
   unpacker->Unpack(base::Bind(&UnpackCompleteOnBlockingTaskRunner,
                               main_task_runner, blocking_task_runner, crx_path,
                               fingerprint, installer, callback));
 }
 
 }  // namespace
@@ skipping 538 matching lines @@
 Component::StateUninstalled::~StateUninstalled() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void Component::StateUninstalled::DoHandle() {
   DCHECK(thread_checker_.CalledOnValidThread());
   TransitionState(nullptr);
 }
 
 }  // namespace update_client