Refactor chrome.alarms interface to support absolute alarm deadlines.

chrome/browser/extensions/api/alarms/alarms_api.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/alarms_api.h"
 
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/alarms/alarm_manager.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/common/extensions/api/alarms.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 
 namespace alarms = extensions::api::alarms;
 
 namespace extensions {
 
 namespace {
 
 const char kDefaultAlarmName[] = "";
 const char kAlarmNotFound[] = "No alarm named '*' exists.";
 const char kDelayLessThanMinimum[] = "Delay is less than minimum of * minutes.";
 const char kDelayIsNonInteger[] = "Delay is not an integer value.";
-
+const char kBothRelativeAndAbsoluteTime[] =
+    "Cannot set both approxTimeToFire and delayInMinutes.";

[Matt Perry, 2012/06/11 22:32:44]

error messages are out of date

[Jeffrey Yasskin, 2012/06/12 19:12:31]

Oops, fixed.

+const char kNeitherRelativeNorAbsoluteTime[] =
+    "Must set one of approxTimeToFire and delayInMinutes.";
+const char kRepeatingAlarmMustBeRelative[] =
+    "A repeating alarm must set delayInMinutes.";
 const int kReleaseDelayMinimum = 5;
 const int kDevDelayMinimum = 0;
 
-bool ValidateDelayTime(double delay_in_minutes,
-                       const Extension* extension,
-                       std::string* error) {
+bool ValidateDelay(double delay_in_minutes,
+                   const Extension* extension,
+                   std::string* error) {
   double delay_minimum = kDevDelayMinimum;
   if (extension->location() != Extension::LOAD) {
     // In release mode we check for integer delay values and a stricter delay
     // minimum.
     if (delay_in_minutes != static_cast<int>(delay_in_minutes)) {
       *error = kDelayIsNonInteger;
       return false;
     }
     delay_minimum = kReleaseDelayMinimum;
   }
 
   // Validate against our found delay minimum.
   if (delay_in_minutes < delay_minimum) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(kDelayLessThanMinimum,
+    *error = ExtensionErrorUtils::FormatErrorMessage(
+        kDelayLessThanMinimum,
         base::DoubleToString(delay_minimum));
     return false;
   }
+
+  return true;
+}
+
+bool ValidateAlarmOneShotCreateInfo(
+    const alarms::AlarmOneShotCreateInfo& create_info,
+    const Extension* extension,
+    std::string* error) {
+  if (create_info.delay_in_minutes.get() &&
+      create_info.time.get()) {
+    *error = kBothRelativeAndAbsoluteTime;
+    return false;
+  }
+  if (create_info.delay_in_minutes == NULL &&
+      create_info.time == NULL) {
+    *error = kNeitherRelativeNorAbsoluteTime;
+    return false;
+  }
+
+  // Users can always use an absolute timeout to request an arbitrarily-short or
+  // negative delay.  We won't honor the short timeout, but we can't check it
+  // and warn the user because it would introduce race conditions (say they
+  // compute a long-enough timeout, but then the call into the alarms interface
+  // gets delayed past the boundary).  However, it's still worth warning about
+  // relative delays that are shorter than we'll honor.
+  if (create_info.delay_in_minutes.get()) {
+    if (!ValidateDelay(*create_info.delay_in_minutes,
+                       extension, error))
+      return false;
+  }
+
   return true;
 }
 
 }  // namespace
 
-bool AlarmsCreateFunction::RunImpl() {
-  scoped_ptr<alarms::Create::Params> params(
-      alarms::Create::Params::Create(*args_));
+AlarmsCreateOneShotFunction::AlarmsCreateOneShotFunction()
+    : now_(&base::Time::Now) {
+}
+
+bool AlarmsCreateOneShotFunction::RunImpl() {
+  scoped_ptr<alarms::CreateOneShot::Params> params(
+      alarms::CreateOneShot::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
-
-  double delay_in_minutes = params->alarm_info.delay_in_minutes;
-  if (!ValidateDelayTime(delay_in_minutes, GetExtension(), &error_))
+  if (!ValidateAlarmOneShotCreateInfo(
+          params->alarm_info, GetExtension(), &error_))
     return false;
 
-  linked_ptr<AlarmManager::Alarm> alarm(new AlarmManager::Alarm());
-  alarm->name = params->name.get() ? *params->name : kDefaultAlarmName;
-  alarm->delay_in_minutes = params->alarm_info.delay_in_minutes;
-  alarm->repeating = params->alarm_info.repeating.get() ?
-      *params->alarm_info.repeating : false;
+  Alarm alarm(params->name.get() ? *params->name : kDefaultAlarmName,
+              params->alarm_info,
+              base::TimeDelta::FromMinutes(
+                  GetExtension()->location() == Extension::LOAD
+                  ? kDevDelayMinimum : kReleaseDelayMinimum),

[Matt Perry, 2012/06/11 22:32:44]

chrome style is to put operators on the line preceeding the linewrap

[Jeffrey Yasskin, 2012/06/12 19:12:31]

Yay for style comments. :) Done.

+              now_);
   ExtensionSystem::Get(profile())->alarm_manager()->AddAlarm(
       extension_id(), alarm);
 
+  return true;
+}
+
+AlarmsCreateRepeatingFunction::AlarmsCreateRepeatingFunction()
+    : now_(&base::Time::Now) {
+}
+
+bool AlarmsCreateRepeatingFunction::RunImpl() {
+  scoped_ptr<alarms::CreateRepeating::Params> params(
+      alarms::CreateRepeating::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+  if (!ValidateDelay(params->alarm_info.period_in_minutes,
+                     GetExtension(), &error_))
+    return false;
+
+  Alarm alarm(params->name.get() ? *params->name : kDefaultAlarmName,
+              params->alarm_info,
+              base::TimeDelta::FromMinutes(
+                  GetExtension()->location() == Extension::LOAD
+                  ? kDevDelayMinimum : kReleaseDelayMinimum),
+              now_);
+  ExtensionSystem::Get(profile())->alarm_manager()->AddAlarm(
+      extension_id(), alarm);
+
   return true;
 }
 
 bool AlarmsGetFunction::RunImpl() {
   scoped_ptr<alarms::Get::Params> params(
       alarms::Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::string name = params->name.get() ? *params->name : kDefaultAlarmName;
-  const AlarmManager::Alarm* alarm =
+  const Alarm* alarm =
       ExtensionSystem::Get(profile())->alarm_manager()->GetAlarm(
           extension_id(), name);
 
   if (!alarm) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(kAlarmNotFound, name);
     return false;
   }
 
-  result_.reset(alarms::Get::Result::Create(*alarm));
+  result_.reset(alarms::Get::Result::Create(*alarm->js_alarm));
   return true;
 }
 
 bool AlarmsGetAllFunction::RunImpl() {
   const AlarmManager::AlarmList* alarms =
       ExtensionSystem::Get(profile())->alarm_manager()->GetAllAlarms(
           extension_id());
   if (alarms) {
-    result_.reset(alarms::GetAll::Result::Create(*alarms));
+    std::vector<linked_ptr<extensions::api::alarms::Alarm> > create_arg;
+    create_arg.reserve(alarms->size());
+    for (size_t i = 0, size = alarms->size(); i < size; ++i) {
+      create_arg.push_back((*alarms)[i].js_alarm);
+    }
+    result_.reset(alarms::GetAll::Result::Create(create_arg));
   } else {
     result_.reset(new base::ListValue());
   }
   return true;
 }
 
 bool AlarmsClearFunction::RunImpl() {
   scoped_ptr<alarms::Clear::Params> params(
       alarms::Clear::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
@@ skipping 10 matching lines @@
   return true;
 }
 
 bool AlarmsClearAllFunction::RunImpl() {
   ExtensionSystem::Get(profile())->alarm_manager()->RemoveAllAlarms(
      extension_id());
   return true;
 }
 
 }  // namespace extensions