Perform alarm's period limit check while reading alarm info from StateStore.

extensions/browser/api/alarms/alarm_manager.cc

Index: extensions/browser/api/alarms/alarm_manager.cc
diff --git a/extensions/browser/api/alarms/alarm_manager.cc b/extensions/browser/api/alarms/alarm_manager.cc
index b382dff81f05133c22097c4d749053cf796c50f0..a9201d759c7a91c0a4db1e08e21b5128115979e7 100644
--- a/extensions/browser/api/alarms/alarm_manager.cc
+++ b/extensions/browser/api/alarms/alarm_manager.cc
@@ -17,6 +17,7 @@
 #include "base/time/time.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
+#include "extensions/browser/api/alarms/alarms_api_constants.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
@@ -32,6 +33,9 @@ namespace {
 // A list of alarms that this extension has set.
 const char kRegisteredAlarms[] = "alarms";
 const char kAlarmGranularity[] = "granularity";
+const char kAlarmMinimumGranularity[] = "minimum_granularity";
+
+const int kSecondsPerMinute = 60;
 
 // The minimum period between polling for alarms to run.
 const base::TimeDelta kDefaultMinPollPeriod() {
@@ -66,13 +70,32 @@ base::TimeDelta TimeDeltaFromDelay(double delay_in_minutes) {
 std::vector<Alarm> AlarmsFromValue(const base::ListValue* list) {
   std::vector<Alarm> alarms;
   for (size_t i = 0; i < list->GetSize(); ++i) {
-    const base::DictionaryValue* alarm_dict = NULL;
+    const base::DictionaryValue* alarm_dict = nullptr;
     Alarm alarm;
     if (list->GetDictionary(i, &alarm_dict) &&
         alarms::Alarm::Populate(*alarm_dict, alarm.js_alarm.get())) {
-      const base::Value* time_value = NULL;
+      const base::Value* time_value = nullptr;
       if (alarm_dict->Get(kAlarmGranularity, &time_value))
         base::GetValueAsTimeDelta(*time_value, &alarm.granularity);
+      const base::Value* minimum_granularity_value = nullptr;
+      if (alarm_dict->Get(kAlarmMinimumGranularity,
+                          &minimum_granularity_value)) {
+        base::GetValueAsTimeDelta(*time_value, &alarm.minimum_granularity);
+      } else {
+        // We didn't use to write kAlarmMinimumGranularity to storage, so it is
+        // possible that the value is missing. At this point we cannot readily
+        // know whether this alarm's extension was loaded from a release (.crx)

[asargent_no_longer_on_chrome, 2016/06/09 19:44:56]

Can you just look up the extension by id, and call
Extension::IsUnpackedLocation(extension->location()) ?

[lazyboy, 2016/06/09 22:00:21]

deleted kAlarmMinimumGranularity, thanks.
Done.

+        // extension or a dev (unpacked) extension. Use the relaxed limit from
+        // dev version in this case. This should happen only once ever per
+        // alarm, the next WriteToStorage will fix things up.
+        // Also note that it is important to restrict
+        // |alarm.minimum_granularity| to make sure we do not fire alarms too
+        // often.
+        alarm.minimum_granularity = base::TimeDelta::FromSecondsD(
+            alarms_api_constants::kDevDelayMinimum * kSecondsPerMinute);
+      }
+      if (alarm.granularity < alarm.minimum_granularity)
+        alarm.granularity = alarm.minimum_granularity;
       alarms.push_back(alarm);
     }
   }
@@ -87,6 +110,8 @@ std::unique_ptr<base::ListValue> AlarmsToValue(
         alarms[i].js_alarm->ToValue();
     alarm->Set(kAlarmGranularity,
                base::CreateTimeDeltaValue(alarms[i].granularity));
+    alarm->Set(kAlarmMinimumGranularity,
+               base::CreateTimeDeltaValue(alarms[i].minimum_granularity));
     list->Append(alarm.release());
   }
   return list;