Change AlarmManager to use ProfileKeyedAPI.

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/lazy_instance.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "base/time/clock.h"
+#include "base/time/default_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, base::Clock* clock)
+AlarmManager::AlarmManager(Profile* profile)
     : profile_(profile),
-      clock_(clock),
+      owns_clock_(true),
       delegate_(new DefaultAlarmDelegate(profile)) {
+  clock_ = new base::DefaultClock();
+
   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() {
+  if (owns_clock_)
+    delete clock_;
 }
 
 void AlarmManager::AddAlarm(const std::string& extension_id,
                             const Alarm& alarm) {
   AddAlarmImpl(extension_id, alarm);
   WriteToStorage(extension_id);
 }
 
 const Alarm* AlarmManager::GetAlarm(
     const std::string& extension_id, const std::string& name) {
@@ skipping 44 matching lines @@
 
   // Note: I'm using indices rather than iterators here because
   // RemoveAlarmIterator will delete the list when it becomes empty.
   for (size_t i = 0, size = list->second.size(); i < size; ++i)
     RemoveAlarmIterator(AlarmIterator(list, list->second.begin()));
 
   CHECK(alarms_.find(extension_id) == alarms_.end());
   WriteToStorage(extension_id);
 }
 
+void AlarmManager::SetClockForTesting(base::Clock* clock) {
+  if (owns_clock_)
+    delete clock_;
+  owns_clock_ = false;
+  clock_ = clock;
+}
+
+static base::LazyInstance<ProfileKeyedAPIFactory<AlarmManager> >
+g_factory = LAZY_INSTANCE_INITIALIZER;
+
+// static
+ProfileKeyedAPIFactory<AlarmManager>* AlarmManager::GetFactoryInstance() {
+  return &g_factory.Get();
+}
+
+// static
+AlarmManager* AlarmManager::Get(Profile* profile) {
+  return ProfileKeyedAPIFactory<AlarmManager>::GetForProfile(profile);
+}
+
 void AlarmManager::RemoveAlarmIterator(const AlarmIterator& iter) {
   AlarmList& list = iter.first->second;
   list.erase(iter.second);
   if (list.empty())
     alarms_.erase(iter.first);
 
   // Cancel the timer if there are no more alarms.
   // We don't need to reschedule the poll otherwise, because in
   // the worst case we would just poll one extra time.
   if (alarms_.empty())
@@ skipping 189 matching lines @@
   if (create_info.period_in_minutes.get()) {
     js_alarm->period_in_minutes.reset(
         new double(*create_info.period_in_minutes));
   }
 }
 
 Alarm::~Alarm() {
 }
 
 }  // namespace extensions