Rename TaskRunner::RunsTasksOnCurrentThread() in //chrome

chrome/browser/conflicts/module_database_win.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 "chrome/browser/conflicts/module_database_win.h"
 
 #include <algorithm>
 #include <tuple>
 
 #include "base/bind.h"
@@ skipping 37 matching lines @@
     std::unique_ptr<ModuleDatabase> module_database) {
   DCHECK_EQ(nullptr, g_instance);
   // This is deliberately leaked. It can be cleaned up by manually deleting the
   // ModuleDatabase
   g_instance = module_database.release();
 }
 
 void ModuleDatabase::OnProcessStarted(uint32_t process_id,
                                       uint64_t creation_time,
                                       content::ProcessType process_type) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   CreateProcessInfo(process_id, creation_time, process_type);
 }
 
 void ModuleDatabase::OnModuleLoad(uint32_t process_id,
                                   uint64_t creation_time,
                                   const base::FilePath& module_path,
                                   uint32_t module_size,
                                   uint32_t module_time_date_stamp,
                                   uintptr_t module_load_address) {
   // Messages can arrive from any thread (UI thread for calls over IPC, and
   // anywhere at all for calls from ModuleWatcher), so bounce if necessary.
-  if (!task_runner_->RunsTasksOnCurrentThread()) {
+  if (!task_runner_->RunsTasksInCurrentSequence()) {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&ModuleDatabase::OnModuleLoad,
                               weak_ptr_factory_.GetWeakPtr(), process_id,
                               creation_time, module_path, module_size,
                               module_time_date_stamp, module_load_address));
     return;
   }
 
   // In theory this should always succeed. However, it is possible for a client
   // to misbehave and send out-of-order messages. It is easy to be tolerant of
@@ skipping 16 matching lines @@
                     &process_info->second.loaded_modules);
   RemoveLoadAddressById(module_info->first.module_id,
                         &process_info->second.unloaded_modules);
 }
 
 void ModuleDatabase::OnModuleUnload(uint32_t process_id,
                                     uint64_t creation_time,
                                     uintptr_t module_load_address) {
   // Messages can arrive from any thread (UI thread for calls over IPC, and
   // anywhere at all for calls from ModuleWatcher), so bounce if necessary.
-  if (!task_runner_->RunsTasksOnCurrentThread()) {
+  if (!task_runner_->RunsTasksInCurrentSequence()) {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&ModuleDatabase::OnModuleUnload,
                               weak_ptr_factory_.GetWeakPtr(), process_id,
                               creation_time, module_load_address));
     return;
   }
 
   // See the long-winded comment in OnModuleLoad about reasons why this can
   // fail (but shouldn't normally).
   auto* process_info = GetProcessInfo(process_id, creation_time);
@@ skipping 17 matching lines @@
   // list.
   RemoveLoadAddressByIndex(i, &process_info->second.loaded_modules);
   InsertLoadAddress(module_id, module_load_address,
                     &process_info->second.unloaded_modules);
 }
 
 void ModuleDatabase::OnProcessEnded(uint32_t process_id,
                                     uint64_t creation_time) {
   // Messages can arrive from any thread (UI thread for calls over IPC, and
   // anywhere at all for calls from ModuleWatcher), so bounce if necessary.
-  if (!task_runner_->RunsTasksOnCurrentThread()) {
+  if (!task_runner_->RunsTasksInCurrentSequence()) {
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&ModuleDatabase::OnProcessEnded,
                    weak_ptr_factory_.GetWeakPtr(), process_id, creation_time));
     return;
   }
 
   DeleteProcessInfo(process_id, creation_time);
 }
 
@@ skipping 184 matching lines @@
 
 void ModuleDatabase::DeleteProcessInfo(uint32_t process_id,
                                        uint64_t creation_time) {
   ProcessInfoKey key(process_id, creation_time, content::PROCESS_TYPE_UNKNOWN);
   processes_.erase(key);
 }
 
 void ModuleDatabase::OnModuleInspected(
     const ModuleInfoKey& module_key,
     std::unique_ptr<ModuleInspectionResult> inspection_result) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   auto it = modules_.find(module_key);
   if (it == modules_.end())
     return;
 
   it->second.inspection_result = std::move(inspection_result);
 
   for (auto& observer : observer_list_)
     observer.OnNewModuleFound(it->first, it->second);
 }
@@ skipping 19 matching lines @@
 }
 
 // ModuleDatabase::ProcessInfoData ---------------------------------------------
 
 ModuleDatabase::ProcessInfoData::ProcessInfoData() = default;
 
 ModuleDatabase::ProcessInfoData::ProcessInfoData(const ProcessInfoData& other) =
     default;
 
 ModuleDatabase::ProcessInfoData::~ProcessInfoData() = default;