Remove calls to deprecated MessageLoop methods in base.

base/timer/timer_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/timer/timer.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 using base::SingleThreadTaskRunner;
 
 namespace {
 
@@ skipping 86 matching lines @@
   base::RepeatingTimer timer_;
 };
 
 void RunTest_OneShotTimer(base::MessageLoop::Type message_loop_type) {
   base::MessageLoop loop(message_loop_type);
 
   bool did_run = false;
   OneShotTimerTester f(&did_run);
   f.Start();
 
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   EXPECT_TRUE(did_run);
 }
 
 void RunTest_OneShotTimer_Cancel(base::MessageLoop::Type message_loop_type) {
   base::MessageLoop loop(message_loop_type);
 
   bool did_run_a = false;
   OneShotTimerTester* a = new OneShotTimerTester(&did_run_a);
 
   // This should run before the timer expires.
   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, a);
 
   // Now start the timer.
   a->Start();
 
   bool did_run_b = false;
   OneShotTimerTester b(&did_run_b);
   b.Start();
 
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   EXPECT_FALSE(did_run_a);
   EXPECT_TRUE(did_run_b);
 }
 
 void RunTest_OneShotSelfDeletingTimer(
     base::MessageLoop::Type message_loop_type) {
   base::MessageLoop loop(message_loop_type);
 
   bool did_run = false;
   OneShotSelfDeletingTimerTester f(&did_run);
   f.Start();
 
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   EXPECT_TRUE(did_run);
 }
 
 void RunTest_RepeatingTimer(base::MessageLoop::Type message_loop_type,
                             const TimeDelta& delay) {
   base::MessageLoop loop(message_loop_type);
 
   bool did_run = false;
   RepeatingTimerTester f(&did_run, delay);
   f.Start();
 
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   EXPECT_TRUE(did_run);
 }
 
 void RunTest_RepeatingTimer_Cancel(base::MessageLoop::Type message_loop_type,
                                    const TimeDelta& delay) {
   base::MessageLoop loop(message_loop_type);
 
   bool did_run_a = false;
   RepeatingTimerTester* a = new RepeatingTimerTester(&did_run_a, delay);
 
   // This should run before the timer expires.
   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, a);
 
   // Now start the timer.
   a->Start();
 
   bool did_run_b = false;
   RepeatingTimerTester b(&did_run_b, delay);
   b.Start();
 
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   EXPECT_FALSE(did_run_a);
   EXPECT_TRUE(did_run_b);
 }
 
 class DelayTimerTarget {
  public:
   bool signaled() const { return signaled_; }
 
   void Signal() {
     ASSERT_FALSE(signaled_);
     signaled_ = true;
   }
 
  private:
   bool signaled_ = false;
 };
 
 void RunTest_DelayTimer_NoCall(base::MessageLoop::Type message_loop_type) {
   base::MessageLoop loop(message_loop_type);
 
   // If Delay is never called, the timer shouldn't go off.
   DelayTimerTarget target;
   base::DelayTimer timer(FROM_HERE, TimeDelta::FromMilliseconds(1), &target,
                          &DelayTimerTarget::Signal);
 
   bool did_run = false;
   OneShotTimerTester tester(&did_run);
   tester.Start();
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   ASSERT_FALSE(target.signaled());
 }
 
 void RunTest_DelayTimer_OneCall(base::MessageLoop::Type message_loop_type) {
   base::MessageLoop loop(message_loop_type);
 
   DelayTimerTarget target;
   base::DelayTimer timer(FROM_HERE, TimeDelta::FromMilliseconds(1), &target,
                          &DelayTimerTarget::Signal);
   timer.Reset();
 
   bool did_run = false;
   OneShotTimerTester tester(&did_run, 100 /* milliseconds */);
   tester.Start();
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   ASSERT_TRUE(target.signaled());
 }
 
 struct ResetHelper {
   ResetHelper(base::DelayTimer* timer, DelayTimerTarget* target)
       : timer_(timer), target_(target) {}
 
   void Reset() {
     ASSERT_FALSE(target_->signaled());
@@ skipping 18 matching lines @@
 
   base::OneShotTimer timers[20];
   for (size_t i = 0; i < arraysize(timers); ++i) {
     timers[i].Start(FROM_HERE, TimeDelta::FromMilliseconds(i * 10),
                     &reset_helper, &ResetHelper::Reset);
   }
 
   bool did_run = false;
   OneShotTimerTester tester(&did_run, 300);
   tester.Start();
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   ASSERT_TRUE(target.signaled());
 }
 
 class DelayTimerFatalTarget {
  public:
   void Signal() {
     ASSERT_TRUE(false);
   }
 };
@@ skipping 222 matching lines @@
 TEST(TimerTest, ContinuationStopStart) {
   {
     ClearAllCallbackHappened();
     base::MessageLoop loop;
     base::Timer timer(false, false);
     timer.Start(FROM_HERE, TimeDelta::FromMilliseconds(10),
                 base::Bind(&SetCallbackHappened1));
     timer.Stop();
     timer.Start(FROM_HERE, TimeDelta::FromMilliseconds(40),
                 base::Bind(&SetCallbackHappened2));
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
     EXPECT_FALSE(g_callback_happened1);
     EXPECT_TRUE(g_callback_happened2);
   }
 }
 
 TEST(TimerTest, ContinuationReset) {
   {
     ClearAllCallbackHappened();
     base::MessageLoop loop;
     base::Timer timer(false, false);
     timer.Start(FROM_HERE, TimeDelta::FromMilliseconds(10),
                 base::Bind(&SetCallbackHappened1));
     timer.Reset();
     // Since Reset happened before task ran, the user_task must not be cleared:
     ASSERT_FALSE(timer.user_task().is_null());
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
     EXPECT_TRUE(g_callback_happened1);
   }
 }
 
 }  // namespace