Make chrome/browser/extensions use base::Clock instead of MockTimeProvider

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/mock_time_provider.h"
+#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"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
@@ skipping 26 matching lines @@
 
 }  // namespace
 
 class ExtensionAlarmsTest : public BrowserWithTestWindowTest {
  public:
   virtual void SetUp() {
     BrowserWithTestWindowTest::SetUp();
 
     TestExtensionSystem* system = static_cast<TestExtensionSystem*>(
         ExtensionSystem::Get(browser()->profile()));
-    system->CreateAlarmManager(&base::MockTimeProvider::StaticNow);
+    system->CreateAlarmManager(&test_clock_);
     alarm_manager_ = system->alarm_manager();
 
     alarm_delegate_ = new AlarmDelegate();
     alarm_manager_->set_delegate(alarm_delegate_);
 
     extension_ = utils::CreateEmptyExtensionWithLocation(
         extensions::Manifest::LOAD);
 
     // Make sure there's a RenderViewHost for alarms to warn into.
     AddTab(browser(), extension_->GetBackgroundURL());
     contents_ = browser()->tab_strip_model()->GetActiveWebContents();
 
-    current_time_ = base::Time::FromDoubleT(10);
-    ON_CALL(mock_time_, Now())
-        .WillByDefault(testing::ReturnPointee(&current_time_));
+    test_clock_.SetNow(base::Time::FromDoubleT(10));
   }
 
   base::Value* RunFunctionWithExtension(
       UIThreadExtensionFunction* function, const std::string& args) {
     scoped_refptr<UIThreadExtensionFunction> delete_function(function);
     function->set_extension(extension_.get());
     function->SetRenderViewHost(contents_->GetRenderViewHost());
     return utils::RunFunctionAndReturnSingleResult(function, args, browser());
   }
 
@@ skipping 15 matching lines @@
   }
 
   std::string RunFunctionAndReturnError(UIThreadExtensionFunction* function,
                                         const std::string& args) {
     function->set_extension(extension_.get());
     function->SetRenderViewHost(contents_->GetRenderViewHost());
     return utils::RunFunctionAndReturnError(function, args, browser());
   }
 
   void CreateAlarm(const std::string& args) {
-    RunFunction(new AlarmsCreateFunction(&base::MockTimeProvider::StaticNow),
-                args);
+    RunFunction(new AlarmsCreateFunction(&test_clock_), args);
   }
 
   // Takes a JSON result from a function and converts it to a vector of
   // JsAlarms.
   std::vector<linked_ptr<JsAlarm> > ToAlarmList(base::ListValue* value) {
     std::vector<linked_ptr<JsAlarm> > list;
     for (size_t i = 0; i < value->GetSize(); ++i) {
       linked_ptr<JsAlarm> alarm(new JsAlarm);
       base::DictionaryValue* alarm_value;
       if (!value->GetDictionary(i, &alarm_value)) {
@@ skipping 10 matching lines @@
   void CreateAlarms(size_t num_alarms) {
     CHECK(num_alarms <= 3);
 
     const char* kCreateArgs[] = {
       "[null, {\"periodInMinutes\": 0.001}]",
       "[\"7\", {\"periodInMinutes\": 7}]",
       "[\"0\", {\"delayInMinutes\": 0}]",
     };
     for (size_t i = 0; i < num_alarms; ++i) {
       scoped_ptr<base::DictionaryValue> result(RunFunctionAndReturnDict(
-          new AlarmsCreateFunction(&base::MockTimeProvider::StaticNow),
-          kCreateArgs[i]));
+          new AlarmsCreateFunction(&test_clock_), kCreateArgs[i]));
       EXPECT_FALSE(result.get());
     }
   }
 
  protected:
-  base::Time current_time_;
-  testing::NiceMock<base::MockTimeProvider> mock_time_;
+  base::SimpleTestClock test_clock_;
   AlarmManager* alarm_manager_;
   AlarmDelegate* alarm_delegate_;
   scoped_refptr<extensions::Extension> extension_;
   content::WebContents* contents_;
 };
 
 TEST_F(ExtensionAlarmsTest, Create) {
-  current_time_ = base::Time::FromDoubleT(10);
+  test_clock_.SetNow(base::Time::FromDoubleT(10));
   // Create 1 non-repeating alarm.
   CreateAlarm("[null, {\"delayInMinutes\": 0}]");
 
   const Alarm* alarm =
       alarm_manager_->GetAlarm(extension_->id(), "");
   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();
 
   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) {
-  current_time_ = base::Time::FromDoubleT(10);
+  test_clock_.SetNow(base::Time::FromDoubleT(10));
 
   // Create 1 repeating alarm.
   CreateAlarm("[null, {\"periodInMinutes\": 0.001}]");
 
   const Alarm* alarm =
       alarm_manager_->GetAlarm(extension_->id(), "");
   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)));
 
-  current_time_ += base::TimeDelta::FromSeconds(1);
+  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();
 
-  current_time_ += base::TimeDelta::FromSeconds(1);
+  test_clock_.Advance(base::TimeDelta::FromSeconds(1));
   // Wait again, and ensure the alarm fires again.
   alarm_manager_->ScheduleNextPoll();
   MessageLoop::current()->Run();
 
   ASSERT_EQ(2u, alarm_delegate_->alarms_seen.size());
   EXPECT_EQ("", alarm_delegate_->alarms_seen[0]);
 }
 
 TEST_F(ExtensionAlarmsTest, CreateAbsolute) {
-  current_time_ = base::Time::FromDoubleT(9.99);
+  test_clock_.SetNow(base::Time::FromDoubleT(9.99));
   CreateAlarm("[null, {\"when\": 10001}]");
 
   const Alarm* alarm =
       alarm_manager_->GetAlarm(extension_->id(), "");
   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());
 
-  current_time_ = base::Time::FromDoubleT(10.1);
+  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();
 
   ASSERT_FALSE(alarm_manager_->GetAlarm(extension_->id(), ""));
 
   ASSERT_EQ(1u, alarm_delegate_->alarms_seen.size());
   EXPECT_EQ("", alarm_delegate_->alarms_seen[0]);
 }
 
 TEST_F(ExtensionAlarmsTest, CreateRepeatingWithQuickFirstCall) {
-  current_time_ = base::Time::FromDoubleT(9.99);
+  test_clock_.SetNow(base::Time::FromDoubleT(9.99));
   CreateAlarm("[null, {\"when\": 10001, \"periodInMinutes\": 0.001}]");
 
   const Alarm* alarm =
       alarm_manager_->GetAlarm(extension_->id(), "");
   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)));
 
-  current_time_ = base::Time::FromDoubleT(10.1);
+  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();
 
   ASSERT_TRUE(alarm_manager_->GetAlarm(extension_->id(), ""));
   EXPECT_THAT(alarm_delegate_->alarms_seen, testing::ElementsAre(""));
 
-  current_time_ = base::Time::FromDoubleT(10.7);
+  test_clock_.SetNow(base::Time::FromDoubleT(10.7));
   MessageLoop::current()->Run();
 
   ASSERT_TRUE(alarm_manager_->GetAlarm(extension_->id(), ""));
   EXPECT_THAT(alarm_delegate_->alarms_seen, testing::ElementsAre("", ""));
 }
 
 TEST_F(ExtensionAlarmsTest, CreateDupe) {
-  current_time_ = base::Time::FromDoubleT(10);
+  test_clock_.SetNow(base::Time::FromDoubleT(10));
 
   // Create 2 duplicate alarms. The first should be overridden.
   CreateAlarm("[\"dup\", {\"delayInMinutes\": 1}]");
   CreateAlarm("[\"dup\", {\"delayInMinutes\": 7}]");
 
   {
     const AlarmManager::AlarmList* alarms =
         alarm_manager_->GetAllAlarms(extension_->id());
     ASSERT_TRUE(alarms);
     EXPECT_EQ(1u, alarms->size());
@@ skipping 10 matching lines @@
       ExtensionMsg_AddMessageToConsole::ID);
   ASSERT_TRUE(warning);
   content::ConsoleMessageLevel level = content::CONSOLE_MESSAGE_LEVEL_DEBUG;
   std::string message;
   ExtensionMsg_AddMessageToConsole::Read(warning, &level, &message);
   EXPECT_EQ(content::CONSOLE_MESSAGE_LEVEL_WARNING, level);
   EXPECT_THAT(message, testing::HasSubstr("delay is less than minimum of 1"));
 }
 
 TEST_F(ExtensionAlarmsTest, Get) {
-  current_time_ = base::Time::FromDoubleT(4);
+  test_clock_.SetNow(base::Time::FromDoubleT(4));
 
   // Create 2 alarms, and make sure we can query them.
   CreateAlarms(2);
 
   // Get the default one.
   {
     JsAlarm alarm;
     scoped_ptr<base::DictionaryValue> result(RunFunctionAndReturnDict(
         new AlarmsGetFunction(), "[null]"));
     ASSERT_TRUE(result.get());
@@ skipping 138 matching lines @@
     EXPECT_EQ(GetScheduledTime("a"), alarm_manager_->next_poll_time_);
     alarm_manager_->RemoveAllAlarms(extension_->id());
   }
   {
     CreateAlarm("[\"a\", {\"delayInMinutes\": 10}]");
     CreateAlarm("[\"bb\", {\"delayInMinutes\": 21}]");
     EXPECT_EQ(GetScheduledTime("a"), alarm_manager_->next_poll_time_);
     alarm_manager_->RemoveAllAlarms(extension_->id());
   }
   {
-    current_time_ = base::Time::FromDoubleT(10);
+    test_clock_.SetNow(base::Time::FromDoubleT(10));
     CreateAlarm("[\"a\", {\"periodInMinutes\": 10}]");
     Alarm alarm;
     alarm.js_alarm->name = "bb";
     alarm.js_alarm->scheduled_time = 30 * 60000;
     alarm.js_alarm->period_in_minutes.reset(new double(30));
     alarm_manager_->AddAlarmImpl(extension_->id(), alarm);
     EXPECT_DOUBLE_EQ(GetScheduledTime("a").ToDoubleT(),
                      alarm_manager_->next_poll_time_.ToDoubleT());
     alarm_manager_->RemoveAllAlarms(extension_->id());
   }
   {
-    current_time_ = base::Time::FromDoubleT(3 * 60 + 1);
+    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();
     EXPECT_EQ(alarm_manager_->last_poll_time_ + base::TimeDelta::FromMinutes(3),
               alarm_manager_->next_poll_time_);
     alarm_manager_->RemoveAllAlarms(extension_->id());
   }
   {
-    current_time_ = base::Time::FromDoubleT(4 * 60 + 1);
+    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();
     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);
-  current_time_ = base::Time::FromJsTime(300000);
+  test_clock_.SetNow(base::Time::FromJsTime(300000));
   CreateAlarm("[\"a\", {\"when\": 300010}]");
   CreateAlarm("[\"b\", {\"when\": 340000}]");
 
   // On startup (when there's no "last poll"), we let alarms fire as
   // soon as they're scheduled.
   EXPECT_DOUBLE_EQ(300010, alarm_manager_->next_poll_time_.ToJsTime());
 
   alarm_manager_->last_poll_time_ = base::Time::FromJsTime(290000);
   // In released extensions, we set the granularity to at least 5
   // minutes, which makes AddAlarm schedule the next poll after the
@@ skipping 10 matching lines @@
   EXPECT_TRUE(alarm_manager_->timer_.IsRunning());
   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