Use base::MessageLoop in more files.

base/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/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 
 namespace {
 
 // The message loops on which each timer should be tested.
-const MessageLoop::Type testing_message_loops[] = {
-  MessageLoop::TYPE_DEFAULT,
-  MessageLoop::TYPE_IO,
+const base::MessageLoop::Type testing_message_loops[] = {
+  base::MessageLoop::TYPE_DEFAULT,
+  base::MessageLoop::TYPE_IO,
 #if !defined(OS_IOS)  // iOS does not allow direct running of the UI loop.
-  MessageLoop::TYPE_UI,
+  base::MessageLoop::TYPE_UI,
 #endif
 };
 
 const int kNumTestingMessageLoops = arraysize(testing_message_loops);
 
 class OneShotTimerTester {
  public:
   explicit OneShotTimerTester(bool* did_run, unsigned milliseconds = 10)
       : did_run_(did_run),
         delay_ms_(milliseconds) {
   }
   void Start() {
     timer_.Start(FROM_HERE, TimeDelta::FromMilliseconds(delay_ms_), this,
                  &OneShotTimerTester::Run);
   }
  private:
   void Run() {
     *did_run_ = true;
-    MessageLoop::current()->QuitWhenIdle();
+    base::MessageLoop::current()->QuitWhenIdle();
   }
   bool* did_run_;
   base::OneShotTimer<OneShotTimerTester> timer_;
   const unsigned delay_ms_;
 };
 
 class OneShotSelfDeletingTimerTester {
  public:
   explicit OneShotSelfDeletingTimerTester(bool* did_run) :
       did_run_(did_run),
       timer_(new base::OneShotTimer<OneShotSelfDeletingTimerTester>()) {
   }
   void Start() {
     timer_->Start(FROM_HERE, TimeDelta::FromMilliseconds(10), this,
                   &OneShotSelfDeletingTimerTester::Run);
   }
  private:
   void Run() {
     *did_run_ = true;
     timer_.reset();
-    MessageLoop::current()->QuitWhenIdle();
+    base::MessageLoop::current()->QuitWhenIdle();
   }
   bool* did_run_;
   scoped_ptr<base::OneShotTimer<OneShotSelfDeletingTimerTester> > timer_;
 };
 
 class RepeatingTimerTester {
  public:
   explicit RepeatingTimerTester(bool* did_run)
       : did_run_(did_run), counter_(10) {
   }
 
   void Start() {
     timer_.Start(FROM_HERE, TimeDelta::FromMilliseconds(10), this,
                  &RepeatingTimerTester::Run);
   }
  private:
   void Run() {
     if (--counter_ == 0) {
       *did_run_ = true;
-      MessageLoop::current()->QuitWhenIdle();
+      base::MessageLoop::current()->QuitWhenIdle();
     }
   }
   bool* did_run_;
   int counter_;
   base::RepeatingTimer<RepeatingTimerTester> timer_;
 };
 
-void RunTest_OneShotTimer(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+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();
 
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   EXPECT_TRUE(did_run);
 }
 
-void RunTest_OneShotTimer_Cancel(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+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.
-  MessageLoop::current()->DeleteSoon(FROM_HERE, a);
+  base::MessageLoop::current()->DeleteSoon(FROM_HERE, a);
 
   // Now start the timer.
   a->Start();
 
   bool did_run_b = false;
   OneShotTimerTester b(&did_run_b);
   b.Start();
 
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   EXPECT_FALSE(did_run_a);
   EXPECT_TRUE(did_run_b);
 }
 
-void RunTest_OneShotSelfDeletingTimer(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+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();
 
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   EXPECT_TRUE(did_run);
 }
 
-void RunTest_RepeatingTimer(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+void RunTest_RepeatingTimer(base::MessageLoop::Type message_loop_type) {
+  base::MessageLoop loop(message_loop_type);
 
   bool did_run = false;
   RepeatingTimerTester f(&did_run);
   f.Start();
 
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   EXPECT_TRUE(did_run);
 }
 
-void RunTest_RepeatingTimer_Cancel(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+void RunTest_RepeatingTimer_Cancel(base::MessageLoop::Type message_loop_type) {
+  base::MessageLoop loop(message_loop_type);
 
   bool did_run_a = false;
   RepeatingTimerTester* a = new RepeatingTimerTester(&did_run_a);
 
   // This should run before the timer expires.
-  MessageLoop::current()->DeleteSoon(FROM_HERE, a);
+  base::MessageLoop::current()->DeleteSoon(FROM_HERE, a);
 
   // Now start the timer.
   a->Start();
 
   bool did_run_b = false;
   RepeatingTimerTester b(&did_run_b);
   b.Start();
 
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   EXPECT_FALSE(did_run_a);
   EXPECT_TRUE(did_run_b);
 }
 
 class DelayTimerTarget {
  public:
   DelayTimerTarget()
       : signaled_(false) {
   }
 
   bool signaled() const { return signaled_; }
 
   void Signal() {
     ASSERT_FALSE(signaled_);
     signaled_ = true;
   }
 
  private:
   bool signaled_;
 };
 
-void RunTest_DelayTimer_NoCall(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+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<DelayTimerTarget> timer(FROM_HERE,
       TimeDelta::FromMilliseconds(1), &target, &DelayTimerTarget::Signal);
 
   bool did_run = false;
   OneShotTimerTester tester(&did_run);
   tester.Start();
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   ASSERT_FALSE(target.signaled());
 }
 
-void RunTest_DelayTimer_OneCall(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+void RunTest_DelayTimer_OneCall(base::MessageLoop::Type message_loop_type) {
+  base::MessageLoop loop(message_loop_type);
 
   DelayTimerTarget target;
   base::DelayTimer<DelayTimerTarget> timer(FROM_HERE,
       TimeDelta::FromMilliseconds(1), &target, &DelayTimerTarget::Signal);
   timer.Reset();
 
   bool did_run = false;
   OneShotTimerTester tester(&did_run, 100 /* milliseconds */);
   tester.Start();
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   ASSERT_TRUE(target.signaled());
 }
 
 struct ResetHelper {
   ResetHelper(base::DelayTimer<DelayTimerTarget>* timer,
               DelayTimerTarget* target)
       : timer_(timer),
         target_(target) {
   }
 
   void Reset() {
     ASSERT_FALSE(target_->signaled());
     timer_->Reset();
   }
 
  private:
   base::DelayTimer<DelayTimerTarget> *const timer_;
   DelayTimerTarget *const target_;
 };
 
-void RunTest_DelayTimer_Reset(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+void RunTest_DelayTimer_Reset(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<DelayTimerTarget> timer(FROM_HERE,
       TimeDelta::FromMilliseconds(50), &target, &DelayTimerTarget::Signal);
   timer.Reset();
 
   ResetHelper reset_helper(&timer, &target);
 
   base::OneShotTimer<ResetHelper> 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();
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   ASSERT_TRUE(target.signaled());
 }
 
 class DelayTimerFatalTarget {
  public:
   void Signal() {
     ASSERT_TRUE(false);
   }
 };
 
 
-void RunTest_DelayTimer_Deleted(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+void RunTest_DelayTimer_Deleted(base::MessageLoop::Type message_loop_type) {
+  base::MessageLoop loop(message_loop_type);
 
   DelayTimerFatalTarget target;
 
   {
     base::DelayTimer<DelayTimerFatalTarget> timer(
         FROM_HERE, TimeDelta::FromMilliseconds(50), &target,
         &DelayTimerFatalTarget::Signal);
     timer.Reset();
   }
 
@@ skipping 70 matching lines @@
   // message loop does not cause crashes if there were pending
   // timers not yet fired.  It may only trigger exceptions
   // if debug heap checking is enabled.
   bool did_run = false;
   {
     OneShotTimerTester a(&did_run);
     OneShotTimerTester b(&did_run);
     OneShotTimerTester c(&did_run);
     OneShotTimerTester d(&did_run);
     {
-      MessageLoop loop(MessageLoop::TYPE_DEFAULT);
+      base::MessageLoop loop(base::MessageLoop::TYPE_DEFAULT);
       a.Start();
       b.Start();
     }  // MessageLoop destructs by falling out of scope.
   }  // OneShotTimers destruct.  SHOULD NOT CRASH, of course.
 
   EXPECT_FALSE(did_run);
 }
 
 void TimerTestCallback() {
 }
 
 TEST(TimerTest, NonRepeatIsRunning) {
   {
-    MessageLoop loop(MessageLoop::TYPE_DEFAULT);
+    base::MessageLoop loop(base::MessageLoop::TYPE_DEFAULT);
     base::Timer timer(false, false);
     EXPECT_FALSE(timer.IsRunning());
     timer.Start(FROM_HERE, TimeDelta::FromDays(1),
                 base::Bind(&TimerTestCallback));
     EXPECT_TRUE(timer.IsRunning());
     timer.Stop();
     EXPECT_FALSE(timer.IsRunning());
     EXPECT_TRUE(timer.user_task().is_null());
   }
 
   {
     base::Timer timer(true, false);
-    MessageLoop loop(MessageLoop::TYPE_DEFAULT);
+    base::MessageLoop loop(base::MessageLoop::TYPE_DEFAULT);
     EXPECT_FALSE(timer.IsRunning());
     timer.Start(FROM_HERE, TimeDelta::FromDays(1),
                 base::Bind(&TimerTestCallback));
     EXPECT_TRUE(timer.IsRunning());
     timer.Stop();
     EXPECT_FALSE(timer.IsRunning());
     ASSERT_FALSE(timer.user_task().is_null());
     timer.Reset();
     EXPECT_TRUE(timer.IsRunning());
   }
 }
 
 TEST(TimerTest, NonRepeatMessageLoopDeath) {
   base::Timer timer(false, false);
   {
-    MessageLoop loop(MessageLoop::TYPE_DEFAULT);
+    base::MessageLoop loop(base::MessageLoop::TYPE_DEFAULT);
     EXPECT_FALSE(timer.IsRunning());
     timer.Start(FROM_HERE, TimeDelta::FromDays(1),
                 base::Bind(&TimerTestCallback));
     EXPECT_TRUE(timer.IsRunning());
   }
   EXPECT_FALSE(timer.IsRunning());
   EXPECT_TRUE(timer.user_task().is_null());
 }
 
 TEST(TimerTest, RetainRepeatIsRunning) {
-  MessageLoop loop(MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop loop(base::MessageLoop::TYPE_DEFAULT);
   base::Timer timer(FROM_HERE, TimeDelta::FromDays(1),
                     base::Bind(&TimerTestCallback), true);
   EXPECT_FALSE(timer.IsRunning());
   timer.Reset();
   EXPECT_TRUE(timer.IsRunning());
   timer.Stop();
   EXPECT_FALSE(timer.IsRunning());
   timer.Reset();
   EXPECT_TRUE(timer.IsRunning());
 }
 
 TEST(TimerTest, RetainNonRepeatIsRunning) {
-  MessageLoop loop(MessageLoop::TYPE_DEFAULT);
+  base::MessageLoop loop(base::MessageLoop::TYPE_DEFAULT);
   base::Timer timer(FROM_HERE, TimeDelta::FromDays(1),
                     base::Bind(&TimerTestCallback), false);
   EXPECT_FALSE(timer.IsRunning());
   timer.Reset();
   EXPECT_TRUE(timer.IsRunning());
   timer.Stop();
   EXPECT_FALSE(timer.IsRunning());
   timer.Reset();
   EXPECT_TRUE(timer.IsRunning());
 }
 
 namespace {
 
 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;
-  MessageLoop::current()->QuitWhenIdle();
+  base::MessageLoop::current()->QuitWhenIdle();
 }
 
 void SetCallbackHappened2() {
   g_callback_happened2 = true;
-  MessageLoop::current()->QuitWhenIdle();
+  base::MessageLoop::current()->QuitWhenIdle();
 }
 
 TEST(TimerTest, ContinuationStopStart) {
   {
     ClearAllCallbackHappened();
-    MessageLoop loop(MessageLoop::TYPE_DEFAULT);
+    base::MessageLoop loop(base::MessageLoop::TYPE_DEFAULT);
     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));
-    MessageLoop::current()->Run();
+    base::MessageLoop::current()->Run();
     EXPECT_FALSE(g_callback_happened1);
     EXPECT_TRUE(g_callback_happened2);
   }
 }
 
 TEST(TimerTest, ContinuationReset) {
   {
     ClearAllCallbackHappened();
-    MessageLoop loop(MessageLoop::TYPE_DEFAULT);
+    base::MessageLoop loop(base::MessageLoop::TYPE_DEFAULT);
     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());
-    MessageLoop::current()->Run();
+    base::MessageLoop::current()->Run();
     EXPECT_TRUE(g_callback_happened1);
   }
 }
 
 }  // namespace