Remove remaining calls to deprecated MessageLoop methods on Mac.

components/scheduler/base/task_queue_manager_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 "components/scheduler/base/task_queue_manager.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 135 matching lines @@
   for (size_t i = 0; i < 3; i++)
     runners_.push_back(manager_->NewTaskQueue(TaskQueue::Spec("test_queue")));
 
   runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
   runners_[1]->PostTask(FROM_HERE, base::Bind(&NopTask));
   runners_[1]->PostTask(FROM_HERE, base::Bind(&NopTask));
   runners_[2]->PostTask(FROM_HERE, base::Bind(&NopTask));
   runners_[2]->PostTask(FROM_HERE, base::Bind(&NopTask));
 
-  message_loop_->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   // We need to call Now for the beginning of the first task, and then the end
   // of every task after. We reuse the end time of one task for the start time
   // of the next task. In this case, there were 6 tasks, so we expect 7 calls to
   // Now.
   EXPECT_EQ(7, test_count_uses_time_source->now_calls_count());
 }
 
 TEST_F(TaskQueueManagerTest,
        NowNotCalledForNestedTasks) {
   message_loop_.reset(new base::MessageLoop());
@@ skipping 14 matching lines @@
   for (int i = 0; i <= 6; ++i) {
     tasks_to_post_from_nested_loop.push_back(
         std::make_pair(base::Bind(&NopTask), true));
   }
 
   runners_[0]->PostTask(
       FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(),
                             base::RetainedRef(runners_[0]),
                             base::Unretained(&tasks_to_post_from_nested_loop)));
 
-  message_loop_->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   // We need to call Now twice, to measure the start and end of the outermost
   // task. We shouldn't call it for any of the nested tasks.
   EXPECT_EQ(2, test_count_uses_time_source->now_calls_count());
 }
 
 void NullTask() {}
 
 void TestTask(EnqueueOrder value, std::vector<EnqueueOrder>* out_result) {
   out_result->push_back(value);
 }
@@ skipping 25 matching lines @@
   EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4, 5, 6));
 }
 
 TEST_F(TaskQueueManagerTest, NonNestableTaskPosting) {
   InitializeWithRealMessageLoop(1u);
 
   std::vector<EnqueueOrder> run_order;
   runners_[0]->PostNonNestableTask(FROM_HERE,
                                    base::Bind(&TestTask, 1, &run_order));
 
-  message_loop_->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 TEST_F(TaskQueueManagerTest, NonNestableTaskExecutesInExpectedOrder) {
   InitializeWithRealMessageLoop(1u);
 
   std::vector<EnqueueOrder> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order));
   runners_[0]->PostNonNestableTask(FROM_HERE,
                                    base::Bind(&TestTask, 5, &run_order));
 
-  message_loop_->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4, 5));
 }
 
 TEST_F(TaskQueueManagerTest, NonNestableTaskDoesntExecuteInNestedLoop) {
   InitializeWithRealMessageLoop(1u);
 
   std::vector<EnqueueOrder> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 
   std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop;
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 3, &run_order), false));
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 4, &run_order), true));
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 5, &run_order), true));
 
   runners_[0]->PostTask(
       FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(),
                             base::RetainedRef(runners_[0]),
                             base::Unretained(&tasks_to_post_from_nested_loop)));
 
-  message_loop_->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   // Note we expect task 3 to run last because it's non-nestable.
   EXPECT_THAT(run_order, ElementsAre(1, 2, 4, 5, 3));
 }
 
 TEST_F(TaskQueueManagerTest, QueuePolling) {
   Initialize(1u);
 
   std::vector<EnqueueOrder> run_order;
   EXPECT_FALSE(runners_[0]->HasPendingImmediateWork());
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
@@ skipping 348 matching lines @@
 TEST_F(TaskQueueManagerTest, PostFromThread) {
   InitializeWithRealMessageLoop(1u);
 
   std::vector<EnqueueOrder> run_order;
   base::Thread thread("TestThread");
   thread.Start();
   thread.task_runner()->PostTask(
       FROM_HERE, base::Bind(&PostTaskToRunner, runners_[0], &run_order));
   thread.Stop();
 
-  message_loop_->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 void RePostingTestTask(scoped_refptr<base::SingleThreadTaskRunner> runner,
                        int* run_count) {
   (*run_count)++;
   runner->PostTask(FROM_HERE, Bind(&RePostingTestTask,
                                    base::Unretained(runner.get()), run_count));
 }
 
@@ skipping 19 matching lines @@
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 1, &run_order), true));
 
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 0, &run_order));
   runners_[0]->PostTask(
       FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(),
                             base::RetainedRef(runners_[0]),
                             base::Unretained(&tasks_to_post_from_nested_loop)));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 
-  message_loop_->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(run_order, ElementsAre(0, 2, 1));
 }
 
 TEST_F(TaskQueueManagerTest, WorkBatching) {
   Initialize(1u);
 
   manager_->SetWorkBatchSize(2);
 
   std::vector<EnqueueOrder> run_order;
@@ skipping 169 matching lines @@
 
   manager_->SetWorkBatchSize(2);
   manager_->AddTaskObserver(&observer);
 
   std::vector<EnqueueOrder> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 
   EXPECT_CALL(observer, WillProcessTask(_)).Times(2);
   EXPECT_CALL(observer, DidProcessTask(_)).Times(2);
-  message_loop_->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(TaskQueueManagerTest, TaskObserverRemoving) {
   InitializeWithRealMessageLoop(1u);
   MockTaskObserver observer;
   manager_->SetWorkBatchSize(2);
   manager_->AddTaskObserver(&observer);
   manager_->RemoveTaskObserver(&observer);
 
   std::vector<EnqueueOrder> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 
   EXPECT_CALL(observer, WillProcessTask(_)).Times(0);
   EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
 
-  message_loop_->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 void RemoveObserverTask(TaskQueueManager* manager,
                         base::MessageLoop::TaskObserver* observer) {
   manager->RemoveTaskObserver(observer);
 }
 
 TEST_F(TaskQueueManagerTest, TaskObserverRemovingInsideTask) {
   InitializeWithRealMessageLoop(1u);
   MockTaskObserver observer;
   manager_->SetWorkBatchSize(3);
   manager_->AddTaskObserver(&observer);
 
   runners_[0]->PostTask(
       FROM_HERE, base::Bind(&RemoveObserverTask, manager_.get(), &observer));
 
   EXPECT_CALL(observer, WillProcessTask(_)).Times(1);
   EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
-  message_loop_->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(TaskQueueManagerTest, QueueTaskObserverAdding) {
   InitializeWithRealMessageLoop(2u);
   MockTaskObserver observer;
 
   manager_->SetWorkBatchSize(2);
   runners_[0]->AddTaskObserver(&observer);
 
   std::vector<EnqueueOrder> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 
   EXPECT_CALL(observer, WillProcessTask(_)).Times(1);
   EXPECT_CALL(observer, DidProcessTask(_)).Times(1);
-  message_loop_->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(TaskQueueManagerTest, QueueTaskObserverRemoving) {
   InitializeWithRealMessageLoop(1u);
   MockTaskObserver observer;
   manager_->SetWorkBatchSize(2);
   runners_[0]->AddTaskObserver(&observer);
   runners_[0]->RemoveTaskObserver(&observer);
 
   std::vector<EnqueueOrder> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
 
   EXPECT_CALL(observer, WillProcessTask(_)).Times(0);
   EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
 
-  message_loop_->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 void RemoveQueueObserverTask(scoped_refptr<TaskQueue> queue,
                              base::MessageLoop::TaskObserver* observer) {
   queue->RemoveTaskObserver(observer);
 }
 
 TEST_F(TaskQueueManagerTest, QueueTaskObserverRemovingInsideTask) {
   InitializeWithRealMessageLoop(1u);
   MockTaskObserver observer;
   runners_[0]->AddTaskObserver(&observer);
 
   runners_[0]->PostTask(
       FROM_HERE, base::Bind(&RemoveQueueObserverTask, runners_[0], &observer));
 
   EXPECT_CALL(observer, WillProcessTask(_)).Times(1);
   EXPECT_CALL(observer, DidProcessTask(_)).Times(0);
-  message_loop_->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(TaskQueueManagerTest, ThreadCheckAfterTermination) {
   Initialize(1u);
   EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread());
   manager_.reset();
   EXPECT_TRUE(runners_[0]->RunsTasksOnCurrentThread());
 }
 
 TEST_F(TaskQueueManagerTest, TimeDomain_NextScheduledRunTime) {
@@ skipping 283 matching lines @@
   InitializeWithRealMessageLoop(1u);
   manager_->SetWorkBatchSize(2);
 
   bool was_nested = true;
   base::RunLoop run_loop;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&PostAndQuitFromNestedRunloop,
                                               base::Unretained(&run_loop),
                                               base::RetainedRef(runners_[0]),
                                               base::Unretained(&was_nested)));
 
-  message_loop_->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(was_nested);
 }
 
 class SequenceNumberCapturingTaskObserver
     : public base::MessageLoop::TaskObserver {
  public:
   // MessageLoop::TaskObserver overrides.
   void WillProcessTask(const base::PendingTask& pending_task) override {}
   void DidProcessTask(const base::PendingTask& pending_task) override {
     sequence_numbers_.push_back(pending_task.sequence_num);
@@ skipping 139 matching lines @@
   // nested run loop does not trigger the pumping of an on-wakeup queue.
   InitializeWithRealMessageLoop(2u);
   runners_[1]->SetPumpPolicy(TaskQueue::PumpPolicy::AFTER_WAKEUP);
 
   std::vector<EnqueueOrder> run_order;
   runners_[0]->PostTask(
       FROM_HERE,
       base::Bind(&PostTestTasksFromNestedMessageLoop, message_loop_.get(),
                  runners_[0], runners_[1], base::Unretained(&run_order)));
 
-  message_loop_->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   ASSERT_THAT(run_order, ElementsAre(1));
 }
 
 namespace {
 
 class MockObserver : public TaskQueueManager::Observer {
  public:
   MOCK_METHOD1(OnUnregisterTaskQueue,
                void(const scoped_refptr<TaskQueue>& queue));
   MOCK_METHOD2(OnTriedToExecuteBlockedTask,
@@ skipping 77 matching lines @@
       base::Bind(&internal::TaskQueueImpl::UnregisterTaskQueue,
                  base::Unretained(task_queue.get())), true));
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&HasOneRefTask, base::Unretained(&log),
                                 base::Unretained(task_queue.get())),
                      true));
   runners_[0]->PostTask(
       FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(),
                             base::RetainedRef(runners_[0]),
                             base::Unretained(&tasks_to_post_from_nested_loop)));
-  message_loop_->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Add a final call to HasOneRefTask.  This gives the manager a chance to
   // release its reference, and checks that it has.
   runners_[0]->PostTask(FROM_HERE,
                         base::Bind(&HasOneRefTask, base::Unretained(&log),
                                    base::Unretained(task_queue.get())));
-  message_loop_->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(log, ElementsAre(false, false, true));
 }
 
 TEST_F(TaskQueueManagerTest, TimeDomainsAreIndependant) {
   Initialize(2u);
 
   base::TimeTicks start_time = manager_->delegate()->NowTicks();
   std::unique_ptr<VirtualTimeDomain> domain_a(
       new VirtualTimeDomain(nullptr, start_time));
@@ skipping 350 matching lines @@
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&CurrentlyExecutingTaskQueueTestTask,
                                 manager_.get(), &task_sources),
                      queue2));
 
   queue0->PostTask(
       FROM_HERE, base::Bind(&RunloopCurrentlyExecutingTaskQueueTestTask,
                             message_loop_.get(), manager_.get(), &task_sources,
                             &tasks_to_post_from_nested_loop));
 
-  message_loop_->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_THAT(task_sources, ElementsAre(queue0, queue1, queue2, queue0));
   EXPECT_EQ(nullptr, manager_->currently_executing_task_queue());
 }
 
 void OnTraceDataCollected(base::Closure quit_closure,
                           base::trace_event::TraceResultBuffer* buffer,
                           const scoped_refptr<base::RefCountedString>& json,
                           bool has_more_events) {
   buffer->AddFragment(json->data());
   if (!has_more_events)
@@ skipping 40 matching lines @@
   InitializeWithRealMessageLoop(1u);
   TaskQueue* queue = runners_[0].get();
 
   StartTracing();
   {
     base::trace_event::BlameContext blame_context("cat", "name", "type",
                                                   "scope", 0, nullptr);
     blame_context.Initialize();
     queue->SetBlameContext(&blame_context);
     queue->PostTask(FROM_HERE, base::Bind(&NopTask));
-    message_loop_->RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
   StopTracing();
   std::unique_ptr<trace_analyzer::TraceAnalyzer> analyzer =
       CreateTraceAnalyzer();
 
   trace_analyzer::TraceEventVector events;
   Query q = Query::EventPhaseIs(TRACE_EVENT_PHASE_ENTER_CONTEXT) ||
             Query::EventPhaseIs(TRACE_EVENT_PHASE_LEAVE_CONTEXT);
   analyzer->FindEvents(q, &events);
 
   EXPECT_EQ(2u, events.size());
 }
 
 }  // namespace scheduler