Remove calls to deprecated MessageLoop methods in components.

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 97 matching lines @@
                            base::SingleThreadTaskRunner* runner,
                            std::vector<std::pair<base::Closure, bool>>* tasks) {
   base::MessageLoop::ScopedNestableTaskAllower allow(message_loop);
   for (std::pair<base::Closure, bool>& pair : *tasks) {
     if (pair.second) {
       runner->PostTask(FROM_HERE, pair.first);
     } else {
       runner->PostNonNestableTask(FROM_HERE, pair.first);
     }
   }
-  message_loop->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 void NopTask() {}
 
 TEST_F(TaskQueueManagerTest, NowNotCalledWhenThereAreNoDelayedTasks) {
   message_loop_.reset(new base::MessageLoop());
   manager_ = base::WrapUnique(new TaskQueueManager(
       MessageLoopTaskRunner::Create(
           base::WrapUnique(new TestAlwaysFailTimeSource())),
       "test.scheduler", "test.scheduler", "test.scheduler.debug"));
@@ skipping 1216 matching lines @@
 void PostTestTasksFromNestedMessageLoop(
     base::MessageLoop* message_loop,
     scoped_refptr<base::SingleThreadTaskRunner> main_runner,
     scoped_refptr<base::SingleThreadTaskRunner> wake_up_runner,
     std::vector<EnqueueOrder>* run_order) {
   base::MessageLoop::ScopedNestableTaskAllower allow(message_loop);
   main_runner->PostNonNestableTask(FROM_HERE,
                                    base::Bind(&TestTask, 1, run_order));
   // The following should never get executed.
   wake_up_runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, run_order));
-  message_loop->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(TaskQueueManagerTest, DeferredNonNestableTaskDoesNotTriggerWakeUp) {
   // This test checks that running (i.e., deferring) a non-nestable task in a
   // 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(
@@ skipping 441 matching lines @@
     TaskQueueManager* task_queue_manager,
     std::vector<TaskQueue*>* task_sources,
     std::vector<std::pair<base::Closure, TaskQueue*>>* tasks) {
   base::MessageLoop::ScopedNestableTaskAllower allow(message_loop);
   task_sources->push_back(task_queue_manager->currently_executing_task_queue());
 
   for (std::pair<base::Closure, TaskQueue*>& pair : *tasks) {
     pair.second->PostTask(FROM_HERE, pair.first);
   }
 
-  message_loop->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   task_sources->push_back(task_queue_manager->currently_executing_task_queue());
 }
 }
 
 TEST_F(TaskQueueManagerTest, CurrentlyExecutingTaskQueue_NestedLoop) {
   InitializeWithRealMessageLoop(3u);
 
   TaskQueue* queue0 = runners_[0].get();
   TaskQueue* queue1 = runners_[1].get();
   TaskQueue* queue2 = runners_[2].get();
@@ skipping 84 matching lines @@
 
   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