Remove calls to deprecated MessageLoop methods in base.

base/message_loop/message_loop_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/message_loop/message_loop_task_runner.h"
 
 #include <memory>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/debug/leak_annotations.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_task_runner.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"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace base {
 
 class MessageLoopTaskRunnerTest : public testing::Test {
  public:
   MessageLoopTaskRunnerTest()
       : current_loop_(new MessageLoop()),
         task_thread_("task_thread"),
         thread_sync_(WaitableEvent::ResetPolicy::MANUAL,
                      WaitableEvent::InitialState::NOT_SIGNALED) {}
 
   void DeleteCurrentMessageLoop() { current_loop_.reset(); }
 
  protected:
   void SetUp() override {
     // Use SetUp() instead of the constructor to avoid posting a task to a
     // partially constructed object.
     task_thread_.Start();
 
     // Allow us to pause the |task_thread_|'s MessageLoop.
-    task_thread_.message_loop()->PostTask(
+    task_thread_.message_loop()->task_runner()->PostTask(
         FROM_HERE, Bind(&MessageLoopTaskRunnerTest::BlockTaskThreadHelper,
                         Unretained(this)));
   }
 
   void TearDown() override {
     // Make sure the |task_thread_| is not blocked, and stop the thread
     // fully before destruction because its tasks may still depend on the
     // |thread_sync_| event.
     thread_sync_.Signal();
     task_thread_.Stop();
@@ skipping 201 matching lines @@
 }
 
 class MessageLoopTaskRunnerThreadingTest : public testing::Test {
  public:
   void Release() const {
     AssertOnIOThread();
     Quit();
   }
 
   void Quit() const {
-    loop_.PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure());
+    loop_.task_runner()->PostTask(FROM_HERE,
+                                  MessageLoop::QuitWhenIdleClosure());
   }
 
   void AssertOnIOThread() const {
     ASSERT_TRUE(io_thread_->task_runner()->BelongsToCurrentThread());
     ASSERT_EQ(io_thread_->task_runner(), ThreadTaskRunnerHandle::Get());
   }
 
   void AssertOnFileThread() const {
     ASSERT_TRUE(file_thread_->task_runner()->BelongsToCurrentThread());
     ASSERT_EQ(file_thread_->task_runner(), ThreadTaskRunnerHandle::Get());
@@ skipping 35 matching lines @@
 
   std::unique_ptr<Thread> io_thread_;
   std::unique_ptr<Thread> file_thread_;
 
  private:
   mutable MessageLoop loop_;
 };
 
 TEST_F(MessageLoopTaskRunnerThreadingTest, Release) {
   EXPECT_TRUE(io_thread_->task_runner()->ReleaseSoon(FROM_HERE, this));
-  MessageLoop::current()->Run();
+  RunLoop().Run();
 }
 
 TEST_F(MessageLoopTaskRunnerThreadingTest, Delete) {
   DeletedOnFile* deleted_on_file = new DeletedOnFile(this);
   EXPECT_TRUE(
       file_thread_->task_runner()->DeleteSoon(FROM_HERE, deleted_on_file));
-  MessageLoop::current()->Run();
+  RunLoop().Run();
 }
 
 TEST_F(MessageLoopTaskRunnerThreadingTest, PostTask) {
   EXPECT_TRUE(file_thread_->task_runner()->PostTask(
       FROM_HERE, Bind(&MessageLoopTaskRunnerThreadingTest::BasicFunction,
                       Unretained(this))));
-  MessageLoop::current()->Run();
+  RunLoop().Run();
 }
 
 TEST_F(MessageLoopTaskRunnerThreadingTest, PostTaskAfterThreadExits) {
   std::unique_ptr<Thread> test_thread(
       new Thread("MessageLoopTaskRunnerThreadingTest_Dummy"));
   test_thread->Start();
   scoped_refptr<SingleThreadTaskRunner> task_runner =
       test_thread->task_runner();
   test_thread->Stop();
 
   bool ret = task_runner->PostTask(
       FROM_HERE, Bind(&MessageLoopTaskRunnerThreadingTest::AssertNotRun));
   EXPECT_FALSE(ret);
 }
 
 TEST_F(MessageLoopTaskRunnerThreadingTest, PostTaskAfterThreadIsDeleted) {
   scoped_refptr<SingleThreadTaskRunner> task_runner;
   {
     std::unique_ptr<Thread> test_thread(
         new Thread("MessageLoopTaskRunnerThreadingTest_Dummy"));
     test_thread->Start();
     task_runner = test_thread->task_runner();
   }
   bool ret = task_runner->PostTask(
       FROM_HERE, Bind(&MessageLoopTaskRunnerThreadingTest::AssertNotRun));
   EXPECT_FALSE(ret);
 }
 
 }  // namespace base