quic_chromium_alarm_factory.cc 3.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102
  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. #include "net/quic/quic_chromium_alarm_factory.h"
  5. #include "base/bind.h"
  6. #include "base/check.h"
  7. #include "base/location.h"
  8. #include "base/memory/raw_ptr.h"
  9. #include "base/time/tick_clock.h"
  10. #include "base/time/time.h"
  11. #include "base/timer/timer.h"
  12. #include "net/quic/platform/impl/quic_chromium_clock.h"
  13. namespace net {
  14. namespace {
  15. class QuicChromeAlarm : public quic::QuicAlarm, public base::TickClock {
  16. public:
  17. QuicChromeAlarm(const quic::QuicClock* clock,
  18. base::SequencedTaskRunner* task_runner,
  19. quic::QuicArenaScopedPtr<quic::QuicAlarm::Delegate> delegate)
  20. : quic::QuicAlarm(std::move(delegate)),
  21. clock_(clock),
  22. // Unretained is safe because base::OneShotTimer never runs its task
  23. // after being deleted.
  24. on_alarm_callback_(base::BindRepeating(&QuicChromeAlarm::OnAlarm,
  25. base::Unretained(this))),
  26. timer_(std::make_unique<base::OneShotTimer>(this)) {
  27. timer_->SetTaskRunner(task_runner);
  28. }
  29. protected:
  30. void SetImpl() override {
  31. DCHECK(deadline().IsInitialized());
  32. const int64_t delay_us = (deadline() - clock_->Now()).ToMicroseconds();
  33. timer_->Start(FROM_HERE, base::Microseconds(delay_us), on_alarm_callback_);
  34. }
  35. void CancelImpl() override {
  36. DCHECK(!deadline().IsInitialized());
  37. timer_->Stop();
  38. }
  39. private:
  40. void OnAlarm() {
  41. DCHECK(deadline().IsInitialized());
  42. // In tests, the time source used by the scheduler may not be in sync with
  43. // |clock_|. Because of this, the scheduler may run this task when
  44. // |clock->Now()| is smaller than |deadline()|. In that case, retry later.
  45. // This shouldn't happen in production.
  46. if (clock_->Now() < deadline()) {
  47. SetImpl();
  48. return;
  49. }
  50. DCHECK_LE(deadline(), clock_->Now());
  51. Fire();
  52. }
  53. // base::TickClock:
  54. base::TimeTicks NowTicks() const override {
  55. return quic::QuicChromiumClock::QuicTimeToTimeTicks(clock_->Now());
  56. }
  57. const raw_ptr<const quic::QuicClock> clock_;
  58. base::RepeatingClosure on_alarm_callback_;
  59. const std::unique_ptr<base::OneShotTimer> timer_;
  60. };
  61. } // namespace
  62. QuicChromiumAlarmFactory::QuicChromiumAlarmFactory(
  63. base::SequencedTaskRunner* task_runner,
  64. const quic::QuicClock* clock)
  65. : task_runner_(task_runner), clock_(clock) {}
  66. QuicChromiumAlarmFactory::~QuicChromiumAlarmFactory() = default;
  67. quic::QuicArenaScopedPtr<quic::QuicAlarm> QuicChromiumAlarmFactory::CreateAlarm(
  68. quic::QuicArenaScopedPtr<quic::QuicAlarm::Delegate> delegate,
  69. quic::QuicConnectionArena* arena) {
  70. if (arena != nullptr) {
  71. return arena->New<QuicChromeAlarm>(clock_, task_runner_,
  72. std::move(delegate));
  73. } else {
  74. return quic::QuicArenaScopedPtr<quic::QuicAlarm>(
  75. new QuicChromeAlarm(clock_, task_runner_, std::move(delegate)));
  76. }
  77. }
  78. quic::QuicAlarm* QuicChromiumAlarmFactory::CreateAlarm(
  79. quic::QuicAlarm::Delegate* delegate) {
  80. return new QuicChromeAlarm(
  81. clock_, task_runner_,
  82. quic::QuicArenaScopedPtr<quic::QuicAlarm::Delegate>(delegate));
  83. }
  84. } // namespace net