chrome: Use base::MessageLoop. (Part 3)

chrome/browser/extensions/api/alarms/alarms_api_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.
 
 // This file tests the chrome.alarms extension API.
 
 #include "base/test/simple_test_clock.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/alarms/alarm_manager.h"
 #include "chrome/browser/extensions/api/alarms/alarms_api.h"
@@ skipping 18 matching lines @@
 
 namespace {
 
 // Test delegate which quits the message loop when an alarm fires.
 class AlarmDelegate : public AlarmManager::Delegate {
  public:
   virtual ~AlarmDelegate() {}
   virtual void OnAlarm(const std::string& extension_id,
                        const Alarm& alarm) OVERRIDE {
     alarms_seen.push_back(alarm.js_alarm->name);
-    MessageLoop::current()->Quit();
+    base::MessageLoop::current()->Quit();
   }
 
   std::vector<std::string> alarms_seen;
 };
 
 }  // namespace
 
 class ExtensionAlarmsTest : public BrowserWithTestWindowTest {
  public:
   virtual void SetUp() {
@@ skipping 100 matching lines @@
 
   const Alarm* alarm =
       alarm_manager_->GetAlarm(extension_->id(), std::string());
   ASSERT_TRUE(alarm);
   EXPECT_EQ("", alarm->js_alarm->name);
   EXPECT_DOUBLE_EQ(10000, alarm->js_alarm->scheduled_time);
   EXPECT_FALSE(alarm->js_alarm->period_in_minutes.get());
 
   // Now wait for the alarm to fire. Our test delegate will quit the
   // MessageLoop when that happens.
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   ASSERT_EQ(1u, alarm_delegate_->alarms_seen.size());
   EXPECT_EQ("", alarm_delegate_->alarms_seen[0]);
 
   // Ensure the alarm is gone.
   {
     const AlarmManager::AlarmList* alarms =
         alarm_manager_->GetAllAlarms(extension_->id());
     ASSERT_FALSE(alarms);
   }
 }
 
 TEST_F(ExtensionAlarmsTest, CreateRepeating) {
   test_clock_->SetNow(base::Time::FromDoubleT(10));
 
   // Create 1 repeating alarm.
   CreateAlarm("[null, {\"periodInMinutes\": 0.001}]");
 
   const Alarm* alarm =
       alarm_manager_->GetAlarm(extension_->id(), std::string());
   ASSERT_TRUE(alarm);
   EXPECT_EQ("", alarm->js_alarm->name);
   EXPECT_DOUBLE_EQ(10060, alarm->js_alarm->scheduled_time);
   EXPECT_THAT(alarm->js_alarm->period_in_minutes,
               testing::Pointee(testing::DoubleEq(0.001)));
 
   test_clock_->Advance(base::TimeDelta::FromSeconds(1));
   // Now wait for the alarm to fire. Our test delegate will quit the
   // MessageLoop when that happens.
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   test_clock_->Advance(base::TimeDelta::FromSeconds(1));
   // Wait again, and ensure the alarm fires again.
   alarm_manager_->ScheduleNextPoll();
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   ASSERT_EQ(2u, alarm_delegate_->alarms_seen.size());
   EXPECT_EQ("", alarm_delegate_->alarms_seen[0]);
 }
 
 TEST_F(ExtensionAlarmsTest, CreateAbsolute) {
   test_clock_->SetNow(base::Time::FromDoubleT(9.99));
   CreateAlarm("[null, {\"when\": 10001}]");
 
   const Alarm* alarm =
       alarm_manager_->GetAlarm(extension_->id(), std::string());
   ASSERT_TRUE(alarm);
   EXPECT_EQ("", alarm->js_alarm->name);
   EXPECT_DOUBLE_EQ(10001, alarm->js_alarm->scheduled_time);
   EXPECT_THAT(alarm->js_alarm->period_in_minutes,
               testing::IsNull());
 
   test_clock_->SetNow(base::Time::FromDoubleT(10.1));
   // Now wait for the alarm to fire. Our test delegate will quit the
   // MessageLoop when that happens.
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   ASSERT_FALSE(alarm_manager_->GetAlarm(extension_->id(), std::string()));
 
   ASSERT_EQ(1u, alarm_delegate_->alarms_seen.size());
   EXPECT_EQ("", alarm_delegate_->alarms_seen[0]);
 }
 
 TEST_F(ExtensionAlarmsTest, CreateRepeatingWithQuickFirstCall) {
   test_clock_->SetNow(base::Time::FromDoubleT(9.99));
   CreateAlarm("[null, {\"when\": 10001, \"periodInMinutes\": 0.001}]");
 
   const Alarm* alarm =
       alarm_manager_->GetAlarm(extension_->id(), std::string());
   ASSERT_TRUE(alarm);
   EXPECT_EQ("", alarm->js_alarm->name);
   EXPECT_DOUBLE_EQ(10001, alarm->js_alarm->scheduled_time);
   EXPECT_THAT(alarm->js_alarm->period_in_minutes,
               testing::Pointee(testing::DoubleEq(0.001)));
 
   test_clock_->SetNow(base::Time::FromDoubleT(10.1));
   // Now wait for the alarm to fire. Our test delegate will quit the
   // MessageLoop when that happens.
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   ASSERT_TRUE(alarm_manager_->GetAlarm(extension_->id(), std::string()));
   EXPECT_THAT(alarm_delegate_->alarms_seen, testing::ElementsAre(""));
 
   test_clock_->SetNow(base::Time::FromDoubleT(10.7));
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   ASSERT_TRUE(alarm_manager_->GetAlarm(extension_->id(), std::string()));
   EXPECT_THAT(alarm_delegate_->alarms_seen, testing::ElementsAre("", ""));
 }
 
 TEST_F(ExtensionAlarmsTest, CreateDupe) {
   test_clock_->SetNow(base::Time::FromDoubleT(10));
 
   // Create 2 duplicate alarms. The first should be overridden.
   CreateAlarm("[\"dup\", {\"delayInMinutes\": 1}]");
@@ skipping 109 matching lines @@
         alarm_manager_->GetAllAlarms(extension_->id());
     ASSERT_TRUE(alarms);
     EXPECT_EQ(1u, alarms->size());
     EXPECT_THAT((*alarms)[0].js_alarm->period_in_minutes,
                 testing::Pointee(0.001));
   }
 
   // Now wait for the alarms to fire, and ensure the cancelled alarms don't
   // fire.
   alarm_manager_->ScheduleNextPoll();
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   ASSERT_EQ(1u, alarm_delegate_->alarms_seen.size());
   EXPECT_EQ("", alarm_delegate_->alarms_seen[0]);
 
   // Ensure the 0.001-minute alarm is still there, since it's repeating.
   {
     const AlarmManager::AlarmList* alarms =
         alarm_manager_->GetAllAlarms(extension_->id());
     ASSERT_TRUE(alarms);
     EXPECT_EQ(1u, alarms->size());
@@ skipping 64 matching lines @@
                      alarm_manager_->next_poll_time_.ToDoubleT());
     alarm_manager_->RemoveAllAlarms(extension_->id());
   }
   {
     test_clock_->SetNow(base::Time::FromDoubleT(3 * 60 + 1));
     Alarm alarm;
     alarm.js_alarm->name = "bb";
     alarm.js_alarm->scheduled_time = 3 * 60000;
     alarm.js_alarm->period_in_minutes.reset(new double(3));
     alarm_manager_->AddAlarmImpl(extension_->id(), alarm);
-    MessageLoop::current()->Run();
+    base::MessageLoop::current()->Run();
     EXPECT_EQ(alarm_manager_->last_poll_time_ + base::TimeDelta::FromMinutes(3),
               alarm_manager_->next_poll_time_);
     alarm_manager_->RemoveAllAlarms(extension_->id());
   }
   {
     test_clock_->SetNow(base::Time::FromDoubleT(4 * 60 + 1));
     CreateAlarm("[\"a\", {\"periodInMinutes\": 2}]");
     alarm_manager_->RemoveAlarm(extension_->id(), "a");
     Alarm alarm2;
     alarm2.js_alarm->name = "bb";
     alarm2.js_alarm->scheduled_time = 4 * 60000;
     alarm2.js_alarm->period_in_minutes.reset(new double(4));
     alarm_manager_->AddAlarmImpl(extension_->id(), alarm2);
     Alarm alarm3;
     alarm3.js_alarm->name = "ccc";
     alarm3.js_alarm->scheduled_time = 25 * 60000;
     alarm3.js_alarm->period_in_minutes.reset(new double(25));
     alarm_manager_->AddAlarmImpl(extension_->id(), alarm3);
-    MessageLoop::current()->Run();
+    base::MessageLoop::current()->Run();
     EXPECT_EQ(alarm_manager_->last_poll_time_ + base::TimeDelta::FromMinutes(4),
               alarm_manager_->next_poll_time_);
     alarm_manager_->RemoveAllAlarms(extension_->id());
   }
 }
 
 TEST_F(ExtensionAlarmsSchedulingTest, ReleasedExtensionPollsInfrequently) {
   extension_ = utils::CreateEmptyExtensionWithLocation(
       extensions::Manifest::INTERNAL);
   test_clock_->SetNow(base::Time::FromJsTime(300000));
@@ skipping 11 matching lines @@
   alarm_manager_->ScheduleNextPoll();
   EXPECT_DOUBLE_EQ((alarm_manager_->last_poll_time_ +
                     base::TimeDelta::FromMinutes(1)).ToJsTime(),
                    alarm_manager_->next_poll_time_.ToJsTime());
 }
 
 TEST_F(ExtensionAlarmsSchedulingTest, TimerRunning) {
   EXPECT_FALSE(alarm_manager_->timer_.IsRunning());
   CreateAlarm("[\"a\", {\"delayInMinutes\": 0.001}]");
   EXPECT_TRUE(alarm_manager_->timer_.IsRunning());
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
   EXPECT_FALSE(alarm_manager_->timer_.IsRunning());
   CreateAlarm("[\"bb\", {\"delayInMinutes\": 10}]");
   EXPECT_TRUE(alarm_manager_->timer_.IsRunning());
   alarm_manager_->RemoveAllAlarms(extension_->id());
   EXPECT_FALSE(alarm_manager_->timer_.IsRunning());
 }
 
 }  // namespace extensions