Move chrome.alarms API from chrome/ to extensions/.

extensions/browser/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 "extensions/browser/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"
 #include "base/time/clock.h"
 #include "base/time/default_clock.h"
 #include "base/time/time.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
-#include "chrome/browser/extensions/extension_service.h"
-#include "chrome/common/extensions/api/alarms.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/state_store.h"
+#include "extensions/common/api/alarms.h"
 
 namespace extensions {
 
-namespace alarms = api::alarms;
+namespace alarms = core_api::alarms;
 
 namespace {
 
 // 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() {
   return base::TimeDelta::FromDays(1);
 }
 
 class DefaultAlarmDelegate : public AlarmManager::Delegate {
  public:
   explicit DefaultAlarmDelegate(content::BrowserContext* context)
       : browser_context_(context) {}
   ~DefaultAlarmDelegate() override {}
 
   void OnAlarm(const std::string& extension_id, const Alarm& alarm) override {
     scoped_ptr<base::ListValue> args(new base::ListValue());
     args->Append(alarm.js_alarm->ToValue().release());
-    scoped_ptr<Event> event(new Event(alarms::OnAlarm::kEventName,
-                                      args.Pass()));
+    scoped_ptr<Event> event(
+        new Event(alarms::OnAlarm::kEventName, args.Pass()));
     EventRouter::Get(browser_context_)
         ->DispatchEventToExtension(extension_id, event.Pass());
   }
 
  private:
   content::BrowserContext* browser_context_;
 };
 
 // Creates a TimeDelta from a delay as specified in the API.
 base::TimeDelta TimeDeltaFromDelay(double delay_in_minutes) {
-  return base::TimeDelta::FromMicroseconds(
-      delay_in_minutes * base::Time::kMicrosecondsPerMinute);
+  return base::TimeDelta::FromMicroseconds(delay_in_minutes *
+                                           base::Time::kMicrosecondsPerMinute);
 }
 
 std::vector<Alarm> AlarmsFromValue(const base::ListValue* list) {
   std::vector<Alarm> alarms;
   for (size_t i = 0; i < list->GetSize(); ++i) {
     const base::DictionaryValue* alarm_dict = NULL;
     Alarm alarm;
     if (list->GetDictionary(i, &alarm_dict) &&
-        api::alarms::Alarm::Populate(*alarm_dict, alarm.js_alarm.get())) {
+        alarms::Alarm::Populate(*alarm_dict, alarm.js_alarm.get())) {
       const base::Value* time_value = NULL;
       if (alarm_dict->Get(kAlarmGranularity, &time_value))
         base::GetValueAsTimeDelta(*time_value, &alarm.granularity);
       alarms.push_back(alarm);
     }
   }
   return alarms;
 }
 
 scoped_ptr<base::ListValue> AlarmsToValue(const std::vector<Alarm>& alarms) {
@@ skipping 23 matching lines @@
   if (storage)
     storage->RegisterKey(kRegisteredAlarms);
 }
 
 AlarmManager::~AlarmManager() {
 }
 
 void AlarmManager::AddAlarm(const std::string& extension_id,
                             const Alarm& alarm,
                             const AddAlarmCallback& callback) {
-  RunWhenReady(extension_id, base::Bind(
-      &AlarmManager::AddAlarmWhenReady, AsWeakPtr(), alarm, callback));
+  RunWhenReady(extension_id, base::Bind(&AlarmManager::AddAlarmWhenReady,
+                                        AsWeakPtr(), alarm, callback));
 }
 
 void AlarmManager::GetAlarm(const std::string& extension_id,
                             const std::string& name,
                             const GetAlarmCallback& callback) {
-  RunWhenReady(extension_id, base::Bind(
-      &AlarmManager::GetAlarmWhenReady, AsWeakPtr(), name, callback));
+  RunWhenReady(extension_id, base::Bind(&AlarmManager::GetAlarmWhenReady,
+                                        AsWeakPtr(), name, callback));
 }
 
-void AlarmManager::GetAllAlarms(
-    const std::string& extension_id, const GetAllAlarmsCallback& callback) {
-  RunWhenReady(extension_id, base::Bind(
-      &AlarmManager::GetAllAlarmsWhenReady, AsWeakPtr(), callback));
+void AlarmManager::GetAllAlarms(const std::string& extension_id,
+                                const GetAllAlarmsCallback& callback) {
+  RunWhenReady(extension_id, base::Bind(&AlarmManager::GetAllAlarmsWhenReady,
+                                        AsWeakPtr(), callback));
 }
 
 void AlarmManager::RemoveAlarm(const std::string& extension_id,
                                const std::string& name,
                                const RemoveAlarmCallback& callback) {
-  RunWhenReady(extension_id, base::Bind(
-      &AlarmManager::RemoveAlarmWhenReady, AsWeakPtr(), name, callback));
+  RunWhenReady(extension_id, base::Bind(&AlarmManager::RemoveAlarmWhenReady,
+                                        AsWeakPtr(), name, callback));
 }
 
 void AlarmManager::RemoveAllAlarms(const std::string& extension_id,
                                    const RemoveAllAlarmsCallback& callback) {
-  RunWhenReady(extension_id, base::Bind(
-      &AlarmManager::RemoveAllAlarmsWhenReady, AsWeakPtr(), callback));
+  RunWhenReady(extension_id, base::Bind(&AlarmManager::RemoveAllAlarmsWhenReady,
+                                        AsWeakPtr(), callback));
 }
 
 void AlarmManager::AddAlarmWhenReady(const Alarm& alarm,
                                      const AddAlarmCallback& callback,
                                      const std::string& extension_id) {
   AddAlarmImpl(extension_id, alarm);
   WriteToStorage(extension_id);
   callback.Run();
 }
 
@@ skipping 18 matching lines @@
     callback.Run(false);
     return;
   }
 
   RemoveAlarmIterator(it);
   WriteToStorage(extension_id);
   callback.Run(true);
 }
 
 void AlarmManager::RemoveAllAlarmsWhenReady(
-    const RemoveAllAlarmsCallback& callback, const std::string& extension_id) {
+    const RemoveAllAlarmsCallback& callback,
+    const std::string& extension_id) {
   AlarmMap::iterator list = alarms_.find(extension_id);
   if (list != alarms_.end()) {
     // Note: I'm using indices rather than iterators here because
     // RemoveAlarmIterator will delete the list when it becomes empty.
     for (size_t i = 0, size = list->second.size(); i < size; ++i)
       RemoveAlarmIterator(AlarmIterator(list, list->second.begin()));
 
     CHECK(alarms_.find(extension_id) == alarms_.end());
     WriteToStorage(extension_id);
   }
   callback.Run();
 }
 
 AlarmManager::AlarmIterator AlarmManager::GetAlarmIterator(
-    const std::string& extension_id, const std::string& name) {
+    const std::string& extension_id,
+    const std::string& name) {
   AlarmMap::iterator list = alarms_.find(extension_id);
   if (list == alarms_.end())
     return make_pair(alarms_.end(), AlarmList::iterator());
 
-  for (AlarmList::iterator it = list->second.begin();
-       it != list->second.end(); ++it) {
+  for (AlarmList::iterator it = list->second.begin(); it != list->second.end();
+       ++it) {
     if (it->js_alarm->name == name)
       return make_pair(list, it);
   }
 
   return make_pair(alarms_.end(), AlarmList::iterator());
 }
 
 void AlarmManager::SetClockForTesting(base::Clock* clock) {
   clock_.reset(clock);
 }
 
-static base::LazyInstance<BrowserContextKeyedAPIFactory<AlarmManager> >
+static base::LazyInstance<BrowserContextKeyedAPIFactory<AlarmManager>>
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<AlarmManager>*
 AlarmManager::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 // static
 AlarmManager* AlarmManager::Get(content::BrowserContext* browser_context) {
@@ skipping 15 matching lines @@
   }
 }
 
 void AlarmManager::OnAlarm(AlarmIterator it) {
   CHECK(it.first != alarms_.end());
   Alarm& alarm = *it.second;
   std::string extension_id_copy(it.first->first);
   delegate_->OnAlarm(extension_id_copy, alarm);
 
   // Update our scheduled time for the next alarm.
-  if (double* period_in_minutes =
-      alarm.js_alarm->period_in_minutes.get()) {
+  if (double* period_in_minutes = alarm.js_alarm->period_in_minutes.get()) {
     // Get the timer's delay in JS time (i.e., convert it from minutes to
     // milliseconds).
-    double period_in_js_time =
-        *period_in_minutes * base::Time::kMicrosecondsPerMinute /
-        base::Time::kMicrosecondsPerMillisecond;
+    double period_in_js_time = *period_in_minutes *
+                               base::Time::kMicrosecondsPerMinute /
+                               base::Time::kMicrosecondsPerMillisecond;
     // Find out how many periods have transpired since the alarm last went off
     // (it's possible that we missed some).
     int transpired_periods =
         (last_poll_time_.ToJsTime() - alarm.js_alarm->scheduled_time) /
         period_in_js_time;
     // Schedule the alarm for the next period that is in-line with the original
     // scheduling.
     alarm.js_alarm->scheduled_time +=
         period_in_js_time * (transpired_periods + 1);
   } else {
     RemoveAlarmIterator(it);
   }
   WriteToStorage(extension_id_copy);
 }
 
 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);
+  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);
   base::Time alarm_time =
       base::Time::FromJsTime(alarm.js_alarm->scheduled_time);
   if (next_poll_time_.is_null() || alarm_time < next_poll_time_)
     SetNextPollTime(alarm_time);
 }
 
@@ skipping 25 matching lines @@
     extension_ready_queue.front().Run(extension_id);
     extension_ready_queue.pop();
   }
   ready_actions_.erase(extension_id);
 }
 
 void AlarmManager::SetNextPollTime(const base::Time& time) {
   next_poll_time_ = time;
   timer_.Start(FROM_HERE,
                std::max(base::TimeDelta::FromSeconds(0), time - clock_->Now()),
-               this,
-               &AlarmManager::PollAlarms);
+               this, &AlarmManager::PollAlarms);
 }
 
 void AlarmManager::ScheduleNextPoll() {
   // If there are no alarms, stop the timer.
   if (alarms_.empty()) {
     timer_.Stop();
     next_poll_time_ = base::Time();
     return;
   }
 
@@ skipping 52 matching lines @@
       if (base::Time::FromJsTime(cur_alarm->js_alarm->scheduled_time) <=
           last_poll_time_) {
         OnAlarm(make_pair(cur_extension, cur_alarm));
       }
     }
   }
 
   ScheduleNextPoll();
 }
 
-static void RemoveAllOnUninstallCallback() {}
+static void RemoveAllOnUninstallCallback() {
+}
 
-void AlarmManager::RunWhenReady(
-    const std::string& extension_id, const ReadyAction& action) {
+void AlarmManager::RunWhenReady(const std::string& extension_id,
+                                const ReadyAction& action) {
   ReadyMap::iterator it = ready_actions_.find(extension_id);
 
   if (it == ready_actions_.end())
     action.Run(extension_id);
   else
     it->second.push(action);
 }
 
 void AlarmManager::OnExtensionLoaded(content::BrowserContext* browser_context,
                                      const Extension* extension) {
   StateStore* storage = ExtensionSystem::Get(browser_context_)->state_store();
   if (storage) {
     ready_actions_.insert(ReadyMap::value_type(extension->id(), ReadyQueue()));
-    storage->GetExtensionValue(
-        extension->id(),
-        kRegisteredAlarms,
-        base::Bind(
-            &AlarmManager::ReadFromStorage, AsWeakPtr(), extension->id()));
+    storage->GetExtensionValue(extension->id(), kRegisteredAlarms,
+                               base::Bind(&AlarmManager::ReadFromStorage,
+                                          AsWeakPtr(), extension->id()));
   }
 }
 
 void AlarmManager::OnExtensionUninstalled(
     content::BrowserContext* browser_context,
     const Extension* extension,
     extensions::UninstallReason reason) {
   RemoveAllAlarms(extension->id(), base::Bind(RemoveAllOnUninstallCallback));
 }
 
 // AlarmManager::Alarm
 
-Alarm::Alarm()
-    : js_alarm(new api::alarms::Alarm()) {
+Alarm::Alarm() : js_alarm(new alarms::Alarm()) {
 }
 
 Alarm::Alarm(const std::string& name,
-             const api::alarms::AlarmCreateInfo& create_info,
+             const alarms::AlarmCreateInfo& create_info,
              base::TimeDelta min_granularity,
              base::Time now)
-    : js_alarm(new api::alarms::Alarm()) {
+    : js_alarm(new 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();
@@ skipping 14 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