Do not reschedule all alarms when adding a new alarm

chrome/browser/extensions/api/alarms/alarms_api_unittest.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.
 
 // This file tests the chrome.alarms extension API.
 
 #include "base/test/simple_test_clock.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/alarms/alarm_manager.h"
 #include "chrome/browser/extensions/api/alarms/alarms_api.h"
@@ skipping 423 matching lines @@
   CreateAlarms(3);
   alarm_manager_->GetAllAlarms(extension()->id(), base::Bind(
       ExtensionAlarmsTestClearAllGetAllAlarms1Callback, this));
 }
 
 class ExtensionAlarmsSchedulingTest : public ExtensionAlarmsTest {
   void GetAlarmCallback(Alarm* alarm) {
     CHECK(alarm);
     const base::Time scheduled_time =
         base::Time::FromJsTime(alarm->js_alarm->scheduled_time);
-    EXPECT_EQ(scheduled_time, alarm_manager_->test_next_poll_time_);
+    EXPECT_EQ(scheduled_time, alarm_manager_->next_poll_time_);
   }
 
   static void RemoveAlarmCallback (bool success) { EXPECT_TRUE(success); }
   static void RemoveAllAlarmsCallback () {}
  public:
   // Get the time that the alarm named is scheduled to run.
   void VerifyScheduledTime(const std::string& alarm_name) {
     alarm_manager_->GetAlarm(extension()->id(), alarm_name, base::Bind(
         &ExtensionAlarmsSchedulingTest::GetAlarmCallback,
         base::Unretained(this)));
@@ skipping 39 matching lines @@
   {
     test_clock_->SetNow(base::Time::FromDoubleT(3 * 60 + 1));
     Alarm alarm;
     alarm.js_alarm->name = "bb";
     alarm.js_alarm->scheduled_time = 3 * 60000;
     alarm.js_alarm->period_in_minutes.reset(new double(3));
     alarm_manager_->AddAlarmImpl(extension()->id(), alarm);
     base::MessageLoop::current()->Run();
     EXPECT_EQ(base::Time::FromJsTime(3 * 60000) +
                   base::TimeDelta::FromMinutes(3),
-              alarm_manager_->test_next_poll_time_);
+              alarm_manager_->next_poll_time_);
     RemoveAllAlarms();
   }
   {
     test_clock_->SetNow(base::Time::FromDoubleT(4 * 60 + 1));
     CreateAlarm("[\"a\", {\"periodInMinutes\": 2}]");
     RemoveAlarm("a");
     Alarm alarm2;
     alarm2.js_alarm->name = "bb";
     alarm2.js_alarm->scheduled_time = 4 * 60000;
     alarm2.js_alarm->period_in_minutes.reset(new double(4));
     alarm_manager_->AddAlarmImpl(extension()->id(), alarm2);
     Alarm alarm3;
     alarm3.js_alarm->name = "ccc";
     alarm3.js_alarm->scheduled_time = 25 * 60000;
     alarm3.js_alarm->period_in_minutes.reset(new double(25));
     alarm_manager_->AddAlarmImpl(extension()->id(), alarm3);
     base::MessageLoop::current()->Run();
     EXPECT_EQ(base::Time::FromJsTime(4 * 60000) +
                   base::TimeDelta::FromMinutes(4),
-              alarm_manager_->test_next_poll_time_);
+              alarm_manager_->next_poll_time_);
     RemoveAllAlarms();
   }
 }
 
 TEST_F(ExtensionAlarmsSchedulingTest, ReleasedExtensionPollsInfrequently) {
   set_extension(utils::CreateEmptyExtensionWithLocation(
       extensions::Manifest::INTERNAL));
   test_clock_->SetNow(base::Time::FromJsTime(300000));
   CreateAlarm("[\"a\", {\"when\": 300010}]");
   CreateAlarm("[\"b\", {\"when\": 340000}]");
 
   // On startup (when there's no "last poll"), we let alarms fire as
   // soon as they're scheduled.
-  EXPECT_DOUBLE_EQ(300010, alarm_manager_->test_next_poll_time_.ToJsTime());
+  EXPECT_DOUBLE_EQ(300010, alarm_manager_->next_poll_time_.ToJsTime());
 
   alarm_manager_->last_poll_time_ = base::Time::FromJsTime(290000);
   // In released extensions, we set the granularity to at least 1
   // minute, which makes AddAlarm schedule the next poll after the
   // extension requested.
   alarm_manager_->ScheduleNextPoll();
   EXPECT_DOUBLE_EQ((alarm_manager_->last_poll_time_ +
                     base::TimeDelta::FromMinutes(1)).ToJsTime(),
-                    alarm_manager_->test_next_poll_time_.ToJsTime());
+                    alarm_manager_->next_poll_time_.ToJsTime());
 }
 
 TEST_F(ExtensionAlarmsSchedulingTest, TimerRunning) {
   EXPECT_FALSE(alarm_manager_->timer_.IsRunning());
   CreateAlarm("[\"a\", {\"delayInMinutes\": 0.001}]");
   EXPECT_TRUE(alarm_manager_->timer_.IsRunning());
   test_clock_->Advance(base::TimeDelta::FromMilliseconds(60));
   base::MessageLoop::current()->Run();
   EXPECT_FALSE(alarm_manager_->timer_.IsRunning());
   CreateAlarm("[\"bb\", {\"delayInMinutes\": 10}]");
@@ skipping 11 matching lines @@
   CreateAlarm("[\"b\", {\"periodInMinutes\": 2}]");
   test_clock_->Advance(base::TimeDelta::FromMinutes(2));
 
   alarm_manager_->last_poll_time_ = base::Time::FromJsTime(2 * 60000);
   // In released extensions, we set the granularity to at least 1
   // minute, which makes scheduler set it to 1 minute, rather than
   // 1 second later (when b is supposed to go off).
   alarm_manager_->ScheduleNextPoll();
   EXPECT_DOUBLE_EQ((alarm_manager_->last_poll_time_ +
                     base::TimeDelta::FromMinutes(1)).ToJsTime(),
-                    alarm_manager_->test_next_poll_time_.ToJsTime());
+                    alarm_manager_->next_poll_time_.ToJsTime());
 }
 
 TEST_F(ExtensionAlarmsSchedulingTest, DifferentMinimumGranularities) {
   test_clock_->SetNow(base::Time::FromJsTime(0));
   // Create an alarm to go off in 12 seconds. This uses the default, unpacked
   // extension - so there is no minimum granularity.
   CreateAlarm("[\"a\", {\"periodInMinutes\": 0.2}]");  // 12 seconds.
 
   // Create a new extension, which is packed, and has a granularity of 1 minute.
   // CreateAlarm() uses extension_, so keep a ref of the old one around, and
   // repopulate extension_.
   scoped_refptr<Extension> extension2(extension_ref());
   set_extension(
       utils::CreateEmptyExtensionWithLocation(extensions::Manifest::INTERNAL));
 
   CreateAlarm("[\"b\", {\"periodInMinutes\": 2}]");
 
   alarm_manager_->last_poll_time_ = base::Time::FromJsTime(0);
   alarm_manager_->ScheduleNextPoll();
 
   // The next poll time should be 12 seconds from now - the time at which the
   // first alarm should go off.
   EXPECT_DOUBLE_EQ((alarm_manager_->last_poll_time_ +
                     base::TimeDelta::FromSeconds(12)).ToJsTime(),
-                    alarm_manager_->test_next_poll_time_.ToJsTime());
+                    alarm_manager_->next_poll_time_.ToJsTime());
 }
 
 // Test that scheduled alarms go off at set intervals, even if their actual
 // trigger is off.
 TEST_F(ExtensionAlarmsSchedulingTest, RepeatingAlarmsScheduledPredictably) {
   test_clock_->SetNow(base::Time::FromJsTime(0));
   CreateAlarm("[\"a\", {\"periodInMinutes\": 2}]");
 
   alarm_manager_->last_poll_time_ = base::Time::FromJsTime(0);
   alarm_manager_->ScheduleNextPoll();
 
   // We expect the first poll to happen two minutes from the start.
   EXPECT_DOUBLE_EQ((alarm_manager_->last_poll_time_ +
                        base::TimeDelta::FromSeconds(120)).ToJsTime(),
-                   alarm_manager_->test_next_poll_time_.ToJsTime());
+                   alarm_manager_->next_poll_time_.ToJsTime());
 
   // Poll more than two minutes later.
   test_clock_->Advance(base::TimeDelta::FromSeconds(125));
   alarm_manager_->PollAlarms();
 
   // The alarm should have triggered once.
   EXPECT_EQ(1u, alarm_delegate_->alarms_seen.size());
 
   // The next poll should still be scheduled for four minutes from the start,
   // even though this is less than two minutes since the last alarm.
   // Last poll was at 125 seconds; next poll should be at 240 seconds.
   EXPECT_DOUBLE_EQ((alarm_manager_->last_poll_time_ +
                        base::TimeDelta::FromSeconds(115)).ToJsTime(),
-                   alarm_manager_->test_next_poll_time_.ToJsTime());
+                   alarm_manager_->next_poll_time_.ToJsTime());
 
   // Completely miss a scheduled trigger.
   test_clock_->Advance(base::TimeDelta::FromSeconds(255));  // Total Time: 380s
   alarm_manager_->PollAlarms();
 
   // The alarm should have triggered again at this last poll.
   EXPECT_EQ(2u, alarm_delegate_->alarms_seen.size());
 
   // The next poll should be the first poll that hasn't happened and is in-line
   // with the original scheduling.
   // Last poll was at 380 seconds; next poll should be at 480 seconds.
   EXPECT_DOUBLE_EQ((alarm_manager_->last_poll_time_ +
                        base::TimeDelta::FromSeconds(100)).ToJsTime(),
-                   alarm_manager_->test_next_poll_time_.ToJsTime());
+                   alarm_manager_->next_poll_time_.ToJsTime());
 }
 
 }  // namespace extensions