Remove calls to deprecated MessageLoop methods in base.

base/mac/libdispatch_task_runner_unittest.cc

 // Copyright (c) 2012 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/mac/libdispatch_task_runner.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 class LibDispatchTaskRunnerTest : public testing::Test {
  public:
   void SetUp() override {
     task_runner_ = new base::mac::LibDispatchTaskRunner(
         "org.chromium.LibDispatchTaskRunnerTest");
   }
 
   // DispatchLastTask is used to run the main test thread's MessageLoop until
   // all non-delayed tasks are run on the LibDispatchTaskRunner.
   void DispatchLastTask() {
     dispatch_async(task_runner_->GetDispatchQueue(), ^{
-        message_loop_.PostTask(FROM_HERE,
-                               base::MessageLoop::QuitWhenIdleClosure());
+      message_loop_.task_runner()->PostTask(
+          FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
     });
-    message_loop_.Run();
+    base::RunLoop().Run();
     task_runner_->Shutdown();
   }
 
   // VerifyTaskOrder takes the expectations from TaskOrderMarkers and compares
   // them against the recorded values.
   void VerifyTaskOrder(const char* const expectations[],
                        size_t num_expectations) {
     size_t actual_size = task_order_.size();
 
     for (size_t i = 0; i < num_expectations; ++i) {
@@ skipping 112 matching lines @@
     "END Second Task",
   };
   VerifyTaskOrder(expectations, arraysize(expectations));
 }
 
 TEST_F(LibDispatchTaskRunnerTest, NonNestable) {
   task_runner_->PostTask(FROM_HERE, base::BindBlock(^{
       TaskOrderMarker marker(this, "First");
       task_runner_->PostNonNestableTask(FROM_HERE, base::BindBlock(^{
           TaskOrderMarker marker(this, "Second NonNestable");
-          message_loop_.PostTask(FROM_HERE,
-                                 base::MessageLoop::QuitWhenIdleClosure());
+          message_loop_.task_runner()->PostTask(
+              FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
       }));
   }));
-  message_loop_.Run();
+  base::RunLoop().Run();
   task_runner_->Shutdown();
 
   const char* const expectations[] = {
     "BEGIN First",
     "END First",
     "BEGIN Second NonNestable",
     "END Second NonNestable"
   };
   VerifyTaskOrder(expectations, arraysize(expectations));
 }
 
 TEST_F(LibDispatchTaskRunnerTest, PostDelayed) {
   base::TimeTicks post_time;
   __block base::TimeTicks run_time;
   const base::TimeDelta delta = base::TimeDelta::FromMilliseconds(50);
 
   task_runner_->PostTask(FROM_HERE, BoundRecordTaskOrder(this, "First"));
   post_time = base::TimeTicks::Now();
   task_runner_->PostDelayedTask(FROM_HERE, base::BindBlock(^{
       TaskOrderMarker marker(this, "Timed");
       run_time = base::TimeTicks::Now();
-      message_loop_.PostTask(FROM_HERE,
-                             base::MessageLoop::QuitWhenIdleClosure());
+      message_loop_.task_runner()->PostTask(
+          FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
   }), delta);
   task_runner_->PostTask(FROM_HERE, BoundRecordTaskOrder(this, "Second"));
-  message_loop_.Run();
+  base::RunLoop().Run();
   task_runner_->Shutdown();
 
   const char* const expectations[] = {
     "BEGIN First",
     "END First",
     "BEGIN Second",
     "END Second",
     "BEGIN Timed",
     "END Timed",
   };
@@ skipping 14 matching lines @@
   })));
 
   const char* const expectations[] = {
     "BEGIN First",
     "END First",
     "BEGIN Second",
     "END Second"
   };
   VerifyTaskOrder(expectations, arraysize(expectations));
 }