Rename TaskRunner::RunsTasksOnCurrentThread() in //media, //ui, //ipc

ipc/ipc_channel_mojo.cc

 // Copyright 2014 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 "ipc/ipc_channel_mojo.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 264 matching lines @@
     Listener* listener,
     const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner)
     : task_runner_(ipc_task_runner),
       pipe_(handle.get()),
       listener_(listener),
       weak_factory_(this) {
   bootstrap_ = MojoBootstrap::Create(std::move(handle), mode, ipc_task_runner);
 }
 
 void ChannelMojo::ForwardMessageFromThreadSafePtr(mojo::Message message) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   if (!message_reader_ || !message_reader_->sender().is_bound())
     return;
   message_reader_->sender().internal_state()->ForwardMessage(
       std::move(message));
 }
 
 void ChannelMojo::ForwardMessageWithResponderFromThreadSafePtr(
     mojo::Message message,
     std::unique_ptr<mojo::MessageReceiver> responder) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   if (!message_reader_ || !message_reader_->sender().is_bound())
     return;
   message_reader_->sender().internal_state()->ForwardMessageWithResponder(
       std::move(message), std::move(responder));
 }
 
 ChannelMojo::~ChannelMojo() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
   Close();
 }
 
 bool ChannelMojo::Connect() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
   WillConnect();
 
   mojom::ChannelAssociatedPtr sender;
   mojom::ChannelAssociatedRequest receiver;
   bootstrap_->Connect(&sender, &receiver);
 
   DCHECK(!message_reader_);
   sender->SetPeerPid(GetSelfPID());
   message_reader_.reset(new internal::MessagePipeReader(
@@ skipping 21 matching lines @@
   std::unique_ptr<internal::MessagePipeReader> reader =
       std::move(message_reader_);
   reader.reset();
 
   base::AutoLock lock(associated_interface_lock_);
   associated_interfaces_.clear();
 }
 
 void ChannelMojo::OnPipeError() {
   DCHECK(task_runner_);
-  if (task_runner_->RunsTasksOnCurrentThread()) {
+  if (task_runner_->RunsTasksInCurrentSequence()) {
     listener_->OnChannelError();
   } else {
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&ChannelMojo::OnPipeError, weak_factory_.GetWeakPtr()));
   }
 }
 
 void ChannelMojo::OnAssociatedInterfaceRequest(
     const std::string& name,
@@ skipping 122 matching lines @@
     message_reader_->GetRemoteInterface(name, std::move(handle));
   } else {
     // Attach the associated interface to a disconnected pipe, so that the
     // associated interface pointer can be used to make calls (which are
     // dropped).
     mojo::GetIsolatedInterface(std::move(handle));
   }
 }
 
 }  // namespace IPC