Fix a bug where the minimum granular time for Alarms was not calculated properly.

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/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 281 matching lines @@
 
   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);
 }
 
 void AlarmManager::ScheduleNextPoll() {
-  // 0. If there are no alarms, stop the timer.
+  // 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.
 
   // 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;
+      base::TimeDelta cur_alarm_delta = cur_alarm_time - clock_->Now();

[dhnishi (use Chromium), 2013/08/16 22:28:29]

I am worried about this causing a potential race condition. Thoughts?

[Matt Perry, 2013/08/16 22:30:59]

In what sense? I'm not sure I see a problem.

+      if (cur_alarm_delta < min_granularity)
+        min_granularity = cur_alarm_delta;
+      if (min_granularity < l_it->minimum_granularity)
+        min_granularity = l_it->minimum_granularity;
     }
   }
 
   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;
@@ skipping 82 matching lines @@
 Alarm::Alarm()
     : js_alarm(new api::alarms::Alarm()) {
 }
 
 Alarm::Alarm(const std::string& name,
              const api::alarms::AlarmCreateInfo& create_info,
              base::TimeDelta min_granularity,
              base::Time now)
     : js_alarm(new api::alarms::Alarm()) {
   js_alarm->name = name;
+  minimum_granularity = min_granularity;
 
   if (create_info.when.get()) {
     // Absolute scheduling.
     js_alarm->scheduled_time = *create_info.when;
     granularity = base::Time::FromJsTime(js_alarm->scheduled_time) - now;
   } else {
     // Relative scheduling.
     double* delay_in_minutes = create_info.delay_in_minutes.get();
     if (delay_in_minutes == NULL)
       delay_in_minutes = create_info.period_in_minutes.get();
@@ skipping 12 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