Rename TaskRunner::RunsTasksOnCurrentThread() in //service, //components

services/service_manager/embedder/embedded_service_runner.cc

 // Copyright 2016 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 "services/service_manager/embedder/embedded_service_runner.h"
 
 #include <map>
 #include <memory>
 #include <utility>
 #include <vector>
@@ skipping 46 matching lines @@
         FROM_HERE,
         base::Bind(&InstanceManager::BindServiceRequestOnServiceSequence, this,
                    base::Passed(&request)));
   }
 
   void ShutDown() {
     DCHECK(runner_thread_checker_.CalledOnValidThread());
     if (!service_task_runner_)
       return;
     // Any extant ServiceContexts must be destroyed on the application thread.
-    if (service_task_runner_->RunsTasksOnCurrentThread()) {
+    if (service_task_runner_->RunsTasksInCurrentSequence()) {
       QuitOnServiceSequence();
     } else {
       service_task_runner_->PostTask(
           FROM_HERE, base::Bind(&InstanceManager::QuitOnServiceSequence, this));
     }
   }
 
  private:
   friend class base::RefCountedThreadSafe<InstanceManager>;
 
   ~InstanceManager() {
     // If this instance had its own thread, it MUST be explicitly destroyed by
     // QuitOnRunnerThread() by the time this destructor is run.
     DCHECK(!thread_);
   }
 
   void BindServiceRequestOnServiceSequence(
       service_manager::mojom::ServiceRequest request) {
-    DCHECK(service_task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(service_task_runner_->RunsTasksInCurrentSequence());
 
     int instance_id = next_instance_id_++;
 
     std::unique_ptr<service_manager::ServiceContext> context =
         base::MakeUnique<service_manager::ServiceContext>(
             factory_callback_.Run(), std::move(request));
 
     service_manager::ServiceContext* raw_context = context.get();
     context->SetQuitClosure(
         base::Bind(&InstanceManager::OnInstanceLost, this, instance_id));
     contexts_.insert(std::make_pair(raw_context, std::move(context)));
     id_to_context_map_.insert(std::make_pair(instance_id, raw_context));
   }
 
   void OnInstanceLost(int instance_id) {
-    DCHECK(service_task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(service_task_runner_->RunsTasksInCurrentSequence());
 
     auto id_iter = id_to_context_map_.find(instance_id);
     CHECK(id_iter != id_to_context_map_.end());
 
     auto context_iter = contexts_.find(id_iter->second);
     CHECK(context_iter != contexts_.end());
     contexts_.erase(context_iter);
     id_to_context_map_.erase(id_iter);
 
     // If we've lost the last instance, run the quit closure.
     if (contexts_.empty())
       QuitOnServiceSequence();
   }
 
   void QuitOnServiceSequence() {
-    DCHECK(service_task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(service_task_runner_->RunsTasksInCurrentSequence());
 
     contexts_.clear();
-    if (quit_task_runner_->RunsTasksOnCurrentThread()) {
+    if (quit_task_runner_->RunsTasksInCurrentSequence()) {
       QuitOnRunnerThread();
     } else {
       quit_task_runner_->PostTask(
           FROM_HERE, base::Bind(&InstanceManager::QuitOnRunnerThread, this));
     }
   }
 
   void QuitOnRunnerThread() {
     DCHECK(runner_thread_checker_.CalledOnValidThread());
     if (thread_) {
@@ skipping 60 matching lines @@
 void EmbeddedServiceRunner::SetQuitClosure(const base::Closure& quit_closure) {
   quit_closure_ = quit_closure;
 }
 
 void EmbeddedServiceRunner::OnQuit() {
   if (!quit_closure_.is_null())
     quit_closure_.Run();
 }
 
 }  // namespace service_manager