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

chrome/browser/extensions/api/alarms/alarm_manager.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 "chrome/browser/extensions/api/alarms/alarm_manager.h"
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
 #include "base/time.h"
+#include "base/time/clock.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/state_store.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_service.h"
 
@@ skipping 60 matching lines @@
     list->Append(alarm.release());
   }
   return list.Pass();
 }
 
 
 }  // namespace
 
 // AlarmManager
 
-AlarmManager::AlarmManager(Profile* profile, TimeProvider now)
+AlarmManager::AlarmManager(Profile* profile, base::Clock* clock)
     : profile_(profile),
-      now_(now),
-      delegate_(new DefaultAlarmDelegate(profile)),
-      last_poll_time_(base::Time()) {
+      clock_(clock),
+      delegate_(new DefaultAlarmDelegate(profile)) {
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<Profile>(profile_));
 
   StateStore* storage = ExtensionSystem::Get(profile_)->state_store();
   if (storage)
     storage->RegisterKey(kRegisteredAlarms);
 }
 
 AlarmManager::~AlarmManager() {
 }
@@ skipping 163 matching lines @@
   // If the next alarm is more than min_granularity in the future, wait for it.
   // Otherwise, only poll as often as min_granularity.
   // As a special case, if we've never checked for an alarm before
   // (e.g. during startup), let alarms fire asap.
   if (last_poll_time_.is_null() || next_poll < soonest_alarm_time)
     next_poll = soonest_alarm_time;
 
   // Schedule the poll.
   next_poll_time_ = next_poll;
   base::TimeDelta delay = std::max(base::TimeDelta::FromSeconds(0),
-                                   next_poll - now_());
+                                   next_poll - clock_->Now());
   timer_.Start(FROM_HERE,
                delay,
                this,
                &AlarmManager::PollAlarms);
 }
 
 void AlarmManager::PollAlarms() {
-  last_poll_time_ = now_();
+  last_poll_time_ = clock_->Now();
 
   // Run any alarms scheduled in the past. OnAlarm uses vector::erase to remove
   // elements from the AlarmList, and map::erase to remove AlarmLists from the
   // AlarmMap.
   for (AlarmMap::iterator m_it = alarms_.begin(), m_end = alarms_.end();
        m_it != m_end;) {
     AlarmMap::iterator cur_extension = m_it++;
 
     // Iterate (a) backwards so that removing elements doesn't affect
     // upcoming iterations, and (b) with indices so that if the last
@@ skipping 35 matching lines @@
 
 // AlarmManager::Alarm
 
 Alarm::Alarm()
     : js_alarm(new api::alarms::Alarm()) {
 }
 
 Alarm::Alarm(const std::string& name,
              const api::alarms::AlarmCreateInfo& create_info,
              base::TimeDelta min_granularity,
-             TimeProvider now)
+             base::Time now)
     : js_alarm(new api::alarms::Alarm()) {
   js_alarm->name = name;
 
   if (create_info.when.get()) {
     // Absolute scheduling.
     js_alarm->scheduled_time = *create_info.when;
-    granularity = base::Time::FromJsTime(js_alarm->scheduled_time) - now();
+    granularity = base::Time::FromJsTime(js_alarm->scheduled_time) - now;
   } else {
     // Relative scheduling.
     double* delay_in_minutes = create_info.delay_in_minutes.get();
     if (delay_in_minutes == NULL)
       delay_in_minutes = create_info.period_in_minutes.get();
     CHECK(delay_in_minutes != NULL)
         << "ValidateAlarmCreateInfo in alarms_api.cc should have "
         << "prevented this call.";
     base::TimeDelta delay = TimeDeltaFromDelay(*delay_in_minutes);
-    js_alarm->scheduled_time = (now() + delay).ToJsTime();
+    js_alarm->scheduled_time = (now + delay).ToJsTime();
     granularity = delay;
   }
 
   if (granularity < min_granularity)
     granularity = min_granularity;
 
   // Check for repetition.
   if (create_info.period_in_minutes.get()) {
     js_alarm->period_in_minutes.reset(
         new double(*create_info.period_in_minutes));
   }
 }
 
 Alarm::~Alarm() {
 }
 
 }  // namespace extensions