Replace MessageLoop::current()->task_runner() with ThreadTaskRunnerHandle::Get().

base/message_loop/message_loop_test.cc

 // Copyright 2013 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 "base/message_loop/message_loop_test.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
+#include "base/threading/thread_task_runner_handle.h"
 
 namespace base {
 namespace test {
 
 namespace {
 
 class Foo : public RefCounted<Foo> {
  public:
   Foo() : test_count_(0) {
   }
@@ skipping 62 matching lines @@
 }
 
 }  // namespace
 
 void RunTest_PostTask(MessagePumpFactory factory) {
   std::unique_ptr<MessagePump> pump(factory());
   MessageLoop loop(std::move(pump));
   // Add tests to message loop
   scoped_refptr<Foo> foo(new Foo());
   std::string a("a"), b("b"), c("c"), d("d");
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  Bind(&Foo::Test0, foo));
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&Foo::Test1ConstRef, foo, a));
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&Foo::Test1Ptr, foo, &b));
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&Foo::Test1Int, foo, 100));
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&Foo::Test2Ptr, foo, &a, &c));
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&Foo::Test2Mixed, foo, a, &d));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, Bind(&Foo::Test0, foo));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&Foo::Test1ConstRef, foo, a));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&Foo::Test1Ptr, foo, &b));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&Foo::Test1Int, foo, 100));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&Foo::Test2Ptr, foo, &a, &c));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&Foo::Test2Mixed, foo, a, &d));
   // After all tests, post a message that will shut down the message loop
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       Bind(&MessageLoop::QuitWhenIdle, Unretained(MessageLoop::current())));
 
   // Now kick things off
   RunLoop().Run();
 
   EXPECT_EQ(foo->test_count(), 105);
   EXPECT_EQ(foo->result(), "abacad");
 }
 
@@ skipping 171 matching lines @@
       : post_on_delete_(post_on_delete), was_deleted_(was_deleted) {
   }
   void Run() {}
 
  private:
   friend class RefCounted<RecordDeletionProbe>;
 
   ~RecordDeletionProbe() {
     *was_deleted_ = true;
     if (post_on_delete_.get())
-      MessageLoop::current()->task_runner()->PostTask(
+      ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, Bind(&RecordDeletionProbe::Run, post_on_delete_));
   }
 
   scoped_refptr<RecordDeletionProbe> post_on_delete_;
   bool* was_deleted_;
 };
 
 void RunTest_EnsureDeletion(MessagePumpFactory factory) {
   bool a_was_deleted = false;
   bool b_was_deleted = false;
@@ skipping 28 matching lines @@
     loop.task_runner()->PostTask(FROM_HERE, Bind(&RecordDeletionProbe::Run, c));
   }
   EXPECT_TRUE(a_was_deleted);
   EXPECT_TRUE(b_was_deleted);
   EXPECT_TRUE(c_was_deleted);
 }
 
 void NestingFunc(int* depth) {
   if (*depth > 0) {
     *depth -= 1;
-    MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                    Bind(&NestingFunc, depth));
+    ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                            Bind(&NestingFunc, depth));
 
     MessageLoop::current()->SetNestableTasksAllowed(true);
     RunLoop().Run();
   }
   MessageLoop::current()->QuitWhenIdle();
 }
 
 void RunTest_Nesting(MessagePumpFactory factory) {
   std::unique_ptr<MessagePump> pump(factory());
   MessageLoop loop(std::move(pump));
 
   int depth = 100;
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  Bind(&NestingFunc, &depth));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&NestingFunc, &depth));
   RunLoop().Run();
   EXPECT_EQ(depth, 0);
 }
 
 // A NestingObserver that tracks the number of nested message loop starts it
 // has seen.
 class TestNestingObserver : public MessageLoop::NestingObserver {
  public:
   TestNestingObserver() {}
   ~TestNestingObserver() override {}
@@ skipping 16 matching lines @@
 // Starts a nested message loop.
 void RunNestedLoop(TestNestingObserver* observer,
                    const Closure& quit_outer_loop) {
   // The nested loop hasn't started yet.
   EXPECT_EQ(0, observer->begin_nested_loop_count());
 
   MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
   RunLoop nested_loop;
   // Verify that by the time the first task is run the observer has seen the
   // message loop begin.
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&ExpectOneBeginNestedLoop, observer));
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  nested_loop.QuitClosure());
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, nested_loop.QuitClosure());
   nested_loop.Run();
 
   // Quitting message loops doesn't change the begin count.
   EXPECT_EQ(1, observer->begin_nested_loop_count());
 
   quit_outer_loop.Run();
 }
 
 // Tests that a NestingObserver is notified when a nested message loop begins.
 void RunTest_NestingObserver(MessagePumpFactory factory) {
@@ skipping 91 matching lines @@
  private:
   std::vector<TaskItem> task_list_;
 };
 
 void RecursiveFunc(TaskList* order, int cookie, int depth,
                    bool is_reentrant) {
   order->RecordStart(RECURSIVE, cookie);
   if (depth > 0) {
     if (is_reentrant)
       MessageLoop::current()->SetNestableTasksAllowed(true);
-    MessageLoop::current()->task_runner()->PostTask(
+    ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         Bind(&RecursiveFunc, order, cookie, depth - 1, is_reentrant));
   }
   order->RecordEnd(RECURSIVE, cookie);
 }
 
 void QuitFunc(TaskList* order, int cookie) {
   order->RecordStart(QUITMESSAGELOOP, cookie);
   MessageLoop::current()->QuitWhenIdle();
   order->RecordEnd(QUITMESSAGELOOP, cookie);
 }
 void RunTest_RecursiveDenial1(MessagePumpFactory factory) {
   std::unique_ptr<MessagePump> pump(factory());
   MessageLoop loop(std::move(pump));
 
   EXPECT_TRUE(MessageLoop::current()->NestableTasksAllowed());
   TaskList order;
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&RecursiveFunc, &order, 1, 2, false));
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&RecursiveFunc, &order, 2, 2, false));
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  Bind(&QuitFunc, &order, 3));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&QuitFunc, &order, 3));
 
   RunLoop().Run();
 
   // FIFO order.
   ASSERT_EQ(14U, order.Size());
   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(2), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false));
   EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true));
@@ skipping 18 matching lines @@
   order->RecordStart(ORDERED, cookie);
   order->RecordEnd(ORDERED, cookie);
 }
 
 void RunTest_RecursiveDenial3(MessagePumpFactory factory) {
   std::unique_ptr<MessagePump> pump(factory());
   MessageLoop loop(std::move(pump));
 
   EXPECT_TRUE(MessageLoop::current()->NestableTasksAllowed());
   TaskList order;
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&RecursiveSlowFunc, &order, 1, 2, false));
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&RecursiveSlowFunc, &order, 2, 2, false));
-  MessageLoop::current()->task_runner()->PostDelayedTask(
+  ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, Bind(&OrderedFunc, &order, 3), TimeDelta::FromMilliseconds(5));
-  MessageLoop::current()->task_runner()->PostDelayedTask(
+  ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, Bind(&QuitFunc, &order, 4), TimeDelta::FromMilliseconds(5));
 
   RunLoop().Run();
 
   // FIFO order.
   ASSERT_EQ(16U, order.Size());
   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(2), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false));
   EXPECT_EQ(order.Get(4), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(5), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(6), TaskItem(ORDERED, 3, true));
   EXPECT_EQ(order.Get(7), TaskItem(ORDERED, 3, false));
   EXPECT_EQ(order.Get(8), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false));
   EXPECT_EQ(order.Get(10), TaskItem(QUITMESSAGELOOP, 4, true));
   EXPECT_EQ(order.Get(11), TaskItem(QUITMESSAGELOOP, 4, false));
   EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(14), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(15), TaskItem(RECURSIVE, 2, false));
 }
 
 void RunTest_RecursiveSupport1(MessagePumpFactory factory) {
   std::unique_ptr<MessagePump> pump(factory());
   MessageLoop loop(std::move(pump));
 
   TaskList order;
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&RecursiveFunc, &order, 1, 2, true));
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&RecursiveFunc, &order, 2, 2, true));
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  Bind(&QuitFunc, &order, 3));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&QuitFunc, &order, 3));
 
   RunLoop().Run();
 
   // FIFO order.
   ASSERT_EQ(14U, order.Size());
   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(2), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false));
   EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true));
   EXPECT_EQ(order.Get(5), TaskItem(QUITMESSAGELOOP, 3, false));
   EXPECT_EQ(order.Get(6), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(7), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(8), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false));
   EXPECT_EQ(order.Get(10), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(11), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 2, false));
 }
 
 // Tests that non nestable tasks run in FIFO if there are no nested loops.
 void RunTest_NonNestableWithNoNesting(MessagePumpFactory factory) {
   std::unique_ptr<MessagePump> pump(factory());
   MessageLoop loop(std::move(pump));
 
   TaskList order;
 
-  MessageLoop::current()->task_runner()->PostNonNestableTask(
-      FROM_HERE,
-      Bind(&OrderedFunc, &order, 1));
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE,
-      Bind(&OrderedFunc, &order, 2));
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  Bind(&QuitFunc, &order, 3));
+  ThreadTaskRunnerHandle::Get()->PostNonNestableTask(
+      FROM_HERE, Bind(&OrderedFunc, &order, 1));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&OrderedFunc, &order, 2));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&QuitFunc, &order, 3));
   RunLoop().Run();
 
   // FIFO order.
   ASSERT_EQ(6U, order.Size());
   EXPECT_EQ(order.Get(0), TaskItem(ORDERED, 1, true));
   EXPECT_EQ(order.Get(1), TaskItem(ORDERED, 1, false));
   EXPECT_EQ(order.Get(2), TaskItem(ORDERED, 2, true));
   EXPECT_EQ(order.Get(3), TaskItem(ORDERED, 2, false));
   EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true));
   EXPECT_EQ(order.Get(5), TaskItem(QUITMESSAGELOOP, 3, false));
@@ skipping 14 matching lines @@
   order->RecordEnd(SLEEP, cookie);
 }
 
 // Tests that non nestable tasks don't run when there's code in the call stack.
 void RunTest_NonNestableInNestedLoop(MessagePumpFactory factory) {
   std::unique_ptr<MessagePump> pump(factory());
   MessageLoop loop(std::move(pump));
 
   TaskList order;
 
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE,
-      Bind(&FuncThatPumps, &order, 1));
-  MessageLoop::current()->task_runner()->PostNonNestableTask(
-      FROM_HERE,
-      Bind(&OrderedFunc, &order, 2));
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE,
-      Bind(&OrderedFunc, &order, 3));
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE,
-      Bind(&SleepFunc, &order, 4, TimeDelta::FromMilliseconds(50)));
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE,
-      Bind(&OrderedFunc, &order, 5));
-  MessageLoop::current()->task_runner()->PostNonNestableTask(
-      FROM_HERE,
-      Bind(&QuitFunc, &order, 6));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&FuncThatPumps, &order, 1));
+  ThreadTaskRunnerHandle::Get()->PostNonNestableTask(
+      FROM_HERE, Bind(&OrderedFunc, &order, 2));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&OrderedFunc, &order, 3));
+  ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, Bind(&SleepFunc, &order, 4, TimeDelta::FromMilliseconds(50)));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&OrderedFunc, &order, 5));
+  ThreadTaskRunnerHandle::Get()->PostNonNestableTask(
+      FROM_HERE, Bind(&QuitFunc, &order, 6));
 
   RunLoop().Run();
 
   // FIFO order.
   ASSERT_EQ(12U, order.Size());
   EXPECT_EQ(order.Get(0), TaskItem(PUMPS, 1, true));
   EXPECT_EQ(order.Get(1), TaskItem(ORDERED, 3, true));
   EXPECT_EQ(order.Get(2), TaskItem(ORDERED, 3, false));
   EXPECT_EQ(order.Get(3), TaskItem(SLEEP, 4, true));
   EXPECT_EQ(order.Get(4), TaskItem(SLEEP, 4, false));
@@ skipping 20 matching lines @@
 }
 // Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
 void RunTest_QuitNow(MessagePumpFactory factory) {
   std::unique_ptr<MessagePump> pump(factory());
   MessageLoop loop(std::move(pump));
 
   TaskList order;
 
   RunLoop run_loop;
 
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&FuncThatRuns, &order, 1, Unretained(&run_loop)));
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&OrderedFunc, &order, 2));
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  Bind(&FuncThatQuitsNow));
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&OrderedFunc, &order, 3));
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  Bind(&FuncThatQuitsNow));
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&OrderedFunc, &order, 2));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, Bind(&FuncThatQuitsNow));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&OrderedFunc, &order, 3));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, Bind(&FuncThatQuitsNow));
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&OrderedFunc, &order, 4));  // never runs
 
   RunLoop().Run();
 
   ASSERT_EQ(6U, order.Size());
   int task_index = 0;
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, false));
   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 }
 
 // Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
 void RunTest_RunLoopQuitTop(MessagePumpFactory factory) {
   std::unique_ptr<MessagePump> pump(factory());
   MessageLoop loop(std::move(pump));
 
   TaskList order;
 
   RunLoop outer_run_loop;
   RunLoop nested_run_loop;
 
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&FuncThatRuns, &order, 1, Unretained(&nested_run_loop)));
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  outer_run_loop.QuitClosure());
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&OrderedFunc, &order, 2));
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, nested_run_loop.QuitClosure());
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          outer_run_loop.QuitClosure());
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&OrderedFunc, &order, 2));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          nested_run_loop.QuitClosure());
 
   outer_run_loop.Run();
 
   ASSERT_EQ(4U, order.Size());
   int task_index = 0;
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 }
 
 // Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
 void RunTest_RunLoopQuitNested(MessagePumpFactory factory) {
   std::unique_ptr<MessagePump> pump(factory());
   MessageLoop loop(std::move(pump));
 
   TaskList order;
 
   RunLoop outer_run_loop;
   RunLoop nested_run_loop;
 
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&FuncThatRuns, &order, 1, Unretained(&nested_run_loop)));
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, nested_run_loop.QuitClosure());
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&OrderedFunc, &order, 2));
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  outer_run_loop.QuitClosure());
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          nested_run_loop.QuitClosure());
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&OrderedFunc, &order, 2));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          outer_run_loop.QuitClosure());
 
   outer_run_loop.Run();
 
   ASSERT_EQ(4U, order.Size());
   int task_index = 0;
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 }
 
 // Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
 void RunTest_RunLoopQuitBogus(MessagePumpFactory factory) {
   std::unique_ptr<MessagePump> pump(factory());
   MessageLoop loop(std::move(pump));
 
   TaskList order;
 
   RunLoop outer_run_loop;
   RunLoop nested_run_loop;
   RunLoop bogus_run_loop;
 
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&FuncThatRuns, &order, 1, Unretained(&nested_run_loop)));
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  bogus_run_loop.QuitClosure());
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&OrderedFunc, &order, 2));
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  outer_run_loop.QuitClosure());
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, nested_run_loop.QuitClosure());
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          bogus_run_loop.QuitClosure());
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&OrderedFunc, &order, 2));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          outer_run_loop.QuitClosure());
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          nested_run_loop.QuitClosure());
 
   outer_run_loop.Run();
 
   ASSERT_EQ(4U, order.Size());
   int task_index = 0;
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 }
 
 // Tests RunLoopQuit only quits the corresponding MessageLoop::Run.
 void RunTest_RunLoopQuitDeep(MessagePumpFactory factory) {
   std::unique_ptr<MessagePump> pump(factory());
   MessageLoop loop(std::move(pump));
 
   TaskList order;
 
   RunLoop outer_run_loop;
   RunLoop nested_loop1;
   RunLoop nested_loop2;
   RunLoop nested_loop3;
   RunLoop nested_loop4;
 
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&FuncThatRuns, &order, 1, Unretained(&nested_loop1)));
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&FuncThatRuns, &order, 2, Unretained(&nested_loop2)));
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&FuncThatRuns, &order, 3, Unretained(&nested_loop3)));
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&FuncThatRuns, &order, 4, Unretained(&nested_loop4)));
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&OrderedFunc, &order, 5));
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  outer_run_loop.QuitClosure());
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&OrderedFunc, &order, 6));
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  nested_loop1.QuitClosure());
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&OrderedFunc, &order, 7));
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  nested_loop2.QuitClosure());
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&OrderedFunc, &order, 8));
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  nested_loop3.QuitClosure());
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&OrderedFunc, &order, 9));
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  nested_loop4.QuitClosure());
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&OrderedFunc, &order, 10));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&OrderedFunc, &order, 5));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          outer_run_loop.QuitClosure());
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&OrderedFunc, &order, 6));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          nested_loop1.QuitClosure());
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&OrderedFunc, &order, 7));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          nested_loop2.QuitClosure());
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&OrderedFunc, &order, 8));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          nested_loop3.QuitClosure());
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&OrderedFunc, &order, 9));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          nested_loop4.QuitClosure());
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&OrderedFunc, &order, 10));
 
   outer_run_loop.Run();
 
   ASSERT_EQ(18U, order.Size());
   int task_index = 0;
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 2, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 3, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 4, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 5, true));
@@ skipping 17 matching lines @@
 void RunTest_RunLoopQuitOrderBefore(MessagePumpFactory factory) {
   std::unique_ptr<MessagePump> pump(factory());
   MessageLoop loop(std::move(pump));
 
   TaskList order;
 
   RunLoop run_loop;
 
   run_loop.Quit();
 
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&OrderedFunc, &order, 1));  // never runs
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&FuncThatQuitsNow));  // never runs
 
   run_loop.Run();
 
   ASSERT_EQ(0U, order.Size());
 }
 
 // Tests RunLoopQuit works during RunWithID.
 void RunTest_RunLoopQuitOrderDuring(MessagePumpFactory factory) {
   std::unique_ptr<MessagePump> pump(factory());
   MessageLoop loop(std::move(pump));
 
   TaskList order;
 
   RunLoop run_loop;
 
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&OrderedFunc, &order, 1));
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  run_loop.QuitClosure());
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&OrderedFunc, &order, 1));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, run_loop.QuitClosure());
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&OrderedFunc, &order, 2));  // never runs
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&FuncThatQuitsNow));  // never runs
 
   run_loop.Run();
 
   ASSERT_EQ(2U, order.Size());
   int task_index = 0;
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 1, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 1, false));
   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 }
 
 // Tests RunLoopQuit works after RunWithID.
 void RunTest_RunLoopQuitOrderAfter(MessagePumpFactory factory) {
   std::unique_ptr<MessagePump> pump(factory());
   MessageLoop loop(std::move(pump));
 
   TaskList order;
 
   RunLoop run_loop;
 
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&FuncThatRuns, &order, 1, Unretained(&run_loop)));
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&OrderedFunc, &order, 2));
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  Bind(&FuncThatQuitsNow));
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&OrderedFunc, &order, 3));
-  MessageLoop::current()->task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&OrderedFunc, &order, 2));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, Bind(&FuncThatQuitsNow));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&OrderedFunc, &order, 3));
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, run_loop.QuitClosure());  // has no affect
-  MessageLoop::current()->task_runner()->PostTask(
-      FROM_HERE, Bind(&OrderedFunc, &order, 4));
-  MessageLoop::current()->task_runner()->PostTask(FROM_HERE,
-                                                  Bind(&FuncThatQuitsNow));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          Bind(&OrderedFunc, &order, 4));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, Bind(&FuncThatQuitsNow));
 
   RunLoop outer_run_loop;
   outer_run_loop.Run();
 
   ASSERT_EQ(8U, order.Size());
   int task_index = 0;
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, false));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 4, true));
   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 4, false));
   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
 }
 
 void PostNTasksThenQuit(int posts_remaining) {
   if (posts_remaining > 1) {
-    MessageLoop::current()->task_runner()->PostTask(
+    ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, Bind(&PostNTasksThenQuit, posts_remaining - 1));
   } else {
     MessageLoop::current()->QuitWhenIdle();
   }
 }
 
 // There was a bug in the MessagePumpGLib where posting tasks recursively
 // caused the message loop to hang, due to the buffer of the internal pipe
 // becoming full. Test all MessageLoop types to ensure this issue does not
 // exist in other MessagePumps.
 //
 // On Linux, the pipe buffer size is 64KiB by default. The bug caused one
 // byte accumulated in the pipe per two posts, so we should repeat 128K
 // times to reproduce the bug.
 void RunTest_RecursivePosts(MessagePumpFactory factory) {
   const int kNumTimes = 1 << 17;
   std::unique_ptr<MessagePump> pump(factory());
   MessageLoop loop(std::move(pump));
   loop.task_runner()->PostTask(FROM_HERE, Bind(&PostNTasksThenQuit, kNumTimes));
   RunLoop().Run();
 }
 
 }  // namespace test
 }  // namespace base