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
90
91
92
93
94
95
96
97
98
99
|
/*
* Copyright (c) 2021 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "net/dcsctp/timer/task_queue_timeout.h"
#include "api/task_queue/pending_task_safety_flag.h"
#include "api/units/time_delta.h"
#include "rtc_base/logging.h"
namespace dcsctp {
TaskQueueTimeoutFactory::TaskQueueTimeout::TaskQueueTimeout(
TaskQueueTimeoutFactory& parent,
webrtc::TaskQueueBase::DelayPrecision precision)
: parent_(parent),
precision_(precision),
pending_task_safety_flag_(webrtc::PendingTaskSafetyFlag::Create()) {}
TaskQueueTimeoutFactory::TaskQueueTimeout::~TaskQueueTimeout() {
RTC_DCHECK_RUN_ON(&parent_.thread_checker_);
pending_task_safety_flag_->SetNotAlive();
}
void TaskQueueTimeoutFactory::TaskQueueTimeout::Start(DurationMs duration_ms,
TimeoutID timeout_id) {
RTC_DCHECK_RUN_ON(&parent_.thread_checker_);
RTC_DCHECK(timeout_expiration_ == TimeMs::InfiniteFuture());
timeout_expiration_ = parent_.get_time_() + duration_ms;
timeout_id_ = timeout_id;
if (timeout_expiration_ >= posted_task_expiration_) {
// There is already a running task, and it's scheduled to expire sooner than
// the new expiration time. Don't do anything; The `timeout_expiration_` has
// already been updated and if the delayed task _does_ expire and the timer
// hasn't been stopped, that will be noticed in the timeout handler, and the
// task will be re-scheduled. Most timers are stopped before they expire.
return;
}
if (posted_task_expiration_ != TimeMs::InfiniteFuture()) {
RTC_DLOG(LS_VERBOSE) << "New timeout duration is less than scheduled - "
"ghosting old delayed task.";
// There is already a scheduled delayed task, but its expiration time is
// further away than the new expiration, so it can't be used. It will be
// "killed" by replacing the safety flag. This is not expected to happen
// especially often; Mainly when a timer did exponential backoff and
// later recovered.
pending_task_safety_flag_->SetNotAlive();
pending_task_safety_flag_ = webrtc::PendingTaskSafetyFlag::Create();
}
posted_task_expiration_ = timeout_expiration_;
parent_.task_queue_.PostDelayedTaskWithPrecision(
precision_,
webrtc::SafeTask(
pending_task_safety_flag_,
[timeout_id, this]() {
RTC_DLOG(LS_VERBOSE) << "Timout expired: " << timeout_id.value();
RTC_DCHECK_RUN_ON(&parent_.thread_checker_);
RTC_DCHECK(posted_task_expiration_ != TimeMs::InfiniteFuture());
posted_task_expiration_ = TimeMs::InfiniteFuture();
if (timeout_expiration_ == TimeMs::InfiniteFuture()) {
// The timeout was stopped before it expired. Very common.
} else {
// Note that the timeout might have been restarted, which updated
// `timeout_expiration_` but left the scheduled task running. So
// if it's not quite time to trigger the timeout yet, schedule a
// new delayed task with what's remaining and retry at that point
// in time.
DurationMs remaining = timeout_expiration_ - parent_.get_time_();
timeout_expiration_ = TimeMs::InfiniteFuture();
if (*remaining > 0) {
Start(remaining, timeout_id_);
} else {
// It has actually triggered.
RTC_DLOG(LS_VERBOSE)
<< "Timout triggered: " << timeout_id.value();
parent_.on_expired_(timeout_id_);
}
}
}),
webrtc::TimeDelta::Millis(duration_ms.value()));
}
void TaskQueueTimeoutFactory::TaskQueueTimeout::Stop() {
// As the TaskQueue doesn't support deleting a posted task, just mark the
// timeout as not running.
RTC_DCHECK_RUN_ON(&parent_.thread_checker_);
timeout_expiration_ = TimeMs::InfiniteFuture();
}
} // namespace dcsctp
|
