Rename TaskRunner::RunsTasksOnCurrentThread() in //components

components/policy/core/common/async_policy_loader.cc

 // Copyright 2013 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/common/async_policy_loader.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 23 matching lines @@
     : task_runner_(task_runner),
       weak_factory_(this) {}
 
 AsyncPolicyLoader::~AsyncPolicyLoader() {}
 
 Time AsyncPolicyLoader::LastModificationTime() {
   return Time();
 }
 
 void AsyncPolicyLoader::Reload(bool force) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   TimeDelta delay;
   Time now = Time::Now();
   // Check if there was a recent modification to the underlying files.
   if (!force && !IsSafeToReload(now, &delay)) {
     ScheduleNextReload(delay);
     return;
   }
 
   std::unique_ptr<PolicyBundle> bundle(Load());
@@ skipping 18 matching lines @@
   // installing the watches can be detected.
   last_modification_time_ = LastModificationTime();
   schema_map_ = schema_map;
   std::unique_ptr<PolicyBundle> bundle(Load());
   // Filter out mismatching policies.
   schema_map_->FilterBundle(bundle.get());
   return bundle;
 }
 
 void AsyncPolicyLoader::Init(const UpdateCallback& update_callback) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(update_callback_.is_null());
   DCHECK(!update_callback.is_null());
   update_callback_ = update_callback;
 
   InitOnBackgroundThread();
 
   // There might have been changes to the underlying files since the initial
   // load and before the watchers have been created.
   if (LastModificationTime() != last_modification_time_)
     Reload(false);
 
   // Start periodic refreshes.
   ScheduleNextReload(TimeDelta::FromSeconds(kReloadIntervalSeconds));
 }
 
 void AsyncPolicyLoader::RefreshPolicies(scoped_refptr<SchemaMap> schema_map) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   schema_map_ = schema_map;
   Reload(true);
 }
 
 void AsyncPolicyLoader::ScheduleNextReload(TimeDelta delay) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   weak_factory_.InvalidateWeakPtrs();
   task_runner_->PostDelayedTask(FROM_HERE,
                                 base::Bind(&AsyncPolicyLoader::Reload,
                                            weak_factory_.GetWeakPtr(),
                                            false /* force */),
                                 delay);
 }
 
 bool AsyncPolicyLoader::IsSafeToReload(const Time& now, TimeDelta* delay) {
   Time last_modification = LastModificationTime();
@@ skipping 14 matching lines @@
   const TimeDelta age = now - last_modification_clock_;
   if (age < kSettleInterval) {
     *delay = kSettleInterval - age;
     return false;
   }
 
   return true;
 }
 
 }  // namespace policy