Alarm resolution changed to minutes and minimum delay added.

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/values.h"
 #include "chrome/browser/browser_process_impl.h"
 #include "chrome/browser/extensions/api/alarms/alarm_manager.h"
 #include "chrome/browser/extensions/api/alarms/alarms_api.h"
@@ skipping 29 matching lines @@
     BrowserWithTestWindowTest::SetUp();
 
     TestExtensionSystem* system = static_cast<TestExtensionSystem*>(
         ExtensionSystem::Get(browser()->profile()));
     system->CreateAlarmManager();
     alarm_manager_ = system->alarm_manager();
 
     alarm_delegate_ = new AlarmDelegate();
     alarm_manager_->set_delegate(alarm_delegate_);
 
-    extension_ = utils::CreateEmptyExtension();
+    extension_ = utils::CreateEmptyExtensionWithLocation(Extension::LOAD);
   }
 
   base::Value* RunFunctionWithExtension(
       UIThreadExtensionFunction* function, const std::string& args) {
     function->set_extension(extension_.get());
     return utils::RunFunctionAndReturnResult(function, args, browser());
   }
 
   base::DictionaryValue* RunFunctionAndReturnDict(
       UIThreadExtensionFunction* function, const std::string& args) {
@@ skipping 33 matching lines @@
       list.push_back(alarm);
     }
     return list;
   }
 
   // Creates up to 3 alarms using the extension API.
   void CreateAlarms(size_t num_alarms) {
     CHECK(num_alarms <= 3);
 
     const char* kCreateArgs[] = {
-      "[null, {\"delayInSeconds\": 1, \"repeating\": true}]",
-      "[\"7\", {\"delayInSeconds\": 7, \"repeating\": true}]",
-      "[\"0\", {\"delayInSeconds\": 0}]"
+      "[null, {\"delayInMinutes\": 0.001, \"repeating\": true}]",
+      "[\"7\", {\"delayInMinutes\": 7, \"repeating\": true}]",
+      "[\"0\", {\"delayInMinutes\": 0}]"
     };
     for (size_t i = 0; i < num_alarms; ++i) {
       scoped_ptr<base::DictionaryValue> result(RunFunctionAndReturnDict(
           new AlarmsCreateFunction(), kCreateArgs[i]));
       EXPECT_FALSE(result.get());
     }
   }
 
  protected:
   AlarmManager* alarm_manager_;
   AlarmDelegate* alarm_delegate_;
   scoped_refptr<Extension> extension_;
 };
 
 }  // namespace
 
 TEST_F(ExtensionAlarmsTest, Create) {
   // Create 1 non-repeating alarm.
-  RunFunction(new AlarmsCreateFunction(), "[null, {\"delayInSeconds\": 0}]");
+  RunFunction(new AlarmsCreateFunction(), "[null, {\"delayInMinutes\": 0}]");
 
   const AlarmManager::Alarm* alarm =
       alarm_manager_->GetAlarm(extension_->id(), "");
   ASSERT_TRUE(alarm);
   EXPECT_EQ("", alarm->name);
-  EXPECT_EQ(0, alarm->delay_in_seconds);
+  EXPECT_EQ(0, alarm->delay_in_minutes);
   EXPECT_FALSE(alarm->repeating);
 
   // Now wait for the alarm to fire. Our test delegate will quit the
   // MessageLoop when that happens.
   MessageLoop::current()->Run();
 
   ASSERT_EQ(1u, alarm_delegate_->alarms_seen.size());
   EXPECT_EQ("", alarm_delegate_->alarms_seen[0]);
 
   // Ensure the alarm is gone.
   {
     const AlarmManager::AlarmList* alarms =
         alarm_manager_->GetAllAlarms(extension_->id());
     ASSERT_FALSE(alarms);
   }
 }
 
 TEST_F(ExtensionAlarmsTest, CreateRepeating) {
   // Create 1 repeating alarm.
-  // TODO(mpcmoplete): Use a shorter delay if we switch to allow fractions.
-  // A repeating timer with a 0-second delay fires infinitely.
   RunFunction(new AlarmsCreateFunction(),
-              "[null, {\"delayInSeconds\": 1, \"repeating\": true}]");
+              "[null, {\"delayInMinutes\": 0.001, \"repeating\": true}]");
 
   const AlarmManager::Alarm* alarm =
       alarm_manager_->GetAlarm(extension_->id(), "");
   ASSERT_TRUE(alarm);
   EXPECT_EQ("", alarm->name);
-  EXPECT_EQ(1, alarm->delay_in_seconds);
+  EXPECT_EQ(0.001, alarm->delay_in_minutes);
   EXPECT_TRUE(alarm->repeating);
 
   // Now wait for the alarm to fire. Our test delegate will quit the
   // MessageLoop when that happens.
   MessageLoop::current()->Run();
 
   // Wait again, and ensure the alarm fires again.
   MessageLoop::current()->Run();
 
   ASSERT_EQ(2u, alarm_delegate_->alarms_seen.size());
   EXPECT_EQ("", alarm_delegate_->alarms_seen[0]);
 }
 
 TEST_F(ExtensionAlarmsTest, CreateDupe) {
   // Create 2 duplicate alarms. The first should be overridden.
-  RunFunction(new AlarmsCreateFunction(), "[\"dup\", {\"delayInSeconds\": 1}]");
-  RunFunction(new AlarmsCreateFunction(), "[\"dup\", {\"delayInSeconds\": 7}]");
+  RunFunction(new AlarmsCreateFunction(), "[\"dup\", {\"delayInMinutes\": 1}]");
+  RunFunction(new AlarmsCreateFunction(), "[\"dup\", {\"delayInMinutes\": 7}]");
 
   {
     const AlarmManager::AlarmList* alarms =
         alarm_manager_->GetAllAlarms(extension_->id());
     ASSERT_TRUE(alarms);
     EXPECT_EQ(1u, alarms->size());
-    EXPECT_EQ(7, (*alarms)[0]->delay_in_seconds);
+    EXPECT_EQ(7, (*alarms)[0]->delay_in_minutes);
   }
 }
 
+TEST_F(ExtensionAlarmsTest, CreateDelayBelowMinimum) {
+  // Create an alarm with delay below the minimum accepted value.
+  std::string error = RunFunctionAndReturnError(new AlarmsCreateFunction(),
+      "[\"negative\", {\"delayInMinutes\": -0.2}]");
+  EXPECT_FALSE(error.empty());
+}
+
 TEST_F(ExtensionAlarmsTest, Get) {
   // Create 2 alarms, and make sure we can query them.
   CreateAlarms(2);
 
   // Get the default one.
   {
     AlarmManager::Alarm alarm;
     scoped_ptr<base::DictionaryValue> result(RunFunctionAndReturnDict(
         new AlarmsGetFunction(), "[null]"));
     ASSERT_TRUE(result.get());
     EXPECT_TRUE(AlarmManager::Alarm::Populate(*result, &alarm));
     EXPECT_EQ("", alarm.name);
-    EXPECT_EQ(1, alarm.delay_in_seconds);
+    EXPECT_EQ(0.001, alarm.delay_in_minutes);
     EXPECT_TRUE(alarm.repeating);
   }
 
   // Get "7".
   {
     AlarmManager::Alarm alarm;
     scoped_ptr<base::DictionaryValue> result(RunFunctionAndReturnDict(
         new AlarmsGetFunction(), "[\"7\"]"));
     ASSERT_TRUE(result.get());
     EXPECT_TRUE(AlarmManager::Alarm::Populate(*result, &alarm));
     EXPECT_EQ("7", alarm.name);
-    EXPECT_EQ(7, alarm.delay_in_seconds);
+    EXPECT_EQ(7, alarm.delay_in_minutes);
     EXPECT_TRUE(alarm.repeating);
   }
 
   // Get a non-existent one.
   {
     std::string error = RunFunctionAndReturnError(
         new AlarmsGetFunction(), "[\"nobody\"]");
     EXPECT_FALSE(error.empty());
   }
 }
@@ skipping 14 matching lines @@
     scoped_ptr<base::ListValue> result(RunFunctionAndReturnList(
         new AlarmsGetAllFunction(), "[null]"));
     AlarmManager::AlarmList alarms = ToAlarmList(result.get());
     EXPECT_EQ(2u, alarms.size());
 
     // Test the "7" alarm.
     AlarmManager::Alarm* alarm = alarms[0].get();
     if (alarm->name != "7")
       alarm = alarms[1].get();
     EXPECT_EQ("7", alarm->name);
-    EXPECT_EQ(7, alarm->delay_in_seconds);
+    EXPECT_EQ(7, alarm->delay_in_minutes);
     EXPECT_TRUE(alarm->repeating);
   }
 }
 
 TEST_F(ExtensionAlarmsTest, Clear) {
   // Clear a non-existent one.
   {
     std::string error = RunFunctionAndReturnError(
         new AlarmsClearFunction(), "[\"nobody\"]");
     EXPECT_FALSE(error.empty());
   }
 
   // Create 3 alarms.
   CreateAlarms(3);
 
-  // Clear all but the 1-second one.
+  // Clear all but the 0.001-minute alarm.
   {
     RunFunction(new AlarmsClearFunction(), "[\"7\"]");
     RunFunction(new AlarmsClearFunction(), "[\"0\"]");
 
     const AlarmManager::AlarmList* alarms =
         alarm_manager_->GetAllAlarms(extension_->id());
     ASSERT_TRUE(alarms);
     EXPECT_EQ(1u, alarms->size());
-    EXPECT_EQ(1, (*alarms)[0]->delay_in_seconds);
+    EXPECT_EQ(0.001, (*alarms)[0]->delay_in_minutes);
   }
 
   // Now wait for the alarms to fire, and ensure the cancelled alarms don't
   // fire.
   MessageLoop::current()->Run();
 
   ASSERT_EQ(1u, alarm_delegate_->alarms_seen.size());
   EXPECT_EQ("", alarm_delegate_->alarms_seen[0]);
 
-  // Ensure the 1-second alarm is still there, since its repeating.
+  // Ensure the 0.001-minute alarm is still there, since it's repeating.
   {
     const AlarmManager::AlarmList* alarms =
         alarm_manager_->GetAllAlarms(extension_->id());
     ASSERT_TRUE(alarms);
     EXPECT_EQ(1u, alarms->size());
-    EXPECT_EQ(1, (*alarms)[0]->delay_in_seconds);
+    EXPECT_EQ(0.001, (*alarms)[0]->delay_in_minutes);
   }
 }
 
 TEST_F(ExtensionAlarmsTest, ClearAll) {
   // ClearAll with no alarms set.
   {
     scoped_ptr<base::Value> result(RunFunctionWithExtension(
         new AlarmsClearAllFunction(), "[]"));
     EXPECT_FALSE(result.get());
   }
@@ skipping 10 matching lines @@
   // Clear them.
   {
     RunFunction(new AlarmsClearAllFunction(), "[]");
     const AlarmManager::AlarmList* alarms =
         alarm_manager_->GetAllAlarms(extension_->id());
     ASSERT_FALSE(alarms);
   }
 }
 
 }  // namespace extensions