Deprecate --gfe2_reloadable_flag_quic_use_alarm_multiplexer.
This does not remove QuicAlarmProxy, but it dismantles the rest of the scaffolding that was necessary to support two alarm types at once.
It also reduces the size of QuicConnection by about 1kB.
PiperOrigin-RevId: 742367207
diff --git a/quiche/common/quiche_feature_flags_list.h b/quiche/common/quiche_feature_flags_list.h
index f3c8c18..9a01830 100755
--- a/quiche/common/quiche_feature_flags_list.h
+++ b/quiche/common/quiche_feature_flags_list.h
@@ -53,7 +53,6 @@
QUICHE_FLAG(bool, quiche_reloadable_flag_quic_test_peer_addr_change_after_normalize, false, false, "If true, QuicConnection::ProcessValidatedPacket will use normalized address to test peer address changes.")
QUICHE_FLAG(bool, quiche_reloadable_flag_quic_testonly_default_false, false, false, "A testonly reloadable flag that will always default to false.")
QUICHE_FLAG(bool, quiche_reloadable_flag_quic_testonly_default_true, true, true, "A testonly reloadable flag that will always default to true.")
-QUICHE_FLAG(bool, quiche_reloadable_flag_quic_use_alarm_multiplexer, true, true, "Manages all of the connection alarms via QuicAlarmMultiplexer.")
QUICHE_FLAG(bool, quiche_reloadable_flag_quic_use_received_client_addresses_cache, true, true, "If true, use a LRU cache to record client addresses of packets received on server's original address.")
QUICHE_FLAG(bool, quiche_restart_flag_quic_support_release_time_for_gso, false, false, "If true, QuicGsoBatchWriter will support release time if it is available and the process has the permission to do so.")
QUICHE_FLAG(bool, quiche_restart_flag_quic_testonly_default_false, false, false, "A testonly restart flag that will always default to false.")
diff --git a/quiche/quic/core/quic_connection.cc b/quiche/quic/core/quic_connection.cc
index 8a9b785..c68a452 100644
--- a/quiche/quic/core/quic_connection.cc
+++ b/quiche/quic/core/quic_connection.cc
@@ -38,6 +38,7 @@
#include "quiche/quic/core/frames/quic_reset_stream_at_frame.h"
#include "quiche/quic/core/quic_bandwidth.h"
#include "quiche/quic/core/quic_config.h"
+#include "quiche/quic/core/quic_connection_alarms.h"
#include "quiche/quic/core/quic_connection_id.h"
#include "quiche/quic/core/quic_constants.h"
#include "quiche/quic/core/quic_error_codes.h"
@@ -188,7 +189,7 @@
pending_retransmission_alarm_(false),
defer_send_in_response_to_packets_(false),
arena_(),
- alarms_(this, *alarm_factory_, arena_),
+ alarms_(this, arena_, *alarm_factory_),
visitor_(nullptr),
debug_visitor_(nullptr),
packet_creator_(server_connection_id, &framer_, random_generator_, this),
@@ -214,12 +215,16 @@
processing_ack_frame_(false),
supports_release_time_(false),
release_time_into_future_(QuicTime::Delta::Zero()),
- blackhole_detector_(this, alarms_.network_blackhole_detector_alarm()),
- idle_network_detector_(this, clock_->ApproximateNow(),
- alarms_.idle_network_detector_alarm()),
+ blackhole_detector_(
+ this,
+ QuicAlarmProxy(&alarms_, QuicAlarmSlot::kNetworkBlackholeDetector)),
+ idle_network_detector_(
+ this, clock_->ApproximateNow(),
+ QuicAlarmProxy(&alarms_, QuicAlarmSlot::kIdleNetworkDetector)),
path_validator_(alarm_factory_, &arena_, this, random_generator_, clock_,
&context_),
- ping_manager_(perspective, this, alarms_.ping_alarm()),
+ ping_manager_(perspective, this,
+ QuicAlarmProxy(&alarms_, QuicAlarmSlot::kPing)),
multi_port_probing_interval_(kDefaultMultiPortProbingInterval),
connection_id_generator_(generator),
received_client_addresses_cache_(kMaxReceivedClientAddressSize) {
@@ -1130,7 +1135,9 @@
}
}
-bool QuicConnection::HasPendingAcks() const { return ack_alarm().IsSet(); }
+bool QuicConnection::HasPendingAcks() const {
+ return alarms_.IsSet(QuicAlarmSlot::kAck);
+}
void QuicConnection::OnUserAgentIdKnown(const std::string& /*user_agent_id*/) {
sent_packet_manager_.OnUserAgentIdKnown();
diff --git a/quiche/quic/core/quic_connection.h b/quiche/quic/core/quic_connection.h
index b295e59..a005ef0 100644
--- a/quiche/quic/core/quic_connection.h
+++ b/quiche/quic/core/quic_connection.h
@@ -2170,44 +2170,31 @@
void GenerateNewOutgoingFlowLabel();
- QuicAlarmProxy ack_alarm() { return alarms_.ack_alarm(); }
- QuicAlarmProxy retransmission_alarm() {
- return alarms_.retransmission_alarm();
+ QuicAlarmProxy ack_alarm() {
+ return QuicAlarmProxy(&alarms_, QuicAlarmSlot::kAck);
}
- QuicAlarmProxy send_alarm() { return alarms_.send_alarm(); }
- QuicAlarmProxy mtu_discovery_alarm() { return alarms_.mtu_discovery_alarm(); }
+ QuicAlarmProxy retransmission_alarm() {
+ return QuicAlarmProxy(&alarms_, QuicAlarmSlot::kRetransmission);
+ }
+ QuicAlarmProxy send_alarm() {
+ return QuicAlarmProxy(&alarms_, QuicAlarmSlot::kSend);
+ }
+ QuicAlarmProxy mtu_discovery_alarm() {
+ return QuicAlarmProxy(&alarms_, QuicAlarmSlot::kMtuDiscovery);
+ }
QuicAlarmProxy process_undecryptable_packets_alarm() {
- return alarms_.process_undecryptable_packets_alarm();
+ return QuicAlarmProxy(&alarms_,
+ QuicAlarmSlot::kProcessUndecryptablePackets);
}
QuicAlarmProxy discard_previous_one_rtt_keys_alarm() {
- return alarms_.discard_previous_one_rtt_keys_alarm();
+ return QuicAlarmProxy(&alarms_, QuicAlarmSlot::kDiscardPreviousOneRttKeys);
}
QuicAlarmProxy discard_zero_rtt_decryption_keys_alarm() {
- return alarms_.discard_zero_rtt_decryption_keys_alarm();
+ return QuicAlarmProxy(&alarms_,
+ QuicAlarmSlot::kDiscardZeroRttDecryptionKeys);
}
QuicAlarmProxy multi_port_probing_alarm() {
- return alarms_.multi_port_probing_alarm();
- }
-
- QuicConstAlarmProxy ack_alarm() const { return alarms_.ack_alarm(); }
- QuicConstAlarmProxy retransmission_alarm() const {
- return alarms_.retransmission_alarm();
- }
- QuicConstAlarmProxy send_alarm() const { return alarms_.send_alarm(); }
- QuicConstAlarmProxy mtu_discovery_alarm() const {
- return alarms_.mtu_discovery_alarm();
- }
- QuicConstAlarmProxy process_undecryptable_packets_alarm() const {
- return alarms_.process_undecryptable_packets_alarm();
- }
- QuicConstAlarmProxy discard_previous_one_rtt_keys_alarm() const {
- return alarms_.discard_previous_one_rtt_keys_alarm();
- }
- QuicConstAlarmProxy discard_zero_rtt_decryption_keys_alarm() const {
- return alarms_.discard_zero_rtt_decryption_keys_alarm();
- }
- QuicConstAlarmProxy multi_port_probing_alarm() const {
- return alarms_.multi_port_probing_alarm();
+ return QuicAlarmProxy(&alarms_, QuicAlarmSlot::kMultiPortProbing);
}
QuicConnectionContext context_;
@@ -2337,7 +2324,7 @@
QuicConnectionArena arena_;
// Alarms used by the connection.
- QuicConnectionAlarms alarms_;
+ QuicAlarmMultiplexer alarms_;
// Neither visitor is owned by this class.
QuicConnectionVisitorInterface* visitor_;
diff --git a/quiche/quic/core/quic_connection_alarms.cc b/quiche/quic/core/quic_connection_alarms.cc
index f588574..1741111 100644
--- a/quiche/quic/core/quic_connection_alarms.cc
+++ b/quiche/quic/core/quic_connection_alarms.cc
@@ -20,7 +20,6 @@
#include "quiche/quic/core/quic_connection_context.h"
#include "quiche/quic/core/quic_one_block_arena.h"
#include "quiche/quic/core/quic_time.h"
-#include "quiche/quic/core/quic_types.h"
#include "quiche/quic/platform/api/quic_flags.h"
#include "quiche/common/platform/api/quiche_bug_tracker.h"
#include "quiche/common/platform/api/quiche_logging.h"
@@ -399,42 +398,4 @@
later_alarm_->PermanentCancel();
}
-QuicConnectionAlarmHolder::QuicConnectionAlarmHolder(
- QuicConnectionAlarmsDelegate* delegate, QuicAlarmFactory& alarm_factory,
- QuicConnectionArena& arena)
- : ack_alarm_(alarm_factory.CreateAlarm(
- arena.New<AckAlarmDelegate>(delegate), &arena)),
- retransmission_alarm_(alarm_factory.CreateAlarm(
- arena.New<RetransmissionAlarmDelegate>(delegate), &arena)),
- send_alarm_(alarm_factory.CreateAlarm(
- arena.New<SendAlarmDelegate>(delegate), &arena)),
- mtu_discovery_alarm_(alarm_factory.CreateAlarm(
- arena.New<MtuDiscoveryAlarmDelegate>(delegate), &arena)),
- process_undecryptable_packets_alarm_(alarm_factory.CreateAlarm(
- arena.New<ProcessUndecryptablePacketsAlarmDelegate>(delegate),
- &arena)),
- discard_previous_one_rtt_keys_alarm_(alarm_factory.CreateAlarm(
- arena.New<DiscardPreviousOneRttKeysAlarmDelegate>(delegate), &arena)),
- discard_zero_rtt_decryption_keys_alarm_(alarm_factory.CreateAlarm(
- arena.New<DiscardZeroRttDecryptionKeysAlarmDelegate>(delegate),
- &arena)),
- multi_port_probing_alarm_(alarm_factory.CreateAlarm(
- arena.New<MultiPortProbingAlarmDelegate>(delegate), &arena)),
- idle_network_detector_alarm_(alarm_factory.CreateAlarm(
- arena.New<IdleDetectorAlarmDelegate>(delegate), &arena)),
- network_blackhole_detector_alarm_(alarm_factory.CreateAlarm(
- arena.New<NetworkBlackholeDetectorAlarmDelegate>(delegate), &arena)),
- ping_alarm_(alarm_factory.CreateAlarm(
- arena.New<PingAlarmDelegate>(delegate), &arena)) {}
-
-QuicConnectionAlarms::QuicConnectionAlarms(
- QuicConnectionAlarmsDelegate* delegate, QuicAlarmFactory& alarm_factory,
- QuicConnectionArena& arena)
- : use_multiplexer_(GetQuicReloadableFlag(quic_use_alarm_multiplexer)) {
- if (use_multiplexer_) {
- multiplexer_.emplace(delegate, arena, alarm_factory);
- } else {
- holder_.emplace(delegate, alarm_factory, arena);
- }
-}
} // namespace quic
diff --git a/quiche/quic/core/quic_connection_alarms.h b/quiche/quic/core/quic_connection_alarms.h
index a8e45d5..31ecbb3 100644
--- a/quiche/quic/core/quic_connection_alarms.h
+++ b/quiche/quic/core/quic_connection_alarms.h
@@ -8,9 +8,7 @@
#include <array>
#include <cstddef>
#include <cstdint>
-#include <optional>
#include <string>
-#include <variant>
#include "absl/base/nullability.h"
#include "quiche/quic/core/quic_alarm.h"
@@ -88,52 +86,6 @@
// alarms that QuicConnection has by reducing all of those alarms to just two.
class QUICHE_EXPORT QuicAlarmMultiplexer {
public:
- // Proxy classes that allow an individual alarm to be accessed via
- // a QuicAlarm-compatible API.
- class AlarmProxy {
- public:
- AlarmProxy(QuicAlarmMultiplexer* multiplexer, QuicAlarmSlot slot)
- : multiplexer_(multiplexer), slot_(slot) {}
-
- bool IsSet() const { return multiplexer_->IsSet(slot_); }
- QuicTime deadline() const { return multiplexer_->GetDeadline(slot_); }
- bool IsPermanentlyCancelled() const {
- return multiplexer_->IsPermanentlyCancelled();
- }
-
- void Set(QuicTime new_deadline) { multiplexer_->Set(slot_, new_deadline); }
- void Update(QuicTime new_deadline, QuicTime::Delta granularity) {
- multiplexer_->Update(slot_, new_deadline, granularity);
- }
- void Cancel() { multiplexer_->Cancel(slot_); }
-
- void PermanentCancel() {}
-
- private:
- friend class ::quic::test::QuicConnectionAlarmsPeer;
-
- QuicAlarmMultiplexer* multiplexer_;
- QuicAlarmSlot slot_;
- };
-
- // Proxy classes that allow an individual alarm to be accessed via
- // a QuicAlarm-compatible API.
- class ConstAlarmProxy {
- public:
- ConstAlarmProxy(const QuicAlarmMultiplexer* multiplexer, QuicAlarmSlot slot)
- : multiplexer_(multiplexer), slot_(slot) {}
-
- bool IsSet() const { return multiplexer_->IsSet(slot_); }
- QuicTime deadline() const { return multiplexer_->GetDeadline(slot_); }
- bool IsPermanentlyCancelled() const {
- return multiplexer_->IsPermanentlyCancelled();
- }
-
- private:
- const QuicAlarmMultiplexer* multiplexer_;
- QuicAlarmSlot slot_;
- };
-
static constexpr size_t kNumberOfSlots =
static_cast<size_t>(QuicAlarmSlot::kSlotCount);
@@ -225,439 +177,34 @@
bool defer_updates_of_underlying_alarms_ = false;
};
-class QUICHE_EXPORT QuicConnectionAlarmHolder {
+// Proxy classes that allow an individual alarm to be accessed via
+// a QuicAlarm-compatible API.
+class QUICHE_EXPORT QuicAlarmProxy {
public:
- // Provides a QuicAlarm-like interface to an alarm contained within
- // QuicConnectionAlarms.
- class AlarmProxy {
- public:
- explicit AlarmProxy(absl::Nonnull<QuicAlarm*> alarm) : alarm_(alarm) {}
+ QuicAlarmProxy(QuicAlarmMultiplexer* multiplexer, QuicAlarmSlot slot)
+ : multiplexer_(multiplexer), slot_(slot) {}
- bool IsSet() const { return alarm_->IsSet(); }
- QuicTime deadline() const { return alarm_->deadline(); }
- bool IsPermanentlyCancelled() const {
- return alarm_->IsPermanentlyCancelled();
- }
+ bool IsSet() const { return multiplexer_->IsSet(slot_); }
+ QuicTime deadline() const { return multiplexer_->GetDeadline(slot_); }
+ bool IsPermanentlyCancelled() const {
+ return multiplexer_->IsPermanentlyCancelled();
+ }
- void Set(QuicTime new_deadline) { alarm_->Set(new_deadline); }
- void Update(QuicTime new_deadline, QuicTime::Delta granularity) {
- alarm_->Update(new_deadline, granularity);
- }
- void Cancel() { alarm_->Cancel(); }
- void PermanentCancel() { alarm_->PermanentCancel(); }
+ void Set(QuicTime new_deadline) { multiplexer_->Set(slot_, new_deadline); }
+ void Update(QuicTime new_deadline, QuicTime::Delta granularity) {
+ multiplexer_->Update(slot_, new_deadline, granularity);
+ }
+ void Cancel() { multiplexer_->Cancel(slot_); }
- private:
- friend class ::quic::test::QuicConnectionAlarmsPeer;
-
- absl::Nonnull<QuicAlarm*> alarm_;
- };
-
- // Provides a QuicAlarm-like interface to an alarm contained within
- // QuicConnectionAlarms.
- class ConstAlarmProxy {
- public:
- explicit ConstAlarmProxy(const QuicAlarm* alarm) : alarm_(alarm) {}
-
- bool IsSet() const { return alarm_->IsSet(); }
- QuicTime deadline() const { return alarm_->deadline(); }
- bool IsPermanentlyCancelled() const {
- return alarm_->IsPermanentlyCancelled();
- }
-
- private:
- friend class ::quic::test::QuicConnectionAlarmsPeer;
-
- const QuicAlarm* alarm_;
- };
-
- QuicConnectionAlarmHolder(QuicConnectionAlarmsDelegate* delegate,
- QuicAlarmFactory& alarm_factory,
- QuicConnectionArena& arena);
-
- AlarmProxy ack_alarm() { return AlarmProxy(ack_alarm_.get()); }
- AlarmProxy retransmission_alarm() {
- return AlarmProxy(retransmission_alarm_.get());
- }
- AlarmProxy send_alarm() { return AlarmProxy(send_alarm_.get()); }
- AlarmProxy mtu_discovery_alarm() {
- return AlarmProxy(mtu_discovery_alarm_.get());
- }
- AlarmProxy process_undecryptable_packets_alarm() {
- return AlarmProxy(process_undecryptable_packets_alarm_.get());
- }
- AlarmProxy discard_previous_one_rtt_keys_alarm() {
- return AlarmProxy(discard_previous_one_rtt_keys_alarm_.get());
- }
- AlarmProxy discard_zero_rtt_decryption_keys_alarm() {
- return AlarmProxy(discard_zero_rtt_decryption_keys_alarm_.get());
- }
- AlarmProxy multi_port_probing_alarm() {
- return AlarmProxy(multi_port_probing_alarm_.get());
- }
- AlarmProxy idle_network_detector_alarm() {
- return AlarmProxy(idle_network_detector_alarm_.get());
- }
- AlarmProxy network_blackhole_detector_alarm() {
- return AlarmProxy(network_blackhole_detector_alarm_.get());
- }
- AlarmProxy ping_alarm() { return AlarmProxy(ping_alarm_.get()); }
-
- ConstAlarmProxy ack_alarm() const {
- return ConstAlarmProxy(ack_alarm_.get());
- }
- ConstAlarmProxy retransmission_alarm() const {
- return ConstAlarmProxy(retransmission_alarm_.get());
- }
- ConstAlarmProxy send_alarm() const {
- return ConstAlarmProxy(send_alarm_.get());
- }
- ConstAlarmProxy mtu_discovery_alarm() const {
- return ConstAlarmProxy(mtu_discovery_alarm_.get());
- }
- ConstAlarmProxy process_undecryptable_packets_alarm() const {
- return ConstAlarmProxy(process_undecryptable_packets_alarm_.get());
- }
- ConstAlarmProxy discard_previous_one_rtt_keys_alarm() const {
- return ConstAlarmProxy(discard_previous_one_rtt_keys_alarm_.get());
- }
- ConstAlarmProxy discard_zero_rtt_decryption_keys_alarm() const {
- return ConstAlarmProxy(discard_zero_rtt_decryption_keys_alarm_.get());
- }
- ConstAlarmProxy multi_port_probing_alarm() const {
- return ConstAlarmProxy(multi_port_probing_alarm_.get());
- }
- ConstAlarmProxy idle_network_detector_alarm() const {
- return ConstAlarmProxy(idle_network_detector_alarm_.get());
- }
- ConstAlarmProxy network_blackhole_detector_alarm() const {
- return ConstAlarmProxy(network_blackhole_detector_alarm_.get());
- }
- ConstAlarmProxy ping_alarm() const {
- return ConstAlarmProxy(ping_alarm_.get());
- }
+ void PermanentCancel() {}
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_;
- // An alarm for QuicIdleNetworkDetector.
- QuicArenaScopedPtr<QuicAlarm> idle_network_detector_alarm_;
- // An alarm for QuicNetworkBlackholeDetection.
- QuicArenaScopedPtr<QuicAlarm> network_blackhole_detector_alarm_;
- // An alarm for QuicPingManager.
- QuicArenaScopedPtr<QuicAlarm> ping_alarm_;
+ friend class ::quic::test::QuicConnectionAlarmsPeer;
+
+ QuicAlarmMultiplexer* multiplexer_;
+ QuicAlarmSlot slot_;
};
-// A class for holding all QuicAlarms belonging to a single connection.
-// Dispatches all calls to either QuicConnectionAlarmHolder of
-// QuicAlarmMultiplexer.
-class QUICHE_EXPORT QuicConnectionAlarms {
- public:
- // Wraps a ConstAlarmProxy provided by either QuicConnectionAlarmHolder or
- // QuicAlarmMultiplexer.
- class ConstAlarmProxy {
- public:
- explicit ConstAlarmProxy(QuicConnectionAlarmHolder::ConstAlarmProxy alarm)
- : alarm_(alarm) {}
- explicit ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy alarm)
- : alarm_(alarm) {}
-
- bool IsSet() const {
- return std::visit([](auto& alarm) { return alarm.IsSet(); }, alarm_);
- }
- QuicTime deadline() const {
- return std::visit([](auto& alarm) { return alarm.deadline(); }, alarm_);
- }
- bool IsPermanentlyCancelled() const {
- return std::visit(
- [](auto& alarm) { return alarm.IsPermanentlyCancelled(); }, alarm_);
- }
-
- private:
- friend class ::quic::test::QuicConnectionAlarmsPeer;
-
- std::variant<QuicConnectionAlarmHolder::ConstAlarmProxy,
- QuicAlarmMultiplexer::ConstAlarmProxy>
- alarm_;
- };
-
- // Wraps an AlarmProxy provided by either QuicConnectionAlarmHolder or
- // QuicAlarmMultiplexer.
- class AlarmProxy {
- public:
- explicit AlarmProxy(QuicConnectionAlarmHolder::AlarmProxy alarm)
- : alarm_(alarm) {}
- explicit AlarmProxy(QuicAlarmMultiplexer::AlarmProxy alarm)
- : alarm_(alarm) {}
-
- bool IsSet() const {
- return std::visit([](auto& alarm) { return alarm.IsSet(); }, alarm_);
- }
- QuicTime deadline() const {
- return std::visit([](auto& alarm) { return alarm.deadline(); }, alarm_);
- }
- bool IsPermanentlyCancelled() const {
- return std::visit(
- [](auto& alarm) { return alarm.IsPermanentlyCancelled(); }, alarm_);
- }
-
- void Set(QuicTime new_deadline) {
- std::visit([&](auto& alarm) { alarm.Set(new_deadline); }, alarm_);
- }
- void Update(QuicTime new_deadline, QuicTime::Delta granularity) {
- std::visit([&](auto& alarm) { alarm.Update(new_deadline, granularity); },
- alarm_);
- }
- void Cancel() {
- std::visit([&](auto& alarm) { alarm.Cancel(); }, alarm_);
- }
- void PermanentCancel() {
- std::visit([&](auto& alarm) { alarm.PermanentCancel(); }, alarm_);
- }
-
- private:
- friend class ::quic::test::QuicConnectionAlarmsPeer;
-
- std::variant<QuicConnectionAlarmHolder::AlarmProxy,
- QuicAlarmMultiplexer::AlarmProxy>
- alarm_;
- };
-
- QuicConnectionAlarms(QuicConnectionAlarmsDelegate* delegate,
- QuicAlarmFactory& alarm_factory,
- QuicConnectionArena& arena);
-
- AlarmProxy ack_alarm() {
- if (use_multiplexer_) {
- return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(&*multiplexer_,
- QuicAlarmSlot::kAck));
- }
- return AlarmProxy(
- QuicConnectionAlarmHolder::AlarmProxy(holder_->ack_alarm()));
- }
- ConstAlarmProxy ack_alarm() const {
- if (use_multiplexer_) {
- return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kAck));
- }
- return ConstAlarmProxy(
- QuicConnectionAlarmHolder::ConstAlarmProxy(holder_->ack_alarm()));
- }
-
- AlarmProxy retransmission_alarm() {
- if (use_multiplexer_) {
- return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kRetransmission));
- }
- return AlarmProxy(
- QuicConnectionAlarmHolder::AlarmProxy(holder_->retransmission_alarm()));
- }
- ConstAlarmProxy retransmission_alarm() const {
- if (use_multiplexer_) {
- return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kRetransmission));
- }
- return ConstAlarmProxy(QuicConnectionAlarmHolder::ConstAlarmProxy(
- holder_->retransmission_alarm()));
- }
-
- AlarmProxy send_alarm() {
- if (use_multiplexer_) {
- return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(&*multiplexer_,
- QuicAlarmSlot::kSend));
- }
- return AlarmProxy(
- QuicConnectionAlarmHolder::AlarmProxy(holder_->send_alarm()));
- }
- ConstAlarmProxy send_alarm() const {
- if (use_multiplexer_) {
- return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kSend));
- }
- return ConstAlarmProxy(
- QuicConnectionAlarmHolder::ConstAlarmProxy(holder_->send_alarm()));
- }
-
- AlarmProxy mtu_discovery_alarm() {
- if (use_multiplexer_) {
- return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kMtuDiscovery));
- }
- return AlarmProxy(
- QuicConnectionAlarmHolder::AlarmProxy(holder_->mtu_discovery_alarm()));
- }
- ConstAlarmProxy mtu_discovery_alarm() const {
- if (use_multiplexer_) {
- return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kMtuDiscovery));
- }
- return ConstAlarmProxy(QuicConnectionAlarmHolder::ConstAlarmProxy(
- holder_->mtu_discovery_alarm()));
- }
-
- AlarmProxy process_undecryptable_packets_alarm() {
- if (use_multiplexer_) {
- return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kProcessUndecryptablePackets));
- }
- return AlarmProxy(QuicConnectionAlarmHolder::AlarmProxy(
- holder_->process_undecryptable_packets_alarm()));
- }
- ConstAlarmProxy process_undecryptable_packets_alarm() const {
- if (use_multiplexer_) {
- return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kProcessUndecryptablePackets));
- }
- return ConstAlarmProxy(QuicConnectionAlarmHolder::ConstAlarmProxy(
- holder_->process_undecryptable_packets_alarm()));
- }
-
- AlarmProxy discard_previous_one_rtt_keys_alarm() {
- if (use_multiplexer_) {
- return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kDiscardPreviousOneRttKeys));
- }
- return AlarmProxy(QuicConnectionAlarmHolder::AlarmProxy(
- holder_->discard_previous_one_rtt_keys_alarm()));
- }
- ConstAlarmProxy discard_previous_one_rtt_keys_alarm() const {
- if (use_multiplexer_) {
- return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kDiscardPreviousOneRttKeys));
- }
- return ConstAlarmProxy(QuicConnectionAlarmHolder::ConstAlarmProxy(
- holder_->discard_previous_one_rtt_keys_alarm()));
- }
-
- AlarmProxy discard_zero_rtt_decryption_keys_alarm() {
- if (use_multiplexer_) {
- return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kDiscardZeroRttDecryptionKeys));
- }
- return AlarmProxy(QuicConnectionAlarmHolder::AlarmProxy(
- holder_->discard_zero_rtt_decryption_keys_alarm()));
- }
- ConstAlarmProxy discard_zero_rtt_decryption_keys_alarm() const {
- if (use_multiplexer_) {
- return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kDiscardZeroRttDecryptionKeys));
- }
- return ConstAlarmProxy(QuicConnectionAlarmHolder::ConstAlarmProxy(
- holder_->discard_zero_rtt_decryption_keys_alarm()));
- }
-
- AlarmProxy multi_port_probing_alarm() {
- if (use_multiplexer_) {
- return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kMultiPortProbing));
- }
- return AlarmProxy(QuicConnectionAlarmHolder::AlarmProxy(
- holder_->multi_port_probing_alarm()));
- }
- ConstAlarmProxy multi_port_probing_alarm() const {
- if (use_multiplexer_) {
- return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kMultiPortProbing));
- }
- return ConstAlarmProxy(QuicConnectionAlarmHolder::ConstAlarmProxy(
- holder_->multi_port_probing_alarm()));
- }
-
- AlarmProxy idle_network_detector_alarm() {
- if (use_multiplexer_) {
- return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kIdleNetworkDetector));
- }
- return AlarmProxy(QuicConnectionAlarmHolder::AlarmProxy(
- holder_->idle_network_detector_alarm()));
- }
- ConstAlarmProxy idle_network_detector_alarm() const {
- if (use_multiplexer_) {
- return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kIdleNetworkDetector));
- }
- return ConstAlarmProxy(QuicConnectionAlarmHolder::ConstAlarmProxy(
- holder_->idle_network_detector_alarm()));
- }
-
- AlarmProxy network_blackhole_detector_alarm() {
- if (use_multiplexer_) {
- return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kNetworkBlackholeDetector));
- }
- return AlarmProxy(QuicConnectionAlarmHolder::AlarmProxy(
- holder_->network_blackhole_detector_alarm()));
- }
- ConstAlarmProxy network_blackhole_detector_alarm() const {
- if (use_multiplexer_) {
- return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kNetworkBlackholeDetector));
- }
- return ConstAlarmProxy(QuicConnectionAlarmHolder::ConstAlarmProxy(
- holder_->network_blackhole_detector_alarm()));
- }
-
- AlarmProxy ping_alarm() {
- if (use_multiplexer_) {
- return AlarmProxy(QuicAlarmMultiplexer::AlarmProxy(&*multiplexer_,
- QuicAlarmSlot::kPing));
- }
- return AlarmProxy(
- QuicConnectionAlarmHolder::AlarmProxy(holder_->ping_alarm()));
- }
- ConstAlarmProxy ping_alarm() const {
- if (use_multiplexer_) {
- return ConstAlarmProxy(QuicAlarmMultiplexer::ConstAlarmProxy(
- &*multiplexer_, QuicAlarmSlot::kPing));
- }
- return ConstAlarmProxy(
- QuicConnectionAlarmHolder::ConstAlarmProxy(holder_->ping_alarm()));
- }
-
- void CancelAllAlarms() {
- if (use_multiplexer_) {
- multiplexer_->CancelAllAlarms();
- }
- }
-
- void DeferUnderlyingAlarmScheduling() {
- if (use_multiplexer_) {
- multiplexer_->DeferUnderlyingAlarmScheduling();
- }
- }
- void ResumeUnderlyingAlarmScheduling() {
- if (use_multiplexer_) {
- multiplexer_->ResumeUnderlyingAlarmScheduling();
- }
- }
-
- private:
- std::optional<QuicConnectionAlarmHolder> holder_;
- std::optional<QuicAlarmMultiplexer> multiplexer_;
- const bool use_multiplexer_;
-};
-
-using QuicAlarmProxy = QuicConnectionAlarms::AlarmProxy;
-using QuicConstAlarmProxy = QuicConnectionAlarms::ConstAlarmProxy;
-
} // namespace quic
#endif // QUICHE_QUIC_CORE_QUIC_CONNECTION_ALARMS_H_
diff --git a/quiche/quic/core/quic_idle_network_detector_test.cc b/quiche/quic/core/quic_idle_network_detector_test.cc
index 458bc27..8896693 100644
--- a/quiche/quic/core/quic_idle_network_detector_test.cc
+++ b/quiche/quic/core/quic_idle_network_detector_test.cc
@@ -35,10 +35,10 @@
class QuicIdleNetworkDetectorTest : public QuicTest {
public:
QuicIdleNetworkDetectorTest()
- : alarms_(&connection_alarms_delegate_, alarm_factory_, arena_),
+ : alarms_(&connection_alarms_delegate_, arena_, alarm_factory_),
+ alarm_(&alarms_, QuicAlarmSlot::kIdleNetworkDetector),
detector_(&delegate_, clock_.Now() + QuicTimeDelta::FromSeconds(1),
- alarms_.idle_network_detector_alarm()),
- alarm_(alarms_.idle_network_detector_alarm()) {
+ alarm_) {
clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
ON_CALL(connection_alarms_delegate_, OnIdleDetectorAlarm())
.WillByDefault([&] { detector_.OnAlarm(); });
@@ -49,10 +49,10 @@
MockConnectionAlarmsDelegate connection_alarms_delegate_;
QuicConnectionArena arena_;
MockAlarmFactory alarm_factory_;
- QuicConnectionAlarms alarms_;
+ QuicAlarmMultiplexer alarms_;
+ QuicTestAlarmProxy alarm_;
MockClock clock_;
QuicIdleNetworkDetector detector_;
- QuicTestAlarmProxy alarm_;
};
TEST_F(QuicIdleNetworkDetectorTest,
diff --git a/quiche/quic/core/quic_network_blackhole_detector_test.cc b/quiche/quic/core/quic_network_blackhole_detector_test.cc
index 7849ff2..5d5d15b 100644
--- a/quiche/quic/core/quic_network_blackhole_detector_test.cc
+++ b/quiche/quic/core/quic_network_blackhole_detector_test.cc
@@ -36,9 +36,9 @@
class QuicNetworkBlackholeDetectorTest : public QuicTest {
public:
QuicNetworkBlackholeDetectorTest()
- : alarms_(&connection_alarms_delegate_, alarm_factory_, arena_),
- detector_(&delegate_, alarms_.network_blackhole_detector_alarm()),
- alarm_(QuicNetworkBlackholeDetectorPeer::GetAlarm(&detector_)),
+ : alarms_(&connection_alarms_delegate_, arena_, alarm_factory_),
+ alarm_(&alarms_, QuicAlarmSlot::kNetworkBlackholeDetector),
+ detector_(&delegate_, alarm_),
path_degrading_delay_(
QuicTime::Delta::FromSeconds(kPathDegradingDelayInSeconds)),
path_mtu_reduction_delay_(
@@ -61,11 +61,11 @@
MockConnectionAlarmsDelegate connection_alarms_delegate_;
QuicConnectionArena arena_;
MockAlarmFactory alarm_factory_;
- QuicConnectionAlarms alarms_;
+ QuicAlarmMultiplexer alarms_;
+ QuicTestAlarmProxy alarm_;
QuicNetworkBlackholeDetector detector_;
- QuicTestAlarmProxy alarm_;
MockClock clock_;
const QuicTime::Delta path_degrading_delay_;
const QuicTime::Delta path_mtu_reduction_delay_;
diff --git a/quiche/quic/core/quic_one_block_arena.h b/quiche/quic/core/quic_one_block_arena.h
index 4dd9ba3..2b28904 100644
--- a/quiche/quic/core/quic_one_block_arena.h
+++ b/quiche/quic/core/quic_one_block_arena.h
@@ -68,9 +68,9 @@
uint32_t offset_;
};
-// QuicConnections currently use around 1KB of polymorphic types which would
+// QuicConnections currently use around 0.5kB of polymorphic types which would
// ordinarily be on the heap. Instead, store them inline in an arena.
-using QuicConnectionArena = QuicOneBlockArena<1380>;
+using QuicConnectionArena = QuicOneBlockArena<320>;
} // namespace quic
diff --git a/quiche/quic/core/quic_ping_manager_test.cc b/quiche/quic/core/quic_ping_manager_test.cc
index 4b82224..e2a3155 100644
--- a/quiche/quic/core/quic_ping_manager_test.cc
+++ b/quiche/quic/core/quic_ping_manager_test.cc
@@ -16,10 +16,6 @@
class QuicPingManagerPeer {
public:
- static QuicAlarmProxy GetAlarm(QuicPingManager* manager) {
- return manager->alarm_;
- }
-
static void SetPerspective(QuicPingManager* manager,
Perspective perspective) {
manager->perspective_ = perspective;
@@ -40,9 +36,9 @@
class QuicPingManagerTest : public QuicTest {
public:
QuicPingManagerTest()
- : alarms_(&connection_alarms_delegate_, alarm_factory_, arena_),
- manager_(Perspective::IS_CLIENT, &delegate_, alarms_.ping_alarm()),
- alarm_(QuicPingManagerPeer::GetAlarm(&manager_)) {
+ : alarms_(&connection_alarms_delegate_, arena_, alarm_factory_),
+ alarm_(&alarms_, QuicAlarmSlot::kPing),
+ manager_(Perspective::IS_CLIENT, &delegate_, alarm_) {
clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
ON_CALL(connection_alarms_delegate_, OnPingAlarm()).WillByDefault([&] {
manager_.OnAlarm();
@@ -55,9 +51,9 @@
MockClock clock_;
QuicConnectionArena arena_;
MockAlarmFactory alarm_factory_;
- QuicConnectionAlarms alarms_;
- QuicPingManager manager_;
+ QuicAlarmMultiplexer alarms_;
QuicTestAlarmProxy alarm_;
+ QuicPingManager manager_;
};
TEST_F(QuicPingManagerTest, KeepAliveTimeout) {
diff --git a/quiche/quic/test_tools/quic_connection_peer.cc b/quiche/quic/test_tools/quic_connection_peer.cc
index e74ae4c..f5428d1 100644
--- a/quiche/quic/test_tools/quic_connection_peer.cc
+++ b/quiche/quic/test_tools/quic_connection_peer.cc
@@ -6,8 +6,6 @@
#include <memory>
#include <string>
-#include <variant>
-
#include "absl/strings/string_view.h"
#include "quiche/quic/core/congestion_control/send_algorithm_interface.h"
@@ -27,16 +25,7 @@
// static
void QuicConnectionAlarmsPeer::Fire(QuicAlarmProxy alarm) {
- struct {
- void operator()(QuicConnectionAlarmHolder::AlarmProxy alarm) {
- auto* real_alarm = static_cast<TestAlarmFactory::TestAlarm*>(alarm.alarm_);
- real_alarm->Fire();
- }
- void operator()(QuicAlarmMultiplexer::AlarmProxy alarm) {
- alarm.multiplexer_->Fire(alarm.slot_);
- }
- } visitor;
- std::visit(visitor, alarm.alarm_);
+ alarm.multiplexer_->Fire(alarm.slot_);
}
// static
@@ -140,47 +129,50 @@
// static
QuicAlarmProxy QuicConnectionPeer::GetAckAlarm(QuicConnection* connection) {
- return connection->alarms_.ack_alarm();
+ return QuicAlarmProxy(&connection->alarms_, QuicAlarmSlot::kAck);
}
// static
QuicAlarmProxy QuicConnectionPeer::GetPingAlarm(QuicConnection* connection) {
- return connection->alarms_.ping_alarm();
+ return QuicAlarmProxy(&connection->alarms_, QuicAlarmSlot::kPing);
}
// static
QuicAlarmProxy QuicConnectionPeer::GetRetransmissionAlarm(
QuicConnection* connection) {
- return connection->alarms_.retransmission_alarm();
+ return QuicAlarmProxy(&connection->alarms_, QuicAlarmSlot::kRetransmission);
}
// static
QuicAlarmProxy QuicConnectionPeer::GetSendAlarm(QuicConnection* connection) {
- return connection->alarms_.send_alarm();
+ return QuicAlarmProxy(&connection->alarms_, QuicAlarmSlot::kSend);
}
// static
QuicAlarmProxy QuicConnectionPeer::GetMtuDiscoveryAlarm(
QuicConnection* connection) {
- return connection->alarms_.mtu_discovery_alarm();
+ return QuicAlarmProxy(&connection->alarms_, QuicAlarmSlot::kMtuDiscovery);
}
// static
QuicAlarmProxy QuicConnectionPeer::GetProcessUndecryptablePacketsAlarm(
QuicConnection* connection) {
- return connection->alarms_.process_undecryptable_packets_alarm();
+ return QuicAlarmProxy(&connection->alarms_,
+ QuicAlarmSlot::kProcessUndecryptablePackets);
}
// static
QuicAlarmProxy QuicConnectionPeer::GetDiscardPreviousOneRttKeysAlarm(
QuicConnection* connection) {
- return connection->alarms_.discard_previous_one_rtt_keys_alarm();
+ return QuicAlarmProxy(&connection->alarms_,
+ QuicAlarmSlot::kDiscardPreviousOneRttKeys);
}
// static
QuicAlarmProxy QuicConnectionPeer::GetDiscardZeroRttDecryptionKeysAlarm(
QuicConnection* connection) {
- return connection->alarms_.discard_zero_rtt_decryption_keys_alarm();
+ return QuicAlarmProxy(&connection->alarms_,
+ QuicAlarmSlot::kDiscardZeroRttDecryptionKeys);
}
// static
@@ -345,7 +337,8 @@
// static
QuicAlarmProxy QuicConnectionPeer::GetBlackholeDetectorAlarm(
QuicConnection* connection) {
- return connection->alarms_.network_blackhole_detector_alarm();
+ return QuicAlarmProxy(&connection->alarms_,
+ QuicAlarmSlot::kNetworkBlackholeDetector);
}
// static
@@ -375,7 +368,8 @@
// static
QuicAlarmProxy QuicConnectionPeer::GetIdleNetworkDetectorAlarm(
QuicConnection* connection) {
- return connection->alarms_.idle_network_detector_alarm();
+ return QuicAlarmProxy(&connection->alarms_,
+ QuicAlarmSlot::kIdleNetworkDetector);
}
// static
@@ -387,7 +381,7 @@
// static
QuicAlarmProxy QuicConnectionPeer::GetMultiPortProbingAlarm(
QuicConnection* connection) {
- return connection->alarms_.multi_port_probing_alarm();
+ return QuicAlarmProxy(&connection->alarms_, QuicAlarmSlot::kMultiPortProbing);
}
// static
diff --git a/quiche/quic/test_tools/quic_connection_peer.h b/quiche/quic/test_tools/quic_connection_peer.h
index 401d86a..06d8c97 100644
--- a/quiche/quic/test_tools/quic_connection_peer.h
+++ b/quiche/quic/test_tools/quic_connection_peer.h
@@ -40,6 +40,8 @@
class QuicTestAlarmProxy : public QuicAlarmProxy {
public:
explicit QuicTestAlarmProxy(QuicAlarmProxy proxy) : QuicAlarmProxy(proxy) {}
+ QuicTestAlarmProxy(QuicAlarmMultiplexer* multiplexer, QuicAlarmSlot slot)
+ : QuicAlarmProxy(multiplexer, slot) {}
void Fire() { QuicConnectionAlarmsPeer::Fire(*this); }
