dcsctp: Convert timers to rtc::TimeDelta
With this, the code base should be mostly converted from using
DurationMs to rtc::TimeDelta, and the work can continue to replace
TimeMs with rtc::Timestamp.
Bug: webrtc:15593
Change-Id: I083fee6eccb173efc0232bb8d46e2554a5fbee5b
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/326161
Reviewed-by: Florent Castelli <orphis@webrtc.org>
Commit-Queue: Victor Boivie <boivie@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#41101}
diff --git a/net/dcsctp/rx/data_tracker_test.cc b/net/dcsctp/rx/data_tracker_test.cc
index 2abc444..2a5c6a2 100644
--- a/net/dcsctp/rx/data_tracker_test.cc
+++ b/net/dcsctp/rx/data_tracker_test.cc
@@ -25,6 +25,7 @@
namespace dcsctp {
namespace {
+using ::webrtc::TimeDelta;
using ::testing::ElementsAre;
using ::testing::IsEmpty;
using ::testing::SizeIs;
@@ -42,8 +43,8 @@
}),
timer_(timer_manager_.CreateTimer(
"test/delayed_ack",
- []() { return DurationMs(0); },
- TimerOptions(DurationMs(0)))),
+ []() { return TimeDelta::Zero(); },
+ TimerOptions(TimeDelta::Zero()))),
tracker_(
std::make_unique<DataTracker>("log: ", timer_.get(), kInitialTSN)) {
}
diff --git a/net/dcsctp/socket/BUILD.gn b/net/dcsctp/socket/BUILD.gn
index 681ddd4..9820207 100644
--- a/net/dcsctp/socket/BUILD.gn
+++ b/net/dcsctp/socket/BUILD.gn
@@ -11,6 +11,7 @@
rtc_source_set("context") {
sources = [ "context.h" ]
deps = [
+ "../../../api/units:time_delta",
"../common:internal_types",
"../packet:sctp_packet",
"../public:socket",
@@ -24,6 +25,7 @@
":context",
"../../../api:array_view",
"../../../rtc_base:checks",
+ "../../../api/units:time_delta",
"../../../rtc_base:logging",
"../packet:bounded_io",
"../packet:chunk",
@@ -48,6 +50,7 @@
deps = [
":context",
"../../../api:array_view",
+ "../../../api/units:time_delta",
"../../../rtc_base:checks",
"../../../rtc_base:logging",
"../../../rtc_base/containers:flat_set",
@@ -96,6 +99,7 @@
":packet_sender",
":stream_reset_handler",
"../../../api:array_view",
+ "../../../api/units:time_delta",
"../../../api/task_queue:task_queue",
"../../../rtc_base:checks",
"../../../rtc_base:logging",
diff --git a/net/dcsctp/socket/context.h b/net/dcsctp/socket/context.h
index e7a6cd5..8e970e8 100644
--- a/net/dcsctp/socket/context.h
+++ b/net/dcsctp/socket/context.h
@@ -13,6 +13,7 @@
#include <cstdint>
#include "absl/strings/string_view.h"
+#include "api/units/time_delta.h"
#include "net/dcsctp/common/internal_types.h"
#include "net/dcsctp/packet/sctp_packet.h"
#include "net/dcsctp/public/dcsctp_socket.h"
diff --git a/net/dcsctp/socket/dcsctp_socket.cc b/net/dcsctp/socket/dcsctp_socket.cc
index 795a9d7..c9ecb71 100644
--- a/net/dcsctp/socket/dcsctp_socket.cc
+++ b/net/dcsctp/socket/dcsctp_socket.cc
@@ -82,6 +82,7 @@
namespace dcsctp {
namespace {
+using ::webrtc::TimeDelta;
// https://tools.ietf.org/html/rfc4960#section-5.1
constexpr uint32_t kMinVerificationTag = 1;
@@ -187,19 +188,19 @@
t1_init_(timer_manager_.CreateTimer(
"t1-init",
absl::bind_front(&DcSctpSocket::OnInitTimerExpiry, this),
- TimerOptions(options.t1_init_timeout,
+ TimerOptions(options.t1_init_timeout.ToTimeDelta(),
TimerBackoffAlgorithm::kExponential,
options.max_init_retransmits))),
t1_cookie_(timer_manager_.CreateTimer(
"t1-cookie",
absl::bind_front(&DcSctpSocket::OnCookieTimerExpiry, this),
- TimerOptions(options.t1_cookie_timeout,
+ TimerOptions(options.t1_cookie_timeout.ToTimeDelta(),
TimerBackoffAlgorithm::kExponential,
options.max_init_retransmits))),
t2_shutdown_(timer_manager_.CreateTimer(
"t2-shutdown",
absl::bind_front(&DcSctpSocket::OnShutdownTimerExpiry, this),
- TimerOptions(options.t2_shutdown_timeout,
+ TimerOptions(options.t2_shutdown_timeout.ToTimeDelta(),
TimerBackoffAlgorithm::kExponential,
options.max_retransmissions))),
packet_sender_(callbacks_,
@@ -631,7 +632,7 @@
// respond to each received packet containing one or more DATA chunks with
// a SHUTDOWN chunk and restart the T2-shutdown timer.""
SendShutdown();
- t2_shutdown_->set_duration(DurationMs(tcb_->current_rto()));
+ t2_shutdown_->set_duration(tcb_->current_rto());
t2_shutdown_->Start();
}
}
@@ -921,7 +922,7 @@
return continue_processing;
}
-DurationMs DcSctpSocket::OnInitTimerExpiry() {
+TimeDelta DcSctpSocket::OnInitTimerExpiry() {
RTC_DLOG(LS_VERBOSE) << log_prefix() << "Timer " << t1_init_->name()
<< " has expired: " << t1_init_->expiration_count()
<< "/" << t1_init_->options().max_restarts.value_or(-1);
@@ -933,10 +934,10 @@
InternalClose(ErrorKind::kTooManyRetries, "No INIT_ACK received");
}
RTC_DCHECK(IsConsistent());
- return DurationMs(0);
+ return TimeDelta::Zero();
}
-DurationMs DcSctpSocket::OnCookieTimerExpiry() {
+TimeDelta DcSctpSocket::OnCookieTimerExpiry() {
// https://tools.ietf.org/html/rfc4960#section-4
// "If the T1-cookie timer expires, the endpoint MUST retransmit COOKIE
// ECHO and restart the T1-cookie timer without changing state. This MUST
@@ -957,10 +958,10 @@
}
RTC_DCHECK(IsConsistent());
- return DurationMs(0);
+ return TimeDelta::Zero();
}
-DurationMs DcSctpSocket::OnShutdownTimerExpiry() {
+TimeDelta DcSctpSocket::OnShutdownTimerExpiry() {
RTC_DLOG(LS_VERBOSE) << log_prefix() << "Timer " << t2_shutdown_->name()
<< " has expired: " << t2_shutdown_->expiration_count()
<< "/"
@@ -980,7 +981,7 @@
InternalClose(ErrorKind::kTooManyRetries, "No SHUTDOWN_ACK received");
RTC_DCHECK(IsConsistent());
- return DurationMs(0);
+ return TimeDelta::Zero();
}
// https://tools.ietf.org/html/rfc4960#section-9.2
@@ -988,7 +989,7 @@
// updated last sequential TSN received from its peer."
SendShutdown();
RTC_DCHECK(IsConsistent());
- return DurationMs(tcb_->current_rto());
+ return tcb_->current_rto();
}
void DcSctpSocket::OnSentPacket(rtc::ArrayView<const uint8_t> packet,
@@ -1731,7 +1732,7 @@
// state.""
SendShutdown();
- t2_shutdown_->set_duration(DurationMs(tcb_->current_rto()));
+ t2_shutdown_->set_duration(tcb_->current_rto());
t2_shutdown_->Start();
SetState(State::kShutdownSent, "No more outstanding data");
} else if (state_ == State::kShutdownReceived) {
@@ -1754,7 +1755,7 @@
void DcSctpSocket::SendShutdownAck() {
packet_sender_.Send(tcb_->PacketBuilder().Add(ShutdownAckChunk()));
- t2_shutdown_->set_duration(DurationMs(tcb_->current_rto()));
+ t2_shutdown_->set_duration(tcb_->current_rto());
t2_shutdown_->Start();
}
diff --git a/net/dcsctp/socket/dcsctp_socket.h b/net/dcsctp/socket/dcsctp_socket.h
index 2240ff6..deb6ee2 100644
--- a/net/dcsctp/socket/dcsctp_socket.h
+++ b/net/dcsctp/socket/dcsctp_socket.h
@@ -155,9 +155,9 @@
// Closes the association, because of too many retransmission errors.
void CloseConnectionBecauseOfTooManyTransmissionErrors();
// Timer expiration handlers
- DurationMs OnInitTimerExpiry();
- DurationMs OnCookieTimerExpiry();
- DurationMs OnShutdownTimerExpiry();
+ webrtc::TimeDelta OnInitTimerExpiry();
+ webrtc::TimeDelta OnCookieTimerExpiry();
+ webrtc::TimeDelta OnShutdownTimerExpiry();
void OnSentPacket(rtc::ArrayView<const uint8_t> packet,
SendPacketStatus status);
// Sends SHUTDOWN or SHUTDOWN-ACK if the socket is shutting down and if all
diff --git a/net/dcsctp/socket/heartbeat_handler.cc b/net/dcsctp/socket/heartbeat_handler.cc
index 9336c70..d7c71f5 100644
--- a/net/dcsctp/socket/heartbeat_handler.cc
+++ b/net/dcsctp/socket/heartbeat_handler.cc
@@ -21,6 +21,7 @@
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "api/array_view.h"
+#include "api/units/time_delta.h"
#include "net/dcsctp/packet/bounded_byte_reader.h"
#include "net/dcsctp/packet/bounded_byte_writer.h"
#include "net/dcsctp/packet/chunk/heartbeat_ack_chunk.h"
@@ -35,6 +36,7 @@
#include "rtc_base/logging.h"
namespace dcsctp {
+using ::webrtc::TimeDelta;
// This is stored (in serialized form) as HeartbeatInfoParameter sent in
// HeartbeatRequestChunk and received back in HeartbeatAckChunk. It should be
@@ -97,12 +99,12 @@
interval_timer_(timer_manager_->CreateTimer(
"heartbeat-interval",
absl::bind_front(&HeartbeatHandler::OnIntervalTimerExpiry, this),
- TimerOptions(DurationMs(interval_duration_),
+ TimerOptions(interval_duration_,
TimerBackoffAlgorithm::kFixed))),
timeout_timer_(timer_manager_->CreateTimer(
"heartbeat-timeout",
absl::bind_front(&HeartbeatHandler::OnTimeoutTimerExpiry, this),
- TimerOptions(options.rto_initial,
+ TimerOptions(options.rto_initial.ToTimeDelta(),
TimerBackoffAlgorithm::kExponential,
/*max_restarts=*/0))) {
// The interval timer must always be running as long as the association is up.
@@ -119,9 +121,9 @@
// The RTT should be used, but it's not easy accessible. The RTO will
// suffice.
interval_timer_->set_duration(
- DurationMs(interval_duration_ + ctx_->current_rto()));
+ interval_duration_ + ctx_->current_rto());
} else {
- interval_timer_->set_duration(DurationMs(interval_duration_));
+ interval_timer_->set_duration(interval_duration_);
}
interval_timer_->Start();
@@ -166,13 +168,13 @@
ctx_->ClearTxErrorCounter();
}
-DurationMs HeartbeatHandler::OnIntervalTimerExpiry() {
+TimeDelta HeartbeatHandler::OnIntervalTimerExpiry() {
if (ctx_->is_connection_established()) {
HeartbeatInfo info(ctx_->callbacks().TimeMillis());
- timeout_timer_->set_duration(DurationMs(ctx_->current_rto()));
+ timeout_timer_->set_duration(ctx_->current_rto());
timeout_timer_->Start();
RTC_DLOG(LS_INFO) << log_prefix_ << "Sending HEARTBEAT with timeout "
- << *timeout_timer_->duration();
+ << webrtc::ToString(timeout_timer_->duration());
Parameters parameters = Parameters::Builder()
.Add(HeartbeatInfoParameter(info.Serialize()))
@@ -185,14 +187,14 @@
<< log_prefix_
<< "Will not send HEARTBEAT when connection not established";
}
- return DurationMs(0);
+ return TimeDelta::Zero();
}
-DurationMs HeartbeatHandler::OnTimeoutTimerExpiry() {
+TimeDelta HeartbeatHandler::OnTimeoutTimerExpiry() {
// Note that the timeout timer is not restarted. It will be started again when
// the interval timer expires.
RTC_DCHECK(!timeout_timer_->is_running());
ctx_->IncrementTxErrorCounter("HEARTBEAT timeout");
- return DurationMs(0);
+ return TimeDelta::Zero();
}
} // namespace dcsctp
diff --git a/net/dcsctp/socket/heartbeat_handler.h b/net/dcsctp/socket/heartbeat_handler.h
index d84a50f..ac58b97 100644
--- a/net/dcsctp/socket/heartbeat_handler.h
+++ b/net/dcsctp/socket/heartbeat_handler.h
@@ -50,8 +50,8 @@
void HandleHeartbeatAck(HeartbeatAckChunk chunk);
private:
- DurationMs OnIntervalTimerExpiry();
- DurationMs OnTimeoutTimerExpiry();
+ webrtc::TimeDelta OnIntervalTimerExpiry();
+ webrtc::TimeDelta OnTimeoutTimerExpiry();
const absl::string_view log_prefix_;
Context* ctx_;
diff --git a/net/dcsctp/socket/stream_reset_handler.cc b/net/dcsctp/socket/stream_reset_handler.cc
index 0defae8..f81057d 100644
--- a/net/dcsctp/socket/stream_reset_handler.cc
+++ b/net/dcsctp/socket/stream_reset_handler.cc
@@ -16,6 +16,7 @@
#include "absl/types/optional.h"
#include "api/array_view.h"
+#include "api/units/time_delta.h"
#include "net/dcsctp/common/internal_types.h"
#include "net/dcsctp/common/str_join.h"
#include "net/dcsctp/packet/chunk/reconfig_chunk.h"
@@ -38,6 +39,7 @@
namespace dcsctp {
namespace {
+using ::webrtc::TimeDelta;
using ResponseResult = ReconfigurationResponseParameter::Result;
bool DescriptorsAre(const std::vector<ParameterDescriptor>& c,
@@ -277,7 +279,7 @@
});
// Force this request to be sent again, but with new req_seq_nbr.
current_request_->PrepareRetransmission();
- reconfig_timer_->set_duration(DurationMs(ctx_->current_rto()));
+ reconfig_timer_->set_duration(ctx_->current_rto());
reconfig_timer_->Start();
break;
case ResponseResult::kErrorRequestAlreadyInProgress:
@@ -312,7 +314,7 @@
current_request_.emplace(retransmission_queue_->last_assigned_tsn(),
retransmission_queue_->BeginResetStreams());
- reconfig_timer_->set_duration(DurationMs(ctx_->current_rto()));
+ reconfig_timer_->set_duration(ctx_->current_rto());
reconfig_timer_->Start();
return MakeReconfigChunk();
}
@@ -347,13 +349,13 @@
}
}
-DurationMs StreamResetHandler::OnReconfigTimerExpiry() {
+TimeDelta StreamResetHandler::OnReconfigTimerExpiry() {
if (current_request_->has_been_sent()) {
// There is an outstanding request, which timed out while waiting for a
// response.
if (!ctx_->IncrementTxErrorCounter("RECONFIG timeout")) {
// Timed out. The connection will close after processing the timers.
- return DurationMs(0);
+ return TimeDelta::Zero();
}
} else {
// There is no outstanding request, but there is a prepared one. This means
@@ -362,7 +364,7 @@
}
ctx_->Send(ctx_->PacketBuilder().Add(MakeReconfigChunk()));
- return DurationMs(ctx_->current_rto());
+ return ctx_->current_rto();
}
HandoverReadinessStatus StreamResetHandler::GetHandoverReadiness() const {
diff --git a/net/dcsctp/socket/stream_reset_handler.h b/net/dcsctp/socket/stream_reset_handler.h
index 2f604f3..77e8f3b 100644
--- a/net/dcsctp/socket/stream_reset_handler.h
+++ b/net/dcsctp/socket/stream_reset_handler.h
@@ -20,6 +20,7 @@
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "api/array_view.h"
+#include "api/units/time_delta.h"
#include "net/dcsctp/common/internal_types.h"
#include "net/dcsctp/packet/chunk/reconfig_chunk.h"
#include "net/dcsctp/packet/parameter/incoming_ssn_reset_request_parameter.h"
@@ -80,7 +81,7 @@
reconfig_timer_(timer_manager->CreateTimer(
"re-config",
absl::bind_front(&StreamResetHandler::OnReconfigTimerExpiry, this),
- TimerOptions(DurationMs(0)))),
+ TimerOptions(webrtc::TimeDelta::Zero()))),
next_outgoing_req_seq_nbr_(
handover_state
? ReconfigRequestSN(handover_state->tx.next_reset_req_sn)
@@ -211,7 +212,7 @@
void HandleResponse(const ParameterDescriptor& descriptor);
// Expiration handler for the Reconfig timer.
- DurationMs OnReconfigTimerExpiry();
+ webrtc::TimeDelta OnReconfigTimerExpiry();
const absl::string_view log_prefix_;
Context* ctx_;
diff --git a/net/dcsctp/socket/stream_reset_handler_test.cc b/net/dcsctp/socket/stream_reset_handler_test.cc
index 483c139..fa0a6a8 100644
--- a/net/dcsctp/socket/stream_reset_handler_test.cc
+++ b/net/dcsctp/socket/stream_reset_handler_test.cc
@@ -98,12 +98,12 @@
}),
delayed_ack_timer_(timer_manager_.CreateTimer(
"test/delayed_ack",
- []() { return DurationMs(0); },
- TimerOptions(DurationMs(0)))),
+ []() { return TimeDelta::Zero(); },
+ TimerOptions(TimeDelta::Zero()))),
t3_rtx_timer_(timer_manager_.CreateTimer(
"test/t3_rtx",
- []() { return DurationMs(0); },
- TimerOptions(DurationMs(0)))),
+ []() { return TimeDelta::Zero(); },
+ TimerOptions(TimeDelta::Zero()))),
data_tracker_(std::make_unique<DataTracker>("log: ",
delayed_ack_timer_.get(),
kPeerInitialTsn)),
@@ -205,8 +205,8 @@
std::make_unique<ReassemblyQueue>("log: ", kPeerInitialTsn, kArwnd);
reasm_->RestoreFromState(state);
retransmission_queue_ = std::make_unique<RetransmissionQueue>(
- "", &callbacks_, kMyInitialTsn, kArwnd, producer_,
- [](TimeDelta rtt) {}, []() {}, *t3_rtx_timer_, DcSctpOptions(),
+ "", &callbacks_, kMyInitialTsn, kArwnd, producer_, [](TimeDelta rtt) {},
+ []() {}, *t3_rtx_timer_, DcSctpOptions(),
/*supports_partial_reliability=*/true,
/*use_message_interleaving=*/false);
retransmission_queue_->RestoreFromState(state);
diff --git a/net/dcsctp/socket/transmission_control_block.cc b/net/dcsctp/socket/transmission_control_block.cc
index a91bbc2..2bbb721 100644
--- a/net/dcsctp/socket/transmission_control_block.cc
+++ b/net/dcsctp/socket/transmission_control_block.cc
@@ -17,6 +17,7 @@
#include <vector>
#include "absl/types/optional.h"
+#include "api/units/time_delta.h"
#include "net/dcsctp/packet/chunk/data_chunk.h"
#include "net/dcsctp/packet/chunk/forward_tsn_chunk.h"
#include "net/dcsctp/packet/chunk/idata_chunk.h"
@@ -62,20 +63,20 @@
t3_rtx_(timer_manager_.CreateTimer(
"t3-rtx",
absl::bind_front(&TransmissionControlBlock::OnRtxTimerExpiry, this),
- TimerOptions(options.rto_initial,
+ TimerOptions(options.rto_initial.ToTimeDelta(),
TimerBackoffAlgorithm::kExponential,
/*max_restarts=*/absl::nullopt,
options.max_timer_backoff_duration.has_value()
- ? *options.max_timer_backoff_duration
- : DurationMs::InfiniteDuration()))),
+ ? options.max_timer_backoff_duration->ToTimeDelta()
+ : TimeDelta::PlusInfinity()))),
delayed_ack_timer_(timer_manager_.CreateTimer(
"delayed-ack",
absl::bind_front(&TransmissionControlBlock::OnDelayedAckTimerExpiry,
this),
- TimerOptions(options.delayed_ack_max_timeout,
+ TimerOptions(options.delayed_ack_max_timeout.ToTimeDelta(),
TimerBackoffAlgorithm::kExponential,
/*max_restarts=*/0,
- /*max_backoff_duration=*/DurationMs::InfiniteDuration(),
+ /*max_backoff_duration=*/TimeDelta::PlusInfinity(),
webrtc::TaskQueueBase::DelayPrecision::kHigh))),
my_verification_tag_(my_verification_tag),
my_initial_tsn_(my_initial_tsn),
@@ -120,14 +121,14 @@
<< ", srtt=" << webrtc::ToString(rto_.srtt())
<< ", rto=" << webrtc::ToString(rto_.rto()) << " ("
<< webrtc::ToString(prev_rto) << ")";
- t3_rtx_->set_duration(DurationMs(rto_.rto()));
+ t3_rtx_->set_duration(rto_.rto());
- DurationMs delayed_ack_tmo =
- std::min(DurationMs(rto_.rto()) * 0.5, options_.delayed_ack_max_timeout);
+ TimeDelta delayed_ack_tmo = std::min(
+ rto_.rto() * 0.5, options_.delayed_ack_max_timeout.ToTimeDelta());
delayed_ack_timer_->set_duration(delayed_ack_tmo);
}
-DurationMs TransmissionControlBlock::OnRtxTimerExpiry() {
+TimeDelta TransmissionControlBlock::OnRtxTimerExpiry() {
TimeMs now = callbacks_.TimeMillis();
RTC_DLOG(LS_INFO) << log_prefix_ << "Timer " << t3_rtx_->name()
<< " has expired";
@@ -141,13 +142,13 @@
SendBufferedPackets(now);
}
}
- return DurationMs(0);
+ return TimeDelta::Zero();
}
-DurationMs TransmissionControlBlock::OnDelayedAckTimerExpiry() {
+TimeDelta TransmissionControlBlock::OnDelayedAckTimerExpiry() {
data_tracker_.HandleDelayedAckTimerExpiry();
MaybeSendSack();
- return DurationMs(0);
+ return TimeDelta::Zero();
}
void TransmissionControlBlock::MaybeSendSack() {
diff --git a/net/dcsctp/socket/transmission_control_block.h b/net/dcsctp/socket/transmission_control_block.h
index ebe5b23..c4c48af 100644
--- a/net/dcsctp/socket/transmission_control_block.h
+++ b/net/dcsctp/socket/transmission_control_block.h
@@ -149,9 +149,9 @@
private:
// Will be called when the retransmission timer (t3-rtx) expires.
- DurationMs OnRtxTimerExpiry();
+ webrtc::TimeDelta OnRtxTimerExpiry();
// Will be called when the delayed ack timer expires.
- DurationMs OnDelayedAckTimerExpiry();
+ webrtc::TimeDelta OnDelayedAckTimerExpiry();
const absl::string_view log_prefix_;
const DcSctpOptions options_;
diff --git a/net/dcsctp/timer/BUILD.gn b/net/dcsctp/timer/BUILD.gn
index d3be1ec..00a18a4 100644
--- a/net/dcsctp/timer/BUILD.gn
+++ b/net/dcsctp/timer/BUILD.gn
@@ -12,6 +12,7 @@
deps = [
"../../../api:array_view",
"../../../api/task_queue:task_queue",
+ "../../../api/units:time_delta",
"../../../rtc_base:checks",
"../../../rtc_base:strong_alias",
"../../../rtc_base/containers:flat_map",
@@ -57,6 +58,7 @@
":task_queue_timeout",
":timer",
"../../../api:array_view",
+ "../../../api/units:time_delta",
"../../../api/task_queue:task_queue",
"../../../api/task_queue/test:mock_task_queue_base",
"../../../rtc_base:checks",
diff --git a/net/dcsctp/timer/timer.cc b/net/dcsctp/timer/timer.cc
index 1c23d6d..07c9f3d 100644
--- a/net/dcsctp/timer/timer.cc
+++ b/net/dcsctp/timer/timer.cc
@@ -22,21 +22,23 @@
namespace dcsctp {
namespace {
+using ::webrtc::TimeDelta;
+
TimeoutID MakeTimeoutId(TimerID timer_id, TimerGeneration generation) {
return TimeoutID(static_cast<uint64_t>(*timer_id) << 32 | *generation);
}
-DurationMs GetBackoffDuration(const TimerOptions& options,
- DurationMs base_duration,
- int expiration_count) {
+TimeDelta GetBackoffDuration(const TimerOptions& options,
+ TimeDelta base_duration,
+ int expiration_count) {
switch (options.backoff_algorithm) {
case TimerBackoffAlgorithm::kFixed:
return base_duration;
case TimerBackoffAlgorithm::kExponential: {
- DurationMs duration = base_duration;
+ TimeDelta duration = base_duration;
while (expiration_count > 0 && duration < Timer::kMaxTimerDuration) {
- duration *= 2;
+ duration = duration * 2;
--expiration_count;
if (duration > options.max_backoff_duration) {
@@ -44,13 +46,13 @@
}
}
- return DurationMs(std::min(duration, Timer::kMaxTimerDuration));
+ return TimeDelta(std::min(duration, Timer::kMaxTimerDuration));
}
}
}
} // namespace
-constexpr DurationMs Timer::kMaxTimerDuration;
+constexpr TimeDelta Timer::kMaxTimerDuration;
Timer::Timer(TimerID id,
absl::string_view name,
@@ -76,12 +78,12 @@
if (!is_running()) {
is_running_ = true;
generation_ = TimerGeneration(*generation_ + 1);
- timeout_->Start(duration_, MakeTimeoutId(id_, generation_));
+ timeout_->Start(DurationMs(duration_), MakeTimeoutId(id_, generation_));
} else {
// Timer was running - stop and restart it, to make it expire in `duration_`
// from now.
generation_ = TimerGeneration(*generation_ + 1);
- timeout_->Restart(duration_, MakeTimeoutId(id_, generation_));
+ timeout_->Restart(DurationMs(duration_), MakeTimeoutId(id_, generation_));
}
}
@@ -103,24 +105,24 @@
// timer. Note that it might be very quickly restarted again, if the
// `on_expired_` callback returns a new duration.
is_running_ = true;
- DurationMs duration =
+ TimeDelta duration =
GetBackoffDuration(options_, duration_, expiration_count_);
generation_ = TimerGeneration(*generation_ + 1);
- timeout_->Start(duration, MakeTimeoutId(id_, generation_));
+ timeout_->Start(DurationMs(duration), MakeTimeoutId(id_, generation_));
}
- DurationMs new_duration = on_expired_();
- RTC_DCHECK(new_duration != DurationMs::InfiniteDuration());
- if (new_duration > DurationMs(0) && new_duration != duration_) {
+ TimeDelta new_duration = on_expired_();
+ RTC_DCHECK(new_duration != TimeDelta::PlusInfinity());
+ if (new_duration > TimeDelta::Zero() && new_duration != duration_) {
duration_ = new_duration;
if (is_running_) {
// Restart it with new duration.
timeout_->Stop();
- DurationMs duration =
+ TimeDelta duration =
GetBackoffDuration(options_, duration_, expiration_count_);
generation_ = TimerGeneration(*generation_ + 1);
- timeout_->Start(duration, MakeTimeoutId(id_, generation_));
+ timeout_->Start(DurationMs(duration), MakeTimeoutId(id_, generation_));
}
}
}
diff --git a/net/dcsctp/timer/timer.h b/net/dcsctp/timer/timer.h
index 6159737..30b07f9 100644
--- a/net/dcsctp/timer/timer.h
+++ b/net/dcsctp/timer/timer.h
@@ -22,6 +22,7 @@
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "api/task_queue/task_queue_base.h"
+#include "api/units/time_delta.h"
#include "net/dcsctp/public/timeout.h"
#include "rtc_base/strong_alias.h"
@@ -40,30 +41,31 @@
};
struct TimerOptions {
- explicit TimerOptions(DurationMs duration)
+ explicit TimerOptions(webrtc::TimeDelta duration)
: TimerOptions(duration, TimerBackoffAlgorithm::kExponential) {}
- TimerOptions(DurationMs duration, TimerBackoffAlgorithm backoff_algorithm)
+ TimerOptions(webrtc::TimeDelta duration,
+ TimerBackoffAlgorithm backoff_algorithm)
: TimerOptions(duration, backoff_algorithm, absl::nullopt) {}
- TimerOptions(DurationMs duration,
+ TimerOptions(webrtc::TimeDelta duration,
TimerBackoffAlgorithm backoff_algorithm,
absl::optional<int> max_restarts)
: TimerOptions(duration,
backoff_algorithm,
max_restarts,
- DurationMs::InfiniteDuration()) {}
- TimerOptions(DurationMs duration,
+ webrtc::TimeDelta::PlusInfinity()) {}
+ TimerOptions(webrtc::TimeDelta duration,
TimerBackoffAlgorithm backoff_algorithm,
absl::optional<int> max_restarts,
- DurationMs max_backoff_duration)
+ webrtc::TimeDelta max_backoff_duration)
: TimerOptions(duration,
backoff_algorithm,
max_restarts,
max_backoff_duration,
webrtc::TaskQueueBase::DelayPrecision::kLow) {}
- TimerOptions(DurationMs duration,
+ TimerOptions(webrtc::TimeDelta duration,
TimerBackoffAlgorithm backoff_algorithm,
absl::optional<int> max_restarts,
- DurationMs max_backoff_duration,
+ webrtc::TimeDelta max_backoff_duration,
webrtc::TaskQueueBase::DelayPrecision precision)
: duration(duration),
backoff_algorithm(backoff_algorithm),
@@ -72,7 +74,7 @@
precision(precision) {}
// The initial timer duration. Can be overridden with `set_duration`.
- const DurationMs duration;
+ const webrtc::TimeDelta duration;
// If the duration should be increased (using exponential backoff) when it is
// restarted. If not set, the same duration will be used.
const TimerBackoffAlgorithm backoff_algorithm;
@@ -80,7 +82,7 @@
// or absl::nullopt if there is no limit.
const absl::optional<int> max_restarts;
// The maximum timeout value for exponential backoff.
- const DurationMs max_backoff_duration;
+ const webrtc::TimeDelta max_backoff_duration;
// The precision of the webrtc::TaskQueueBase used for scheduling.
const webrtc::TaskQueueBase::DelayPrecision precision;
};
@@ -100,13 +102,14 @@
class Timer {
public:
// The maximum timer duration - one day.
- static constexpr DurationMs kMaxTimerDuration = DurationMs(24 * 3600 * 1000);
+ static constexpr webrtc::TimeDelta kMaxTimerDuration =
+ webrtc::TimeDelta::Seconds(24 * 3600);
// When expired, the timer handler can optionally return a new non-zero
// duration which will be set as `duration` and used as base duration when the
// timer is restarted and as input to the backoff algorithm. If zero is
// returned, the current duration is used.
- using OnExpired = std::function<DurationMs()>;
+ using OnExpired = std::function<webrtc::TimeDelta()>;
// TimerManager will have pointers to these instances, so they must not move.
Timer(const Timer&) = delete;
@@ -124,13 +127,13 @@
// Sets the base duration. The actual timer duration may be larger depending
// on the backoff algorithm.
- void set_duration(DurationMs duration) {
+ void set_duration(webrtc::TimeDelta duration) {
duration_ = std::min(duration, kMaxTimerDuration);
}
// Retrieves the base duration. The actual timer duration may be larger
// depending on the backoff algorithm.
- DurationMs duration() const { return duration_; }
+ webrtc::TimeDelta duration() const { return duration_; }
// Returns the number of times the timer has expired.
int expiration_count() const { return expiration_count_; }
@@ -168,7 +171,7 @@
const UnregisterHandler unregister_handler_;
const std::unique_ptr<Timeout> timeout_;
- DurationMs duration_;
+ webrtc::TimeDelta duration_;
// Increased on each start, and is matched on Trigger, to avoid races. And by
// race, meaning that a timeout - which may be evaluated/expired on a
diff --git a/net/dcsctp/timer/timer_test.cc b/net/dcsctp/timer/timer_test.cc
index e0e210e..5584b50 100644
--- a/net/dcsctp/timer/timer_test.cc
+++ b/net/dcsctp/timer/timer_test.cc
@@ -13,6 +13,7 @@
#include "absl/types/optional.h"
#include "api/task_queue/task_queue_base.h"
+#include "api/units/time_delta.h"
#include "net/dcsctp/public/timeout.h"
#include "net/dcsctp/timer/fake_timeout.h"
#include "rtc_base/gunit.h"
@@ -21,6 +22,7 @@
namespace dcsctp {
namespace {
using ::testing::Return;
+using ::webrtc::TimeDelta;
class TimerTest : public testing::Test {
protected:
@@ -29,11 +31,11 @@
manager_([this](webrtc::TaskQueueBase::DelayPrecision precision) {
return timeout_manager_.CreateTimeout(precision);
}) {
- ON_CALL(on_expired_, Call).WillByDefault(Return(DurationMs(0)));
+ ON_CALL(on_expired_, Call).WillByDefault(Return(TimeDelta::Zero()));
}
- void AdvanceTimeAndRunTimers(DurationMs duration) {
- now_ = now_ + duration;
+ void AdvanceTimeAndRunTimers(TimeDelta duration) {
+ now_ = now_ + DurationMs(duration);
for (;;) {
absl::optional<TimeoutID> timeout_id =
@@ -48,13 +50,13 @@
TimeMs now_ = TimeMs(0);
FakeTimeoutManager timeout_manager_;
TimerManager manager_;
- testing::MockFunction<DurationMs()> on_expired_;
+ testing::MockFunction<TimeDelta()> on_expired_;
};
TEST_F(TimerTest, TimerIsInitiallyStopped) {
std::unique_ptr<Timer> t1 = manager_.CreateTimer(
"t1", on_expired_.AsStdFunction(),
- TimerOptions(DurationMs(5000), TimerBackoffAlgorithm::kFixed));
+ TimerOptions(TimeDelta::Seconds(5), TimerBackoffAlgorithm::kFixed));
EXPECT_FALSE(t1->is_running());
}
@@ -62,50 +64,50 @@
TEST_F(TimerTest, TimerExpiresAtGivenTime) {
std::unique_ptr<Timer> t1 = manager_.CreateTimer(
"t1", on_expired_.AsStdFunction(),
- TimerOptions(DurationMs(5000), TimerBackoffAlgorithm::kFixed));
+ TimerOptions(TimeDelta::Seconds(5), TimerBackoffAlgorithm::kFixed));
EXPECT_CALL(on_expired_, Call).Times(0);
t1->Start();
EXPECT_TRUE(t1->is_running());
- AdvanceTimeAndRunTimers(DurationMs(4000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(4));
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
}
TEST_F(TimerTest, TimerReschedulesAfterExpiredWithFixedBackoff) {
std::unique_ptr<Timer> t1 = manager_.CreateTimer(
"t1", on_expired_.AsStdFunction(),
- TimerOptions(DurationMs(5000), TimerBackoffAlgorithm::kFixed));
+ TimerOptions(TimeDelta::Seconds(5), TimerBackoffAlgorithm::kFixed));
EXPECT_CALL(on_expired_, Call).Times(0);
t1->Start();
EXPECT_EQ(t1->expiration_count(), 0);
- AdvanceTimeAndRunTimers(DurationMs(4000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(4));
// Fire first time
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
EXPECT_TRUE(t1->is_running());
EXPECT_EQ(t1->expiration_count(), 1);
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(4000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(4));
// Second time
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
EXPECT_TRUE(t1->is_running());
EXPECT_EQ(t1->expiration_count(), 2);
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(4000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(4));
// Third time
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
EXPECT_TRUE(t1->is_running());
EXPECT_EQ(t1->expiration_count(), 3);
}
@@ -113,151 +115,151 @@
TEST_F(TimerTest, TimerWithNoRestarts) {
std::unique_ptr<Timer> t1 = manager_.CreateTimer(
"t1", on_expired_.AsStdFunction(),
- TimerOptions(DurationMs(5000), TimerBackoffAlgorithm::kFixed,
+ TimerOptions(TimeDelta::Seconds(5), TimerBackoffAlgorithm::kFixed,
/*max_restart=*/0));
EXPECT_CALL(on_expired_, Call).Times(0);
t1->Start();
- AdvanceTimeAndRunTimers(DurationMs(4000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(4));
// Fire first time
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
EXPECT_FALSE(t1->is_running());
// Second time - shouldn't fire
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(5000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(5));
EXPECT_FALSE(t1->is_running());
}
TEST_F(TimerTest, TimerWithOneRestart) {
std::unique_ptr<Timer> t1 = manager_.CreateTimer(
"t1", on_expired_.AsStdFunction(),
- TimerOptions(DurationMs(5000), TimerBackoffAlgorithm::kFixed,
+ TimerOptions(TimeDelta::Seconds(5), TimerBackoffAlgorithm::kFixed,
/*max_restart=*/1));
EXPECT_CALL(on_expired_, Call).Times(0);
t1->Start();
- AdvanceTimeAndRunTimers(DurationMs(4000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(4));
// Fire first time
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
EXPECT_TRUE(t1->is_running());
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(4000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(4));
// Second time - max restart limit reached.
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
EXPECT_FALSE(t1->is_running());
// Third time - should not fire.
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(5000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(5));
EXPECT_FALSE(t1->is_running());
}
TEST_F(TimerTest, TimerWithTwoRestart) {
std::unique_ptr<Timer> t1 = manager_.CreateTimer(
"t1", on_expired_.AsStdFunction(),
- TimerOptions(DurationMs(5000), TimerBackoffAlgorithm::kFixed,
+ TimerOptions(TimeDelta::Seconds(5), TimerBackoffAlgorithm::kFixed,
/*max_restart=*/2));
EXPECT_CALL(on_expired_, Call).Times(0);
t1->Start();
- AdvanceTimeAndRunTimers(DurationMs(4000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(4));
// Fire first time
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
EXPECT_TRUE(t1->is_running());
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(4000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(4));
// Second time
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
EXPECT_TRUE(t1->is_running());
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(4000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(4));
// Third time
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
EXPECT_FALSE(t1->is_running());
}
TEST_F(TimerTest, TimerWithExponentialBackoff) {
std::unique_ptr<Timer> t1 = manager_.CreateTimer(
"t1", on_expired_.AsStdFunction(),
- TimerOptions(DurationMs(5000), TimerBackoffAlgorithm::kExponential));
+ TimerOptions(TimeDelta::Seconds(5), TimerBackoffAlgorithm::kExponential));
t1->Start();
// Fire first time at 5 seconds
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(5000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(5));
// Second time at 5*2^1 = 10 seconds later.
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(9000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(9));
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
// Third time at 5*2^2 = 20 seconds later.
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(19000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(19));
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
// Fourth time at 5*2^3 = 40 seconds later.
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(39000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(39));
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
}
TEST_F(TimerTest, StartTimerWillStopAndStart) {
std::unique_ptr<Timer> t1 = manager_.CreateTimer(
"t1", on_expired_.AsStdFunction(),
- TimerOptions(DurationMs(5000), TimerBackoffAlgorithm::kExponential));
+ TimerOptions(TimeDelta::Seconds(5), TimerBackoffAlgorithm::kExponential));
t1->Start();
- AdvanceTimeAndRunTimers(DurationMs(3000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(3));
t1->Start();
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(2000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(2));
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(3000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(3));
}
TEST_F(TimerTest, ExpirationCounterWillResetIfStopped) {
std::unique_ptr<Timer> t1 = manager_.CreateTimer(
"t1", on_expired_.AsStdFunction(),
- TimerOptions(DurationMs(5000), TimerBackoffAlgorithm::kExponential));
+ TimerOptions(TimeDelta::Seconds(5), TimerBackoffAlgorithm::kExponential));
t1->Start();
// Fire first time at 5 seconds
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(5000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(5));
EXPECT_EQ(t1->expiration_count(), 1);
// Second time at 5*2^1 = 10 seconds later.
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(9000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(9));
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
EXPECT_EQ(t1->expiration_count(), 2);
t1->Start();
@@ -265,79 +267,79 @@
// Third time at 5*2^0 = 5 seconds later.
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(4000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(4));
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
EXPECT_EQ(t1->expiration_count(), 1);
}
TEST_F(TimerTest, StopTimerWillMakeItNotExpire) {
std::unique_ptr<Timer> t1 = manager_.CreateTimer(
"t1", on_expired_.AsStdFunction(),
- TimerOptions(DurationMs(5000), TimerBackoffAlgorithm::kExponential));
+ TimerOptions(TimeDelta::Seconds(5), TimerBackoffAlgorithm::kExponential));
t1->Start();
EXPECT_TRUE(t1->is_running());
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(4000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(4));
t1->Stop();
EXPECT_FALSE(t1->is_running());
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
}
TEST_F(TimerTest, ReturningNewDurationWhenExpired) {
std::unique_ptr<Timer> t1 = manager_.CreateTimer(
"t1", on_expired_.AsStdFunction(),
- TimerOptions(DurationMs(5000), TimerBackoffAlgorithm::kFixed));
+ TimerOptions(TimeDelta::Seconds(5), TimerBackoffAlgorithm::kFixed));
EXPECT_CALL(on_expired_, Call).Times(0);
t1->Start();
- EXPECT_EQ(t1->duration(), DurationMs(5000));
+ EXPECT_EQ(t1->duration(), TimeDelta::Seconds(5));
- AdvanceTimeAndRunTimers(DurationMs(4000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(4));
// Fire first time
- EXPECT_CALL(on_expired_, Call).WillOnce(Return(DurationMs(2000)));
- AdvanceTimeAndRunTimers(DurationMs(1000));
- EXPECT_EQ(t1->duration(), DurationMs(2000));
+ EXPECT_CALL(on_expired_, Call).WillOnce(Return(TimeDelta::Seconds(2)));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
+ EXPECT_EQ(t1->duration(), TimeDelta::Seconds(2));
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
// Second time
- EXPECT_CALL(on_expired_, Call).WillOnce(Return(DurationMs(10000)));
- AdvanceTimeAndRunTimers(DurationMs(1000));
- EXPECT_EQ(t1->duration(), DurationMs(10000));
+ EXPECT_CALL(on_expired_, Call).WillOnce(Return(TimeDelta::Seconds(10)));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
+ EXPECT_EQ(t1->duration(), TimeDelta::Seconds(10));
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(9000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(9));
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
}
TEST_F(TimerTest, TimersHaveMaximumDuration) {
std::unique_ptr<Timer> t1 = manager_.CreateTimer(
"t1", on_expired_.AsStdFunction(),
- TimerOptions(DurationMs(1000), TimerBackoffAlgorithm::kExponential));
+ TimerOptions(TimeDelta::Seconds(1), TimerBackoffAlgorithm::kExponential));
- t1->set_duration(DurationMs(2 * *Timer::kMaxTimerDuration));
+ t1->set_duration(2 * Timer::kMaxTimerDuration);
EXPECT_EQ(t1->duration(), Timer::kMaxTimerDuration);
}
TEST_F(TimerTest, TimersHaveMaximumBackoffDuration) {
std::unique_ptr<Timer> t1 = manager_.CreateTimer(
"t1", on_expired_.AsStdFunction(),
- TimerOptions(DurationMs(1000), TimerBackoffAlgorithm::kExponential));
+ TimerOptions(TimeDelta::Seconds(1), TimerBackoffAlgorithm::kExponential));
t1->Start();
- int max_exponent = static_cast<int>(log2(*Timer::kMaxTimerDuration / 1000));
+ int max_exponent = static_cast<int>(log2(Timer::kMaxTimerDuration.seconds()));
for (int i = 0; i < max_exponent; ++i) {
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1000 * (1 << i)));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1 * (1 << i)));
}
// Reached the maximum duration.
@@ -357,73 +359,73 @@
TEST_F(TimerTest, TimerCanBeStartedFromWithinExpirationHandler) {
std::unique_ptr<Timer> t1 = manager_.CreateTimer(
"t1", on_expired_.AsStdFunction(),
- TimerOptions(DurationMs(1000), TimerBackoffAlgorithm::kFixed));
+ TimerOptions(TimeDelta::Seconds(1), TimerBackoffAlgorithm::kFixed));
t1->Start();
// Start a timer, but don't return any new duration in callback.
EXPECT_CALL(on_expired_, Call).WillOnce([&]() {
EXPECT_TRUE(t1->is_running());
- t1->set_duration(DurationMs(5000));
+ t1->set_duration(TimeDelta::Seconds(5));
t1->Start();
- return DurationMs(0);
+ return TimeDelta::Zero();
});
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(4999));
+ AdvanceTimeAndRunTimers(TimeDelta::Millis(4999));
// Start a timer, and return any new duration in callback.
EXPECT_CALL(on_expired_, Call).WillOnce([&]() {
EXPECT_TRUE(t1->is_running());
- t1->set_duration(DurationMs(5000));
+ t1->set_duration(TimeDelta::Seconds(5));
t1->Start();
- return DurationMs(8000);
+ return TimeDelta::Seconds(8);
});
- AdvanceTimeAndRunTimers(DurationMs(1));
+ AdvanceTimeAndRunTimers(TimeDelta::Millis(1));
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(7999));
+ AdvanceTimeAndRunTimers(TimeDelta::Millis(7999));
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1));
+ AdvanceTimeAndRunTimers(TimeDelta::Millis(1));
}
TEST_F(TimerTest, DurationStaysWithinMaxTimerBackOffDuration) {
std::unique_ptr<Timer> t1 = manager_.CreateTimer(
"t1", on_expired_.AsStdFunction(),
- TimerOptions(DurationMs(1000), TimerBackoffAlgorithm::kExponential,
- /*max_restarts=*/absl::nullopt, DurationMs(5000)));
+ TimerOptions(TimeDelta::Seconds(1), TimerBackoffAlgorithm::kExponential,
+ /*max_restarts=*/absl::nullopt, TimeDelta::Seconds(5)));
t1->Start();
// Initial timeout, 1000 ms
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1000));
+ AdvanceTimeAndRunTimers(TimeDelta::Seconds(1));
// Exponential backoff -> 2000 ms
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(1999));
+ AdvanceTimeAndRunTimers(TimeDelta::Millis(1999));
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1));
+ AdvanceTimeAndRunTimers(TimeDelta::Millis(1));
// Exponential backoff -> 4000 ms
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(3999));
+ AdvanceTimeAndRunTimers(TimeDelta::Millis(3999));
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1));
+ AdvanceTimeAndRunTimers(TimeDelta::Millis(1));
// Limited backoff -> 5000ms
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(4999));
+ AdvanceTimeAndRunTimers(TimeDelta::Millis(4999));
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1));
+ AdvanceTimeAndRunTimers(TimeDelta::Millis(1));
// ... where it plateaus
EXPECT_CALL(on_expired_, Call).Times(0);
- AdvanceTimeAndRunTimers(DurationMs(4999));
+ AdvanceTimeAndRunTimers(TimeDelta::Millis(4999));
EXPECT_CALL(on_expired_, Call).Times(1);
- AdvanceTimeAndRunTimers(DurationMs(1));
+ AdvanceTimeAndRunTimers(TimeDelta::Millis(1));
}
TEST(TimerManagerTest, TimerManagerPassesPrecisionToCreateTimeoutMethod) {
@@ -435,22 +437,22 @@
});
// Default TimerOptions.
manager.CreateTimer(
- "test_timer", []() { return DurationMs(0); },
- TimerOptions(DurationMs(123)));
+ "test_timer", []() { return TimeDelta::Zero(); },
+ TimerOptions(TimeDelta::Millis(123)));
EXPECT_EQ(create_timer_precison, webrtc::TaskQueueBase::DelayPrecision::kLow);
// High precision TimerOptions.
manager.CreateTimer(
- "test_timer", []() { return DurationMs(0); },
- TimerOptions(DurationMs(123), TimerBackoffAlgorithm::kExponential,
- absl::nullopt, DurationMs::InfiniteDuration(),
+ "test_timer", []() { return TimeDelta::Zero(); },
+ TimerOptions(TimeDelta::Millis(123), TimerBackoffAlgorithm::kExponential,
+ absl::nullopt, TimeDelta::PlusInfinity(),
webrtc::TaskQueueBase::DelayPrecision::kHigh));
EXPECT_EQ(create_timer_precison,
webrtc::TaskQueueBase::DelayPrecision::kHigh);
// Low precision TimerOptions.
manager.CreateTimer(
- "test_timer", []() { return DurationMs(0); },
- TimerOptions(DurationMs(123), TimerBackoffAlgorithm::kExponential,
- absl::nullopt, DurationMs::InfiniteDuration(),
+ "test_timer", []() { return TimeDelta::Zero(); },
+ TimerOptions(TimeDelta::Millis(123), TimerBackoffAlgorithm::kExponential,
+ absl::nullopt, TimeDelta::PlusInfinity(),
webrtc::TaskQueueBase::DelayPrecision::kLow));
EXPECT_EQ(create_timer_precison, webrtc::TaskQueueBase::DelayPrecision::kLow);
}
diff --git a/net/dcsctp/tx/retransmission_queue_test.cc b/net/dcsctp/tx/retransmission_queue_test.cc
index d7b39e50..4cbdea1 100644
--- a/net/dcsctp/tx/retransmission_queue_test.cc
+++ b/net/dcsctp/tx/retransmission_queue_test.cc
@@ -75,8 +75,8 @@
}),
timer_(timer_manager_.CreateTimer(
"test/t3_rtx",
- []() { return DurationMs(0); },
- TimerOptions(options_.rto_initial))) {}
+ []() { return TimeDelta::Zero(); },
+ TimerOptions(options_.rto_initial.ToTimeDelta()))) {}
std::function<SendQueue::DataToSend(TimeMs, size_t)> CreateChunk(
OutgoingMessageId message_id) {
