Rename TaskRunner::RunsTasksOnCurrentThread() in //chrome

chrome/browser/safe_browsing/local_database_manager.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 "chrome/browser/safe_browsing/local_database_manager.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 790 matching lines @@
     return true;
   safe_browsing_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(
           base::IgnoreResult(&LocalSafeBrowsingDatabaseManager::GetDatabase),
           this));
   return false;
 }
 
 SafeBrowsingDatabase* LocalSafeBrowsingDatabaseManager::GetDatabase() {
-  DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(safe_browsing_task_runner_->RunsTasksInCurrentSequence());
 
   if (database_)
     return database_;
 
   const base::TimeTicks before = base::TimeTicks::Now();
   std::unique_ptr<SafeBrowsingDatabase> database = SafeBrowsingDatabase::Create(
       safe_browsing_task_runner_, enable_download_protection_,
       enable_csd_whitelist_, enable_download_whitelist_,
       enable_extension_blacklist_, enable_ip_blacklist_,
       enable_unwanted_software_blacklist_, enable_module_whitelist_);
@@ skipping 101 matching lines @@
   bool is_download = check->check_type == BINURL;
   sb_service_->protocol_manager()->GetFullHash(
       check->prefix_hits,
       base::Bind(&LocalSafeBrowsingDatabaseManager::HandleGetHashResults,
                  base::Unretained(this), check),
       is_download, check->extended_reporting_level);
 }
 
 void LocalSafeBrowsingDatabaseManager::GetAllChunksFromDatabase(
     GetChunksCallback callback) {
-  DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(safe_browsing_task_runner_->RunsTasksInCurrentSequence());
 
   bool database_error = true;
   std::vector<SBListChunkRanges> lists;
   DCHECK(!database_update_in_progress_);
   database_update_in_progress_ = true;
   GetDatabase();  // This guarantees that |database_| is non-NULL.
   if (database_->UpdateStarted(&lists)) {
     database_error = false;
   } else {
     database_->UpdateFinished(false);
@@ skipping 65 matching lines @@
       sb_check.OnSafeBrowsingResult();
     }
     queued_checks_.pop_front();
   }
 }
 
 void LocalSafeBrowsingDatabaseManager::AddDatabaseChunks(
     const std::string& list_name,
     std::unique_ptr<std::vector<std::unique_ptr<SBChunkData>>> chunks,
     AddChunksCallback callback) {
-  DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(safe_browsing_task_runner_->RunsTasksInCurrentSequence());
   if (chunks)
     GetDatabase()->InsertChunks(list_name, *chunks);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::BindOnce(&LocalSafeBrowsingDatabaseManager::OnAddChunksComplete,
                      this, callback));
 }
 
 void LocalSafeBrowsingDatabaseManager::DeleteDatabaseChunks(
     std::unique_ptr<std::vector<SBChunkDelete>> chunk_deletes) {
-  DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(safe_browsing_task_runner_->RunsTasksInCurrentSequence());
   if (chunk_deletes)
     GetDatabase()->DeleteChunks(*chunk_deletes);
 }
 
 void LocalSafeBrowsingDatabaseManager::DatabaseUpdateFinished(
     bool update_succeeded) {
-  DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(safe_browsing_task_runner_->RunsTasksInCurrentSequence());
   GetDatabase()->UpdateFinished(update_succeeded);
   DCHECK(database_update_in_progress_);
   database_update_in_progress_ = false;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::BindOnce(
           &LocalSafeBrowsingDatabaseManager::NotifyDatabaseUpdateFinished, this,
           update_succeeded));
 }
 
 void LocalSafeBrowsingDatabaseManager::OnCloseDatabase() {
-  DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(safe_browsing_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(closing_database_);
 
   // Because |closing_database_| is true, nothing on the IO thread will be
   // accessing the database, so it's safe to delete and then NULL the pointer.
   delete database_;
   database_ = NULL;
 
   // Acquiring the lock here guarantees correct ordering between the resetting
   // of |database_| above and of |closing_database_| below, which ensures there
   // won't be a window during which the IO thread falsely believes the database
   // is available.
   base::AutoLock lock(database_lock_);
   closing_database_ = false;
 }
 
 void LocalSafeBrowsingDatabaseManager::OnResetDatabase() {
-  DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(safe_browsing_task_runner_->RunsTasksInCurrentSequence());
 
   GetDatabase()->ResetDatabase();
 }
 
 void LocalSafeBrowsingDatabaseManager::OnHandleGetHashResults(
     SafeBrowsingCheck* check,
     const std::vector<SBFullHashResult>& full_hashes) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ListType check_type = check->check_type;
   SBPrefix prefix = check->prefix_hits[0];
@@ skipping 89 matching lines @@
     SafeBrowsingCheckDone(check);
   } else {
     check->need_get_hash = true;
     OnCheckDone(check);
   }
 }
 
 std::vector<SBPrefix>
 LocalSafeBrowsingDatabaseManager::CheckDownloadUrlOnSBThread(
     const std::vector<SBPrefix>& prefixes) {
-  DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(safe_browsing_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(enable_download_protection_);
 
   std::vector<SBPrefix> prefix_hits;
   const bool result =
       database_->ContainsDownloadUrlPrefixes(prefixes, &prefix_hits);
   DCHECK_EQ(result, !prefix_hits.empty());
   return prefix_hits;
 }
 
 std::vector<SBPrefix>
 LocalSafeBrowsingDatabaseManager::CheckExtensionIDsOnSBThread(
     const std::vector<SBPrefix>& prefixes) {
-  DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(safe_browsing_task_runner_->RunsTasksInCurrentSequence());
 
   std::vector<SBPrefix> prefix_hits;
   const bool result =
       database_->ContainsExtensionPrefixes(prefixes, &prefix_hits);
   DCHECK_EQ(result, !prefix_hits.empty());
   return prefix_hits;
 }
 
 std::vector<SBPrefix>
 LocalSafeBrowsingDatabaseManager::CheckResourceUrlOnSBThread(
     const std::vector<SBPrefix>& prefixes) {
-  DCHECK(safe_browsing_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(safe_browsing_task_runner_->RunsTasksInCurrentSequence());
 
   std::vector<SBPrefix> prefix_hits;
   const bool result =
       database_->ContainsResourceUrlPrefixes(prefixes, &prefix_hits);
   DCHECK_EQ(result, !prefix_hits.empty());
   return prefix_hits;
 }
 
 void LocalSafeBrowsingDatabaseManager::TimeoutCallback(
     SafeBrowsingCheck* check) {
@@ skipping 42 matching lines @@
       base::BindOnce(&LocalSafeBrowsingDatabaseManager::TimeoutCallback,
                      check_ptr->weak_ptr_factory_->GetWeakPtr(), check_ptr),
       check_timeout_);
 }
 
 bool LocalSafeBrowsingDatabaseManager::IsDownloadProtectionEnabled() const {
   return enable_download_protection_;
 }
 
 }  // namespace safe_browsing