Rename TaskRunner::RunsTasksOnCurrentThread() in //extensions, //headless, //mojo

mojo/public/cpp/bindings/lib/interface_endpoint_client.cc

 // Copyright 2015 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 "mojo/public/cpp/bindings/interface_endpoint_client.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 34 matching lines @@
       : endpoint_client_(endpoint_client),
         accept_was_invoked_(false),
         task_runner_(std::move(runner)) {}
   ~ResponderThunk() override {
     if (!accept_was_invoked_) {
       // The Service handled a message that was expecting a response
       // but did not send a response.
       // We raise an error to signal the calling application that an error
       // condition occurred. Without this the calling application would have no
       // way of knowing it should stop waiting for a response.
-      if (task_runner_->RunsTasksOnCurrentThread()) {
+      if (task_runner_->RunsTasksInCurrentSequence()) {
         // Please note that even if this code is run from a different task
         // runner on the same thread as |task_runner_|, it is okay to directly
         // call InterfaceEndpointClient::RaiseError(), because it will raise
         // error from the correct task runner asynchronously.
         if (endpoint_client_) {
           endpoint_client_->RaiseError();
         }
       } else {
         task_runner_->PostTask(
             FROM_HERE,
             base::Bind(&InterfaceEndpointClient::RaiseError, endpoint_client_));
       }
     }
   }
 
   // MessageReceiver implementation:
   bool Accept(Message* message) override {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     accept_was_invoked_ = true;
     DCHECK(message->has_flag(Message::kFlagIsResponse));
 
     bool result = false;
 
     if (endpoint_client_)
       result = endpoint_client_->Accept(message);
 
     return result;
   }
 
   // MessageReceiverWithStatus implementation:
   bool IsValid() override {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     return endpoint_client_ && !endpoint_client_->encountered_error();
   }
 
   void DCheckInvalid(const std::string& message) override {
-    if (task_runner_->RunsTasksOnCurrentThread()) {
+    if (task_runner_->RunsTasksInCurrentSequence()) {
       DCheckIfInvalid(endpoint_client_, message);
     } else {
       task_runner_->PostTask(
           FROM_HERE, base::Bind(&DCheckIfInvalid, endpoint_client_, message));
     }
  }
 
  private:
   base::WeakPtr<InterfaceEndpointClient> endpoint_client_;
   bool accept_was_invoked_;
@@ skipping 300 matching lines @@
     return responder->Accept(message);
   } else {
     if (mojo::internal::ControlMessageHandler::IsControlMessage(message))
       return control_message_handler_.Accept(message);
 
     return incoming_receiver_->Accept(message);
   }
 }
 
 }  // namespace mojo