Refactor chrome.alarms interface to support absolute alarm deadlines.

chrome/browser/extensions/extension_prefs.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/extension_prefs.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/admin_policy.h"
@@ skipping 155 matching lines @@
 
 // A preference that contains extension-set content settings.
 const char kPrefIncognitoContentSettings[] = "incognito_content_settings";
 
 // A list of event names that this extension has registered from its lazy
 // background page.
 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";
 
 // A preference containing context menu items, persisted for event pages.
 const char kPrefContextMenus[] = "context_menus";
 
 // Provider of write access to a dictionary storing extension prefs.
 class ScopedExtensionPrefUpdate : public DictionaryPrefUpdate {
  public:
@@ skipping 569 matching lines @@
     }
   }
   for (unsigned int i = 0; i < remove_pref_ids.size(); ++i) {
     DeleteExtensionPrefs(remove_pref_ids[i]);
   }
 }
 
 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());
   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) {
+// 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) {
   const DictionaryValue* dictionary = GetExtensionPref(extension_id);
   bool result = false;
   if (dictionary && dictionary->GetBoolean(kActiveBit, &result))
     return result;
   return false;
 }
 
@@ skipping 116 matching lines @@
 void ExtensionPrefs::SetRegisteredEvents(
     const std::string& extension_id, const std::set<std::string>& events) {
   ListValue* value = new ListValue();
   for (std::set<std::string>::const_iterator it = events.begin();
        it != events.end(); ++it) {
     value->Append(new StringValue(*it));
   }
   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;
 
   base::ListValue* list = NULL;
   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);
     }
   }
   return alarms;
 }
 
 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);
 }
 
 extensions::ExtensionOmniboxSuggestion
 ExtensionPrefs::GetOmniboxDefaultSuggestion(const std::string& extension_id) {
   extensions::ExtensionOmniboxSuggestion suggestion;
 
   const base::DictionaryValue* extension = GetExtensionPref(extension_id);
@@ skipping 946 matching lines @@
                             PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kLastExtensionsUpdateCheck,
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kNextExtensionsUpdateCheck,
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionAllowedInstallSites,
                           PrefService::UNSYNCABLE_PREF);
 }