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

extensions/browser/api/alarms/alarm_manager.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 "extensions/browser/api/alarms/alarm_manager.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/clock.h"
 #include "base/time/default_clock.h"
 #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"
 #include "extensions/browser/state_store.h"
 #include "extensions/common/api/alarms.h"
 
 namespace extensions {
 
 namespace alarms = api::alarms;
 
 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() {
   return base::TimeDelta::FromDays(1);
 }
 
 class DefaultAlarmDelegate : public AlarmManager::Delegate {
  public:
   explicit DefaultAlarmDelegate(content::BrowserContext* context)
       : browser_context_(context) {}
@@ skipping 14 matching lines @@
 
 // Creates a TimeDelta from a delay as specified in the API.
 base::TimeDelta TimeDeltaFromDelay(double delay_in_minutes) {
   return base::TimeDelta::FromMicroseconds(delay_in_minutes *
                                            base::Time::kMicrosecondsPerMinute);
 }
 
 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);
     }
   }
   return alarms;
 }
 
 std::unique_ptr<base::ListValue> AlarmsToValue(
     const std::vector<Alarm>& alarms) {
   std::unique_ptr<base::ListValue> list(new base::ListValue());
   for (size_t i = 0; i < alarms.size(); ++i) {
     std::unique_ptr<base::DictionaryValue> alarm =
         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;
 }
 
 }  // namespace
 
 // AlarmManager
 
 AlarmManager::AlarmManager(content::BrowserContext* context)
@@ skipping 366 matching lines @@
         new double(*create_info.period_in_minutes));
   }
 }
 
 Alarm::Alarm(const Alarm& other) = default;
 
 Alarm::~Alarm() {
 }
 
 }  // namespace extensions