Rename TaskRunner::RunsTasksOnCurrentThread() in //ipc, //mojo

mojo/public/cpp/bindings/tests/associated_interface_unittest.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 <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 127 matching lines @@
   void CreateIntegerSender(IntegerSenderAssociatedPtrInfo* ptr_info,
                            IntegerSenderAssociatedRequest* request) {
     scoped_refptr<MultiplexRouter> router0;
     scoped_refptr<MultiplexRouter> router1;
     CreateRouterPair(&router0, &router1);
     CreateIntegerSenderWithExistingRouters(router1, ptr_info, router0, request);
   }
 
   // Okay to call from any thread.
   void QuitRunLoop(base::RunLoop* run_loop) {
-    if (main_runner_->RunsTasksOnCurrentThread()) {
+    if (main_runner_->RunsTasksInCurrentSequence()) {
       run_loop->Quit();
     } else {
       main_runner_->PostTask(
           FROM_HERE,
           base::Bind(&AssociatedInterfaceTest::QuitRunLoop,
                      base::Unretained(this), base::Unretained(run_loop)));
     }
   }
 
  private:
@@ skipping 89 matching lines @@
  public:
   TestSender()
       : task_runner_(base::CreateSequencedTaskRunnerWithTraits({})),
         next_sender_(nullptr),
         max_value_to_send_(-1) {}
 
   // The following three methods are called on the corresponding sender thread.
   void SetUp(IntegerSenderAssociatedPtrInfo ptr_info,
              TestSender* next_sender,
              int32_t max_value_to_send) {
-    CHECK(task_runner()->RunsTasksOnCurrentThread());
+    CHECK(task_runner()->RunsTasksInCurrentSequence());
 
     ptr_.Bind(std::move(ptr_info));
     next_sender_ = next_sender ? next_sender : this;
     max_value_to_send_ = max_value_to_send;
   }
 
   void Send(int32_t value) {
-    CHECK(task_runner()->RunsTasksOnCurrentThread());
+    CHECK(task_runner()->RunsTasksInCurrentSequence());
 
     if (value > max_value_to_send_)
       return;
 
     ptr_->Send(value);
 
     next_sender_->task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&TestSender::Send, base::Unretained(next_sender_), ++value));
   }
 
   void TearDown() {
-    CHECK(task_runner()->RunsTasksOnCurrentThread());
+    CHECK(task_runner()->RunsTasksInCurrentSequence());
 
     ptr_.reset();
   }
 
   base::SequencedTaskRunner* task_runner() { return task_runner_.get(); }
 
  private:
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   TestSender* next_sender_;
   int32_t max_value_to_send_;
 
   AssociatedInterfacePtr<IntegerSender> ptr_;
 };
 
 class TestReceiver {
  public:
   TestReceiver()
       : task_runner_(base::CreateSequencedTaskRunnerWithTraits({})),
         expected_calls_(0) {}
 
   void SetUp(AssociatedInterfaceRequest<IntegerSender> request0,
              AssociatedInterfaceRequest<IntegerSender> request1,
              size_t expected_calls,
              const base::Closure& notify_finish) {
-    CHECK(task_runner()->RunsTasksOnCurrentThread());
+    CHECK(task_runner()->RunsTasksInCurrentSequence());
 
     impl0_.reset(new IntegerSenderImpl(std::move(request0)));
     impl0_->set_notify_send_method_called(
         base::Bind(&TestReceiver::SendMethodCalled, base::Unretained(this)));
     impl1_.reset(new IntegerSenderImpl(std::move(request1)));
     impl1_->set_notify_send_method_called(
         base::Bind(&TestReceiver::SendMethodCalled, base::Unretained(this)));
 
     expected_calls_ = expected_calls;
     notify_finish_ = notify_finish;
   }
 
   void TearDown() {
-    CHECK(task_runner()->RunsTasksOnCurrentThread());
+    CHECK(task_runner()->RunsTasksInCurrentSequence());
 
     impl0_.reset();
     impl1_.reset();
   }
 
   base::SequencedTaskRunner* task_runner() { return task_runner_.get(); }
   const std::vector<int32_t>& values() const { return values_; }
 
  private:
   void SendMethodCalled(int32_t value) {
@@ skipping 849 matching lines @@
 
 TEST_F(AssociatedInterfaceTest, GetIsolatedInterface) {
   IntegerSenderAssociatedPtr sender;
   GetIsolatedInterface(MakeRequest(&sender).PassHandle());
   sender->Send(42);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo