Move all of the individual alarms in QuicConnection into a new holder class.
This is a first step towards replacing individual alarms with one big connection-wide alarm.
This CL only covers alarms in the QuicConnection itself; some of the adjacent alarms will be moved in the follow-up CL.
PiperOrigin-RevId: 628392148
diff --git a/build/source_list.bzl b/build/source_list.bzl
index a28d283..67a610a 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl
@@ -282,6 +282,7 @@
"quic/core/quic_coalesced_packet.h",
"quic/core/quic_config.h",
"quic/core/quic_connection.h",
+ "quic/core/quic_connection_alarms.h",
"quic/core/quic_connection_context.h",
"quic/core/quic_connection_id.h",
"quic/core/quic_connection_id_manager.h",
@@ -613,6 +614,7 @@
"quic/core/quic_coalesced_packet.cc",
"quic/core/quic_config.cc",
"quic/core/quic_connection.cc",
+ "quic/core/quic_connection_alarms.cc",
"quic/core/quic_connection_context.cc",
"quic/core/quic_connection_id.cc",
"quic/core/quic_connection_id_manager.cc",
diff --git a/build/source_list.gni b/build/source_list.gni
index 5abdeab..afc2300 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni
@@ -282,6 +282,7 @@
"src/quiche/quic/core/quic_coalesced_packet.h",
"src/quiche/quic/core/quic_config.h",
"src/quiche/quic/core/quic_connection.h",
+ "src/quiche/quic/core/quic_connection_alarms.h",
"src/quiche/quic/core/quic_connection_context.h",
"src/quiche/quic/core/quic_connection_id.h",
"src/quiche/quic/core/quic_connection_id_manager.h",
@@ -613,6 +614,7 @@
"src/quiche/quic/core/quic_coalesced_packet.cc",
"src/quiche/quic/core/quic_config.cc",
"src/quiche/quic/core/quic_connection.cc",
+ "src/quiche/quic/core/quic_connection_alarms.cc",
"src/quiche/quic/core/quic_connection_context.cc",
"src/quiche/quic/core/quic_connection_id.cc",
"src/quiche/quic/core/quic_connection_id_manager.cc",
diff --git a/build/source_list.json b/build/source_list.json
index 38d2b75..b49530e 100644
--- a/build/source_list.json
+++ b/build/source_list.json
@@ -281,6 +281,7 @@
"quiche/quic/core/quic_coalesced_packet.h",
"quiche/quic/core/quic_config.h",
"quiche/quic/core/quic_connection.h",
+ "quiche/quic/core/quic_connection_alarms.h",
"quiche/quic/core/quic_connection_context.h",
"quiche/quic/core/quic_connection_id.h",
"quiche/quic/core/quic_connection_id_manager.h",
@@ -612,6 +613,7 @@
"quiche/quic/core/quic_coalesced_packet.cc",
"quiche/quic/core/quic_config.cc",
"quiche/quic/core/quic_connection.cc",
+ "quiche/quic/core/quic_connection_alarms.cc",
"quiche/quic/core/quic_connection_context.cc",
"quiche/quic/core/quic_connection_id.cc",
"quiche/quic/core/quic_connection_id_manager.cc",
diff --git a/quiche/quic/core/http/end_to_end_test.cc b/quiche/quic/core/http/end_to_end_test.cc
index b644d0d..d60bede 100644
--- a/quiche/quic/core/http/end_to_end_test.cc
+++ b/quiche/quic/core/http/end_to_end_test.cc
@@ -2338,9 +2338,7 @@
// connection is still flow control blocked.
session->connection()->OnCanWrite();
- QuicAlarm* send_alarm =
- QuicConnectionPeer::GetSendAlarm(session->connection());
- EXPECT_FALSE(send_alarm->IsSet());
+ EXPECT_FALSE(QuicConnectionPeer::GetSendAlarm(session->connection()).IsSet());
}
TEST_P(EndToEndTest, InvalidStream) {
diff --git a/quiche/quic/core/quic_connection.cc b/quiche/quic/core/quic_connection.cc
index 3b63ce0..f3d696f 100644
--- a/quiche/quic/core/quic_connection.cc
+++ b/quiche/quic/core/quic_connection.cc
@@ -71,122 +71,6 @@
// but doesn't allow multiple RTTs of user delay in the hope of using ECN.
const uint8_t kEcnPtoLimit = 2;
-// Base class of all alarms owned by a QuicConnection.
-class QuicConnectionAlarmDelegate : public QuicAlarm::Delegate {
- public:
- explicit QuicConnectionAlarmDelegate(QuicConnection* connection)
- : connection_(connection) {}
- QuicConnectionAlarmDelegate(const QuicConnectionAlarmDelegate&) = delete;
- QuicConnectionAlarmDelegate& operator=(const QuicConnectionAlarmDelegate&) =
- delete;
-
- QuicConnectionContext* GetConnectionContext() override {
- return (connection_ == nullptr) ? nullptr : connection_->context();
- }
-
- protected:
- QuicConnection* connection_;
-};
-
-// An alarm that is scheduled to send an ack if a timeout occurs.
-class AckAlarmDelegate : public QuicConnectionAlarmDelegate {
- public:
- using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
-
- void OnAlarm() override {
- QUICHE_DCHECK(connection_->ack_frame_updated());
- QUICHE_DCHECK(connection_->connected());
- QuicConnection::ScopedPacketFlusher flusher(connection_);
- if (connection_->SupportsMultiplePacketNumberSpaces()) {
- connection_->SendAllPendingAcks();
- } else {
- connection_->SendAck();
- }
- }
-};
-
-// This alarm will be scheduled any time a data-bearing packet is sent out.
-// When the alarm goes off, the connection checks to see if the oldest packets
-// have been acked, and retransmit them if they have not.
-class RetransmissionAlarmDelegate : public QuicConnectionAlarmDelegate {
- public:
- using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
-
- void OnAlarm() override {
- QUICHE_DCHECK(connection_->connected());
- connection_->OnRetransmissionTimeout();
- }
-};
-
-// An alarm that is scheduled when the SentPacketManager requires a delay
-// before sending packets and fires when the packet may be sent.
-class SendAlarmDelegate : public QuicConnectionAlarmDelegate {
- public:
- using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
-
- void OnAlarm() override {
- QUICHE_DCHECK(connection_->connected());
- connection_->OnSendAlarm();
- }
-};
-
-class MtuDiscoveryAlarmDelegate : public QuicConnectionAlarmDelegate {
- public:
- using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
-
- void OnAlarm() override {
- QUICHE_DCHECK(connection_->connected());
- connection_->DiscoverMtu();
- }
-};
-
-class ProcessUndecryptablePacketsAlarmDelegate
- : public QuicConnectionAlarmDelegate {
- public:
- using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
-
- void OnAlarm() override {
- QUICHE_DCHECK(connection_->connected());
- QuicConnection::ScopedPacketFlusher flusher(connection_);
- connection_->MaybeProcessUndecryptablePackets();
- }
-};
-
-class DiscardPreviousOneRttKeysAlarmDelegate
- : public QuicConnectionAlarmDelegate {
- public:
- using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
-
- void OnAlarm() override {
- QUICHE_DCHECK(connection_->connected());
- connection_->DiscardPreviousOneRttKeys();
- }
-};
-
-class DiscardZeroRttDecryptionKeysAlarmDelegate
- : public QuicConnectionAlarmDelegate {
- public:
- using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
-
- void OnAlarm() override {
- QUICHE_DCHECK(connection_->connected());
- QUIC_DLOG(INFO) << "0-RTT discard alarm fired";
- connection_->RemoveDecrypter(ENCRYPTION_ZERO_RTT);
- connection_->RetireOriginalDestinationConnectionId();
- }
-};
-
-class MultiPortProbingAlarmDelegate : public QuicConnectionAlarmDelegate {
- public:
- using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
-
- void OnAlarm() override {
- QUICHE_DCHECK(connection_->connected());
- QUIC_DLOG(INFO) << "Alternative path probing alarm fired";
- connection_->MaybeProbeMultiPortPath();
- }
-};
-
// When the clearer goes out of scope, the coalesced packet gets cleared.
class ScopedCoalescedPacketClearer {
public:
@@ -295,23 +179,7 @@
pending_retransmission_alarm_(false),
defer_send_in_response_to_packets_(false),
arena_(),
- ack_alarm_(alarm_factory_->CreateAlarm(arena_.New<AckAlarmDelegate>(this),
- &arena_)),
- retransmission_alarm_(alarm_factory_->CreateAlarm(
- arena_.New<RetransmissionAlarmDelegate>(this), &arena_)),
- send_alarm_(alarm_factory_->CreateAlarm(
- arena_.New<SendAlarmDelegate>(this), &arena_)),
- mtu_discovery_alarm_(alarm_factory_->CreateAlarm(
- arena_.New<MtuDiscoveryAlarmDelegate>(this), &arena_)),
- process_undecryptable_packets_alarm_(alarm_factory_->CreateAlarm(
- arena_.New<ProcessUndecryptablePacketsAlarmDelegate>(this), &arena_)),
- discard_previous_one_rtt_keys_alarm_(alarm_factory_->CreateAlarm(
- arena_.New<DiscardPreviousOneRttKeysAlarmDelegate>(this), &arena_)),
- discard_zero_rtt_decryption_keys_alarm_(alarm_factory_->CreateAlarm(
- arena_.New<DiscardZeroRttDecryptionKeysAlarmDelegate>(this),
- &arena_)),
- multi_port_probing_alarm_(alarm_factory_->CreateAlarm(
- arena_.New<MultiPortProbingAlarmDelegate>(this), &arena_)),
+ alarms_(this, *alarm_factory_, arena_),
visitor_(nullptr),
debug_visitor_(nullptr),
packet_creator_(server_connection_id, &framer_, random_generator_, this),
@@ -1152,7 +1020,7 @@
}
}
-bool QuicConnection::HasPendingAcks() const { return ack_alarm_->IsSet(); }
+bool QuicConnection::HasPendingAcks() const { return ack_alarm().IsSet(); }
void QuicConnection::OnUserAgentIdKnown(const std::string& /*user_agent_id*/) {
sent_packet_manager_.OnUserAgentIdKnown();
@@ -1172,7 +1040,7 @@
// within a short time; the RECOMMENDED time period is three times the
// Probe Timeout.
// https://quicwg.org/base-drafts/draft-ietf-quic-tls.html#name-discarding-0-rtt-keys
- discard_zero_rtt_decryption_keys_alarm_->Set(
+ discard_zero_rtt_decryption_keys_alarm().Set(
clock_->ApproximateNow() + sent_packet_manager_.GetPtoDelay() * 3);
}
}
@@ -1534,8 +1402,8 @@
// Cancel the send alarm because new packets likely have been acked, which
// may change the congestion window and/or pacing rate. Canceling the alarm
// causes CanWrite to recalculate the next send time.
- if (send_alarm_->IsSet()) {
- send_alarm_->Cancel();
+ if (send_alarm().IsSet()) {
+ send_alarm().Cancel();
}
if (supports_release_time_) {
// Update pace time into future because smoothed RTT is likely updated.
@@ -2278,7 +2146,7 @@
// If another key update triggers while the previous
// discard_previous_one_rtt_keys_alarm_ hasn't fired yet, cancel it since the
// old keys would already be discarded.
- discard_previous_one_rtt_keys_alarm_->Cancel();
+ discard_previous_one_rtt_keys_alarm().Cancel();
visitor_->OnKeyUpdate(reason);
}
@@ -2292,7 +2160,7 @@
// Note that this will cause an unnecessary
// discard_previous_one_rtt_keys_alarm_ on the first packet in the 1RTT
// encryption level, but this is harmless.
- discard_previous_one_rtt_keys_alarm_->Set(
+ discard_previous_one_rtt_keys_alarm().Set(
clock_->ApproximateNow() + sent_packet_manager_.GetPtoDelay() * 3);
}
@@ -2386,32 +2254,32 @@
// and cancel the alarm temporarily. The rest of this function will ensure
// the alarm deadline is no later than |max_deadline| when the function exits.
QuicTime max_deadline = QuicTime::Infinite();
- if (send_alarm_->IsSet()) {
- QUIC_DVLOG(1) << "Send alarm already set to " << send_alarm_->deadline();
- max_deadline = send_alarm_->deadline();
- send_alarm_->Cancel();
+ if (send_alarm().IsSet()) {
+ QUIC_DVLOG(1) << "Send alarm already set to " << send_alarm().deadline();
+ max_deadline = send_alarm().deadline();
+ send_alarm().Cancel();
}
if (CanWrite(HAS_RETRANSMITTABLE_DATA)) {
// Some data can be written immediately. Register for immediate resumption
// so we'll keep writing after other connections.
- QUIC_BUG_IF(quic_send_alarm_set_with_data_to_send, send_alarm_->IsSet());
+ QUIC_BUG_IF(quic_send_alarm_set_with_data_to_send, send_alarm().IsSet());
QUIC_DVLOG(1) << "Immediate send alarm scheduled after processing packet.";
- send_alarm_->Set(clock_->ApproximateNow() +
+ send_alarm().Set(clock_->ApproximateNow() +
sent_packet_manager_.GetDeferredSendAlarmDelay());
return;
}
- if (send_alarm_->IsSet()) {
+ if (send_alarm().IsSet()) {
// Pacing limited: CanWrite returned false, and it has scheduled a send
// alarm before it returns.
- if (send_alarm_->deadline() > max_deadline) {
+ if (send_alarm().deadline() > max_deadline) {
QUIC_DVLOG(1)
<< "Send alarm restored after processing packet. previous deadline:"
<< max_deadline
- << ", deadline from CanWrite:" << send_alarm_->deadline();
+ << ", deadline from CanWrite:" << send_alarm().deadline();
// Restore to the previous, earlier deadline.
- send_alarm_->Update(max_deadline, QuicTime::Delta::Zero());
+ send_alarm().Update(max_deadline, QuicTime::Delta::Zero());
} else {
QUIC_DVLOG(1) << "Future send alarm scheduled after processing packet.";
}
@@ -2420,7 +2288,7 @@
if (max_deadline != QuicTime::Infinite()) {
QUIC_DVLOG(1) << "Send alarm restored after processing packet.";
- send_alarm_->Set(max_deadline);
+ send_alarm().Set(max_deadline);
return;
}
// Can not send data due to other reasons: congestion blocked, anti
@@ -2812,11 +2680,11 @@
// After the visitor writes, it may have caused the socket to become write
// blocked or the congestion manager to prohibit sending, so check again.
- if (visitor_->WillingAndAbleToWrite() && !send_alarm_->IsSet() &&
+ if (visitor_->WillingAndAbleToWrite() && !send_alarm().IsSet() &&
CanWrite(HAS_RETRANSMITTABLE_DATA)) {
// We're not write blocked, but some data wasn't written. Register for
// 'immediate' resumption so we'll keep writing after other connections.
- send_alarm_->Set(clock_->ApproximateNow());
+ send_alarm().Set(clock_->ApproximateNow());
}
}
@@ -3100,7 +2968,7 @@
// actual MTU is, so there is no need to probe further.
// TODO(wub): Reduce max packet size to a safe default, or the actual MTU.
mtu_discoverer_.Disable();
- mtu_discovery_alarm_->Cancel();
+ mtu_discovery_alarm().Cancel();
buffered_packets_.pop_front();
continue;
}
@@ -3141,7 +3009,7 @@
// Stop sending ack of initial packet number space.
uber_received_packet_manager_.ResetAckStates(ENCRYPTION_INITIAL);
// Re-arm ack alarm.
- ack_alarm_->Update(uber_received_packet_manager_.GetEarliestAckTimeout(),
+ ack_alarm().Update(uber_received_packet_manager_.GetEarliestAckTimeout(),
kAlarmGranularity);
}
}
@@ -3296,14 +3164,14 @@
return true;
}
// If the send alarm is set, wait for it to fire.
- if (send_alarm_->IsSet()) {
+ if (send_alarm().IsSet()) {
return false;
}
QuicTime now = clock_->Now();
QuicTime::Delta delay = sent_packet_manager_.TimeUntilSend(now);
if (delay.IsInfinite()) {
- send_alarm_->Cancel();
+ send_alarm().Cancel();
return false;
}
@@ -3314,7 +3182,7 @@
return true;
}
// Cannot send packet now because delay is too far in the future.
- send_alarm_->Update(now + delay, kAlarmGranularity);
+ send_alarm().Update(now + delay, kAlarmGranularity);
QUIC_DVLOG(1) << ENDPOINT << "Delaying sending " << delay.ToMilliseconds()
<< "ms";
return false;
@@ -3546,7 +3414,7 @@
<< " MTU probe packet too big, size:" << encrypted_length
<< ", long_term_mtu_:" << long_term_mtu_;
mtu_discoverer_.Disable();
- mtu_discovery_alarm_->Cancel();
+ mtu_discovery_alarm().Cancel();
// The write failed, but the writer is not blocked, so return true.
return true;
}
@@ -3659,7 +3527,7 @@
return true;
}
}
- if (in_flight || !retransmission_alarm_->IsSet()) {
+ if (in_flight || !retransmission_alarm().IsSet()) {
SetRetransmissionAlarm();
}
SetPingAlarm();
@@ -3885,7 +3753,7 @@
SetMaxPacketLength(previous_validated_mtu_);
mtu_discoverer_.Disable();
- mtu_discovery_alarm_->Cancel();
+ mtu_discovery_alarm().Cancel();
previous_validated_mtu_ = 0;
return true;
}
@@ -4059,14 +3927,14 @@
// The client should immediately ack the SHLO to confirm the handshake is
// complete with the server.
if (perspective_ == Perspective::IS_CLIENT && ack_frame_updated()) {
- ack_alarm_->Update(clock_->ApproximateNow(), QuicTime::Delta::Zero());
+ ack_alarm().Update(clock_->ApproximateNow(), QuicTime::Delta::Zero());
}
return;
}
// Stop sending ack of handshake packet number space.
uber_received_packet_manager_.ResetAckStates(ENCRYPTION_HANDSHAKE);
// Re-arm ack alarm.
- ack_alarm_->Update(uber_received_packet_manager_.GetEarliestAckTimeout(),
+ ack_alarm().Update(uber_received_packet_manager_.GetEarliestAckTimeout(),
kAlarmGranularity);
if (!accelerated_server_preferred_address_ &&
received_server_preferred_address_.IsInitialized()) {
@@ -4281,7 +4149,7 @@
// and nothing waiting to be sent.
// This happens if the loss algorithm invokes a timer based loss, but the
// packet doesn't need to be retransmitted.
- if (!HasQueuedData() && !retransmission_alarm_->IsSet()) {
+ if (!HasQueuedData() && !retransmission_alarm().IsSet()) {
SetRetransmissionAlarm();
}
if (packet_writer_params_.ecn_codepoint == ECN_NOT_ECT ||
@@ -4349,8 +4217,8 @@
framer_.SetDecrypter(level, std::move(decrypter));
if (!undecryptable_packets_.empty() &&
- !process_undecryptable_packets_alarm_->IsSet()) {
- process_undecryptable_packets_alarm_->Set(clock_->ApproximateNow());
+ !process_undecryptable_packets_alarm().IsSet()) {
+ process_undecryptable_packets_alarm().Set(clock_->ApproximateNow());
}
}
@@ -4360,8 +4228,8 @@
framer_.SetAlternativeDecrypter(level, std::move(decrypter), latch_once_used);
if (!undecryptable_packets_.empty() &&
- !process_undecryptable_packets_alarm_->IsSet()) {
- process_undecryptable_packets_alarm_->Set(clock_->ApproximateNow());
+ !process_undecryptable_packets_alarm().IsSet()) {
+ process_undecryptable_packets_alarm().Set(clock_->ApproximateNow());
}
}
@@ -4372,8 +4240,8 @@
}
framer_.InstallDecrypter(level, std::move(decrypter));
if (!undecryptable_packets_.empty() &&
- !process_undecryptable_packets_alarm_->IsSet()) {
- process_undecryptable_packets_alarm_->Set(clock_->ApproximateNow());
+ !process_undecryptable_packets_alarm().IsSet()) {
+ process_undecryptable_packets_alarm().Set(clock_->ApproximateNow());
}
}
@@ -4437,7 +4305,7 @@
}
void QuicConnection::MaybeProcessUndecryptablePackets() {
- process_undecryptable_packets_alarm_->Cancel();
+ process_undecryptable_packets_alarm().Cancel();
if (undecryptable_packets_.empty() ||
encryption_level_ == ENCRYPTION_INITIAL) {
@@ -4695,15 +4563,15 @@
void QuicConnection::CancelAllAlarms() {
QUIC_DVLOG(1) << "Cancelling all QuicConnection alarms.";
- ack_alarm_->PermanentCancel();
+ ack_alarm().PermanentCancel();
ping_manager_.Stop();
- retransmission_alarm_->PermanentCancel();
- send_alarm_->PermanentCancel();
- mtu_discovery_alarm_->PermanentCancel();
- process_undecryptable_packets_alarm_->PermanentCancel();
- discard_previous_one_rtt_keys_alarm_->PermanentCancel();
- discard_zero_rtt_decryption_keys_alarm_->PermanentCancel();
- multi_port_probing_alarm_->PermanentCancel();
+ retransmission_alarm().PermanentCancel();
+ send_alarm().PermanentCancel();
+ mtu_discovery_alarm().PermanentCancel();
+ process_undecryptable_packets_alarm().PermanentCancel();
+ discard_previous_one_rtt_keys_alarm().PermanentCancel();
+ discard_zero_rtt_decryption_keys_alarm().PermanentCancel();
+ multi_port_probing_alarm().PermanentCancel();
blackhole_detector_.StopDetection(/*permanent=*/true);
idle_network_detector_.StopDetection();
}
@@ -4748,10 +4616,10 @@
void QuicConnection::SetRetransmissionAlarm() {
if (!connected_) {
- if (retransmission_alarm_->IsSet()) {
+ if (retransmission_alarm().IsSet()) {
QUIC_BUG(quic_bug_10511_29)
<< ENDPOINT << "Retransmission alarm is set while disconnected";
- retransmission_alarm_->Cancel();
+ retransmission_alarm().Cancel();
}
return;
}
@@ -4762,7 +4630,7 @@
if (LimitedByAmplificationFactor(packet_creator_.max_packet_length())) {
// Do not set retransmission timer if connection is anti-amplification limit
// throttled. Otherwise, nothing can be sent when timer fires.
- retransmission_alarm_->Cancel();
+ retransmission_alarm().Cancel();
return;
}
PacketNumberSpace packet_number_space;
@@ -4775,25 +4643,25 @@
// is in flight.
if (perspective_ == Perspective::IS_SERVER) {
// No need to arm PTO on server side.
- retransmission_alarm_->Cancel();
+ retransmission_alarm().Cancel();
return;
}
- if (retransmission_alarm_->IsSet() &&
- GetRetransmissionDeadline() > retransmission_alarm_->deadline()) {
+ if (retransmission_alarm().IsSet() &&
+ GetRetransmissionDeadline() > retransmission_alarm().deadline()) {
// Do not postpone armed PTO on the client side.
return;
}
}
- retransmission_alarm_->Update(GetRetransmissionDeadline(), kAlarmGranularity);
+ retransmission_alarm().Update(GetRetransmissionDeadline(), kAlarmGranularity);
}
void QuicConnection::MaybeSetMtuAlarm(QuicPacketNumber sent_packet_number) {
- if (mtu_discovery_alarm_->IsSet() ||
+ if (mtu_discovery_alarm().IsSet() ||
!mtu_discoverer_.ShouldProbeMtu(sent_packet_number)) {
return;
}
- mtu_discovery_alarm_->Set(clock_->ApproximateNow());
+ mtu_discovery_alarm().Set(clock_->ApproximateNow());
}
QuicConnection::ScopedPacketFlusher::ScopedPacketFlusher(
@@ -4825,23 +4693,23 @@
!connection_->CanWrite(NO_RETRANSMITTABLE_DATA)) {
// Cancel ACK alarm if connection is write blocked, and ACK will be
// sent when connection gets unblocked.
- connection_->ack_alarm_->Cancel();
- } else if (!connection_->ack_alarm_->IsSet() ||
- connection_->ack_alarm_->deadline() > ack_timeout) {
- connection_->ack_alarm_->Update(ack_timeout, QuicTime::Delta::Zero());
+ connection_->ack_alarm().Cancel();
+ } else if (!connection_->ack_alarm().IsSet() ||
+ connection_->ack_alarm().deadline() > ack_timeout) {
+ connection_->ack_alarm().Update(ack_timeout, QuicTime::Delta::Zero());
}
}
- if (connection_->ack_alarm_->IsSet() &&
- connection_->ack_alarm_->deadline() <=
+ if (connection_->ack_alarm().IsSet() &&
+ connection_->ack_alarm().deadline() <=
connection_->clock_->ApproximateNow()) {
// An ACK needs to be sent right now. This ACK did not get bundled
// because either there was no data to write or packets were marked as
// received after frames were queued in the generator.
- if (connection_->send_alarm_->IsSet() &&
- connection_->send_alarm_->deadline() <=
+ if (connection_->send_alarm().IsSet() &&
+ connection_->send_alarm().deadline() <=
connection_->clock_->ApproximateNow()) {
// If send alarm will go off soon, let send alarm send the ACK.
- connection_->ack_alarm_->Cancel();
+ connection_->ack_alarm().Cancel();
} else if (connection_->SupportsMultiplePacketNumberSpaces()) {
connection_->SendAllPendingAcks();
} else {
@@ -5171,11 +5039,11 @@
void QuicConnection::DisableMtuDiscovery() {
mtu_discoverer_.Disable();
- mtu_discovery_alarm_->Cancel();
+ mtu_discovery_alarm().Cancel();
}
void QuicConnection::DiscoverMtu() {
- QUICHE_DCHECK(!mtu_discovery_alarm_->IsSet());
+ QUICHE_DCHECK(!mtu_discovery_alarm().IsSet());
const QuicPacketNumber largest_sent_packet =
sent_packet_manager_.GetLargestSentPacket();
@@ -5184,7 +5052,7 @@
SendMtuDiscoveryPacket(
mtu_discoverer_.GetUpdatedMtuProbeSize(largest_sent_packet));
}
- QUICHE_DCHECK(!mtu_discovery_alarm_->IsSet());
+ QUICHE_DCHECK(!mtu_discovery_alarm().IsSet());
}
void QuicConnection::OnEffectivePeerMigrationValidated(
@@ -5720,7 +5588,7 @@
}
void QuicConnection::ResetAckStates() {
- ack_alarm_->Cancel();
+ ack_alarm().Cancel();
uber_received_packet_manager_.ResetAckStates(encryption_level_);
}
@@ -5829,7 +5697,7 @@
void QuicConnection::SendAllPendingAcks() {
QUICHE_DCHECK(SupportsMultiplePacketNumberSpaces());
QUIC_DVLOG(1) << ENDPOINT << "Trying to send all pending ACKs";
- ack_alarm_->Cancel();
+ ack_alarm().Cancel();
QuicTime earliest_ack_timeout =
uber_received_packet_manager_.GetEarliestAckTimeout();
QUIC_BUG_IF(quic_bug_12714_32, !earliest_ack_timeout.IsInitialized());
@@ -5896,7 +5764,7 @@
uber_received_packet_manager_.GetEarliestAckTimeout();
if (timeout.IsInitialized()) {
// If there are ACKs pending, re-arm ack alarm.
- ack_alarm_->Update(timeout, kAlarmGranularity);
+ ack_alarm().Update(timeout, kAlarmGranularity);
}
// Only try to bundle retransmittable data with ACK frame if default
// encryption level is forward secure.
@@ -6269,7 +6137,7 @@
// The multi-port path should have just finished the recent probe and
// waiting for the next one.
context = std::move(multi_port_path_context_);
- multi_port_probing_alarm_->Cancel();
+ multi_port_probing_alarm().Cancel();
QUIC_CLIENT_HISTOGRAM_ENUM(
"QuicConnection.MultiPortPathStatusWhenMigrating",
MultiPortStatusOnMigration::kWaitingForRefreshValidation,
@@ -6362,7 +6230,7 @@
}
void QuicConnection::OnKeepAliveTimeout() {
- if (retransmission_alarm_->IsSet() ||
+ if (retransmission_alarm().IsSet() ||
!visitor_->ShouldKeepConnectionAlive()) {
return;
}
@@ -6370,7 +6238,7 @@
}
void QuicConnection::OnRetransmittableOnWireTimeout() {
- if (retransmission_alarm_->IsSet() ||
+ if (retransmission_alarm().IsSet() ||
!visitor_->ShouldKeepConnectionAlive()) {
return;
}
@@ -7154,7 +7022,7 @@
QUICHE_DCHECK_EQ(Perspective::IS_CLIENT, perspective());
alternative_path_.validated = true;
multi_port_path_context_ = std::move(context);
- multi_port_probing_alarm_->Set(clock_->ApproximateNow() +
+ multi_port_probing_alarm().Set(clock_->ApproximateNow() +
multi_port_probing_interval_);
if (multi_port_stats_ != nullptr) {
multi_port_stats_->num_successful_probes++;
@@ -7177,7 +7045,7 @@
alternative_path_.peer_address !=
multi_port_path_context_->peer_address() ||
!visitor_->ShouldKeepConnectionAlive() ||
- multi_port_probing_alarm_->IsSet()) {
+ multi_port_probing_alarm().IsSet()) {
return;
}
if (multi_port_stats_ != nullptr) {
@@ -7198,7 +7066,7 @@
}
auto multi_port_validation_result_delegate =
std::make_unique<MultiPortPathValidationResultDelegate>(connection_);
- connection_->multi_port_probing_alarm_->Cancel();
+ connection_->multi_port_probing_alarm().Cancel();
connection_->multi_port_path_context_ = nullptr;
connection_->multi_port_stats_->num_multi_port_paths_created++;
connection_->ValidatePath(std::move(path_context),
diff --git a/quiche/quic/core/quic_connection.h b/quiche/quic/core/quic_connection.h
index 6a4ddfe..0565b1a 100644
--- a/quiche/quic/core/quic_connection.h
+++ b/quiche/quic/core/quic_connection.h
@@ -38,6 +38,7 @@
#include "quiche/quic/core/quic_alarm.h"
#include "quiche/quic/core/quic_alarm_factory.h"
#include "quiche/quic/core/quic_blocked_writer_interface.h"
+#include "quiche/quic/core/quic_connection_alarms.h"
#include "quiche/quic/core/quic_connection_context.h"
#include "quiche/quic/core/quic_connection_id.h"
#include "quiche/quic/core/quic_connection_id_manager.h"
@@ -2029,6 +2030,43 @@
bool PeerAddressChanged() const;
+ QuicAlarm& ack_alarm() { return alarms_.ack_alarm(); }
+ const QuicAlarm& ack_alarm() const { return alarms_.ack_alarm(); }
+ QuicAlarm& retransmission_alarm() { return alarms_.retransmission_alarm(); }
+ const QuicAlarm& retransmission_alarm() const {
+ return alarms_.retransmission_alarm();
+ }
+ QuicAlarm& send_alarm() { return alarms_.send_alarm(); }
+ const QuicAlarm& send_alarm() const { return alarms_.send_alarm(); }
+ QuicAlarm& mtu_discovery_alarm() { return alarms_.mtu_discovery_alarm(); }
+ const QuicAlarm& mtu_discovery_alarm() const {
+ return alarms_.mtu_discovery_alarm();
+ }
+ QuicAlarm& process_undecryptable_packets_alarm() {
+ return alarms_.process_undecryptable_packets_alarm();
+ }
+ const QuicAlarm& process_undecryptable_packets_alarm() const {
+ return alarms_.process_undecryptable_packets_alarm();
+ }
+ QuicAlarm& discard_previous_one_rtt_keys_alarm() {
+ return alarms_.discard_previous_one_rtt_keys_alarm();
+ }
+ const QuicAlarm& discard_previous_one_rtt_keys_alarm() const {
+ return alarms_.discard_previous_one_rtt_keys_alarm();
+ }
+ QuicAlarm& discard_zero_rtt_decryption_keys_alarm() {
+ return alarms_.discard_zero_rtt_decryption_keys_alarm();
+ }
+ const QuicAlarm& discard_zero_rtt_decryption_keys_alarm() const {
+ return alarms_.discard_zero_rtt_decryption_keys_alarm();
+ }
+ QuicAlarm& multi_port_probing_alarm() {
+ return alarms_.multi_port_probing_alarm();
+ }
+ const QuicAlarm& multi_port_probing_alarm() const {
+ return alarms_.multi_port_probing_alarm();
+ }
+
QuicConnectionContext context_;
QuicFramer framer_;
@@ -2156,27 +2194,9 @@
// Arena to store class implementations within the QuicConnection.
QuicConnectionArena arena_;
- // An alarm that fires when an ACK should be sent to the peer.
- QuicArenaScopedPtr<QuicAlarm> ack_alarm_;
- // An alarm that fires when a packet needs to be retransmitted.
- QuicArenaScopedPtr<QuicAlarm> retransmission_alarm_;
- // An alarm that is scheduled when the SentPacketManager requires a delay
- // before sending packets and fires when the packet may be sent.
- QuicArenaScopedPtr<QuicAlarm> send_alarm_;
- // An alarm that fires when an MTU probe should be sent.
- QuicArenaScopedPtr<QuicAlarm> mtu_discovery_alarm_;
- // An alarm that fires to process undecryptable packets when new decyrption
- // keys are available.
- QuicArenaScopedPtr<QuicAlarm> process_undecryptable_packets_alarm_;
- // An alarm that fires to discard keys for the previous key phase some time
- // after a key update has completed.
- QuicArenaScopedPtr<QuicAlarm> discard_previous_one_rtt_keys_alarm_;
- // An alarm that fires to discard 0-RTT decryption keys some time after the
- // first 1-RTT packet has been decrypted. Only used on server connections with
- // TLS handshaker.
- QuicArenaScopedPtr<QuicAlarm> discard_zero_rtt_decryption_keys_alarm_;
- // An alarm that fires to keep probing the multi-port path.
- QuicArenaScopedPtr<QuicAlarm> multi_port_probing_alarm_;
+ // Alarms used by the connection.
+ QuicConnectionAlarms alarms_;
+
// Neither visitor is owned by this class.
QuicConnectionVisitorInterface* visitor_;
QuicConnectionDebugVisitor* debug_visitor_;
diff --git a/quiche/quic/core/quic_connection_alarms.cc b/quiche/quic/core/quic_connection_alarms.cc
new file mode 100644
index 0000000..fcd29d8
--- /dev/null
+++ b/quiche/quic/core/quic_connection_alarms.cc
@@ -0,0 +1,157 @@
+// Copyright 2024 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 "quiche/quic/core/quic_connection_alarms.h"
+
+#include "quiche/quic/core/quic_alarm.h"
+#include "quiche/quic/core/quic_connection.h"
+#include "quiche/quic/core/quic_connection_context.h"
+#include "quiche/common/platform/api/quiche_logging.h"
+
+namespace quic {
+
+namespace {
+
+// Base class of all alarms owned by a QuicConnection.
+class QuicConnectionAlarmDelegate : public QuicAlarm::Delegate {
+ public:
+ explicit QuicConnectionAlarmDelegate(QuicConnection* connection)
+ : connection_(connection) {}
+ QuicConnectionAlarmDelegate(const QuicConnectionAlarmDelegate&) = delete;
+ QuicConnectionAlarmDelegate& operator=(const QuicConnectionAlarmDelegate&) =
+ delete;
+
+ QuicConnectionContext* GetConnectionContext() override {
+ return (connection_ == nullptr) ? nullptr : connection_->context();
+ }
+
+ protected:
+ QuicConnection* connection_;
+};
+
+// An alarm that is scheduled to send an ack if a timeout occurs.
+class AckAlarmDelegate : public QuicConnectionAlarmDelegate {
+ public:
+ using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
+
+ void OnAlarm() override {
+ QUICHE_DCHECK(connection_->ack_frame_updated());
+ QUICHE_DCHECK(connection_->connected());
+ QuicConnection::ScopedPacketFlusher flusher(connection_);
+ if (connection_->SupportsMultiplePacketNumberSpaces()) {
+ connection_->SendAllPendingAcks();
+ } else {
+ connection_->SendAck();
+ }
+ }
+};
+
+// This alarm will be scheduled any time a data-bearing packet is sent out.
+// When the alarm goes off, the connection checks to see if the oldest packets
+// have been acked, and retransmit them if they have not.
+class RetransmissionAlarmDelegate : public QuicConnectionAlarmDelegate {
+ public:
+ using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
+
+ void OnAlarm() override {
+ QUICHE_DCHECK(connection_->connected());
+ connection_->OnRetransmissionTimeout();
+ }
+};
+
+// An alarm that is scheduled when the SentPacketManager requires a delay
+// before sending packets and fires when the packet may be sent.
+class SendAlarmDelegate : public QuicConnectionAlarmDelegate {
+ public:
+ using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
+
+ void OnAlarm() override {
+ QUICHE_DCHECK(connection_->connected());
+ connection_->OnSendAlarm();
+ }
+};
+
+class MtuDiscoveryAlarmDelegate : public QuicConnectionAlarmDelegate {
+ public:
+ using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
+
+ void OnAlarm() override {
+ QUICHE_DCHECK(connection_->connected());
+ connection_->DiscoverMtu();
+ }
+};
+
+class ProcessUndecryptablePacketsAlarmDelegate
+ : public QuicConnectionAlarmDelegate {
+ public:
+ using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
+
+ void OnAlarm() override {
+ QUICHE_DCHECK(connection_->connected());
+ QuicConnection::ScopedPacketFlusher flusher(connection_);
+ connection_->MaybeProcessUndecryptablePackets();
+ }
+};
+
+class DiscardPreviousOneRttKeysAlarmDelegate
+ : public QuicConnectionAlarmDelegate {
+ public:
+ using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
+
+ void OnAlarm() override {
+ QUICHE_DCHECK(connection_->connected());
+ connection_->DiscardPreviousOneRttKeys();
+ }
+};
+
+class DiscardZeroRttDecryptionKeysAlarmDelegate
+ : public QuicConnectionAlarmDelegate {
+ public:
+ using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
+
+ void OnAlarm() override {
+ QUICHE_DCHECK(connection_->connected());
+ QUIC_DLOG(INFO) << "0-RTT discard alarm fired";
+ connection_->RemoveDecrypter(ENCRYPTION_ZERO_RTT);
+ connection_->RetireOriginalDestinationConnectionId();
+ }
+};
+
+class MultiPortProbingAlarmDelegate : public QuicConnectionAlarmDelegate {
+ public:
+ using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
+
+ void OnAlarm() override {
+ QUICHE_DCHECK(connection_->connected());
+ QUIC_DLOG(INFO) << "Alternative path probing alarm fired";
+ connection_->MaybeProbeMultiPortPath();
+ }
+};
+
+} // namespace
+
+QuicConnectionAlarms::QuicConnectionAlarms(QuicConnection* connection,
+ QuicAlarmFactory& alarm_factory,
+ QuicConnectionArena& arena)
+ : ack_alarm_(alarm_factory.CreateAlarm(
+ arena.New<AckAlarmDelegate>(connection), &arena)),
+ retransmission_alarm_(alarm_factory.CreateAlarm(
+ arena.New<RetransmissionAlarmDelegate>(connection), &arena)),
+ send_alarm_(alarm_factory.CreateAlarm(
+ arena.New<SendAlarmDelegate>(connection), &arena)),
+ mtu_discovery_alarm_(alarm_factory.CreateAlarm(
+ arena.New<MtuDiscoveryAlarmDelegate>(connection), &arena)),
+ process_undecryptable_packets_alarm_(alarm_factory.CreateAlarm(
+ arena.New<ProcessUndecryptablePacketsAlarmDelegate>(connection),
+ &arena)),
+ discard_previous_one_rtt_keys_alarm_(alarm_factory.CreateAlarm(
+ arena.New<DiscardPreviousOneRttKeysAlarmDelegate>(connection),
+ &arena)),
+ discard_zero_rtt_decryption_keys_alarm_(alarm_factory.CreateAlarm(
+ arena.New<DiscardZeroRttDecryptionKeysAlarmDelegate>(connection),
+ &arena)),
+ multi_port_probing_alarm_(alarm_factory.CreateAlarm(
+ arena.New<MultiPortProbingAlarmDelegate>(connection), &arena)) {}
+
+} // namespace quic
diff --git a/quiche/quic/core/quic_connection_alarms.h b/quiche/quic/core/quic_connection_alarms.h
new file mode 100644
index 0000000..7a3da27
--- /dev/null
+++ b/quiche/quic/core/quic_connection_alarms.h
@@ -0,0 +1,83 @@
+// Copyright 2024 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.
+
+#ifndef QUICHE_QUIC_CORE_QUIC_CONNECTION_ALARMS_H_
+#define QUICHE_QUIC_CORE_QUIC_CONNECTION_ALARMS_H_
+
+#include "quiche/quic/core/quic_alarm.h"
+#include "quiche/quic/core/quic_alarm_factory.h"
+#include "quiche/quic/core/quic_arena_scoped_ptr.h"
+#include "quiche/quic/core/quic_one_block_arena.h"
+
+namespace quic {
+
+class QuicConnection;
+
+class QUICHE_EXPORT QuicConnectionAlarms {
+ public:
+ QuicConnectionAlarms(QuicConnection* connection,
+ QuicAlarmFactory& alarm_factory,
+ QuicConnectionArena& arena);
+
+ QuicAlarm& ack_alarm() { return *ack_alarm_; }
+ QuicAlarm& retransmission_alarm() { return *retransmission_alarm_; }
+ QuicAlarm& send_alarm() { return *send_alarm_; }
+ QuicAlarm& mtu_discovery_alarm() { return *mtu_discovery_alarm_; }
+ QuicAlarm& process_undecryptable_packets_alarm() {
+ return *process_undecryptable_packets_alarm_;
+ }
+ QuicAlarm& discard_previous_one_rtt_keys_alarm() {
+ return *discard_previous_one_rtt_keys_alarm_;
+ }
+ QuicAlarm& discard_zero_rtt_decryption_keys_alarm() {
+ return *discard_zero_rtt_decryption_keys_alarm_;
+ }
+ QuicAlarm& multi_port_probing_alarm() { return *multi_port_probing_alarm_; }
+
+ const QuicAlarm& ack_alarm() const { return *ack_alarm_; }
+ const QuicAlarm& retransmission_alarm() const {
+ return *retransmission_alarm_;
+ }
+ const QuicAlarm& send_alarm() const { return *send_alarm_; }
+ const QuicAlarm& mtu_discovery_alarm() const { return *mtu_discovery_alarm_; }
+ const QuicAlarm& process_undecryptable_packets_alarm() const {
+ return *process_undecryptable_packets_alarm_;
+ }
+ const QuicAlarm& discard_previous_one_rtt_keys_alarm() const {
+ return *discard_previous_one_rtt_keys_alarm_;
+ }
+ const QuicAlarm& discard_zero_rtt_decryption_keys_alarm() const {
+ return *discard_zero_rtt_decryption_keys_alarm_;
+ }
+ const QuicAlarm& multi_port_probing_alarm() const {
+ return *multi_port_probing_alarm_;
+ }
+
+ private:
+ // An alarm that fires when an ACK should be sent to the peer.
+ QuicArenaScopedPtr<QuicAlarm> ack_alarm_;
+ // An alarm that fires when a packet needs to be retransmitted.
+ QuicArenaScopedPtr<QuicAlarm> retransmission_alarm_;
+ // An alarm that is scheduled when the SentPacketManager requires a delay
+ // before sending packets and fires when the packet may be sent.
+ QuicArenaScopedPtr<QuicAlarm> send_alarm_;
+ // An alarm that fires when an MTU probe should be sent.
+ QuicArenaScopedPtr<QuicAlarm> mtu_discovery_alarm_;
+ // An alarm that fires to process undecryptable packets when new decryption
+ // keys are available.
+ QuicArenaScopedPtr<QuicAlarm> process_undecryptable_packets_alarm_;
+ // An alarm that fires to discard keys for the previous key phase some time
+ // after a key update has completed.
+ QuicArenaScopedPtr<QuicAlarm> discard_previous_one_rtt_keys_alarm_;
+ // An alarm that fires to discard 0-RTT decryption keys some time after the
+ // first 1-RTT packet has been decrypted. Only used on server connections with
+ // TLS handshaker.
+ QuicArenaScopedPtr<QuicAlarm> discard_zero_rtt_decryption_keys_alarm_;
+ // An alarm that fires to keep probing the multi-port path.
+ QuicArenaScopedPtr<QuicAlarm> multi_port_probing_alarm_;
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_CORE_QUIC_CONNECTION_ALARMS_H_
diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc
index 883b6a3..2f27ed8 100644
--- a/quiche/quic/core/quic_connection_test.cc
+++ b/quiche/quic/core/quic_connection_test.cc
@@ -424,52 +424,52 @@
TestAlarmFactory::TestAlarm* GetAckAlarm() {
return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- QuicConnectionPeer::GetAckAlarm(this));
+ &QuicConnectionPeer::GetAckAlarm(this));
}
TestAlarmFactory::TestAlarm* GetPingAlarm() {
return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- QuicConnectionPeer::GetPingAlarm(this));
+ &QuicConnectionPeer::GetPingAlarm(this));
}
TestAlarmFactory::TestAlarm* GetRetransmissionAlarm() {
return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- QuicConnectionPeer::GetRetransmissionAlarm(this));
+ &QuicConnectionPeer::GetRetransmissionAlarm(this));
}
TestAlarmFactory::TestAlarm* GetSendAlarm() {
return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- QuicConnectionPeer::GetSendAlarm(this));
+ &QuicConnectionPeer::GetSendAlarm(this));
}
TestAlarmFactory::TestAlarm* GetTimeoutAlarm() {
return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- QuicConnectionPeer::GetIdleNetworkDetectorAlarm(this));
+ &QuicConnectionPeer::GetIdleNetworkDetectorAlarm(this));
}
TestAlarmFactory::TestAlarm* GetMtuDiscoveryAlarm() {
return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- QuicConnectionPeer::GetMtuDiscoveryAlarm(this));
+ &QuicConnectionPeer::GetMtuDiscoveryAlarm(this));
}
TestAlarmFactory::TestAlarm* GetProcessUndecryptablePacketsAlarm() {
return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- QuicConnectionPeer::GetProcessUndecryptablePacketsAlarm(this));
+ &QuicConnectionPeer::GetProcessUndecryptablePacketsAlarm(this));
}
TestAlarmFactory::TestAlarm* GetDiscardPreviousOneRttKeysAlarm() {
return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- QuicConnectionPeer::GetDiscardPreviousOneRttKeysAlarm(this));
+ &QuicConnectionPeer::GetDiscardPreviousOneRttKeysAlarm(this));
}
TestAlarmFactory::TestAlarm* GetDiscardZeroRttDecryptionKeysAlarm() {
return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- QuicConnectionPeer::GetDiscardZeroRttDecryptionKeysAlarm(this));
+ &QuicConnectionPeer::GetDiscardZeroRttDecryptionKeysAlarm(this));
}
TestAlarmFactory::TestAlarm* GetBlackholeDetectorAlarm() {
return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- QuicConnectionPeer::GetBlackholeDetectorAlarm(this));
+ &QuicConnectionPeer::GetBlackholeDetectorAlarm(this));
}
TestAlarmFactory::TestAlarm* GetRetirePeerIssuedConnectionIdAlarm() {
@@ -484,7 +484,7 @@
TestAlarmFactory::TestAlarm* GetMultiPortProbingAlarm() {
return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- QuicConnectionPeer::GetMultiPortProbingAlarm(this));
+ &QuicConnectionPeer::GetMultiPortProbingAlarm(this));
}
void PathDegradingTimeout() {
diff --git a/quiche/quic/test_tools/quic_connection_peer.cc b/quiche/quic/test_tools/quic_connection_peer.cc
index b08a332..7285922 100644
--- a/quiche/quic/test_tools/quic_connection_peer.cc
+++ b/quiche/quic/test_tools/quic_connection_peer.cc
@@ -117,48 +117,48 @@
}
// static
-QuicAlarm* QuicConnectionPeer::GetAckAlarm(QuicConnection* connection) {
- return connection->ack_alarm_.get();
+QuicAlarm& QuicConnectionPeer::GetAckAlarm(QuicConnection* connection) {
+ return connection->alarms_.ack_alarm();
}
// static
-QuicAlarm* QuicConnectionPeer::GetPingAlarm(QuicConnection* connection) {
- return connection->ping_manager_.alarm_.get();
+QuicAlarm& QuicConnectionPeer::GetPingAlarm(QuicConnection* connection) {
+ return *connection->ping_manager_.alarm_;
}
// static
-QuicAlarm* QuicConnectionPeer::GetRetransmissionAlarm(
+QuicAlarm& QuicConnectionPeer::GetRetransmissionAlarm(
QuicConnection* connection) {
- return connection->retransmission_alarm_.get();
+ return connection->alarms_.retransmission_alarm();
}
// static
-QuicAlarm* QuicConnectionPeer::GetSendAlarm(QuicConnection* connection) {
- return connection->send_alarm_.get();
+QuicAlarm& QuicConnectionPeer::GetSendAlarm(QuicConnection* connection) {
+ return connection->alarms_.send_alarm();
}
// static
-QuicAlarm* QuicConnectionPeer::GetMtuDiscoveryAlarm(
+QuicAlarm& QuicConnectionPeer::GetMtuDiscoveryAlarm(
QuicConnection* connection) {
- return connection->mtu_discovery_alarm_.get();
+ return connection->alarms_.mtu_discovery_alarm();
}
// static
-QuicAlarm* QuicConnectionPeer::GetProcessUndecryptablePacketsAlarm(
+QuicAlarm& QuicConnectionPeer::GetProcessUndecryptablePacketsAlarm(
QuicConnection* connection) {
- return connection->process_undecryptable_packets_alarm_.get();
+ return connection->alarms_.process_undecryptable_packets_alarm();
}
// static
-QuicAlarm* QuicConnectionPeer::GetDiscardPreviousOneRttKeysAlarm(
+QuicAlarm& QuicConnectionPeer::GetDiscardPreviousOneRttKeysAlarm(
QuicConnection* connection) {
- return connection->discard_previous_one_rtt_keys_alarm_.get();
+ return connection->alarms_.discard_previous_one_rtt_keys_alarm();
}
// static
-QuicAlarm* QuicConnectionPeer::GetDiscardZeroRttDecryptionKeysAlarm(
+QuicAlarm& QuicConnectionPeer::GetDiscardZeroRttDecryptionKeysAlarm(
QuicConnection* connection) {
- return connection->discard_zero_rtt_decryption_keys_alarm_.get();
+ return connection->alarms_.discard_zero_rtt_decryption_keys_alarm();
}
// static
@@ -322,9 +322,9 @@
}
// static
-QuicAlarm* QuicConnectionPeer::GetBlackholeDetectorAlarm(
+QuicAlarm& QuicConnectionPeer::GetBlackholeDetectorAlarm(
QuicConnection* connection) {
- return connection->blackhole_detector_.alarm_.get();
+ return *connection->blackhole_detector_.alarm_;
}
// static
@@ -352,9 +352,9 @@
}
// static
-QuicAlarm* QuicConnectionPeer::GetIdleNetworkDetectorAlarm(
+QuicAlarm& QuicConnectionPeer::GetIdleNetworkDetectorAlarm(
QuicConnection* connection) {
- return connection->idle_network_detector_.alarm_.get();
+ return *connection->idle_network_detector_.alarm_;
}
// static
@@ -364,9 +364,9 @@
}
// static
-QuicAlarm* QuicConnectionPeer::GetMultiPortProbingAlarm(
+QuicAlarm& QuicConnectionPeer::GetMultiPortProbingAlarm(
QuicConnection* connection) {
- return connection->multi_port_probing_alarm_.get();
+ return connection->alarms_.multi_port_probing_alarm();
}
// static
diff --git a/quiche/quic/test_tools/quic_connection_peer.h b/quiche/quic/test_tools/quic_connection_peer.h
index 5017d7a..32db849 100644
--- a/quiche/quic/test_tools/quic_connection_peer.h
+++ b/quiche/quic/test_tools/quic_connection_peer.h
@@ -78,16 +78,16 @@
static QuicFramer* GetFramer(QuicConnection* connection);
- static QuicAlarm* GetAckAlarm(QuicConnection* connection);
- static QuicAlarm* GetPingAlarm(QuicConnection* connection);
- static QuicAlarm* GetRetransmissionAlarm(QuicConnection* connection);
- static QuicAlarm* GetSendAlarm(QuicConnection* connection);
- static QuicAlarm* GetMtuDiscoveryAlarm(QuicConnection* connection);
- static QuicAlarm* GetProcessUndecryptablePacketsAlarm(
+ static QuicAlarm& GetAckAlarm(QuicConnection* connection);
+ static QuicAlarm& GetPingAlarm(QuicConnection* connection);
+ static QuicAlarm& GetRetransmissionAlarm(QuicConnection* connection);
+ static QuicAlarm& GetSendAlarm(QuicConnection* connection);
+ static QuicAlarm& GetMtuDiscoveryAlarm(QuicConnection* connection);
+ static QuicAlarm& GetProcessUndecryptablePacketsAlarm(
QuicConnection* connection);
- static QuicAlarm* GetDiscardPreviousOneRttKeysAlarm(
+ static QuicAlarm& GetDiscardPreviousOneRttKeysAlarm(
QuicConnection* connection);
- static QuicAlarm* GetDiscardZeroRttDecryptionKeysAlarm(
+ static QuicAlarm& GetDiscardZeroRttDecryptionKeysAlarm(
QuicConnection* connection);
static QuicAlarm* GetRetirePeerIssuedConnectionIdAlarm(
QuicConnection* connection);
@@ -136,7 +136,7 @@
static QuicNetworkBlackholeDetector& GetBlackholeDetector(
QuicConnection* connection);
- static QuicAlarm* GetBlackholeDetectorAlarm(QuicConnection* connection);
+ static QuicAlarm& GetBlackholeDetectorAlarm(QuicConnection* connection);
static QuicTime GetPathDegradingDeadline(QuicConnection* connection);
@@ -145,7 +145,7 @@
static QuicTime GetPathMtuReductionDetectionDeadline(
QuicConnection* connection);
- static QuicAlarm* GetIdleNetworkDetectorAlarm(QuicConnection* connection);
+ static QuicAlarm& GetIdleNetworkDetectorAlarm(QuicConnection* connection);
static QuicTime GetIdleNetworkDeadline(QuicConnection* connection);
@@ -220,7 +220,7 @@
static void FlushCoalescedPacket(QuicConnection* connection);
- static QuicAlarm* GetMultiPortProbingAlarm(QuicConnection* connection);
+ static QuicAlarm& GetMultiPortProbingAlarm(QuicConnection* connection);
static void SetInProbeTimeOut(QuicConnection* connection, bool value);
