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..bae304d56fb11fceb63fc5ee2d71fd2abefa811c 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";
@@ -762,65 +762,67 @@ void ExtensionPrefs::UpdateBlacklist(
 
 namespace {
 
-// Serializes |time| as a string value mapped to |key| in |dictionary|.
-void SaveTime(DictionaryValue* dictionary,
-              const char* key,
-              const base::Time& time) {
+// Serializes |value| as a string value mapped to |key| in |dictionary|.
+template<typename T>
+void Save(DictionaryValue* dictionary,

[Matt Perry, 2012/06/11 22:32:44]

I would still call this SaveTime since it only works on the time classes.

[Jeffrey Yasskin, 2012/06/12 19:12:31]

Done.

+          const char* key,
+          const T& value) {
   if (!dictionary)
     return;
-  std::string string_value = base::Int64ToString(time.ToInternalValue());
+  std::string string_value = base::Int64ToString(value.ToInternalValue());
   dictionary->SetString(key, string_value);
 }
 
-// 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) {
+// The opposite of Save. If |key| is not found, this returns a
+// default-constructed T (for Times and TimeDeltas, is_null() will return true).
+template<typename T>
+T Read(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 Read<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);
+  Save<base::Time>(update.Get(), kLastPingDay, time);
 }
 
 base::Time ExtensionPrefs::BlacklistLastPingDay() const {
-  return ReadTime(prefs_->GetDictionary(kExtensionsBlacklistUpdate),
-                  kLastPingDay);
+  return Read<base::Time>(prefs_->GetDictionary(kExtensionsBlacklistUpdate),
+                          kLastPingDay);
 }
 
 void ExtensionPrefs::SetBlacklistLastPingDay(const base::Time& time) {
   DictionaryPrefUpdate update(prefs_, kExtensionsBlacklistUpdate);
-  SaveTime(update.Get(), kLastPingDay, time);
+  Save<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 Read<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);
+  Save<base::Time>(update.Get(), kLastActivePingDay, time);
 }
 
 bool ExtensionPrefs::GetActiveBit(const std::string& extension_id) {
@@ -957,9 +959,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 +970,13 @@ 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 = Read<base::TimeDelta>(alarm_dict, kAlarmGranularity);
       alarms.push_back(alarm);
     }
   }
@@ -984,11 +985,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();
+    Save<base::TimeDelta>(alarm.get(), kAlarmGranularity,
+                          alarms[i].granularity);
     list->Append(alarm.release());
   }
   UpdateExtensionPref(extension_id, kRegisteredAlarms, list);