Rename TaskRunner::RunsTasksOnCurrentThread() in //components

components/policy/core/common/cloud/external_policy_data_updater.cc

 // Copyright (c) 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/cloud/external_policy_data_updater.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
@@ skipping 282 matching lines @@
 
 ExternalPolicyDataUpdater::ExternalPolicyDataUpdater(
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     std::unique_ptr<ExternalPolicyDataFetcher> external_policy_data_fetcher,
     size_t max_parallel_fetches)
     : task_runner_(task_runner),
       external_policy_data_fetcher_(external_policy_data_fetcher.release()),
       max_parallel_jobs_(max_parallel_fetches),
       running_jobs_(0),
       shutting_down_(false) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 }
 
 ExternalPolicyDataUpdater::~ExternalPolicyDataUpdater() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   shutting_down_ = true;
 }
 
 void ExternalPolicyDataUpdater::FetchExternalData(
     const std::string key,
     const Request& request,
     const FetchSuccessCallback& callback) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   // Check whether a job exists for this |key| already.
   FetchJob* job = job_map_[key].get();
   if (job) {
     // If the current |job| is handling the given |request| already, nothing
     // needs to be done.
     if (job->request() == request)
       return;
 
     // Otherwise, the current |job| is obsolete. If the |job| is on the queue,
     // its WeakPtr will be invalidated and skipped by StartNextJobs(). If |job|
     // is currently running, it will call OnJobFailed() immediately.
     job_map_.erase(key);
   }
 
   // Start a new job to handle |request|.
   job = new FetchJob(this, key, request, callback);
   job_map_[key] = base::WrapUnique(job);
   ScheduleJob(job);
 }
 
 void ExternalPolicyDataUpdater::CancelExternalDataFetch(
     const std::string& key) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   // If a |job| exists for this |key|, delete it. If the |job| is on the queue,
   // its WeakPtr will be invalidated and skipped by StartNextJobs(). If |job| is
   // currently running, it will call OnJobFailed() immediately.
   auto job = job_map_.find(key);
   if (job != job_map_.end())
     job_map_.erase(job);
 }
 
 void ExternalPolicyDataUpdater::StartNextJobs() {
@@ skipping 37 matching lines @@
 
   // Don't touch job_map_; deletion of FetchJobs cause a call to this method, so
   // job_map_ is possibly in an inconsistent state.
 
   // The job is not deleted when it fails because a retry attempt may have been
   // scheduled.
   StartNextJobs();
 }
 
 }  // namespace policy