Refactor chrome.alarms interface to support absolute alarm deadlines.

chrome/browser/extensions/extension_prefs.cc

Index: chrome/browser/extensions/extension_prefs.cc
diff --git a/chrome/browser/extensions/extension_prefs.cc b/chrome/browser/extensions/extension_prefs.cc
index 6f0f3fbd7915e79add85a92bff3e8ae9d3d7c6b2..0f1a5f1ee1e8bad23cdeec25c9aed227c0d9fd79 100644
--- a/chrome/browser/extensions/extension_prefs.cc
+++ b/chrome/browser/extensions/extension_prefs.cc
@@ -173,7 +173,7 @@ const char kRegisteredEvents[] = "events";
 
 // A list of alarms that this extension has set.
 const char kRegisteredAlarms[] = "alarms";
-const char kAlarmScheduledRunTime[] = "scheduled_run_time";
+const char kAlarmGranularity[] = "granularity";
 
 // Persisted value for omnibox.setDefaultSuggestion.
 const char kOmniboxDefaultSuggestion[] = "omnibox_default_suggestion";
@@ -763,9 +763,11 @@ void ExtensionPrefs::UpdateBlacklist(
 namespace {
 
 // Serializes |time| as a string value mapped to |key| in |dictionary|.
+// 'T' should be base::Time or base::TimeDelta.
+template<typename T>
 void SaveTime(DictionaryValue* dictionary,
               const char* key,
-              const base::Time& time) {
+              const T& time) {
   if (!dictionary)
     return;
   std::string string_value = base::Int64ToString(time.ToInternalValue());
@@ -773,54 +775,56 @@ void SaveTime(DictionaryValue* dictionary,
 }
 
 // The opposite of SaveTime. If |key| is not found, this returns an empty Time
-// (is_null() will return true).
-base::Time ReadTime(const DictionaryValue* dictionary, const char* key) {
+// or TimeDelta (is_null() will return true).
+template<typename T>
+T ReadTime(const DictionaryValue* dictionary, const char* key) {
   if (!dictionary)
-    return base::Time();
+    return T();
   std::string string_value;
   int64 value;
   if (dictionary->GetString(key, &string_value)) {
     if (base::StringToInt64(string_value, &value)) {
-      return base::Time::FromInternalValue(value);
+      return T::FromInternalValue(value);
     }
   }
-  return base::Time();
+  return T();
 }
 
 }  // namespace
 
 base::Time ExtensionPrefs::LastPingDay(const std::string& extension_id) const {
   DCHECK(Extension::IdIsValid(extension_id));
-  return ReadTime(GetExtensionPref(extension_id), kLastPingDay);
+  return ReadTime<base::Time>(GetExtensionPref(extension_id), kLastPingDay);
 }
 
 void ExtensionPrefs::SetLastPingDay(const std::string& extension_id,
                                     const base::Time& time) {
   DCHECK(Extension::IdIsValid(extension_id));
   ScopedExtensionPrefUpdate update(prefs_, extension_id);
-  SaveTime(update.Get(), kLastPingDay, time);
+  SaveTime<base::Time>(update.Get(), kLastPingDay, time);
 }
 
 base::Time ExtensionPrefs::BlacklistLastPingDay() const {
-  return ReadTime(prefs_->GetDictionary(kExtensionsBlacklistUpdate),
-                  kLastPingDay);
+  return ReadTime<base::Time>(prefs_->GetDictionary(kExtensionsBlacklistUpdate),
+                              kLastPingDay);
 }
 
 void ExtensionPrefs::SetBlacklistLastPingDay(const base::Time& time) {
   DictionaryPrefUpdate update(prefs_, kExtensionsBlacklistUpdate);
-  SaveTime(update.Get(), kLastPingDay, time);
+  SaveTime<base::Time>(update.Get(), kLastPingDay, time);
 }
 
 base::Time ExtensionPrefs::LastActivePingDay(const std::string& extension_id) {
   DCHECK(Extension::IdIsValid(extension_id));
-  return ReadTime(GetExtensionPref(extension_id), kLastActivePingDay);
+  return ReadTime<base::Time>(GetExtensionPref(extension_id),
+                              kLastActivePingDay);
 }
 
 void ExtensionPrefs::SetLastActivePingDay(const std::string& extension_id,
                                           const base::Time& time) {
   DCHECK(Extension::IdIsValid(extension_id));
   ScopedExtensionPrefUpdate update(prefs_, extension_id);
-  SaveTime(update.Get(), kLastActivePingDay, time);
+  SaveTime<base::Time>(update.Get(), kLastActivePingDay, time);
 }
 
 bool ExtensionPrefs::GetActiveBit(const std::string& extension_id) {
@@ -957,9 +961,9 @@ void ExtensionPrefs::SetRegisteredEvents(
   UpdateExtensionPref(extension_id, kRegisteredEvents, value);
 }
 
-std::vector<extensions::AlarmPref> ExtensionPrefs::GetRegisteredAlarms(
+std::vector<extensions::Alarm> ExtensionPrefs::GetRegisteredAlarms(
     const std::string& extension_id) {
-  std::vector<extensions::AlarmPref> alarms;
+  std::vector<extensions::Alarm> alarms;
   const base::DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension)
     return alarms;
@@ -968,14 +972,14 @@ std::vector<extensions::AlarmPref> ExtensionPrefs::GetRegisteredAlarms(
   if (!extension->GetList(kRegisteredAlarms, &list))
     return alarms;
 
-  typedef extensions::AlarmManager::Alarm Alarm;
   for (size_t i = 0; i < list->GetSize(); ++i) {
     base::DictionaryValue* alarm_dict = NULL;
-    extensions::AlarmPref alarm;
-    alarm.alarm.reset(new Alarm());
+    extensions::Alarm alarm;
     if (list->GetDictionary(i, &alarm_dict) &&
-        Alarm::Populate(*alarm_dict, alarm.alarm.get())) {
-      alarm.scheduled_run_time = ReadTime(alarm_dict, kAlarmScheduledRunTime);
+        extensions::api::alarms::Alarm::Populate(*alarm_dict,
+                                                 alarm.js_alarm.get())) {
+      alarm.granularity =
+          ReadTime<base::TimeDelta>(alarm_dict, kAlarmGranularity);
       alarms.push_back(alarm);
     }
   }
@@ -984,11 +988,13 @@ std::vector<extensions::AlarmPref> ExtensionPrefs::GetRegisteredAlarms(
 
 void ExtensionPrefs::SetRegisteredAlarms(
     const std::string& extension_id,
-    const std::vector<extensions::AlarmPref>& alarms) {
+    const std::vector<extensions::Alarm>& alarms) {
   base::ListValue* list = new ListValue();
   for (size_t i = 0; i < alarms.size(); ++i) {
-    scoped_ptr<base::DictionaryValue> alarm = alarms[i].alarm->ToValue().Pass();
-    SaveTime(alarm.get(), kAlarmScheduledRunTime, alarms[i].scheduled_run_time);
+    scoped_ptr<base::DictionaryValue> alarm =
+        alarms[i].js_alarm->ToValue().Pass();
+    SaveTime<base::TimeDelta>(alarm.get(), kAlarmGranularity,
+                              alarms[i].granularity);
     list->Append(alarm.release());
   }
   UpdateExtensionPref(extension_id, kRegisteredAlarms, list);