Rename TaskRunner::RunsTasksOnCurrentThread() in //components

components/policy/core/browser/url_blacklist_manager.cc

 // Copyright 2014 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/policy/core/browser/url_blacklist_manager.h"
 
 #include <stdint.h>
 #include <limits>
 #include <utility>
 
@@ skipping 434 matching lines @@
   pref_change_registrar_.Add(policy_prefs::kUrlBlacklist, callback);
   pref_change_registrar_.Add(policy_prefs::kUrlWhitelist, callback);
 
   // Start enforcing the policies without a delay when they are present at
   // startup.
   if (pref_service_->HasPrefPath(policy_prefs::kUrlBlacklist))
     Update();
 }
 
 void URLBlacklistManager::ShutdownOnUIThread() {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   // Cancel any pending updates, and stop listening for pref change updates.
   ui_weak_ptr_factory_.InvalidateWeakPtrs();
   pref_change_registrar_.RemoveAll();
 }
 
 URLBlacklistManager::~URLBlacklistManager() {
 }
 
 void URLBlacklistManager::ScheduleUpdate() {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   // Cancel pending updates, if any. This can happen if two preferences that
   // change the blacklist are updated in one message loop cycle. In those cases,
   // only rebuild the blacklist after all the preference updates are processed.
   ui_weak_ptr_factory_.InvalidateWeakPtrs();
   ui_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&URLBlacklistManager::Update,
                  ui_weak_ptr_factory_.GetWeakPtr()));
 }
 
 void URLBlacklistManager::Update() {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
 
   // The preferences can only be read on the UI thread.
   std::unique_ptr<base::ListValue> block(
       pref_service_->GetList(policy_prefs::kUrlBlacklist)->DeepCopy());
   std::unique_ptr<base::ListValue> allow(
       pref_service_->GetList(policy_prefs::kUrlWhitelist)->DeepCopy());
 
   // Go through the IO thread to grab a WeakPtr to |this|. This is safe from
   // here, since this task will always execute before a potential deletion of
   // ProfileIOData on IO.
   io_task_runner_->PostTask(FROM_HERE,
                             base::Bind(&URLBlacklistManager::UpdateOnIO,
                                        base::Unretained(this),
                                        base::Passed(&block),
                                        base::Passed(&allow)));
 }
 
 void URLBlacklistManager::UpdateOnIO(std::unique_ptr<base::ListValue> block,
                                      std::unique_ptr<base::ListValue> allow) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   // The URLBlacklist is built on a worker thread. Once it's ready, it is passed
   // to the URLBlacklistManager on IO.
   base::PostTaskAndReplyWithResult(
       background_task_runner_.get(),
       FROM_HERE,
       base::Bind(&BuildBlacklist,
                  base::Passed(&block),
                  base::Passed(&allow)),
       base::Bind(&URLBlacklistManager::SetBlacklist,
                  io_weak_ptr_factory_.GetWeakPtr()));
 }
 
 void URLBlacklistManager::SetBlacklist(
     std::unique_ptr<URLBlacklist> blacklist) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   blacklist_ = std::move(blacklist);
 }
 
 bool URLBlacklistManager::IsURLBlocked(const GURL& url) const {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   return blacklist_->IsURLBlocked(url);
 }
 
 URLBlacklist::URLBlacklistState URLBlacklistManager::GetURLBlacklistState(
     const GURL& url) const {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   return blacklist_->GetURLBlacklistState(url);
 }
 
 bool URLBlacklistManager::ShouldBlockRequestForFrame(const GURL& url,
                                                      int* reason) const {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
 
   bool block = false;
   if (override_blacklist_.Run(url, &block, reason))
     return block;
 
   *reason = net::ERR_BLOCKED_BY_ADMINISTRATOR;
   return IsURLBlocked(url);
 }
 
 // static
 void URLBlacklistManager::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterListPref(policy_prefs::kUrlBlacklist);
   registry->RegisterListPref(policy_prefs::kUrlWhitelist);
 }
 
 }  // namespace policy