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

mojo/edk/system/channel_posix.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 "mojo/edk/system/channel.h"
 
 #include <errno.h>
 #include <sys/socket.h>
 
 #include <algorithm>
@@ skipping 85 matching lines @@
         io_task_runner_(io_task_runner)
 #if defined(OS_MACOSX)
         ,
         handles_to_close_(new PlatformHandleVector)
 #endif
   {
     CHECK(handle_.is_valid());
   }
 
   void Start() override {
-    if (io_task_runner_->RunsTasksOnCurrentThread()) {
+    if (io_task_runner_->RunsTasksInCurrentSequence()) {
       StartOnIOThread();
     } else {
       io_task_runner_->PostTask(
           FROM_HERE, base::Bind(&ChannelPosix::StartOnIOThread, this));
     }
   }
 
   void ShutDownImpl() override {
     // Always shut down asynchronously when called through the public interface.
     io_task_runner_->PostTask(
@@ skipping 15 matching lines @@
     }
     if (write_error) {
       // Do not synchronously invoke OnError(). Write() may have been called by
       // the delegate and we don't want to re-enter it.
       io_task_runner_->PostTask(FROM_HERE,
                                 base::Bind(&ChannelPosix::OnError, this));
     }
   }
 
   void LeakHandle() override {
-    DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
     leak_handle_ = true;
   }
 
   bool GetReadPlatformHandles(
       size_t num_handles,
       const void* extra_header,
       size_t extra_header_size,
       ScopedPlatformHandleVectorPtr* handles) override {
     if (num_handles > std::numeric_limits<uint16_t>::max())
       return false;
@@ skipping 79 matching lines @@
   void WaitForWriteOnIOThread() {
     base::AutoLock lock(write_lock_);
     WaitForWriteOnIOThreadNoLock();
   }
 
   void WaitForWriteOnIOThreadNoLock() {
     if (pending_write_)
       return;
     if (!write_watcher_)
       return;
-    if (io_task_runner_->RunsTasksOnCurrentThread()) {
+    if (io_task_runner_->RunsTasksInCurrentSequence()) {
       pending_write_ = true;
       base::MessageLoopForIO::current()->WatchFileDescriptor(
           handle_.get().handle, false /* persistent */,
           base::MessageLoopForIO::WATCH_WRITE, write_watcher_.get(), this);
     } else {
       io_task_runner_->PostTask(
           FROM_HERE, base::Bind(&ChannelPosix::WaitForWriteOnIOThread, this));
     }
   }
 
   void ShutDownOnIOThread() {
     base::MessageLoop::current()->RemoveDestructionObserver(this);
 
     read_watcher_.reset();
     write_watcher_.reset();
     if (leak_handle_)
       ignore_result(handle_.release());
     handle_.reset();
 #if defined(OS_MACOSX)
     handles_to_close_.reset();
 #endif
 
     // May destroy the |this| if it was the last reference.
     self_ = nullptr;
   }
 
   // base::MessageLoop::DestructionObserver:
   void WillDestroyCurrentMessageLoop() override {
-    DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
     if (self_)
       ShutDownOnIOThread();
   }
 
   // base::MessageLoopForIO::Watcher:
   void OnFileCanReadWithoutBlocking(int fd) override {
     CHECK_EQ(fd, handle_.get().handle);
     if (handle_.get().needs_connection) {
 #if !defined(OS_NACL)
       read_watcher_.reset();
@@ skipping 281 matching lines @@
 scoped_refptr<Channel> Channel::Create(
     Delegate* delegate,
     ConnectionParams connection_params,
     scoped_refptr<base::TaskRunner> io_task_runner) {
   return new ChannelPosix(delegate, std::move(connection_params),
                           io_task_runner);
 }
 
 }  // namespace edk
 }  // namespace mojo