Rename TaskRunner::RunsTasksOnCurrentThread() in //components

components/policy/core/common/cloud/external_policy_data_fetcher.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/cloud/external_policy_data_fetcher.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 70 matching lines @@
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     scoped_refptr<base::SequencedTaskRunner> io_task_runner,
     const base::WeakPtr<ExternalPolicyDataFetcherBackend>& backend)
     : task_runner_(task_runner),
       io_task_runner_(io_task_runner),
       backend_(backend),
       weak_factory_(this) {
 }
 
 ExternalPolicyDataFetcher::~ExternalPolicyDataFetcher() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   for (JobSet::iterator it = jobs_.begin(); it != jobs_.end(); ++it)
     CancelJob(*it);
 }
 
 ExternalPolicyDataFetcher::Job* ExternalPolicyDataFetcher::StartJob(
     const GURL& url,
     int64_t max_size,
     const FetchCallback& callback) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   Job* job = new Job(
       url, max_size,
       base::Bind(&ForwardJobFinished,
                  task_runner_,
                  base::Bind(&ExternalPolicyDataFetcher::OnJobFinished,
                             weak_factory_.GetWeakPtr(),
                             callback)));
   jobs_.insert(job);
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ExternalPolicyDataFetcherBackend::StartJob, backend_, job));
   return job;
 }
 
 void ExternalPolicyDataFetcher::CancelJob(Job* job) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(jobs_.find(job) != jobs_.end());
   jobs_.erase(job);
   // Post a task that will cancel the |job| in the |backend_|. The |job| is
   // removed from |jobs_| immediately to indicate that it has been canceled but
   // is not actually deleted until the cancelation has reached the |backend_|
   // and a confirmation has been posted back. This ensures that no new job can
   // be allocated at the same address while an OnJobFinished() callback may
   // still be pending for the canceled |job|.
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ExternalPolicyDataFetcherBackend::CancelJob,
                  backend_,
                  job,
                  base::Bind(&ForwardJobCanceled,
                             task_runner_,
                             base::Bind(&DoNothing, base::Owned(job)))));
 }
 
 void ExternalPolicyDataFetcher::OnJobFinished(
     const FetchCallback& callback,
     Job* job,
     Result result,
     std::unique_ptr<std::string> data) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   JobSet::iterator it = jobs_.find(job);
   if (it == jobs_.end()) {
     // The |job| has been canceled and removed from |jobs_| already. This can
     // happen because the |backend_| runs on a different thread and a |job| may
     // finish before the cancellation has reached that thread.
     return;
   }
   callback.Run(result, std::move(data));
   jobs_.erase(it);
   delete job;
 }
 
 struct ExternalPolicyDataFetcherBackend::FetcherAndJob {
   std::unique_ptr<net::URLFetcher> fetcher;
   ExternalPolicyDataFetcher::Job* job;
 };
 
 ExternalPolicyDataFetcherBackend::ExternalPolicyDataFetcherBackend(
     scoped_refptr<base::SequencedTaskRunner> io_task_runner,
     scoped_refptr<net::URLRequestContextGetter> request_context)
     : io_task_runner_(io_task_runner),
       request_context_(request_context),
       last_fetch_id_(-1),
       weak_factory_(this) {
 }
 
 ExternalPolicyDataFetcherBackend::~ExternalPolicyDataFetcherBackend() {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
 }
 
 std::unique_ptr<ExternalPolicyDataFetcher>
 ExternalPolicyDataFetcherBackend::CreateFrontend(
     scoped_refptr<base::SequencedTaskRunner> task_runner) {
   return base::MakeUnique<ExternalPolicyDataFetcher>(
       task_runner, io_task_runner_, weak_factory_.GetWeakPtr());
 }
 
 void ExternalPolicyDataFetcherBackend::StartJob(
     ExternalPolicyDataFetcher::Job* job) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   net::NetworkTrafficAnnotationTag traffic_annotation =
       net::DefineNetworkTrafficAnnotation("external_policy_fetcher", R"(
         semantics {
           sender: "Cloud Policy"
           description:
             "Used to fetch policy for extensions, policy-controlled wallpaper, "
             "and custom terms of service."
           trigger:
             "Periodically loaded when a managed user is signed in to Chrome."
           data:
@@ skipping 22 matching lines @@
                         net::LOAD_DO_NOT_SEND_COOKIES |
                         net::LOAD_DO_NOT_SEND_AUTH_DATA);
   fetcher->SetAutomaticallyRetryOnNetworkChanges(3);
   fetcher->Start();
   job_map_[fetcher] = {std::move(owned_fetcher), job};
 }
 
 void ExternalPolicyDataFetcherBackend::CancelJob(
     ExternalPolicyDataFetcher::Job* job,
     const base::Closure& callback) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   for (auto it = job_map_.begin(); it != job_map_.end();) {
     if (it->second.job == job) {
       job_map_.erase(it++);
     } else {
       ++it;
     }
   }
   callback.Run();
 }
 
 void ExternalPolicyDataFetcherBackend::OnURLFetchComplete(
     const net::URLFetcher* source) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   auto it = job_map_.find(const_cast<net::URLFetcher*>(source));
   if (it == job_map_.end()) {
     NOTREACHED();
     return;
   }
 
   ExternalPolicyDataFetcher::Result result = ExternalPolicyDataFetcher::SUCCESS;
   std::unique_ptr<std::string> data;
 
   const net::URLRequestStatus status = it->first->GetStatus();
@@ skipping 26 matching lines @@
   ExternalPolicyDataFetcher::Job* job = it->second.job;
   job_map_.erase(it);
   job->callback.Run(job, result, std::move(data));
 }
 
 void ExternalPolicyDataFetcherBackend::OnURLFetchDownloadProgress(
     const net::URLFetcher* source,
     int64_t current,
     int64_t total,
     int64_t current_network_bytes) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   auto it = job_map_.find(source);
   DCHECK(it != job_map_.end());
   if (it == job_map_.end())
     return;
 
   // Reject the data if it exceeds the size limit. The content length is in
   // |total|, and it may be -1 when not known.
   ExternalPolicyDataFetcher::Job* job = it->second.job;
   int64_t max_size = job->max_size;
   if (current > max_size || total > max_size) {
     job_map_.erase(it);
     job->callback.Run(job, ExternalPolicyDataFetcher::MAX_SIZE_EXCEEDED,
                       std::unique_ptr<std::string>());
   }
 }
 
 }  // namespace policy