Remove use of deprecated MessageLoop methods in components.

components/timers/alarm_timer_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 <sys/timerfd.h>
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/location.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/threading/platform_thread.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/timers/alarm_timer_chromeos.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // Most of these tests have been lifted right out of timer_unittest.cc with only
 // cosmetic changes (like replacing calls to MessageLoop::current()->Run() with
 // a RunLoop).  We want the AlarmTimer to be a drop-in replacement for the
 // regular Timer so it should pass the same tests as the Timer class.
 //
 // The only new tests are the .*ConcurrentResetAndTimerFired tests, which test
@@ skipping 21 matching lines @@
         timer_(new timers::OneShotAlarmTimer()) {}
   void Start() {
     timer_->Start(FROM_HERE, delay_, base::Bind(&OneShotAlarmTimerTester::Run,
                                                 base::Unretained(this)));
   }
 
  private:
   void Run() {
     *did_run_ = true;
 
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
   }
 
   bool* did_run_;
   const base::TimeDelta delay_;
   std::unique_ptr<timers::OneShotAlarmTimer> timer_;
 
   DISALLOW_COPY_AND_ASSIGN(OneShotAlarmTimerTester);
 };
 
 class OneShotSelfDeletingAlarmTimerTester {
  public:
   OneShotSelfDeletingAlarmTimerTester(bool* did_run, base::TimeDelta delay)
       : did_run_(did_run),
         delay_(delay),
         timer_(new timers::OneShotAlarmTimer()) {}
   void Start() {
     timer_->Start(FROM_HERE, delay_,
                   base::Bind(&OneShotSelfDeletingAlarmTimerTester::Run,
                              base::Unretained(this)));
   }
 
  private:
   void Run() {
     *did_run_ = true;
     timer_.reset();
 
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
   }
 
   bool* did_run_;
   const base::TimeDelta delay_;
   std::unique_ptr<timers::OneShotAlarmTimer> timer_;
 
   DISALLOW_COPY_AND_ASSIGN(OneShotSelfDeletingAlarmTimerTester);
 };
 
 class RepeatingAlarmTimerTester {
  public:
   RepeatingAlarmTimerTester(bool* did_run, base::TimeDelta delay)
       : did_run_(did_run),
         delay_(delay),
         counter_(10),
         timer_(new timers::RepeatingAlarmTimer()) {}
   void Start() {
     timer_->Start(FROM_HERE, delay_, base::Bind(&RepeatingAlarmTimerTester::Run,
                                                 base::Unretained(this)));
   }
 
  private:
   void Run() {
     if (--counter_ == 0) {
       *did_run_ = true;
       timer_->Stop();
 
-      base::MessageLoop::current()->PostTask(
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
     }
   }
 
   bool* did_run_;
   const base::TimeDelta delay_;
   int counter_;
   std::unique_ptr<timers::RepeatingAlarmTimer> timer_;
 
   DISALLOW_COPY_AND_ASSIGN(RepeatingAlarmTimerTester);
@@ skipping 21 matching lines @@
 
 TEST(AlarmTimerTest, OneShotAlarmTimer_Cancel) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     base::MessageLoop loop(testing_message_loops[i]);
 
     bool did_run_a = false;
     OneShotAlarmTimerTester* a =
         new OneShotAlarmTimerTester(&did_run_a, kTenMilliseconds);
 
     // This should run before the timer expires.
-    base::MessageLoop::current()->DeleteSoon(FROM_HERE, a);
+    base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, a);
 
     // Now start the timer.
     a->Start();
 
     bool did_run_b = false;
     OneShotAlarmTimerTester b(&did_run_b, kTenMilliseconds);
     b.Start();
 
     base::RunLoop().Run();
 
@@ skipping 34 matching lines @@
 
 TEST(AlarmTimerTest, RepeatingAlarmTimer_Cancel) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     base::MessageLoop loop(testing_message_loops[i]);
 
     bool did_run_a = false;
     RepeatingAlarmTimerTester* a =
         new RepeatingAlarmTimerTester(&did_run_a, kTenMilliseconds);
 
     // This should run before the timer expires.
-    base::MessageLoop::current()->DeleteSoon(FROM_HERE, a);
+    base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, a);
 
     // Now start the timer.
     a->Start();
 
     bool did_run_b = false;
     RepeatingAlarmTimerTester b(&did_run_b, kTenMilliseconds);
     b.Start();
 
     base::RunLoop().Run();
 
@@ skipping 18 matching lines @@
 
 TEST(AlarmTimerTest, RepeatingAlarmTimerZeroDelay_Cancel) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     base::MessageLoop loop(testing_message_loops[i]);
 
     bool did_run_a = false;
     RepeatingAlarmTimerTester* a =
         new RepeatingAlarmTimerTester(&did_run_a, base::TimeDelta());
 
     // This should run before the timer expires.
-    base::MessageLoop::current()->DeleteSoon(FROM_HERE, a);
+    base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, a);
 
     // Now start the timer.
     a->Start();
 
     bool did_run_b = false;
     RepeatingAlarmTimerTester b(&did_run_b, base::TimeDelta());
     b.Start();
 
     base::RunLoop().Run();
 
@@ skipping 95 matching lines @@
 bool g_callback_happened1 = false;
 bool g_callback_happened2 = false;
 
 void ClearAllCallbackHappened() {
   g_callback_happened1 = false;
   g_callback_happened2 = false;
 }
 
 void SetCallbackHappened1() {
   g_callback_happened1 = true;
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
 void SetCallbackHappened2() {
   g_callback_happened2 = true;
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
 TEST(AlarmTimerTest, ContinuationStopStart) {
   {
     ClearAllCallbackHappened();
     base::MessageLoop loop;
     timers::OneShotAlarmTimer timer;
     timer.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(10),
                 base::Bind(&SetCallbackHappened1));
@@ skipping 20 matching lines @@
     EXPECT_TRUE(g_callback_happened1);
   }
 }
 
 }  // namespace
 
 namespace {
 void TimerRanCallback(bool* did_run) {
   *did_run = true;
 
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
 bool IsAlarmTimerSupported() {
   int fd = timerfd_create(CLOCK_REALTIME_ALARM, 0);
 
   if (fd == -1) {
     LOG(WARNING) << "CLOCK_REALTIME_ALARM is not supported on this system.  "
                  << "Skipping test.  Upgrade to at least linux version 3.11 to "
                  << "support this timer.";
@@ skipping 82 matching lines @@
     if (!did_run) {
       base::RunLoop().Run();
       EXPECT_TRUE(did_run);
     }
   }
 }
 
 }  // namespace
 
 }  // namespace timers