OLD | NEW |
(Empty) | |
| 1 // Copyright 2014 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 #include "components/timers/alarm_timer_chromeos.h" |
| 6 |
| 7 #include <sys/timerfd.h> |
| 8 |
| 9 #include "base/bind.h" |
| 10 #include "base/bind_helpers.h" |
| 11 #include "base/files/file_util.h" |
| 12 #include "base/lazy_instance.h" |
| 13 #include "base/logging.h" |
| 14 #include "base/macros.h" |
| 15 #include "base/message_loop/message_loop.h" |
| 16 #include "base/message_loop/message_loop_proxy.h" |
| 17 #include "base/pending_task.h" |
| 18 #include "base/threading/thread.h" |
| 19 |
| 20 namespace timers { |
| 21 namespace { |
| 22 // This class represents the IO thread that the AlarmTimer::Delegate may use for |
| 23 // watching file descriptors if it gets called from a thread that does not have |
| 24 // a MessageLoopForIO. It is a lazy global instance because it may not always |
| 25 // be necessary. |
| 26 class RtcAlarmIOThread : public base::Thread { |
| 27 public: |
| 28 RtcAlarmIOThread() : Thread("RTC Alarm IO Thread") { |
| 29 CHECK( |
| 30 StartWithOptions(base::Thread::Options(base::MessageLoop::TYPE_IO, 0))); |
| 31 } |
| 32 ~RtcAlarmIOThread() override { Stop(); } |
| 33 }; |
| 34 |
| 35 base::LazyInstance<RtcAlarmIOThread> g_io_thread = LAZY_INSTANCE_INITIALIZER; |
| 36 |
| 37 } // namespace |
| 38 |
| 39 // Watches a MessageLoop and runs a callback if that MessageLoop will be |
| 40 // destroyed. |
| 41 class AlarmTimer::MessageLoopObserver |
| 42 : public base::MessageLoop::DestructionObserver { |
| 43 public: |
| 44 // Constructs a MessageLoopObserver that will observe |message_loop| and will |
| 45 // call |on_will_be_destroyed_callback| when |message_loop| is about to be |
| 46 // destroyed. |
| 47 MessageLoopObserver(base::MessageLoop* message_loop, |
| 48 base::Closure on_will_be_destroyed_callback) |
| 49 : message_loop_(message_loop), |
| 50 on_will_be_destroyed_callback_(on_will_be_destroyed_callback) { |
| 51 DCHECK(message_loop_); |
| 52 message_loop_->AddDestructionObserver(this); |
| 53 } |
| 54 |
| 55 ~MessageLoopObserver() override { |
| 56 // If |message_loop_| was destroyed, then this class will have already |
| 57 // unregistered itself. Doing it again will trigger a warning. |
| 58 if (message_loop_) |
| 59 message_loop_->RemoveDestructionObserver(this); |
| 60 } |
| 61 |
| 62 // base::MessageLoop::DestructionObserver override. |
| 63 void WillDestroyCurrentMessageLoop() override { |
| 64 message_loop_->RemoveDestructionObserver(this); |
| 65 message_loop_ = NULL; |
| 66 |
| 67 on_will_be_destroyed_callback_.Run(); |
| 68 } |
| 69 |
| 70 private: |
| 71 // The MessageLoop that this class should watch. Is a weak pointer. |
| 72 base::MessageLoop* message_loop_; |
| 73 |
| 74 // The callback to run when |message_loop_| will be destroyed. |
| 75 base::Closure on_will_be_destroyed_callback_; |
| 76 |
| 77 DISALLOW_COPY_AND_ASSIGN(MessageLoopObserver); |
| 78 }; |
| 79 |
| 80 // This class manages a Real Time Clock (RTC) alarm, a feature that is available |
| 81 // from linux version 3.11 onwards. It creates a file descriptor for the RTC |
| 82 // alarm timer and then watches that file descriptor to see when it can be read |
| 83 // without blocking, indicating that the timer has fired. |
| 84 // |
| 85 // A major problem for this class is that watching file descriptors is only |
| 86 // available on a MessageLoopForIO but there is no guarantee the timer is going |
| 87 // to be created on one. To get around this, the timer has a dedicated thread |
| 88 // with a MessageLoopForIO that posts tasks back to the thread that started the |
| 89 // timer. |
| 90 class AlarmTimer::Delegate |
| 91 : public base::RefCountedThreadSafe<AlarmTimer::Delegate>, |
| 92 public base::MessageLoopForIO::Watcher { |
| 93 public: |
| 94 // Construct a Delegate for the AlarmTimer. It should be safe to call |
| 95 // |on_timer_fired_callback| multiple times. |
| 96 explicit Delegate(base::Closure on_timer_fired_callback); |
| 97 |
| 98 // Returns true if the system timer managed by this delegate is capable of |
| 99 // waking the system from suspend. |
| 100 bool CanWakeFromSuspend(); |
| 101 |
| 102 // Resets the timer to fire after |delay| has passed. Cancels any |
| 103 // pre-existing delay. |
| 104 void Reset(base::TimeDelta delay); |
| 105 |
| 106 // Stops the currently running timer. It should be safe to call this even if |
| 107 // the timer is not running. |
| 108 void Stop(); |
| 109 |
| 110 // Sets a hook that will be called when the timer fires and a task has been |
| 111 // queued on |origin_message_loop_|. Used by tests to wait until a task is |
| 112 // pending in the MessageLoop. |
| 113 void SetTimerFiredCallbackForTest(base::Closure test_callback); |
| 114 |
| 115 // base::MessageLoopForIO::Watcher overrides. |
| 116 void OnFileCanReadWithoutBlocking(int fd) override; |
| 117 void OnFileCanWriteWithoutBlocking(int fd) override; |
| 118 |
| 119 private: |
| 120 friend class base::RefCountedThreadSafe<Delegate>; |
| 121 ~Delegate() override; |
| 122 |
| 123 // Actually performs the system calls to set up the timer. This must be |
| 124 // called on a MessageLoopForIO. |
| 125 void ResetImpl(base::TimeDelta delay, int reset_sequence_number); |
| 126 |
| 127 // Callback that is run when the timer fires. Must be run on |
| 128 // |origin_message_loop_|. |
| 129 void OnTimerFired(int reset_sequence_number); |
| 130 |
| 131 // File descriptor associated with the alarm timer. |
| 132 int alarm_fd_; |
| 133 |
| 134 // Message loop which initially started the timer. |
| 135 scoped_refptr<base::MessageLoopProxy> origin_message_loop_; |
| 136 |
| 137 // Callback that should be run when the timer fires. |
| 138 base::Closure on_timer_fired_callback_; |
| 139 |
| 140 // Hook used by tests to be notified when the timer has fired and a task has |
| 141 // been queued in the MessageLoop. |
| 142 base::Closure on_timer_fired_callback_for_test_; |
| 143 |
| 144 // Manages watching file descriptors. |
| 145 scoped_ptr<base::MessageLoopForIO::FileDescriptorWatcher> fd_watcher_; |
| 146 |
| 147 // The sequence numbers of the last Reset() call handled respectively on |
| 148 // |origin_message_loop_| and on the MessageLoopForIO used for watching the |
| 149 // timer file descriptor. Note that these can be the same MessageLoop. |
| 150 // OnTimerFired() runs |on_timer_fired_callback_| only if the sequence number |
| 151 // it receives from the MessageLoopForIO matches |
| 152 // |origin_reset_sequence_number_|. |
| 153 int origin_reset_sequence_number_; |
| 154 int io_reset_sequence_number_; |
| 155 |
| 156 DISALLOW_COPY_AND_ASSIGN(Delegate); |
| 157 }; |
| 158 |
| 159 AlarmTimer::Delegate::Delegate(base::Closure on_timer_fired_callback) |
| 160 : alarm_fd_(timerfd_create(CLOCK_REALTIME_ALARM, 0)), |
| 161 on_timer_fired_callback_(on_timer_fired_callback), |
| 162 origin_reset_sequence_number_(0), |
| 163 io_reset_sequence_number_(0) { |
| 164 // The call to timerfd_create above may fail. This is the only indication |
| 165 // that CLOCK_REALTIME_ALARM is not supported on this system. |
| 166 DPLOG_IF(INFO, (alarm_fd_ == -1)) |
| 167 << "CLOCK_REALTIME_ALARM not supported on this system"; |
| 168 } |
| 169 |
| 170 AlarmTimer::Delegate::~Delegate() { |
| 171 if (alarm_fd_ != -1) |
| 172 close(alarm_fd_); |
| 173 } |
| 174 |
| 175 bool AlarmTimer::Delegate::CanWakeFromSuspend() { |
| 176 return alarm_fd_ != -1; |
| 177 } |
| 178 |
| 179 void AlarmTimer::Delegate::Reset(base::TimeDelta delay) { |
| 180 // Get a proxy for the current message loop. When the timer fires, we will |
| 181 // post tasks to this proxy to let the parent timer know. |
| 182 origin_message_loop_ = base::MessageLoopProxy::current(); |
| 183 |
| 184 // Increment the sequence number. Used to invalidate any events that have |
| 185 // been queued but not yet run since the last time Reset() was called. |
| 186 origin_reset_sequence_number_++; |
| 187 |
| 188 // Calling timerfd_settime with a zero delay actually clears the timer so if |
| 189 // the user has requested a zero delay timer, we need to handle it |
| 190 // differently. We queue the task here but we still go ahead and call |
| 191 // timerfd_settime with the zero delay anyway to cancel any previous delay |
| 192 // that might have been programmed. |
| 193 if (delay <= base::TimeDelta::FromMicroseconds(0)) { |
| 194 // The timerfd_settime documentation is vague on what happens when it is |
| 195 // passed a negative delay. We can sidestep the issue by ensuring that |
| 196 // the delay is 0. |
| 197 delay = base::TimeDelta::FromMicroseconds(0); |
| 198 origin_message_loop_->PostTask( |
| 199 FROM_HERE, |
| 200 base::Bind(&Delegate::OnTimerFired, scoped_refptr<Delegate>(this), |
| 201 origin_reset_sequence_number_)); |
| 202 } |
| 203 |
| 204 // Run ResetImpl() on a MessageLoopForIO. |
| 205 if (base::MessageLoopForIO::IsCurrent()) { |
| 206 ResetImpl(delay, origin_reset_sequence_number_); |
| 207 } else { |
| 208 g_io_thread.Pointer()->task_runner()->PostTask( |
| 209 FROM_HERE, |
| 210 base::Bind(&Delegate::ResetImpl, scoped_refptr<Delegate>(this), delay, |
| 211 origin_reset_sequence_number_)); |
| 212 } |
| 213 } |
| 214 |
| 215 void AlarmTimer::Delegate::Stop() { |
| 216 // Stop the RTC from a MessageLoopForIO. |
| 217 if (!base::MessageLoopForIO::IsCurrent()) { |
| 218 g_io_thread.Pointer()->task_runner()->PostTask( |
| 219 FROM_HERE, base::Bind(&Delegate::Stop, scoped_refptr<Delegate>(this))); |
| 220 return; |
| 221 } |
| 222 |
| 223 // Stop watching for events. |
| 224 fd_watcher_.reset(); |
| 225 |
| 226 // Now clear the timer. |
| 227 DCHECK_NE(alarm_fd_, -1); |
| 228 itimerspec blank_time = {}; |
| 229 if (timerfd_settime(alarm_fd_, 0, &blank_time, NULL) < 0) |
| 230 PLOG(ERROR) << "Unable to clear alarm time. Timer may still fire."; |
| 231 } |
| 232 |
| 233 void AlarmTimer::Delegate::OnFileCanReadWithoutBlocking(int fd) { |
| 234 DCHECK_EQ(alarm_fd_, fd); |
| 235 |
| 236 // Read from the fd to ack the event. |
| 237 char val[sizeof(uint64_t)]; |
| 238 if (!base::ReadFromFD(alarm_fd_, val, sizeof(uint64_t))) |
| 239 PLOG(DFATAL) << "Unable to read from timer file descriptor."; |
| 240 |
| 241 // Make sure that the parent timer is informed on the proper message loop. |
| 242 if (origin_message_loop_->RunsTasksOnCurrentThread()) { |
| 243 OnTimerFired(io_reset_sequence_number_); |
| 244 } else { |
| 245 origin_message_loop_->PostTask( |
| 246 FROM_HERE, |
| 247 base::Bind(&Delegate::OnTimerFired, scoped_refptr<Delegate>(this), |
| 248 io_reset_sequence_number_)); |
| 249 } |
| 250 } |
| 251 |
| 252 void AlarmTimer::Delegate::OnFileCanWriteWithoutBlocking(int fd) { |
| 253 NOTREACHED(); |
| 254 } |
| 255 |
| 256 void AlarmTimer::Delegate::SetTimerFiredCallbackForTest( |
| 257 base::Closure test_callback) { |
| 258 on_timer_fired_callback_for_test_ = test_callback; |
| 259 } |
| 260 |
| 261 void AlarmTimer::Delegate::ResetImpl(base::TimeDelta delay, |
| 262 int reset_sequence_number) { |
| 263 DCHECK(base::MessageLoopForIO::IsCurrent()); |
| 264 DCHECK_NE(alarm_fd_, -1); |
| 265 |
| 266 // Store the sequence number in the IO thread variable. When the timer |
| 267 // fires, we will bind this value to the OnTimerFired callback to ensure |
| 268 // that we do the right thing if the timer gets reset. |
| 269 io_reset_sequence_number_ = reset_sequence_number; |
| 270 |
| 271 // If we were already watching the fd, this will stop watching it. |
| 272 fd_watcher_.reset(new base::MessageLoopForIO::FileDescriptorWatcher); |
| 273 |
| 274 // Start watching the fd to see when the timer fires. |
| 275 if (!base::MessageLoopForIO::current()->WatchFileDescriptor( |
| 276 alarm_fd_, false, base::MessageLoopForIO::WATCH_READ, |
| 277 fd_watcher_.get(), this)) { |
| 278 LOG(ERROR) << "Error while attempting to watch file descriptor for RTC " |
| 279 << "alarm. Timer will not fire."; |
| 280 } |
| 281 |
| 282 // Actually set the timer. This will also clear the pre-existing timer, if |
| 283 // any. |
| 284 itimerspec alarm_time = {}; |
| 285 alarm_time.it_value.tv_sec = delay.InSeconds(); |
| 286 alarm_time.it_value.tv_nsec = |
| 287 (delay.InMicroseconds() % base::Time::kMicrosecondsPerSecond) * |
| 288 base::Time::kNanosecondsPerMicrosecond; |
| 289 if (timerfd_settime(alarm_fd_, 0, &alarm_time, NULL) < 0) |
| 290 PLOG(ERROR) << "Error while setting alarm time. Timer will not fire"; |
| 291 } |
| 292 |
| 293 void AlarmTimer::Delegate::OnTimerFired(int reset_sequence_number) { |
| 294 DCHECK(origin_message_loop_->RunsTasksOnCurrentThread()); |
| 295 |
| 296 // If a test wants to be notified when this function is about to run, then |
| 297 // re-queue this task in the MessageLoop and run the test's callback. |
| 298 if (!on_timer_fired_callback_for_test_.is_null()) { |
| 299 origin_message_loop_->PostTask( |
| 300 FROM_HERE, |
| 301 base::Bind(&Delegate::OnTimerFired, scoped_refptr<Delegate>(this), |
| 302 reset_sequence_number)); |
| 303 |
| 304 on_timer_fired_callback_for_test_.Run(); |
| 305 on_timer_fired_callback_for_test_.Reset(); |
| 306 return; |
| 307 } |
| 308 |
| 309 // Check to make sure that the timer was not reset in the time between when |
| 310 // this task was queued to run and now. If it was reset, then don't do |
| 311 // anything. |
| 312 if (reset_sequence_number != origin_reset_sequence_number_) |
| 313 return; |
| 314 |
| 315 on_timer_fired_callback_.Run(); |
| 316 } |
| 317 |
| 318 AlarmTimer::AlarmTimer(bool retain_user_task, bool is_repeating) |
| 319 : base::Timer(retain_user_task, is_repeating), |
| 320 can_wake_from_suspend_(false), |
| 321 origin_message_loop_(NULL), |
| 322 weak_factory_(this) { |
| 323 Init(); |
| 324 } |
| 325 |
| 326 AlarmTimer::AlarmTimer(const tracked_objects::Location& posted_from, |
| 327 base::TimeDelta delay, |
| 328 const base::Closure& user_task, |
| 329 bool is_repeating) |
| 330 : base::Timer(posted_from, delay, user_task, is_repeating), |
| 331 can_wake_from_suspend_(false), |
| 332 origin_message_loop_(NULL), |
| 333 weak_factory_(this) { |
| 334 Init(); |
| 335 } |
| 336 |
| 337 AlarmTimer::~AlarmTimer() { |
| 338 Stop(); |
| 339 } |
| 340 |
| 341 void AlarmTimer::SetTimerFiredCallbackForTest(base::Closure test_callback) { |
| 342 delegate_->SetTimerFiredCallbackForTest(test_callback); |
| 343 } |
| 344 |
| 345 void AlarmTimer::Init() { |
| 346 delegate_ = make_scoped_refptr(new AlarmTimer::Delegate( |
| 347 base::Bind(&AlarmTimer::OnTimerFired, weak_factory_.GetWeakPtr()))); |
| 348 can_wake_from_suspend_ = delegate_->CanWakeFromSuspend(); |
| 349 } |
| 350 |
| 351 void AlarmTimer::Stop() { |
| 352 if (!can_wake_from_suspend_) { |
| 353 base::Timer::Stop(); |
| 354 return; |
| 355 } |
| 356 |
| 357 // Clear the running flag, stop the delegate, and delete the pending task. |
| 358 base::Timer::set_is_running(false); |
| 359 delegate_->Stop(); |
| 360 pending_task_.reset(); |
| 361 |
| 362 // Stop watching |origin_message_loop_|. |
| 363 origin_message_loop_ = NULL; |
| 364 message_loop_observer_.reset(); |
| 365 |
| 366 if (!base::Timer::retain_user_task()) |
| 367 base::Timer::set_user_task(base::Closure()); |
| 368 } |
| 369 |
| 370 void AlarmTimer::Reset() { |
| 371 if (!can_wake_from_suspend_) { |
| 372 base::Timer::Reset(); |
| 373 return; |
| 374 } |
| 375 |
| 376 DCHECK(!base::Timer::user_task().is_null()); |
| 377 DCHECK(!origin_message_loop_ || |
| 378 origin_message_loop_->task_runner()->RunsTasksOnCurrentThread()); |
| 379 |
| 380 // Make sure that the timer will stop if the underlying message loop is |
| 381 // destroyed. |
| 382 if (!origin_message_loop_) { |
| 383 origin_message_loop_ = base::MessageLoop::current(); |
| 384 message_loop_observer_.reset(new MessageLoopObserver( |
| 385 origin_message_loop_, |
| 386 base::Bind(&AlarmTimer::WillDestroyCurrentMessageLoop, |
| 387 weak_factory_.GetWeakPtr()))); |
| 388 } |
| 389 |
| 390 // Set up the pending task. |
| 391 if (base::Timer::GetCurrentDelay() > base::TimeDelta::FromMicroseconds(0)) { |
| 392 base::Timer::set_desired_run_time(base::TimeTicks::Now() + |
| 393 base::Timer::GetCurrentDelay()); |
| 394 pending_task_.reset(new base::PendingTask( |
| 395 base::Timer::posted_from(), base::Timer::user_task(), |
| 396 base::Timer::desired_run_time(), true /* nestable */)); |
| 397 } else { |
| 398 base::Timer::set_desired_run_time(base::TimeTicks()); |
| 399 pending_task_.reset(new base::PendingTask(base::Timer::posted_from(), |
| 400 base::Timer::user_task())); |
| 401 } |
| 402 base::MessageLoop::current()->task_annotator()->DidQueueTask( |
| 403 "AlarmTimer::Reset", *pending_task_); |
| 404 |
| 405 // Now start up the timer. |
| 406 delegate_->Reset(base::Timer::GetCurrentDelay()); |
| 407 base::Timer::set_is_running(true); |
| 408 } |
| 409 |
| 410 void AlarmTimer::WillDestroyCurrentMessageLoop() { |
| 411 Stop(); |
| 412 } |
| 413 |
| 414 void AlarmTimer::OnTimerFired() { |
| 415 if (!base::Timer::IsRunning()) |
| 416 return; |
| 417 |
| 418 DCHECK(pending_task_.get()); |
| 419 |
| 420 // Take ownership of the pending user task, which is going to be cleared by |
| 421 // the Stop() or Reset() functions below. |
| 422 scoped_ptr<base::PendingTask> pending_user_task(pending_task_.Pass()); |
| 423 |
| 424 // Re-schedule or stop the timer as requested. |
| 425 if (base::Timer::is_repeating()) |
| 426 Reset(); |
| 427 else |
| 428 Stop(); |
| 429 |
| 430 // Now run the user task. |
| 431 base::MessageLoop::current()->task_annotator()->RunTask( |
| 432 "AlarmTimer::Reset", "AlarmTimer::OnTimerFired", *pending_user_task); |
| 433 } |
| 434 |
| 435 OneShotAlarmTimer::OneShotAlarmTimer() : AlarmTimer(false, false) { |
| 436 } |
| 437 |
| 438 OneShotAlarmTimer::~OneShotAlarmTimer() { |
| 439 } |
| 440 |
| 441 RepeatingAlarmTimer::RepeatingAlarmTimer() : AlarmTimer(true, true) { |
| 442 } |
| 443 |
| 444 RepeatingAlarmTimer::RepeatingAlarmTimer( |
| 445 const tracked_objects::Location& posted_from, |
| 446 base::TimeDelta delay, |
| 447 const base::Closure& user_task) |
| 448 : AlarmTimer(posted_from, delay, user_task, true) { |
| 449 } |
| 450 |
| 451 RepeatingAlarmTimer::~RepeatingAlarmTimer() { |
| 452 } |
| 453 |
| 454 SimpleAlarmTimer::SimpleAlarmTimer() : AlarmTimer(true, false) { |
| 455 } |
| 456 |
| 457 SimpleAlarmTimer::SimpleAlarmTimer(const tracked_objects::Location& posted_from, |
| 458 base::TimeDelta delay, |
| 459 const base::Closure& user_task) |
| 460 : AlarmTimer(posted_from, delay, user_task, false) { |
| 461 } |
| 462 |
| 463 SimpleAlarmTimer::~SimpleAlarmTimer() { |
| 464 } |
| 465 |
| 466 } // namespace timers |
OLD | NEW |