blob: 2a088687ef1a5644b1e55dd46a43078726151395 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "quic/core/quic_epoll_alarm_factory.h"
#include <type_traits>
#include "quic/core/quic_arena_scoped_ptr.h"
namespace quic {
namespace {
class QuicEpollAlarm : public QuicAlarm {
public:
QuicEpollAlarm(QuicEpollServer* epoll_server,
QuicArenaScopedPtr<QuicAlarm::Delegate> delegate)
: QuicAlarm(std::move(delegate)),
epoll_server_(epoll_server),
epoll_alarm_impl_(this) {}
protected:
void SetImpl() override {
QUICHE_DCHECK(deadline().IsInitialized());
epoll_server_->RegisterAlarm(
(deadline() - QuicTime::Zero()).ToMicroseconds(), &epoll_alarm_impl_);
}
void CancelImpl() override {
QUICHE_DCHECK(!deadline().IsInitialized());
epoll_alarm_impl_.UnregisterIfRegistered();
}
void UpdateImpl() override {
QUICHE_DCHECK(deadline().IsInitialized());
int64_t epoll_deadline = (deadline() - QuicTime::Zero()).ToMicroseconds();
if (epoll_alarm_impl_.registered()) {
epoll_alarm_impl_.ReregisterAlarm(epoll_deadline);
} else {
epoll_server_->RegisterAlarm(epoll_deadline, &epoll_alarm_impl_);
}
}
private:
class EpollAlarmImpl : public QuicEpollAlarmBase {
public:
using int64_epoll = decltype(QuicEpollAlarmBase().OnAlarm());
explicit EpollAlarmImpl(QuicEpollAlarm* alarm) : alarm_(alarm) {}
// Use the same integer type as the base class.
int64_epoll OnAlarm() override {
QuicEpollAlarmBase::OnAlarm();
alarm_->Fire();
// Fire will take care of registering the alarm, if needed.
return 0;
}
private:
QuicEpollAlarm* alarm_;
};
QuicEpollServer* epoll_server_;
EpollAlarmImpl epoll_alarm_impl_;
};
} // namespace
QuicEpollAlarmFactory::QuicEpollAlarmFactory(QuicEpollServer* epoll_server)
: epoll_server_(epoll_server) {}
QuicEpollAlarmFactory::~QuicEpollAlarmFactory() = default;
QuicAlarm* QuicEpollAlarmFactory::CreateAlarm(QuicAlarm::Delegate* delegate) {
return new QuicEpollAlarm(epoll_server_,
QuicArenaScopedPtr<QuicAlarm::Delegate>(delegate));
}
QuicArenaScopedPtr<QuicAlarm> QuicEpollAlarmFactory::CreateAlarm(
QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,
QuicConnectionArena* arena) {
if (arena != nullptr) {
return arena->New<QuicEpollAlarm>(epoll_server_, std::move(delegate));
}
return QuicArenaScopedPtr<QuicAlarm>(
new QuicEpollAlarm(epoll_server_, std::move(delegate)));
}
} // namespace quic
|
