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 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) {}
   ~DefaultAlarmDelegate() override {}
@@ skipping 10 matching lines @@
  private:
   content::BrowserContext* browser_context_;
 };
 
 // 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> AlarmsFromValue(const std::string extension_id,
+                                   bool is_unpacked,
+                                   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);
+      alarm.minimum_granularity = base::TimeDelta::FromSecondsD(
+          (is_unpacked ? alarms_api_constants::kDevDelayMinimum
+                       : alarms_api_constants::kReleaseDelayMinimum) *
+          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) {
@@ skipping 210 matching lines @@
   AlarmMap::iterator list = alarms_.find(extension_id);
   if (list != alarms_.end())
     alarms.reset(AlarmsToValue(list->second).release());
   else
     alarms.reset(AlarmsToValue(std::vector<Alarm>()).release());
   storage->SetExtensionValue(extension_id, kRegisteredAlarms,
                              std::move(alarms));
 }
 
 void AlarmManager::ReadFromStorage(const std::string& extension_id,
+                                   bool is_unpacked,
                                    std::unique_ptr<base::Value> value) {
   base::ListValue* list = NULL;
   if (value.get() && value->GetAsList(&list)) {
-    std::vector<Alarm> alarm_states = AlarmsFromValue(list);
+    std::vector<Alarm> alarm_states =
+        AlarmsFromValue(extension_id, is_unpacked, list);
     for (size_t i = 0; i < alarm_states.size(); ++i)
       AddAlarmImpl(extension_id, alarm_states[i]);
   }
 
   ReadyQueue& extension_ready_queue = ready_actions_[extension_id];
   while (!extension_ready_queue.empty()) {
     extension_ready_queue.front().Run(extension_id);
     extension_ready_queue.pop();
   }
   ready_actions_.erase(extension_id);
@@ skipping 86 matching lines @@
   if (it == ready_actions_.end())
     action.Run(extension_id);
   else
     it->second.push(action);
 }
 
 void AlarmManager::OnExtensionLoaded(content::BrowserContext* browser_context,
                                      const Extension* extension) {
   StateStore* storage = ExtensionSystem::Get(browser_context_)->state_store();
   if (storage) {
+    bool is_unpacked = Manifest::IsUnpackedLocation(extension->location());
     ready_actions_.insert(ReadyMap::value_type(extension->id(), ReadyQueue()));
-    storage->GetExtensionValue(extension->id(), kRegisteredAlarms,
-                               base::Bind(&AlarmManager::ReadFromStorage,
-                                          AsWeakPtr(), extension->id()));
+    storage->GetExtensionValue(
+        extension->id(), kRegisteredAlarms,
+        base::Bind(&AlarmManager::ReadFromStorage, AsWeakPtr(), extension->id(),
+                   is_unpacked));
   }
 }
 
 void AlarmManager::OnExtensionUninstalled(
     content::BrowserContext* browser_context,
     const Extension* extension,
     extensions::UninstallReason reason) {
   RemoveAllAlarms(extension->id(), base::Bind(RemoveAllOnUninstallCallback));
 }
 
@@ skipping 36 matching lines @@
         new double(*create_info.period_in_minutes));
   }
 }
 
 Alarm::Alarm(const Alarm& other) = default;
 
 Alarm::~Alarm() {
 }
 
 }  // namespace extensions