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 14 matching lines...) Expand all Loading... | |
25 // timer_.Stop(); | 25 // timer_.Stop(); |
26 // } | 26 // } |
27 // private: | 27 // private: |
28 // void DoStuff() { | 28 // void DoStuff() { |
29 // // This method is called every second to do stuff. | 29 // // This method is called every second to do stuff. |
30 // ... | 30 // ... |
31 // } | 31 // } |
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 |
fdoray
2017/05/10 14:22:58
Observation: PostDelayedTask + WeakPtr or Cancelab
gab
2017/05/26 04:26:57
Interesting, would have to think about this, sugge
| |
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 |
fdoray
2017/05/10 14:22:58
Address thread safety here instead of here + at li
gab
2017/05/26 04:26:57
Done.
| |
43 // runner - thread or worker pool. By default the scheduled tasks will be run on | |
44 // the same sequence that the Timer lives on, but this can be changed prior via | |
45 // 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 <memory> | 55 #include <memory> |
53 | 56 |
54 #include "base/base_export.h" | 57 #include "base/base_export.h" |
55 #include "base/bind.h" | 58 #include "base/bind.h" |
56 #include "base/bind_helpers.h" | 59 #include "base/bind_helpers.h" |
57 #include "base/callback.h" | 60 #include "base/callback.h" |
58 #include "base/location.h" | 61 #include "base/location.h" |
59 #include "base/macros.h" | 62 #include "base/macros.h" |
63 #include "base/sequence_checker_impl.h" | |
fdoray
2017/05/10 14:22:58
sequence_checker.h
gab
2017/05/26 04:26:57
Done.
| |
64 #include "base/sequenced_task_runner.h" | |
60 #include "base/time/time.h" | 65 #include "base/time/time.h" |
61 | 66 |
62 namespace base { | 67 namespace base { |
63 | 68 |
64 class BaseTimerTaskInternal; | 69 class BaseTimerTaskInternal; |
65 class SingleThreadTaskRunner; | |
66 class TickClock; | 70 class TickClock; |
67 | 71 |
72 // TODO(gab): Removing this fwd-decl causes IWYU failures in other headers, | |
73 // remove it in a follow- up CL. | |
74 class SingleThreadTaskRunner; | |
75 | |
68 //----------------------------------------------------------------------------- | 76 //----------------------------------------------------------------------------- |
69 // This class wraps MessageLoop::PostDelayedTask to manage delayed and repeating | 77 // This class wraps TaskRunner::PostDelayedTask to manage delayed and repeating |
70 // tasks. It must be destructed on the same thread that starts tasks. There are | 78 // tasks. A Timer is bound to the sequence on which it is started. To destroy it |
71 // DCHECKs in place to verify this. | 79 // on its initial sequence (shall it differ) it must first be stopped on the |
80 // sequence it's bound to. There are DCHECKs in place to verify this. Note: | |
81 // Timer is sequence-affine, but may become thread-affine if coupled with a | |
82 // thread-affine TickClock. | |
72 // | 83 // |
73 class BASE_EXPORT Timer { | 84 class BASE_EXPORT Timer { |
74 public: | 85 public: |
75 // Construct a timer in repeating or one-shot mode. Start or SetTaskInfo must | 86 // Construct a timer in repeating or one-shot mode. Start must be called later |
76 // be called later to set task info. |retain_user_task| determines whether the | 87 // to set task info. |retain_user_task| determines whether the user_task is |
77 // user_task is retained or reset when it runs or stops. If |tick_clock| is | 88 // retained or reset when it runs or stops. If |tick_clock| is provided, it is |
78 // provided, it is used instead of TimeTicks::Now() to get TimeTicks when | 89 // used instead of TimeTicks::Now() to get TimeTicks when scheduling tasks. |
79 // scheduling tasks. | |
80 Timer(bool retain_user_task, bool is_repeating); | 90 Timer(bool retain_user_task, bool is_repeating); |
81 Timer(bool retain_user_task, bool is_repeating, TickClock* tick_clock); | 91 Timer(bool retain_user_task, bool is_repeating, TickClock* tick_clock); |
82 | 92 |
83 // Construct a timer with retained task info. If |tick_clock| is provided, it | 93 // Construct a timer with retained task info. If |tick_clock| is provided, it |
84 // is used instead of TimeTicks::Now() to get TimeTicks when scheduling tasks. | 94 // is used instead of TimeTicks::Now() to get TimeTicks when scheduling tasks. |
85 Timer(const tracked_objects::Location& posted_from, | 95 Timer(const tracked_objects::Location& posted_from, |
86 TimeDelta delay, | 96 TimeDelta delay, |
87 const base::Closure& user_task, | 97 const base::Closure& user_task, |
88 bool is_repeating); | 98 bool is_repeating); |
89 Timer(const tracked_objects::Location& posted_from, | 99 Timer(const tracked_objects::Location& posted_from, |
90 TimeDelta delay, | 100 TimeDelta delay, |
91 const base::Closure& user_task, | 101 const base::Closure& user_task, |
92 bool is_repeating, | 102 bool is_repeating, |
93 TickClock* tick_clock); | 103 TickClock* tick_clock); |
94 | 104 |
95 virtual ~Timer(); | 105 virtual ~Timer(); |
96 | 106 |
97 // Returns true if the timer is running (i.e., not stopped). | 107 // Returns true if the timer is running (i.e., not stopped). |
98 virtual bool IsRunning() const; | 108 virtual bool IsRunning() const; |
99 | 109 |
100 // Returns the current delay for this timer. | 110 // Returns the current delay for this timer. |
101 virtual TimeDelta GetCurrentDelay() const; | 111 virtual TimeDelta GetCurrentDelay() const; |
102 | 112 |
103 // Set the task runner on which the task should be scheduled. This method can | 113 // Set the task runner on which the task should be scheduled. This method can |
104 // only be called before any tasks have been scheduled. The task runner must | 114 // only be called before any tasks have been scheduled. If |task_runner| runs |
105 // run tasks on the same thread the timer is used on. | 115 // tasks on a different sequence than the sequence owning this Timer, |
106 virtual void SetTaskRunner(scoped_refptr<SingleThreadTaskRunner> task_runner); | 116 // |user_task_| will be posted to it when the Timer fires (note that this |
117 // means |user_task_| can run after ~Timer() and should support that). | |
118 void SetTaskRunner(scoped_refptr<SequencedTaskRunner> task_runner); | |
107 | 119 |
108 // Start the timer to run at the given |delay| from now. If the timer is | 120 // Start the timer to run at the given |delay| from now. If the timer is |
109 // already running, it will be replaced to call the given |user_task|. | 121 // already running, it will be replaced to call the given |user_task|. |
110 virtual void Start(const tracked_objects::Location& posted_from, | 122 virtual void Start(const tracked_objects::Location& posted_from, |
111 TimeDelta delay, | 123 TimeDelta delay, |
112 const base::Closure& user_task); | 124 const base::Closure& user_task); |
113 | 125 |
114 // Call this method to stop and cancel the timer. It is a no-op if the timer | 126 // Call this method to stop and cancel the timer. It is a no-op if the timer |
115 // is not running. | 127 // is not running. |
116 virtual void Stop(); | 128 virtual void Stop(); |
117 | 129 |
118 // Call this method to reset the timer delay. The user_task_ must be set. If | 130 // Call this method to reset the timer delay. The |user_task_| must be set. If |
119 // the timer is not running, this will start it by posting a task. | 131 // the timer is not running, this will start it by posting a task. |
120 virtual void Reset(); | 132 virtual void Reset(); |
121 | 133 |
122 const base::Closure& user_task() const { return user_task_; } | 134 const base::Closure& user_task() const { return user_task_; } |
123 const TimeTicks& desired_run_time() const { return desired_run_time_; } | 135 const TimeTicks& desired_run_time() const { return desired_run_time_; } |
124 | 136 |
125 protected: | 137 protected: |
126 // Returns the current tick count. | 138 // Returns the current tick count. |
127 TimeTicks Now() const; | 139 TimeTicks Now() const; |
128 | 140 |
129 // Used to initiate a new delayed task. This has the side-effect of disabling | |
130 // scheduled_task_ if it is non-null. | |
131 void SetTaskInfo(const tracked_objects::Location& posted_from, | |
132 TimeDelta delay, | |
133 const base::Closure& user_task); | |
134 | |
135 void set_user_task(const Closure& task) { user_task_ = task; } | 141 void set_user_task(const Closure& task) { user_task_ = task; } |
136 void set_desired_run_time(TimeTicks desired) { desired_run_time_ = desired; } | 142 void set_desired_run_time(TimeTicks desired) { desired_run_time_ = desired; } |
137 void set_is_running(bool running) { is_running_ = running; } | 143 void set_is_running(bool running) { is_running_ = running; } |
138 | 144 |
139 const tracked_objects::Location& posted_from() const { return posted_from_; } | 145 const tracked_objects::Location& posted_from() const { return posted_from_; } |
140 bool retain_user_task() const { return retain_user_task_; } | 146 bool retain_user_task() const { return retain_user_task_; } |
141 bool is_repeating() const { return is_repeating_; } | 147 bool is_repeating() const { return is_repeating_; } |
142 bool is_running() const { return is_running_; } | 148 bool is_running() const { return is_running_; } |
143 | 149 |
144 private: | 150 private: |
145 friend class BaseTimerTaskInternal; | 151 friend class BaseTimerTaskInternal; |
146 | 152 |
147 // Allocates a new scheduled_task_ and posts it on the current MessageLoop | 153 // Allocates a new |scheduled_task_| and posts it on the current sequence with |
148 // with the given |delay|. scheduled_task_ must be NULL. scheduled_run_time_ | 154 // the given |delay|. |scheduled_task_| must be null. |scheduled_run_time_| |
149 // and desired_run_time_ are reset to Now() + delay. | 155 // and |desired_run_time_| are reset to Now() + delay. |
150 void PostNewScheduledTask(TimeDelta delay); | 156 void PostNewScheduledTask(TimeDelta delay); |
151 | 157 |
152 // Returns the task runner on which the task should be scheduled. If the | 158 // Disable |scheduled_task_| and abandon it so that it no longer refers back |
153 // corresponding task_runner_ field is null, the task runner for the current | 159 // to this object. |
154 // thread is returned. | |
155 scoped_refptr<SingleThreadTaskRunner> GetTaskRunner(); | |
156 | |
157 // Disable scheduled_task_ and abandon it so that it no longer refers back to | |
158 // this object. | |
159 void AbandonScheduledTask(); | 160 void AbandonScheduledTask(); |
160 | 161 |
161 // Called by BaseTimerTaskInternal when the MessageLoop runs it. | 162 // Called by BaseTimerTaskInternal when the delayed task fires. |
162 void RunScheduledTask(); | 163 void RunScheduledTask(); |
163 | 164 |
164 // Stop running task (if any) and abandon scheduled task (if any). | 165 // When non-null, the |scheduled_task_| was posted to call RunScheduledTask() |
165 void StopAndAbandon() { | 166 // at |scheduled_run_time_|. |
166 AbandonScheduledTask(); | |
167 | |
168 Stop(); | |
169 // No more member accesses here: |this| could be deleted at this point. | |
170 } | |
171 | |
172 // When non-NULL, the scheduled_task_ is waiting in the MessageLoop to call | |
173 // RunScheduledTask() at scheduled_run_time_. | |
174 BaseTimerTaskInternal* scheduled_task_; | 167 BaseTimerTaskInternal* scheduled_task_; |
175 | 168 |
176 // The task runner on which the task should be scheduled. If it is null, the | 169 // The task runner on which the task should be scheduled. If it is null, the |
177 // task runner for the current thread should be used. | 170 // task runner for the current sequence will be used. |
178 scoped_refptr<SingleThreadTaskRunner> task_runner_; | 171 scoped_refptr<SequencedTaskRunner> task_runner_; |
179 | 172 |
180 // Location in user code. | 173 // Location in user code. |
181 tracked_objects::Location posted_from_; | 174 tracked_objects::Location posted_from_; |
182 // Delay requested by user. | 175 // Delay requested by user. |
183 TimeDelta delay_; | 176 TimeDelta delay_; |
184 // user_task_ is what the user wants to be run at desired_run_time_. | 177 // |user_task_| is what the user wants to be run at |desired_run_time_|. |
185 base::Closure user_task_; | 178 base::Closure user_task_; |
186 | 179 |
187 // The estimated time that the MessageLoop will run the scheduled_task_ that | 180 // The time at which |scheduled_task_| is expected to fire. This time can be a |
188 // will call RunScheduledTask(). This time can be a "zero" TimeTicks if the | 181 // "zero" TimeTicks if the task must be run immediately. |
189 // task must be run immediately. | |
190 TimeTicks scheduled_run_time_; | 182 TimeTicks scheduled_run_time_; |
191 | 183 |
192 // The desired run time of user_task_. The user may update this at any time, | 184 // The desired run time of |user_task_|. The user may update this at any time, |
193 // even if their previous request has not run yet. If desired_run_time_ is | 185 // even if their previous request has not run yet. If |desired_run_time_| is |
194 // greater than scheduled_run_time_, a continuation task will be posted to | 186 // greater than |scheduled_run_time_|, a continuation task will be posted to |
195 // wait for the remaining time. This allows us to reuse the pending task so as | 187 // wait for the remaining time. This allows us to reuse the pending task so as |
196 // not to flood the MessageLoop with orphaned tasks when the user code | 188 // not to flood the delayed queues with orphaned tasks when the user code |
197 // excessively Stops and Starts the timer. This time can be a "zero" TimeTicks | 189 // excessively Stops and Starts the timer. This time can be a "zero" TimeTicks |
198 // if the task must be run immediately. | 190 // if the task must be run immediately. |
199 TimeTicks desired_run_time_; | 191 TimeTicks desired_run_time_; |
200 | 192 |
201 // Thread ID of current MessageLoop for verifying single-threaded usage. | 193 // Timer isn't thread-safe and must only be used on its origin sequence |
202 int thread_id_; | 194 // (sequence on which it was started). |
195 SequenceChecker origin_sequence_checker_; | |
203 | 196 |
204 // Repeating timers automatically post the task again before calling the task | 197 // Repeating timers automatically post the task again before calling the task |
205 // callback. | 198 // callback. |
206 const bool is_repeating_; | 199 const bool is_repeating_; |
207 | 200 |
208 // If true, hold on to the user_task_ closure object for reuse. | 201 // If true, hold on to the |user_task_| closure object for reuse. |
209 const bool retain_user_task_; | 202 const bool retain_user_task_; |
210 | 203 |
211 // The tick clock used to calculate the run time for scheduled tasks. | 204 // The tick clock used to calculate the run time for scheduled tasks. |
212 TickClock* const tick_clock_; | 205 TickClock* const tick_clock_; |
213 | 206 |
214 // If true, user_task_ is scheduled to run sometime in the future. | 207 // If true, |user_task_| is scheduled to run sometime in the future. |
215 bool is_running_; | 208 bool is_running_; |
216 | 209 |
217 DISALLOW_COPY_AND_ASSIGN(Timer); | 210 DISALLOW_COPY_AND_ASSIGN(Timer); |
218 }; | 211 }; |
219 | 212 |
220 //----------------------------------------------------------------------------- | 213 //----------------------------------------------------------------------------- |
221 // This class is an implementation detail of OneShotTimer and RepeatingTimer. | 214 // This class is an implementation detail of OneShotTimer and RepeatingTimer. |
222 // Please do not use this class directly. | 215 // Please do not use this class directly. |
223 class BaseTimerMethodPointer : public Timer { | 216 class BaseTimerMethodPointer : public Timer { |
224 public: | 217 public: |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
259 // A simple, repeating timer. See usage notes at the top of the file. | 252 // A simple, repeating timer. See usage notes at the top of the file. |
260 class RepeatingTimer : public BaseTimerMethodPointer { | 253 class RepeatingTimer : public BaseTimerMethodPointer { |
261 public: | 254 public: |
262 RepeatingTimer() : RepeatingTimer(nullptr) {} | 255 RepeatingTimer() : RepeatingTimer(nullptr) {} |
263 explicit RepeatingTimer(TickClock* tick_clock) | 256 explicit RepeatingTimer(TickClock* tick_clock) |
264 : BaseTimerMethodPointer(REPEATING, tick_clock) {} | 257 : BaseTimerMethodPointer(REPEATING, tick_clock) {} |
265 }; | 258 }; |
266 | 259 |
267 //----------------------------------------------------------------------------- | 260 //----------------------------------------------------------------------------- |
268 // A Delay timer is like The Button from Lost. Once started, you have to keep | 261 // A Delay timer is like The Button from Lost. Once started, you have to keep |
269 // calling Reset otherwise it will call the given method in the MessageLoop | 262 // calling Reset otherwise it will call the given method on the sequence it was |
270 // thread. | 263 // initially Reset() from. |
271 // | 264 // |
272 // Once created, it is inactive until Reset is called. Once |delay| seconds have | 265 // Once created, it is inactive until Reset is called. Once |delay| seconds have |
273 // passed since the last call to Reset, the callback is made. Once the callback | 266 // passed since the last call to Reset, the callback is made. Once the callback |
274 // has been made, it's inactive until Reset is called again. | 267 // has been made, it's inactive until Reset is called again. |
275 // | 268 // |
276 // If destroyed, the timeout is canceled and will not occur even if already | 269 // If destroyed, the timeout is canceled and will not occur even if already |
277 // inflight. | 270 // inflight. |
278 class DelayTimer : protected Timer { | 271 class DelayTimer : protected Timer { |
279 public: | 272 public: |
280 template <class Receiver> | 273 template <class Receiver> |
(...skipping 22 matching lines...) Expand all Loading... | |
303 // to link in MSVC. But clang-plugin does not allow inline definitions of | 296 // to link in MSVC. But clang-plugin does not allow inline definitions of |
304 // virtual methods, so the inline definition lives in the header file here | 297 // virtual methods, so the inline definition lives in the header file here |
305 // to satisfy both. | 298 // to satisfy both. |
306 inline void DelayTimer::Reset() { | 299 inline void DelayTimer::Reset() { |
307 Timer::Reset(); | 300 Timer::Reset(); |
308 } | 301 } |
309 | 302 |
310 } // namespace base | 303 } // namespace base |
311 | 304 |
312 #endif // BASE_TIMER_TIMER_H_ | 305 #endif // BASE_TIMER_TIMER_H_ |
OLD | NEW |