Change AlarmManager to use ProfileKeyedAPI.

chrome/browser/extensions/api/alarms/alarm_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_API_ALARMS_ALARM_MANAGER_H__
 #define CHROME_BROWSER_EXTENSIONS_API_ALARMS_ALARM_MANAGER_H__
 
 #include <string>
 #include <map>
 #include <vector>
 
 #include "base/memory/weak_ptr.h"
 #include "base/timer.h"
+#include "chrome/browser/extensions/api/profile_keyed_api_factory.h"
 #include "chrome/browser/extensions/extension_function.h"
 #include "chrome/common/extensions/api/alarms.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 
 class Profile;
 
 namespace base {
 class Clock;
 }  // namespace base
@@ skipping 15 matching lines @@
   // least as often as the shortest alarm's granularity.  It's initialized as
   // the relative delay requested in creation, even if creation uses an absolute
   // time.  This will always be at least as large as the min_granularity
   // constructor argument.
   base::TimeDelta granularity;
 };
 
 // Manages the currently pending alarms for every extension in a profile.
 // There is one manager per virtual Profile.
 class AlarmManager
-    : public content::NotificationObserver,
+    : public ProfileKeyedAPI,
+      public content::NotificationObserver,
       public base::SupportsWeakPtr<AlarmManager> {
  public:
   typedef std::vector<Alarm> AlarmList;
 
   class Delegate {
    public:
     virtual ~Delegate() {}
     // Called when an alarm fires.
     virtual void OnAlarm(const std::string& extension_id,
                          const Alarm& alarm) = 0;
   };
 
-  // |clock| is usually a base::DefaultClock, but can be something
-  // else for testing.
-  explicit AlarmManager(Profile* profile, base::Clock* clock);
+  explicit AlarmManager(Profile* profile);
   virtual ~AlarmManager();
 
   // Override the default delegate. Callee assumes onwership. Used for testing.
   void set_delegate(Delegate* delegate) { delegate_.reset(delegate); }
 
   // Adds |alarm| for the given extension, and starts the timer.
   void AddAlarm(const std::string& extension_id,
                 const Alarm& alarm);
 
   // Returns the alarm with the given name, or NULL if none exists.
   const Alarm* GetAlarm(const std::string& extension_id,
                         const std::string& name);
 
   // Returns the list of pending alarms for the given extension, or NULL
   // if none exist.
   const AlarmList* GetAllAlarms(const std::string& extension_id);
 
   // Cancels and removes the alarm with the given name.
   bool RemoveAlarm(const std::string& extension_id,
                    const std::string& name);
 
   // Cancels and removes all alarms for the given extension.
   void RemoveAllAlarms(const std::string& extension_id);
 
+  // Deletes AlarmManager's owned clock and replaces it with |clock|.

[Devlin, 2013/04/22 21:19:28]

You should note that it takes ownership of |clock| as well.

[Patrick Riordan, 2013/04/23 23:32:04]

Done.

+  void SetClockForTesting(base::Clock* clock);
+
+  // ProfileKeyedAPI implementation.
+  static ProfileKeyedAPIFactory<AlarmManager>* GetFactoryInstance();
+
+  // Convenience method to get the AlarmManager for a profile.
+  static AlarmManager* Get(Profile* profile);
+
  private:
   FRIEND_TEST_ALL_PREFIXES(ExtensionAlarmsTest, CreateRepeating);
   FRIEND_TEST_ALL_PREFIXES(ExtensionAlarmsTest, Clear);
   friend class ExtensionAlarmsSchedulingTest;
   FRIEND_TEST_ALL_PREFIXES(ExtensionAlarmsSchedulingTest, PollScheduling);
   FRIEND_TEST_ALL_PREFIXES(ExtensionAlarmsSchedulingTest,
                            ReleasedExtensionPollsInfrequently);
   FRIEND_TEST_ALL_PREFIXES(ExtensionAlarmsSchedulingTest, TimerRunning);
+  friend class ProfileKeyedAPIFactory<AlarmManager>;
 
   typedef std::string ExtensionId;
   typedef std::map<ExtensionId, AlarmList> AlarmMap;
 
   // Iterator used to identify a particular alarm within the Map/List pair.
   // "Not found" is represented by <alarms_.end(), invalid_iterator>.
   typedef std::pair<AlarmMap::iterator, AlarmList::iterator> AlarmIterator;
 
   // Helper to return the iterators within the AlarmMap and AlarmList for the
   // matching alarm, or an iterator to the end of the AlarmMap if none were
@@ skipping 23 matching lines @@
 
   // Polls the alarms, running any that have elapsed. After running them and
   // rescheduling repeating alarms, schedule the next poll.
   void PollAlarms();
 
   // NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
+  // ProfileKeyedAPI implementation.
+  static const char* service_name() {
+    return "AlarmManager";
+  }
+
   Profile* const profile_;
-  base::Clock* const clock_;
+  scoped_ptr<base::Clock> clock_;
   content::NotificationRegistrar registrar_;
   scoped_ptr<Delegate> delegate_;
 
   // The timer for this alarm manager.
   base::OneShotTimer<AlarmManager> timer_;
 
   // A map of our pending alarms, per extension.
   // Invariant: None of the AlarmLists are empty.
   AlarmMap alarms_;
 
   // The previous and next time that alarms were and will be run.
   base::Time last_poll_time_;
   base::Time next_poll_time_;
 
   DISALLOW_COPY_AND_ASSIGN(AlarmManager);
 };
 
 }  //  namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_ALARMS_ALARM_MANAGER_H__