Revert of base: Remove use of MessageLoopProxy

base/task/cancelable_task_tracker_unittest.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 "base/task/cancelable_task_tracker.h"
 
 #include <cstddef>
 #include <deque>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
+#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
-#include "base/single_thread_task_runner.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 namespace {
 
 class CancelableTaskTrackerTest : public testing::Test {
  protected:
@@ skipping 49 matching lines @@
 
 }  // namespace
 
 // With the task tracker, post a task, a task with a reply, and get a
 // new task id without canceling any of them.  The tasks and the reply
 // should run and the "is canceled" callback should return false.
 TEST_F(CancelableTaskTrackerTest, NoCancel) {
   Thread worker_thread("worker thread");
   ASSERT_TRUE(worker_thread.Start());
 
-  ignore_result(task_tracker_.PostTask(worker_thread.task_runner().get(),
+  ignore_result(task_tracker_.PostTask(worker_thread.message_loop_proxy().get(),
                                        FROM_HERE,
                                        MakeExpectedRunClosure(FROM_HERE)));
 
-  ignore_result(task_tracker_.PostTaskAndReply(
-      worker_thread.task_runner().get(), FROM_HERE,
-      MakeExpectedRunClosure(FROM_HERE), MakeExpectedRunClosure(FROM_HERE)));
+  ignore_result(
+      task_tracker_.PostTaskAndReply(worker_thread.message_loop_proxy().get(),
+                                     FROM_HERE,
+                                     MakeExpectedRunClosure(FROM_HERE),
+                                     MakeExpectedRunClosure(FROM_HERE)));
 
   CancelableTaskTracker::IsCanceledCallback is_canceled;
   ignore_result(task_tracker_.NewTrackedTaskId(&is_canceled));
 
   worker_thread.Stop();
 
   RunCurrentLoopUntilIdle();
 
   EXPECT_FALSE(is_canceled.Run());
 }
@@ skipping 53 matching lines @@
   task_tracker_.TryCancel(task_id);
 }
 
 // Post a task with reply with the task tracker on a worker thread and
 // cancel it before running the current message loop.  The task should
 // run but the reply should not.
 TEST_F(CancelableTaskTrackerTest, CancelReplyDifferentThread) {
   Thread worker_thread("worker thread");
   ASSERT_TRUE(worker_thread.Start());
 
-  CancelableTaskTracker::TaskId task_id = task_tracker_.PostTaskAndReply(
-      worker_thread.task_runner().get(), FROM_HERE, Bind(&DoNothing),
-      MakeExpectedNotRunClosure(FROM_HERE));
+  CancelableTaskTracker::TaskId task_id =
+      task_tracker_.PostTaskAndReply(worker_thread.message_loop_proxy().get(),
+                                     FROM_HERE,
+                                     Bind(&DoNothing),
+                                     MakeExpectedNotRunClosure(FROM_HERE));
   EXPECT_NE(CancelableTaskTracker::kBadTaskId, task_id);
 
   task_tracker_.TryCancel(task_id);
 
   worker_thread.Stop();
 }
 
 void ExpectIsCanceled(
     const CancelableTaskTracker::IsCanceledCallback& is_canceled,
     bool expected_is_canceled) {
   EXPECT_EQ(expected_is_canceled, is_canceled.Run());
 }
 
 // Create a new task ID and check its status on a separate thread
 // before and after canceling.  The is-canceled callback should be
 // thread-safe (i.e., nothing should blow up).
 TEST_F(CancelableTaskTrackerTest, NewTrackedTaskIdDifferentThread) {
   CancelableTaskTracker::IsCanceledCallback is_canceled;
   CancelableTaskTracker::TaskId task_id =
       task_tracker_.NewTrackedTaskId(&is_canceled);
 
   EXPECT_FALSE(is_canceled.Run());
 
   Thread other_thread("other thread");
   ASSERT_TRUE(other_thread.Start());
-  other_thread.task_runner()->PostTask(
+  other_thread.message_loop_proxy()->PostTask(
       FROM_HERE, Bind(&ExpectIsCanceled, is_canceled, false));
   other_thread.Stop();
 
   task_tracker_.TryCancel(task_id);
 
   ASSERT_TRUE(other_thread.Start());
-  other_thread.task_runner()->PostTask(
+  other_thread.message_loop_proxy()->PostTask(
       FROM_HERE, Bind(&ExpectIsCanceled, is_canceled, true));
   other_thread.Stop();
 }
 
 // With the task tracker, post a task, a task with a reply, get a new
 // task id, and then cancel all of them.  None of the tasks nor the
 // reply should run and the "is canceled" callback should return
 // true.
 TEST_F(CancelableTaskTrackerTest, CancelAll) {
   scoped_refptr<TestSimpleTaskRunner> test_task_runner(
@@ skipping 154 matching lines @@
   ignore_result(task_tracker->PostTask(
       scoped_refptr<TestSimpleTaskRunner>(new TestSimpleTaskRunner()).get(),
       FROM_HERE,
       Bind(&DoNothing)));
 }
 
 TEST_F(CancelableTaskTrackerDeathTest, PostFromDifferentThread) {
   Thread bad_thread("bad thread");
   ASSERT_TRUE(bad_thread.Start());
 
-  bad_thread.task_runner()->PostTask(
-      FROM_HERE, Bind(&MaybeRunDeadlyTaskTrackerMemberFunction,
-                      Unretained(&task_tracker_), Bind(&PostDoNothingTask)));
+  bad_thread.message_loop_proxy()->PostTask(
+      FROM_HERE,
+      Bind(&MaybeRunDeadlyTaskTrackerMemberFunction,
+           Unretained(&task_tracker_),
+           Bind(&PostDoNothingTask)));
 }
 
 void TryCancel(CancelableTaskTracker::TaskId task_id,
                CancelableTaskTracker* task_tracker) {
   task_tracker->TryCancel(task_id);
 }
 
 TEST_F(CancelableTaskTrackerDeathTest, CancelOnDifferentThread) {
   scoped_refptr<TestSimpleTaskRunner> test_task_runner(
       new TestSimpleTaskRunner());
 
   Thread bad_thread("bad thread");
   ASSERT_TRUE(bad_thread.Start());
 
   CancelableTaskTracker::TaskId task_id = task_tracker_.PostTask(
       test_task_runner.get(), FROM_HERE, Bind(&DoNothing));
   EXPECT_NE(CancelableTaskTracker::kBadTaskId, task_id);
 
-  bad_thread.task_runner()->PostTask(
-      FROM_HERE, Bind(&MaybeRunDeadlyTaskTrackerMemberFunction,
-                      Unretained(&task_tracker_), Bind(&TryCancel, task_id)));
+  bad_thread.message_loop_proxy()->PostTask(
+      FROM_HERE,
+      Bind(&MaybeRunDeadlyTaskTrackerMemberFunction,
+           Unretained(&task_tracker_),
+           Bind(&TryCancel, task_id)));
 
   test_task_runner->RunUntilIdle();
 }
 
 TEST_F(CancelableTaskTrackerDeathTest, CancelAllOnDifferentThread) {
   scoped_refptr<TestSimpleTaskRunner> test_task_runner(
       new TestSimpleTaskRunner());
 
   Thread bad_thread("bad thread");
   ASSERT_TRUE(bad_thread.Start());
 
   CancelableTaskTracker::TaskId task_id = task_tracker_.PostTask(
       test_task_runner.get(), FROM_HERE, Bind(&DoNothing));
   EXPECT_NE(CancelableTaskTracker::kBadTaskId, task_id);
 
-  bad_thread.task_runner()->PostTask(
+  bad_thread.message_loop_proxy()->PostTask(
       FROM_HERE,
-      Bind(&MaybeRunDeadlyTaskTrackerMemberFunction, Unretained(&task_tracker_),
+      Bind(&MaybeRunDeadlyTaskTrackerMemberFunction,
+           Unretained(&task_tracker_),
            Bind(&CancelableTaskTracker::TryCancelAll)));
 
   test_task_runner->RunUntilIdle();
 }
 
 }  // namespace base