OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 // OneShotTimer and RepeatingTimer provide a simple timer API. As the names | 5 // OneShotTimer and RepeatingTimer provide a simple timer API. As the names |
6 // suggest, OneShotTimer calls you back once after a time delay expires. | 6 // suggest, OneShotTimer calls you back once after a time delay expires. |
7 // RepeatingTimer on the other hand calls you back periodically with the | 7 // RepeatingTimer on the other hand calls you back periodically with the |
8 // prescribed time interval. | 8 // prescribed time interval. |
9 // | 9 // |
10 // OneShotTimer and RepeatingTimer both cancel the timer when they go out of | 10 // OneShotTimer and RepeatingTimer both cancel the timer when they go out of |
(...skipping 21 matching lines...) Expand all Loading... |
32 // base::RepeatingTimer timer_; | 32 // base::RepeatingTimer timer_; |
33 // }; | 33 // }; |
34 // | 34 // |
35 // Both OneShotTimer and RepeatingTimer also support a Reset method, which | 35 // Both OneShotTimer and RepeatingTimer also support a Reset method, which |
36 // allows you to easily defer the timer event until the timer delay passes once | 36 // allows you to easily defer the timer event until the timer delay passes once |
37 // again. So, in the above example, if 0.5 seconds have already passed, | 37 // again. So, in the above example, if 0.5 seconds have already passed, |
38 // calling Reset on timer_ would postpone DoStuff by another 1 second. In | 38 // calling Reset on timer_ would postpone DoStuff by another 1 second. In |
39 // other words, Reset is shorthand for calling Stop and then Start again with | 39 // other words, Reset is shorthand for calling Stop and then Start again with |
40 // the same arguments. | 40 // the same arguments. |
41 // | 41 // |
42 // NOTE: These APIs are not thread safe. Always call from the same thread. | 42 // These APIs are not thread safe. Always call from the same sequenced task |
| 43 // runner - thread or worker pool. By default the scheduled tasks will be run |
| 44 // on the same sequence that the APIs are called from, but this can be changed |
| 45 // prior to any tasks being scheduled using SetTaskRunner(). |
43 | 46 |
44 #ifndef BASE_TIMER_TIMER_H_ | 47 #ifndef BASE_TIMER_TIMER_H_ |
45 #define BASE_TIMER_TIMER_H_ | 48 #define BASE_TIMER_TIMER_H_ |
46 | 49 |
47 // IMPORTANT: If you change timer code, make sure that all tests (including | 50 // IMPORTANT: If you change timer code, make sure that all tests (including |
48 // disabled ones) from timer_unittests.cc pass locally. Some are disabled | 51 // disabled ones) from timer_unittests.cc pass locally. Some are disabled |
49 // because they're flaky on the buildbot, but when you run them locally you | 52 // because they're flaky on the buildbot, but when you run them locally you |
50 // should be able to tell the difference. | 53 // should be able to tell the difference. |
51 | 54 |
52 #include "base/base_export.h" | 55 #include "base/base_export.h" |
53 #include "base/basictypes.h" | 56 #include "base/basictypes.h" |
54 #include "base/bind.h" | 57 #include "base/bind.h" |
55 #include "base/bind_helpers.h" | 58 #include "base/bind_helpers.h" |
56 #include "base/callback.h" | 59 #include "base/callback.h" |
57 #include "base/location.h" | 60 #include "base/location.h" |
| 61 #include "base/sequence_checker.h" |
58 #include "base/time/time.h" | 62 #include "base/time/time.h" |
59 | 63 |
60 namespace base { | 64 namespace base { |
61 | 65 |
62 class BaseTimerTaskInternal; | 66 class BaseTimerTaskInternal; |
63 class SingleThreadTaskRunner; | 67 class SequencedTaskRunner; |
64 | 68 |
65 //----------------------------------------------------------------------------- | 69 //----------------------------------------------------------------------------- |
66 // This class wraps MessageLoop::PostDelayedTask to manage delayed and repeating | 70 // This class wraps TaskRunner::PostDelayedTask to manage delayed and |
67 // tasks. It must be destructed on the same thread that starts tasks. There are | 71 // repeating tasks. It must be destructed on the same task runner that starts |
68 // DCHECKs in place to verify this. | 72 // tasks. There are DCHECKs in place to verify this. |
69 // | 73 // |
70 class BASE_EXPORT Timer { | 74 class BASE_EXPORT Timer { |
71 public: | 75 public: |
72 // Construct a timer in repeating or one-shot mode. Start or SetTaskInfo must | 76 // Construct a timer in repeating or one-shot mode. Start or SetTaskInfo must |
73 // be called later to set task info. |retain_user_task| determines whether the | 77 // be called later to set task info. |retain_user_task| determines whether the |
74 // user_task is retained or reset when it runs or stops. | 78 // user_task is retained or reset when it runs or stops. |
75 Timer(bool retain_user_task, bool is_repeating); | 79 Timer(bool retain_user_task, bool is_repeating); |
76 | 80 |
77 // Construct a timer with retained task info. | 81 // Construct a timer with retained task info. |
78 Timer(const tracked_objects::Location& posted_from, | 82 Timer(const tracked_objects::Location& posted_from, |
79 TimeDelta delay, | 83 TimeDelta delay, |
80 const base::Closure& user_task, | 84 const base::Closure& user_task, |
81 bool is_repeating); | 85 bool is_repeating); |
82 | 86 |
83 virtual ~Timer(); | 87 virtual ~Timer(); |
84 | 88 |
85 // Returns true if the timer is running (i.e., not stopped). | 89 // Returns true if the timer is running (i.e., not stopped). |
86 virtual bool IsRunning() const; | 90 virtual bool IsRunning() const; |
87 | 91 |
88 // Returns the current delay for this timer. | 92 // Returns the current delay for this timer. |
89 virtual TimeDelta GetCurrentDelay() const; | 93 virtual TimeDelta GetCurrentDelay() const; |
90 | 94 |
91 // Set the task runner on which the task should be scheduled. This method can | 95 // Set the task runner on which the task should be scheduled. This method can |
92 // only be called before any tasks have been scheduled. The task runner must | 96 // only be called before any tasks have been scheduled. |task_runner| must |
93 // run tasks on the same thread the timer is used on. | 97 // run tasks on the same sequence the timer is used on. |
94 virtual void SetTaskRunner(scoped_refptr<SingleThreadTaskRunner> task_runner); | 98 virtual void SetTaskRunner(scoped_refptr<SequencedTaskRunner> task_runner); |
95 | 99 |
96 // Start the timer to run at the given |delay| from now. If the timer is | 100 // Start the timer to run at the given |delay| from now. If the timer is |
97 // already running, it will be replaced to call the given |user_task|. | 101 // already running, it will be replaced to call the given |user_task|. |
98 virtual void Start(const tracked_objects::Location& posted_from, | 102 virtual void Start(const tracked_objects::Location& posted_from, |
99 TimeDelta delay, | 103 TimeDelta delay, |
100 const base::Closure& user_task); | 104 const base::Closure& user_task); |
101 | 105 |
102 // Call this method to stop and cancel the timer. It is a no-op if the timer | 106 // Call this method to stop and cancel the timer. It is a no-op if the timer |
103 // is not running. | 107 // is not running. |
104 virtual void Stop(); | 108 virtual void Stop(); |
(...skipping 22 matching lines...) Expand all Loading... |
127 bool is_running() const { return is_running_; } | 131 bool is_running() const { return is_running_; } |
128 | 132 |
129 private: | 133 private: |
130 friend class BaseTimerTaskInternal; | 134 friend class BaseTimerTaskInternal; |
131 | 135 |
132 // Allocates a new scheduled_task_ and posts it on the current MessageLoop | 136 // Allocates a new scheduled_task_ and posts it on the current MessageLoop |
133 // with the given |delay|. scheduled_task_ must be NULL. scheduled_run_time_ | 137 // with the given |delay|. scheduled_task_ must be NULL. scheduled_run_time_ |
134 // and desired_run_time_ are reset to Now() + delay. | 138 // and desired_run_time_ are reset to Now() + delay. |
135 void PostNewScheduledTask(TimeDelta delay); | 139 void PostNewScheduledTask(TimeDelta delay); |
136 | 140 |
137 // Returns the task runner on which the task should be scheduled. If the | 141 // Returns the task runner on which the task should be scheduled. If |
138 // corresponding task_runner_ field is null, the task runner for the current | 142 // |destination_task_runner_| field is null, returns the SequencedTaskRunner |
139 // thread is returned. | 143 // for the |
140 scoped_refptr<SingleThreadTaskRunner> GetTaskRunner(); | 144 // current thread. |
| 145 scoped_refptr<SequencedTaskRunner> GetTaskRunner(); |
141 | 146 |
142 // Disable scheduled_task_ and abandon it so that it no longer refers back to | 147 // Disable scheduled_task_ and abandon it so that it no longer refers back to |
143 // this object. | 148 // this object. |
144 void AbandonScheduledTask(); | 149 void AbandonScheduledTask(); |
145 | 150 |
146 // Called by BaseTimerTaskInternal when the MessageLoop runs it. | 151 // Called by BaseTimerTaskInternal when the MessageLoop runs it. |
147 void RunScheduledTask(); | 152 void RunScheduledTask(); |
148 | 153 |
149 // Stop running task (if any) and abandon scheduled task (if any). | 154 // Stop running task (if any) and abandon scheduled task (if any). |
150 void StopAndAbandon() { | 155 void StopAndAbandon() { |
151 Stop(); | 156 Stop(); |
152 AbandonScheduledTask(); | 157 AbandonScheduledTask(); |
153 } | 158 } |
154 | 159 |
155 // When non-NULL, the scheduled_task_ is waiting in the MessageLoop to call | 160 // When non-NULL, the scheduled_task_ is waiting in the MessageLoop to call |
156 // RunScheduledTask() at scheduled_run_time_. | 161 // RunScheduledTask() at scheduled_run_time_. |
157 BaseTimerTaskInternal* scheduled_task_; | 162 BaseTimerTaskInternal* scheduled_task_; |
158 | 163 |
159 // The task runner on which the task should be scheduled. If it is null, the | 164 // The task runner on which the task should be scheduled. If it is null, the |
160 // task runner for the current thread should be used. | 165 // task runner for the current thread is used. |
161 scoped_refptr<SingleThreadTaskRunner> task_runner_; | 166 scoped_refptr<SequencedTaskRunner> destination_task_runner_; |
162 | 167 |
163 // Location in user code. | 168 // Location in user code. |
164 tracked_objects::Location posted_from_; | 169 tracked_objects::Location posted_from_; |
165 // Delay requested by user. | 170 // Delay requested by user. |
166 TimeDelta delay_; | 171 TimeDelta delay_; |
167 // user_task_ is what the user wants to be run at desired_run_time_. | 172 // user_task_ is what the user wants to be run at desired_run_time_. |
168 base::Closure user_task_; | 173 base::Closure user_task_; |
169 | 174 |
170 // The estimated time that the MessageLoop will run the scheduled_task_ that | 175 // The estimated time that the MessageLoop will run the scheduled_task_ that |
171 // will call RunScheduledTask(). This time can be a "zero" TimeTicks if the | 176 // will call RunScheduledTask(). This time can be a "zero" TimeTicks if the |
172 // task must be run immediately. | 177 // task must be run immediately. |
173 TimeTicks scheduled_run_time_; | 178 TimeTicks scheduled_run_time_; |
174 | 179 |
175 // The desired run time of user_task_. The user may update this at any time, | 180 // The desired run time of user_task_. The user may update this at any time, |
176 // even if their previous request has not run yet. If desired_run_time_ is | 181 // even if their previous request has not run yet. If desired_run_time_ is |
177 // greater than scheduled_run_time_, a continuation task will be posted to | 182 // greater than scheduled_run_time_, a continuation task will be posted to |
178 // wait for the remaining time. This allows us to reuse the pending task so as | 183 // wait for the remaining time. This allows us to reuse the pending task so as |
179 // not to flood the MessageLoop with orphaned tasks when the user code | 184 // not to flood the MessageLoop with orphaned tasks when the user code |
180 // excessively Stops and Starts the timer. This time can be a "zero" TimeTicks | 185 // excessively Stops and Starts the timer. This time can be a "zero" TimeTicks |
181 // if the task must be run immediately. | 186 // if the task must be run immediately. |
182 TimeTicks desired_run_time_; | 187 TimeTicks desired_run_time_; |
183 | 188 |
184 // Thread ID of current MessageLoop for verifying single-threaded usage. | 189 // Calls to the timer are not thread safe, so a checker is used detect |
185 int thread_id_; | 190 // incorrect usage in debug builds. Note that this verifies the timer API |
| 191 // calls; the tasks may be scheduled by the timer on a different sequence if |
| 192 // SetTaskRunner() is used. |
| 193 SequenceChecker origin_sequence_checker_; |
| 194 |
| 195 // Once the timer has been scheduled, destination_task_runner_ may not be |
| 196 // changed. |
| 197 bool was_scheduled_; |
186 | 198 |
187 // Repeating timers automatically post the task again before calling the task | 199 // Repeating timers automatically post the task again before calling the task |
188 // callback. | 200 // callback. |
189 const bool is_repeating_; | 201 const bool is_repeating_; |
190 | 202 |
191 // If true, hold on to the user_task_ closure object for reuse. | 203 // If true, hold on to the user_task_ closure object for reuse. |
192 const bool retain_user_task_; | 204 const bool retain_user_task_; |
193 | 205 |
194 // If true, user_task_ is scheduled to run sometime in the future. | 206 // If true, user_task_ is scheduled to run sometime in the future. |
195 bool is_running_; | 207 bool is_running_; |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
235 | 247 |
236 //----------------------------------------------------------------------------- | 248 //----------------------------------------------------------------------------- |
237 // A simple, repeating timer. See usage notes at the top of the file. | 249 // A simple, repeating timer. See usage notes at the top of the file. |
238 class RepeatingTimer : public BaseTimerMethodPointer { | 250 class RepeatingTimer : public BaseTimerMethodPointer { |
239 public: | 251 public: |
240 RepeatingTimer() : BaseTimerMethodPointer(REPEATING) {} | 252 RepeatingTimer() : BaseTimerMethodPointer(REPEATING) {} |
241 }; | 253 }; |
242 | 254 |
243 //----------------------------------------------------------------------------- | 255 //----------------------------------------------------------------------------- |
244 // A Delay timer is like The Button from Lost. Once started, you have to keep | 256 // A Delay timer is like The Button from Lost. Once started, you have to keep |
245 // calling Reset otherwise it will call the given method in the MessageLoop | 257 // calling Reset otherwise it will call the given method on the task runner. |
246 // thread. | |
247 // | 258 // |
248 // Once created, it is inactive until Reset is called. Once |delay| seconds have | 259 // Once created, it is inactive until Reset is called. Once |delay| seconds have |
249 // passed since the last call to Reset, the callback is made. Once the callback | 260 // passed since the last call to Reset, the callback is made. Once the callback |
250 // has been made, it's inactive until Reset is called again. | 261 // has been made, it's inactive until Reset is called again. |
251 // | 262 // |
252 // If destroyed, the timeout is canceled and will not occur even if already | 263 // If destroyed, the timeout is canceled and will not occur even if already |
253 // inflight. | 264 // inflight. |
254 class DelayTimer : protected Timer { | 265 class DelayTimer : protected Timer { |
255 public: | 266 public: |
256 template <class Receiver> | 267 template <class Receiver> |
(...skipping 13 matching lines...) Expand all Loading... |
270 // to link in MSVC. But clang-plugin does not allow inline definitions of | 281 // to link in MSVC. But clang-plugin does not allow inline definitions of |
271 // virtual methods, so the inline definition lives in the header file here | 282 // virtual methods, so the inline definition lives in the header file here |
272 // to satisfy both. | 283 // to satisfy both. |
273 inline void DelayTimer::Reset() { | 284 inline void DelayTimer::Reset() { |
274 Timer::Reset(); | 285 Timer::Reset(); |
275 } | 286 } |
276 | 287 |
277 } // namespace base | 288 } // namespace base |
278 | 289 |
279 #endif // BASE_TIMER_TIMER_H_ | 290 #endif // BASE_TIMER_TIMER_H_ |
OLD | NEW |