Rename TaskRunner::RunsTasksOnCurrentThread() in //chrome

chrome/browser/policy/cloud/test_request_interceptor.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 "chrome/browser/policy/cloud/test_request_interceptor.h"
 
 #include <limits>
 #include <memory>
 #include <queue>
 #include <utility>
@@ skipping 191 matching lines @@
 TestRequestInterceptor::Delegate::Delegate(
     const std::string& hostname,
     scoped_refptr<base::SequencedTaskRunner> io_task_runner)
     : hostname_(hostname), io_task_runner_(io_task_runner) {}
 
 TestRequestInterceptor::Delegate::~Delegate() {}
 
 net::URLRequestJob* TestRequestInterceptor::Delegate::MaybeInterceptRequest(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate) const {
-  CHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  CHECK(io_task_runner_->RunsTasksInCurrentSequence());
 
   if (request->url().host_piece() != hostname_) {
     // Reject requests to other servers.
     return ErrorJobCallback(
         net::ERR_CONNECTION_REFUSED, request, network_delegate);
   }
 
   if (pending_job_callbacks_.empty()) {
     // Reject dmserver requests by default.
     return BadRequestJobCallback(request, network_delegate);
@@ skipping 10 matching lines @@
                                   base::Passed(&callbacks)));
   }
 
   JobCallback callback = pending_job_callbacks_.front();
   pending_job_callbacks_.pop();
   return callback.Run(request, network_delegate);
 }
 
 void TestRequestInterceptor::Delegate::GetPendingSize(
     size_t* pending_size) const {
-  CHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  CHECK(io_task_runner_->RunsTasksInCurrentSequence());
   *pending_size = pending_job_callbacks_.size();
 }
 
 void TestRequestInterceptor::Delegate::AddRequestServicedCallback(
     const base::Closure& callback) {
-  CHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  CHECK(io_task_runner_->RunsTasksInCurrentSequence());
   request_serviced_callbacks_.push_back(callback);
 }
 
 void TestRequestInterceptor::Delegate::PushJobCallback(
     const JobCallback& callback) {
-  CHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  CHECK(io_task_runner_->RunsTasksInCurrentSequence());
   pending_job_callbacks_.push(callback);
 }
 
 // static
 void TestRequestInterceptor::Delegate::InvokeRequestServicedCallbacks(
     std::unique_ptr<std::vector<base::Closure>> callbacks) {
   for (const auto& p : *callbacks)
     p.Run();
 }
 
@@ skipping 75 matching lines @@
   io_task_runner_->PostTask(FROM_HERE, task);
   base::RunLoop run_loop;
   io_task_runner_->PostTask(
       FROM_HERE, base::BindOnce(base::IgnoreResult(&base::TaskRunner::PostTask),
                                 base::ThreadTaskRunnerHandle::Get(), FROM_HERE,
                                 run_loop.QuitClosure()));
   run_loop.Run();
 }
 
 }  // namespace policy