Make chrome.alarms API accept non-integers and too-short delays.

chrome/browser/extensions/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 "chrome/browser/extensions/api/alarms/alarm_manager.h"
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
 #include "base/time.h"
@@ skipping 11 matching lines @@
 
 namespace {
 
 const char kOnAlarmEvent[] = "alarms.onAlarm";
 
 // A list of alarms that this extension has set.
 const char kRegisteredAlarms[] = "alarms";
 const char kAlarmGranularity[] = "granularity";
 
 // The minimum period between polling for alarms to run.
-const base::TimeDelta kDefaultMinPollPeriod = base::TimeDelta::FromMinutes(1);
+const base::TimeDelta kDefaultMinPollPeriod = base::TimeDelta::FromDays(1);
 
 class DefaultAlarmDelegate : public AlarmManager::Delegate {
  public:
   explicit DefaultAlarmDelegate(Profile* profile) : profile_(profile) {}
   virtual ~DefaultAlarmDelegate() {}
 
   virtual void OnAlarm(const std::string& extension_id,
                        const Alarm& alarm) {
     scoped_ptr<ListValue> args(new ListValue());
     args->Append(alarm.js_alarm->ToValue().release());
@@ skipping 157 matching lines @@
 void AlarmManager::AddAlarmImpl(const std::string& extension_id,
                                 const Alarm& alarm) {
   // Override any old alarm with the same name.
   AlarmIterator old_alarm = GetAlarmIterator(extension_id,
                                              alarm.js_alarm->name);
   if (old_alarm.first != alarms_.end())
     RemoveAlarmIterator(old_alarm);
 
   alarms_[extension_id].push_back(alarm);
 
-  // TODO(yoz): Is 0 really sane? There could be thrashing.
-  ScheduleNextPoll(base::TimeDelta::FromMinutes(0));
+  ScheduleNextPoll();
 }
 
 void AlarmManager::WriteToStorage(const std::string& extension_id) {
   StateStore* storage = ExtensionSystem::Get(profile_)->state_store();
   if (!storage)
     return;
 
   scoped_ptr<Value> alarms;
   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, alarms.Pass());
 }
 
 void AlarmManager::ReadFromStorage(const std::string& extension_id,
                                    scoped_ptr<base::Value> value) {
   base::ListValue* list = NULL;
   if (!value.get() || !value->GetAsList(&list))
     return;
 
   std::vector<Alarm> alarm_states = AlarmsFromValue(list);
   for (size_t i = 0; i < alarm_states.size(); ++i) {
     AddAlarmImpl(extension_id, alarm_states[i]);
   }
 }
 
-void AlarmManager::ScheduleNextPoll(base::TimeDelta min_period) {
+void AlarmManager::ScheduleNextPoll() {
   // 0. If there are no alarms, stop the timer.
   if (alarms_.empty()) {
     timer_.Stop();
     return;
   }
 
   // TODO(yoz): Try not to reschedule every single time if we're adding
   // a lot of alarms.
 
-  base::Time next_poll(last_poll_time_ + min_period);
-
-  // Find the soonest alarm that is scheduled to run.
+  // Find the soonest alarm that is scheduled to run and the smallest
+  // granularity of any alarm.
   // alarms_ guarantees that none of its contained lists are empty.
   base::Time soonest_alarm_time = base::Time::FromJsTime(
       alarms_.begin()->second.begin()->js_alarm->scheduled_time);
+  base::TimeDelta min_granularity = kDefaultMinPollPeriod;
   for (AlarmMap::const_iterator m_it = alarms_.begin(), m_end = alarms_.end();
        m_it != m_end; ++m_it) {
     for (AlarmList::const_iterator l_it = m_it->second.begin();
          l_it != m_it->second.end(); ++l_it) {
       base::Time cur_alarm_time =
           base::Time::FromJsTime(l_it->js_alarm->scheduled_time);
       if (cur_alarm_time < soonest_alarm_time)
         soonest_alarm_time = cur_alarm_time;
+      if (l_it->granularity < min_granularity)
+        min_granularity = l_it->granularity;
     }
   }
 
-  // If the next alarm is more than min_period in the future, wait for it.
-  // Otherwise, only poll as often as min_period.
-  if (last_poll_time_.is_null() || next_poll < soonest_alarm_time) {
+  base::Time next_poll(last_poll_time_ + min_granularity);
+  // If the next alarm is more than min_granularity in the future, wait for it.
+  // Otherwise, only poll as often as min_granularity.
+  // As a special case, if we've never checked for an alarm before
+  // (e.g. during startup), let alarms fire asap.
+  if (last_poll_time_.is_null() || next_poll < soonest_alarm_time)
     next_poll = soonest_alarm_time;
-  }
 
   // Schedule the poll.
   next_poll_time_ = next_poll;
   base::TimeDelta delay = std::max(base::TimeDelta::FromSeconds(0),
                                    next_poll - now_());
   timer_.Start(FROM_HERE,
                delay,
                this,
                &AlarmManager::PollAlarms);
 }
@@ skipping 14 matching lines @@
     // iterator that the destruction invalidates.
     for (size_t i = cur_extension->second.size(); i > 0; --i) {
       AlarmList::iterator cur_alarm = cur_extension->second.begin() + i - 1;
       if (base::Time::FromJsTime(cur_alarm->js_alarm->scheduled_time) <=
           next_poll_time_) {
         OnAlarm(make_pair(cur_extension, cur_alarm));
       }
     }
   }
 
-  // Schedule the next poll. The soonest it may happen is after
-  // kDefaultMinPollPeriod or after the shortest granularity of any alarm,
-  // whichever comes sooner.
-  base::TimeDelta min_poll_period = kDefaultMinPollPeriod;
-  for (AlarmMap::const_iterator m_it = alarms_.begin(), m_end = alarms_.end();
-       m_it != m_end; ++m_it) {
-    for (AlarmList::const_iterator l_it = m_it->second.begin();
-         l_it != m_it->second.end(); ++l_it) {
-      if (l_it->granularity < min_poll_period)
-        min_poll_period = l_it->granularity;
-    }
-  }
-  ScheduleNextPoll(min_poll_period);
+  ScheduleNextPoll();
 }
 
 void AlarmManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
@@ skipping 48 matching lines @@
   if (create_info.period_in_minutes.get()) {
     js_alarm->period_in_minutes.reset(
         new double(*create_info.period_in_minutes));
   }
 }
 
 Alarm::~Alarm() {
 }
 
 }  // namespace extensions