Extension alarms now persist in Preferences.

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__
 #pragma once
 
 #include <string>
 #include <map>
 #include <vector>
 
 #include "base/timer.h"
 #include "chrome/browser/extensions/extension_function.h"
 #include "chrome/common/extensions/api/experimental.alarms.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
 
 class Profile;
 
 namespace extensions {
 
 // Manages the currently pending alarms for every extension in a profile.
 // There is one manager per virtual Profile.
-class AlarmManager {
+class AlarmManager : public content::NotificationObserver {
  public:
   typedef extensions::api::experimental_alarms::Alarm Alarm;
   typedef std::vector<linked_ptr<Alarm> > AlarmList;
 
   class Delegate {
    public:
     virtual ~Delegate() {}
     // Called when an alarm fires.
     virtual void OnAlarm(const std::string& extension_id,
                          const Alarm& alarm) = 0;
@@ skipping 25 matching lines @@
   void RemoveAllAlarms(const std::string& extension_id);
 
  private:
   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;
 
+  // The timer associated with an alarm.
+  struct TimerInfo;
+
   // 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
   // found.
   AlarmIterator GetAlarmIterator(const std::string& extension_id,
                                  const std::string& name);
 
   // Helper to cancel and remove the alarm at the given iterator. The iterator
   // must be valid.
   void RemoveAlarmIterator(const AlarmIterator& iter);
 
   // Callback for when an alarm fires.
   void OnAlarm(const std::string& extension_id, const std::string& name);
 
+  // Internal helper to add an alarm and start the timer with the given delay.
+  void AddAlarmImpl(const std::string& extension_id,
+                    const linked_ptr<Alarm>& alarm,
+                    base::TimeDelta timer_delay);
+
+  // Syncs our alarm data for the given extension to/from the prefs file.
+  void WriteToPrefs(const std::string& extension_id);
+  void ReadFromPrefs(const std::string& extension_id);
+
+  // NotificationObserver:
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
+
   Profile* profile_;
+  content::NotificationRegistrar registrar_;
   scoped_ptr<Delegate> delegate_;
 
   // A map of our pending alarms, per extension.
   AlarmMap alarms_;
 
   // A map of the timer associated with each alarm.
-  std::map<const Alarm*, linked_ptr<base::Timer> > timers_;
+  std::map<const Alarm*, linked_ptr<TimerInfo> > timers_;
+};
+
+// Contains the data we store in the extension prefs for each alarm.
+struct AlarmPref {
+  linked_ptr<AlarmManager::Alarm> alarm;
+  base::Time scheduled_run_time;
+
+  AlarmPref();
+  ~AlarmPref();
 };
 
 } //  namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_ALARMS_ALARM_MANAGER_H__