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

mojo/public/cpp/bindings/thread_safe_interface_ptr.h

 // 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.
 
 #ifndef MOJO_PUBLIC_CPP_BINDINGS_THREAD_SAFE_INTERFACE_PTR_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_THREAD_SAFE_INTERFACE_PTR_H_
 
 #include <memory>
 
 #include "base/macros.h"
@@ skipping 99 matching lines @@
           base::MakeUnique<ForwardToCallingThread>(std::move(responder));
       task_runner_->PostTask(
           FROM_HERE, base::Bind(forward_with_responder_, base::Passed(message),
                                 base::Passed(&reply_forwarder)));
       return true;
     }
 
     SyncCallRestrictions::AssertSyncCallAllowed();
 
     // If the InterfacePtr is bound to this thread, dispatch it directly.
-    if (task_runner_->RunsTasksOnCurrentThread()) {
+    if (task_runner_->RunsTasksInCurrentSequence()) {
       forward_with_responder_.Run(std::move(*message), std::move(responder));
       return true;
     }
 
     // If the InterfacePtr is bound on another thread, post the call.
     // TODO(yzshen, watk): We block both this thread and the InterfacePtr
     // thread. Ideally only this thread would block.
     auto response = make_scoped_refptr(new SyncResponseInfo());
     auto response_signaler = base::MakeUnique<SyncResponseSignaler>(response);
     task_runner_->PostTask(
@@ skipping 197 matching lines @@
           base::Bind(&PtrWrapper::AcceptWithResponder, this),
           associated_group_);
     }
 
    private:
     friend struct PtrWrapperDeleter;
 
     ~PtrWrapper() {}
 
     void Bind(PtrInfoType ptr_info) {
-      DCHECK(task_runner_->RunsTasksOnCurrentThread());
+      DCHECK(task_runner_->RunsTasksInCurrentSequence());
       ptr_.Bind(std::move(ptr_info));
     }
 
     void Accept(Message message) {
       ptr_.internal_state()->ForwardMessage(std::move(message));
     }
 
     void AcceptWithResponder(Message message,
                              std::unique_ptr<MessageReceiver> responder) {
       ptr_.internal_state()->ForwardMessageWithResponder(std::move(message),
                                                          std::move(responder));
     }
 
     void DeleteOnCorrectThread() const {
-      if (!task_runner_->RunsTasksOnCurrentThread()) {
+      if (!task_runner_->RunsTasksInCurrentSequence()) {
         // NOTE: This is only called when there are no more references to
         // |this|, so binding it unretained is both safe and necessary.
         task_runner_->PostTask(FROM_HERE,
                                base::Bind(&PtrWrapper::DeleteOnCorrectThread,
                                           base::Unretained(this)));
       } else {
         delete this;
       }
     }
 
@@ skipping 21 matching lines @@
 using ThreadSafeAssociatedInterfacePtr =
     ThreadSafeInterfacePtrBase<AssociatedInterfacePtr<Interface>>;
 
 template <typename Interface>
 using ThreadSafeInterfacePtr =
     ThreadSafeInterfacePtrBase<InterfacePtr<Interface>>;
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_THREAD_SAFE_INTERFACE_PTR_H_