1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CHROME_BROWSER_EXTENSIONS_API_ALARMS_ALARM_MANAGER_H__ 6 #define CHROME_BROWSER_EXTENSIONS_API_ALARMS_ALARM_MANAGER_H__ 7 8 #include <map> 9 #include <queue> 10 #include <string> 11 #include <vector> 12 13 #include "base/callback.h" 14 #include "base/gtest_prod_util.h" 15 #include "base/memory/weak_ptr.h" 16 #include "base/scoped_observer.h" 17 #include "base/timer/timer.h" 18 #include "chrome/common/extensions/api/alarms.h" 19 #include "extensions/browser/browser_context_keyed_api_factory.h" 20 #include "extensions/browser/extension_registry_observer.h" 21 22 namespace base { 23 class Clock; 24 } // namespace base 25 26 namespace content { 27 class BrowserContext; 28 } // namespace content 29 30 namespace extensions { 31 class ExtensionAlarmsSchedulingTest; 32 class ExtensionRegistry; 33 34 struct Alarm { 35 Alarm(); 36 Alarm(const std::string& name, 37 const api::alarms::AlarmCreateInfo& create_info, 38 base::TimeDelta min_granularity, 39 base::Time now); 40 ~Alarm(); 41 42 linked_ptr<api::alarms::Alarm> js_alarm; 43 // The granularity isn't exposed to the extension's javascript, but we poll at 44 // least as often as the shortest alarm's granularity. It's initialized as 45 // the relative delay requested in creation, even if creation uses an absolute 46 // time. This will always be at least as large as the min_granularity 47 // constructor argument. 48 base::TimeDelta granularity; 49 // The minimum granularity is the minimum allowed polling rate. This stops 50 // alarms from polling too often. 51 base::TimeDelta minimum_granularity; 52 }; 53 54 // Manages the currently pending alarms for every extension in a profile. 55 // There is one manager per virtual Profile. 56 class AlarmManager : public BrowserContextKeyedAPI, 57 public ExtensionRegistryObserver, 58 public base::SupportsWeakPtr<AlarmManager> { 59 public: 60 typedef std::vector<Alarm> AlarmList; 61 62 class Delegate { 63 public: ~Delegate()64 virtual ~Delegate() {} 65 // Called when an alarm fires. 66 virtual void OnAlarm(const std::string& extension_id, 67 const Alarm& alarm) = 0; 68 }; 69 70 explicit AlarmManager(content::BrowserContext* context); 71 virtual ~AlarmManager(); 72 73 // Override the default delegate. Callee assumes onwership. Used for testing. set_delegate(Delegate * delegate)74 void set_delegate(Delegate* delegate) { delegate_.reset(delegate); } 75 76 typedef base::Callback<void()> AddAlarmCallback; 77 // Adds |alarm| for the given extension, and starts the timer. Invokes 78 // |callback| when done. 79 void AddAlarm(const std::string& extension_id, 80 const Alarm& alarm, 81 const AddAlarmCallback& callback); 82 83 typedef base::Callback<void(Alarm*)> GetAlarmCallback; 84 // Passes the alarm with the given name, or NULL if none exists, to 85 // |callback|. 86 void GetAlarm(const std::string& extension_id, 87 const std::string& name, 88 const GetAlarmCallback& callback); 89 90 typedef base::Callback<void(const AlarmList*)> GetAllAlarmsCallback; 91 // Passes the list of pending alarms for the given extension, or 92 // NULL if none exist, to |callback|. 93 void GetAllAlarms( 94 const std::string& extension_id, const GetAllAlarmsCallback& callback); 95 96 typedef base::Callback<void(bool)> RemoveAlarmCallback; 97 // Cancels and removes the alarm with the given name. Invokes |callback| when 98 // done. 99 void RemoveAlarm(const std::string& extension_id, 100 const std::string& name, 101 const RemoveAlarmCallback& callback); 102 103 typedef base::Callback<void()> RemoveAllAlarmsCallback; 104 // Cancels and removes all alarms for the given extension. Invokes |callback| 105 // when done. 106 void RemoveAllAlarms( 107 const std::string& extension_id, const RemoveAllAlarmsCallback& callback); 108 109 // Replaces AlarmManager's owned clock with |clock| and takes ownership of it. 110 void SetClockForTesting(base::Clock* clock); 111 112 // BrowserContextKeyedAPI implementation. 113 static BrowserContextKeyedAPIFactory<AlarmManager>* GetFactoryInstance(); 114 115 // Convenience method to get the AlarmManager for a content::BrowserContext. 116 static AlarmManager* Get(content::BrowserContext* browser_context); 117 118 private: 119 friend void RunScheduleNextPoll(AlarmManager*); 120 friend class ExtensionAlarmsSchedulingTest; 121 FRIEND_TEST_ALL_PREFIXES(ExtensionAlarmsSchedulingTest, PollScheduling); 122 FRIEND_TEST_ALL_PREFIXES(ExtensionAlarmsSchedulingTest, 123 ReleasedExtensionPollsInfrequently); 124 FRIEND_TEST_ALL_PREFIXES(ExtensionAlarmsSchedulingTest, TimerRunning); 125 FRIEND_TEST_ALL_PREFIXES(ExtensionAlarmsSchedulingTest, MinimumGranularity); 126 FRIEND_TEST_ALL_PREFIXES(ExtensionAlarmsSchedulingTest, 127 DifferentMinimumGranularities); 128 FRIEND_TEST_ALL_PREFIXES(ExtensionAlarmsSchedulingTest, 129 RepeatingAlarmsScheduledPredictably); 130 friend class BrowserContextKeyedAPIFactory<AlarmManager>; 131 132 typedef std::string ExtensionId; 133 typedef std::map<ExtensionId, AlarmList> AlarmMap; 134 135 typedef base::Callback<void(const std::string&)> ReadyAction; 136 typedef std::queue<ReadyAction> ReadyQueue; 137 typedef std::map<ExtensionId, ReadyQueue> ReadyMap; 138 139 // Iterator used to identify a particular alarm within the Map/List pair. 140 // "Not found" is represented by <alarms_.end(), invalid_iterator>. 141 typedef std::pair<AlarmMap::iterator, AlarmList::iterator> AlarmIterator; 142 143 // Part of AddAlarm that is executed after alarms are loaded. 144 void AddAlarmWhenReady(const Alarm& alarm, 145 const AddAlarmCallback& callback, 146 const std::string& extension_id); 147 148 // Part of GetAlarm that is executed after alarms are loaded. 149 void GetAlarmWhenReady(const std::string& name, 150 const GetAlarmCallback& callback, 151 const std::string& extension_id); 152 153 // Part of GetAllAlarms that is executed after alarms are loaded. 154 void GetAllAlarmsWhenReady(const GetAllAlarmsCallback& callback, 155 const std::string& extension_id); 156 157 // Part of RemoveAlarm that is executed after alarms are loaded. 158 void RemoveAlarmWhenReady(const std::string& name, 159 const RemoveAlarmCallback& callback, 160 const std::string& extension_id); 161 162 // Part of RemoveAllAlarms that is executed after alarms are loaded. 163 void RemoveAllAlarmsWhenReady( 164 const RemoveAllAlarmsCallback& callback, const std::string& extension_id); 165 166 // Helper to return the iterators within the AlarmMap and AlarmList for the 167 // matching alarm, or an iterator to the end of the AlarmMap if none were 168 // found. 169 AlarmIterator GetAlarmIterator(const std::string& extension_id, 170 const std::string& name); 171 172 // Helper to cancel and remove the alarm at the given iterator. The iterator 173 // must be valid. 174 void RemoveAlarmIterator(const AlarmIterator& iter); 175 176 // Callback for when an alarm fires. 177 void OnAlarm(AlarmIterator iter); 178 179 // Internal helper to add an alarm and start the timer with the given delay. 180 void AddAlarmImpl(const std::string& extension_id, 181 const Alarm& alarm); 182 183 // Syncs our alarm data for the given extension to/from the state storage. 184 void WriteToStorage(const std::string& extension_id); 185 void ReadFromStorage(const std::string& extension_id, 186 scoped_ptr<base::Value> value); 187 188 // Set the timer to go off at the specified |time|, and set |next_poll_time| 189 // appropriately. 190 void SetNextPollTime(const base::Time& time); 191 192 // Schedules the next poll of alarms for when the next soonest alarm runs, 193 // but not more often than the minimum granularity of all alarms. 194 void ScheduleNextPoll(); 195 196 // Polls the alarms, running any that have elapsed. After running them and 197 // rescheduling repeating alarms, schedule the next poll. 198 void PollAlarms(); 199 200 // Executes |action| for given extension, making sure that the extension's 201 // alarm data has been synced from the storage. 202 void RunWhenReady(const std::string& extension_id, const ReadyAction& action); 203 204 // ExtensionRegistryObserver implementation. 205 virtual void OnExtensionLoaded(content::BrowserContext* browser_context, 206 const Extension* extension) OVERRIDE; 207 virtual void OnExtensionUninstalled( 208 content::BrowserContext* browser_context, 209 const Extension* extension, 210 extensions::UninstallReason reason) OVERRIDE; 211 212 // BrowserContextKeyedAPI implementation. service_name()213 static const char* service_name() { 214 return "AlarmManager"; 215 } 216 static const bool kServiceHasOwnInstanceInIncognito = true; 217 218 content::BrowserContext* const browser_context_; 219 scoped_ptr<base::Clock> clock_; 220 scoped_ptr<Delegate> delegate_; 221 222 // Listen to extension load notifications. 223 ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver> 224 extension_registry_observer_; 225 226 // The timer for this alarm manager. 227 base::OneShotTimer<AlarmManager> timer_; 228 229 // A map of our pending alarms, per extension. 230 // Invariant: None of the AlarmLists are empty. 231 AlarmMap alarms_; 232 233 // A map of actions waiting for alarm data to be synced from storage, per 234 // extension. 235 ReadyMap ready_actions_; 236 237 // The previous time that alarms were run. 238 base::Time last_poll_time_; 239 240 // Next poll's time. 241 base::Time next_poll_time_; 242 243 DISALLOW_COPY_AND_ASSIGN(AlarmManager); 244 }; 245 246 } // namespace extensions 247 248 #endif // CHROME_BROWSER_EXTENSIONS_API_ALARMS_ALARM_MANAGER_H__ 249