Refactor QuicConnectionAlarms to take a delegate instead of a QuicConnection.
This will allow QuicConnectionAlarms to be unit-tested by itself.
PiperOrigin-RevId: 639063824
diff --git a/build/source_list.bzl b/build/source_list.bzl
index b04eb4c..f8f6e7e 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl
@@ -797,6 +797,7 @@
"quic/test_tools/mock_clock.h",
"quic/test_tools/mock_connection_id_generator.h",
"quic/test_tools/mock_load_balancer_encoder.h",
+ "quic/test_tools/mock_quic_connection_alarms.h",
"quic/test_tools/mock_quic_dispatcher.h",
"quic/test_tools/mock_quic_session_visitor.h",
"quic/test_tools/mock_quic_spdy_client_stream.h",
diff --git a/build/source_list.gni b/build/source_list.gni
index 9af07f6..f203a7a 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni
@@ -797,6 +797,7 @@
"src/quiche/quic/test_tools/mock_clock.h",
"src/quiche/quic/test_tools/mock_connection_id_generator.h",
"src/quiche/quic/test_tools/mock_load_balancer_encoder.h",
+ "src/quiche/quic/test_tools/mock_quic_connection_alarms.h",
"src/quiche/quic/test_tools/mock_quic_dispatcher.h",
"src/quiche/quic/test_tools/mock_quic_session_visitor.h",
"src/quiche/quic/test_tools/mock_quic_spdy_client_stream.h",
diff --git a/build/source_list.json b/build/source_list.json
index 09f6d11..c5edd4d 100644
--- a/build/source_list.json
+++ b/build/source_list.json
@@ -796,6 +796,7 @@
"quiche/quic/test_tools/mock_clock.h",
"quiche/quic/test_tools/mock_connection_id_generator.h",
"quiche/quic/test_tools/mock_load_balancer_encoder.h",
+ "quiche/quic/test_tools/mock_quic_connection_alarms.h",
"quiche/quic/test_tools/mock_quic_dispatcher.h",
"quiche/quic/test_tools/mock_quic_session_visitor.h",
"quiche/quic/test_tools/mock_quic_spdy_client_stream.h",
diff --git a/quiche/quic/core/quic_connection.cc b/quiche/quic/core/quic_connection.cc
index 81cbbc4..a714349 100644
--- a/quiche/quic/core/quic_connection.cc
+++ b/quiche/quic/core/quic_connection.cc
@@ -183,8 +183,7 @@
pending_retransmission_alarm_(false),
defer_send_in_response_to_packets_(false),
arena_(),
- alarms_(this, &context_, &idle_network_detector_, &blackhole_detector_,
- &ping_manager_, *alarm_factory_, arena_),
+ alarms_(this, *alarm_factory_, arena_),
visitor_(nullptr),
debug_visitor_(nullptr),
packet_creator_(server_connection_id, &framer_, random_generator_, this),
@@ -835,6 +834,13 @@
}
}
+void QuicConnection::OnDiscardZeroRttDecryptionKeysAlarm() {
+ QUICHE_DCHECK(connected());
+ QUIC_DLOG(INFO) << "0-RTT discard alarm fired";
+ RemoveDecrypter(ENCRYPTION_ZERO_RTT);
+ RetireOriginalDestinationConnectionId();
+}
+
bool QuicConnection::ValidateServerConnectionId(
const QuicPacketHeader& header) const {
if (perspective_ == Perspective::IS_CLIENT &&
@@ -2697,7 +2703,10 @@
}
}
-void QuicConnection::OnSendAlarm() { WriteIfNotBlocked(); }
+void QuicConnection::OnSendAlarm() {
+ QUICHE_DCHECK(connected());
+ WriteIfNotBlocked();
+}
void QuicConnection::WriteIfNotBlocked() {
if (framer().is_processing_packet()) {
@@ -3984,6 +3993,17 @@
WritePacket(&packet);
}
+void QuicConnection::OnAckAlarm() {
+ QUICHE_DCHECK(ack_frame_updated());
+ QUICHE_DCHECK(connected());
+ QuicConnection::ScopedPacketFlusher flusher(this);
+ if (SupportsMultiplePacketNumberSpaces()) {
+ SendAllPendingAcks();
+ } else {
+ SendAck();
+ }
+}
+
void QuicConnection::SendAck() {
QUICHE_DCHECK(!SupportsMultiplePacketNumberSpaces());
QUIC_DVLOG(1) << ENDPOINT << "Sending an ACK proactively";
@@ -4057,7 +4077,8 @@
return result;
}
-void QuicConnection::OnRetransmissionTimeout() {
+void QuicConnection::OnRetransmissionAlarm() {
+ QUICHE_DCHECK(connected());
ScopedRetransmissionTimeoutIndicator indicator(this);
#ifndef NDEBUG
if (sent_packet_manager_.unacked_packets().empty()) {
@@ -4258,7 +4279,8 @@
framer_.RemoveDecrypter(level);
}
-void QuicConnection::DiscardPreviousOneRttKeys() {
+void QuicConnection::OnDiscardPreviousOneRttKeysAlarm() {
+ QUICHE_DCHECK(connected());
framer_.DiscardPreviousOneRttKeys();
}
@@ -4313,6 +4335,12 @@
}
}
+void QuicConnection::OnProcessUndecryptablePacketsAlarm() {
+ QUICHE_DCHECK(connected());
+ ScopedPacketFlusher flusher(this);
+ MaybeProcessUndecryptablePackets();
+}
+
void QuicConnection::MaybeProcessUndecryptablePackets() {
process_undecryptable_packets_alarm().Cancel();
@@ -5051,7 +5079,8 @@
mtu_discovery_alarm().Cancel();
}
-void QuicConnection::DiscoverMtu() {
+void QuicConnection::OnMtuDiscoveryAlarm() {
+ QUICHE_DCHECK(connected());
QUICHE_DCHECK(!mtu_discovery_alarm().IsSet());
const QuicPacketNumber largest_sent_packet =
@@ -7317,5 +7346,14 @@
return true;
}
+void QuicConnection::OnIdleDetectorAlarm() { idle_network_detector_.OnAlarm(); }
+
+void QuicConnection::OnPingAlarm() { ping_manager_.OnAlarm(); }
+
+void QuicConnection::OnNetworkBlackholeDetectorAlarm() {
+ blackhole_detector_.OnAlarm();
+}
+
#undef ENDPOINT // undef for jumbo builds
+
} // namespace quic
diff --git a/quiche/quic/core/quic_connection.h b/quiche/quic/core/quic_connection.h
index 0565b1a..91bc01d 100644
--- a/quiche/quic/core/quic_connection.h
+++ b/quiche/quic/core/quic_connection.h
@@ -493,7 +493,8 @@
public QuicIdleNetworkDetector::Delegate,
public QuicPathValidator::SendDelegate,
public QuicConnectionIdManagerVisitorInterface,
- public QuicPingManager::Delegate {
+ public QuicPingManager::Delegate,
+ public QuicConnectionAlarmsDelegate {
public:
// Constructs a new QuicConnection for |connection_id| and
// |initial_peer_address| using |writer| to write packets. |owns_writer|
@@ -638,7 +639,7 @@
bool IsMsgTooBig(const QuicPacketWriter* writer, const WriteResult& result);
// Called from the SendAlarmDelegate to initiate writing data.
- virtual void OnSendAlarm();
+ void OnSendAlarm() override;
// If the socket is not blocked, writes queued packets.
void WriteIfNotBlocked();
@@ -802,7 +803,7 @@
// Probe the existing alternative path. Does not create a new alternative
// path. This method is the callback for |multi_port_probing_alarm_|.
- virtual void MaybeProbeMultiPortPath();
+ void MaybeProbeMultiPortPath() override;
// Accessors
void set_visitor(QuicConnectionVisitorInterface* visitor) {
@@ -874,12 +875,14 @@
return multi_port_stats_.get();
}
+ void OnAckAlarm() override;
+
// Sets up a packet with an QuicAckFrame and sends it out.
void SendAck();
// Called when an RTO fires. Resets the retransmission alarm if there are
// remaining unacked packets.
- void OnRetransmissionTimeout();
+ void OnRetransmissionAlarm() override;
// Mark all sent 0-RTT encrypted packets for retransmission. Called when new
// 0-RTT or 1-RTT key is available in gQUIC, or when 0-RTT is rejected in IETF
@@ -929,7 +932,7 @@
void RemoveDecrypter(EncryptionLevel level);
// Discard keys for the previous key phase.
- void DiscardPreviousOneRttKeys();
+ void OnDiscardPreviousOneRttKeysAlarm() override;
// Returns true if it is currently allowed to initiate a key update.
bool IsKeyUpdateAllowed() const;
@@ -1023,7 +1026,7 @@
void DisableMtuDiscovery();
// Sends an MTU discovery packet and updates the MTU discovery alarm.
- void DiscoverMtu();
+ void OnMtuDiscoveryAlarm() override;
// Sets the session notifier on the SentPacketManager.
void SetSessionNotifier(SessionNotifierInterface* session_notifier);
@@ -1119,6 +1122,7 @@
// Attempts to process any queued undecryptable packets.
void MaybeProcessUndecryptablePackets();
+ void OnProcessUndecryptablePacketsAlarm() override;
// Queue a coalesced packet.
void QueueCoalescedPacket(const QuicEncryptedPacket& packet);
@@ -1285,7 +1289,7 @@
// Log QUIC_BUG if there is pending frames for the stream with |id|.
void QuicBugIfHasPendingFrames(QuicStreamId id) const;
- QuicConnectionContext* context() { return &context_; }
+ QuicConnectionContext* context() override { return &context_; }
const QuicConnectionContext* context() const { return &context_; }
void set_tracer(std::unique_ptr<QuicConnectionTracer> tracer) {
@@ -1363,6 +1367,11 @@
return quic_limit_new_streams_per_loop_2_;
}
+ void OnDiscardZeroRttDecryptionKeysAlarm() override;
+ void OnIdleDetectorAlarm() override;
+ void OnNetworkBlackholeDetectorAlarm() override;
+ void OnPingAlarm() override;
+
protected:
// Calls cancel() on all the alarms owned by this connection.
void CancelAllAlarms();
diff --git a/quiche/quic/core/quic_connection_alarms.cc b/quiche/quic/core/quic_connection_alarms.cc
index 64cd62f..347ede0 100644
--- a/quiche/quic/core/quic_connection_alarms.cc
+++ b/quiche/quic/core/quic_connection_alarms.cc
@@ -6,12 +6,8 @@
#include "quiche/quic/core/quic_alarm.h"
#include "quiche/quic/core/quic_alarm_factory.h"
-#include "quiche/quic/core/quic_connection.h"
#include "quiche/quic/core/quic_connection_context.h"
-#include "quiche/quic/core/quic_idle_network_detector.h"
-#include "quiche/quic/core/quic_network_blackhole_detector.h"
#include "quiche/quic/core/quic_one_block_arena.h"
-#include "quiche/quic/core/quic_ping_manager.h"
#include "quiche/common/platform/api/quiche_logging.h"
namespace quic {
@@ -21,7 +17,7 @@
// Base class of all alarms owned by a QuicConnection.
class QuicConnectionAlarmDelegate : public QuicAlarm::Delegate {
public:
- explicit QuicConnectionAlarmDelegate(QuicConnection* connection)
+ explicit QuicConnectionAlarmDelegate(QuicConnectionAlarmsDelegate* connection)
: connection_(connection) {}
QuicConnectionAlarmDelegate(const QuicConnectionAlarmDelegate&) = delete;
QuicConnectionAlarmDelegate& operator=(const QuicConnectionAlarmDelegate&) =
@@ -32,7 +28,7 @@
}
protected:
- QuicConnection* connection_;
+ QuicConnectionAlarmsDelegate* connection_;
};
// An alarm that is scheduled to send an ack if a timeout occurs.
@@ -40,16 +36,7 @@
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();
- }
- }
+ void OnAlarm() override { connection_->OnAckAlarm(); }
};
// This alarm will be scheduled any time a data-bearing packet is sent out.
@@ -59,10 +46,7 @@
public:
using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
- void OnAlarm() override {
- QUICHE_DCHECK(connection_->connected());
- connection_->OnRetransmissionTimeout();
- }
+ void OnAlarm() override { connection_->OnRetransmissionAlarm(); }
};
// An alarm that is scheduled when the SentPacketManager requires a delay
@@ -72,7 +56,6 @@
using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
void OnAlarm() override {
- QUICHE_DCHECK(connection_->connected());
connection_->OnSendAlarm();
}
};
@@ -81,10 +64,7 @@
public:
using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
- void OnAlarm() override {
- QUICHE_DCHECK(connection_->connected());
- connection_->DiscoverMtu();
- }
+ void OnAlarm() override { connection_->OnMtuDiscoveryAlarm(); }
};
class ProcessUndecryptablePacketsAlarmDelegate
@@ -92,11 +72,7 @@
public:
using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
- void OnAlarm() override {
- QUICHE_DCHECK(connection_->connected());
- QuicConnection::ScopedPacketFlusher flusher(connection_);
- connection_->MaybeProcessUndecryptablePackets();
- }
+ void OnAlarm() override { connection_->OnProcessUndecryptablePacketsAlarm(); }
};
class DiscardPreviousOneRttKeysAlarmDelegate
@@ -104,10 +80,7 @@
public:
using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
- void OnAlarm() override {
- QUICHE_DCHECK(connection_->connected());
- connection_->DiscardPreviousOneRttKeys();
- }
+ void OnAlarm() override { connection_->OnDiscardPreviousOneRttKeysAlarm(); }
};
class DiscardZeroRttDecryptionKeysAlarmDelegate
@@ -116,10 +89,7 @@
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();
+ connection_->OnDiscardZeroRttDecryptionKeysAlarm();
}
};
@@ -128,93 +98,73 @@
using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
void OnAlarm() override {
- QUICHE_DCHECK(connection_->connected());
QUIC_DLOG(INFO) << "Alternative path probing alarm fired";
connection_->MaybeProbeMultiPortPath();
}
};
-class IdleDetectorAlarmDelegate : public QuicAlarm::DelegateWithContext {
+class IdleDetectorAlarmDelegate : public QuicConnectionAlarmDelegate {
public:
- explicit IdleDetectorAlarmDelegate(QuicIdleNetworkDetector* detector,
- QuicConnectionContext* context)
- : QuicAlarm::DelegateWithContext(context), detector_(detector) {}
+ using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
+
IdleDetectorAlarmDelegate(const IdleDetectorAlarmDelegate&) = delete;
IdleDetectorAlarmDelegate& operator=(const IdleDetectorAlarmDelegate&) =
delete;
- void OnAlarm() override { detector_->OnAlarm(); }
-
- private:
- QuicIdleNetworkDetector* detector_;
+ void OnAlarm() override { connection_->OnIdleDetectorAlarm(); }
};
class NetworkBlackholeDetectorAlarmDelegate
- : public QuicAlarm::DelegateWithContext {
+ : public QuicConnectionAlarmDelegate {
public:
- explicit NetworkBlackholeDetectorAlarmDelegate(
- QuicNetworkBlackholeDetector* detector, QuicConnectionContext* context)
- : QuicAlarm::DelegateWithContext(context), detector_(detector) {}
+ using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
+
NetworkBlackholeDetectorAlarmDelegate(
const NetworkBlackholeDetectorAlarmDelegate&) = delete;
NetworkBlackholeDetectorAlarmDelegate& operator=(
const NetworkBlackholeDetectorAlarmDelegate&) = delete;
- void OnAlarm() override { detector_->OnAlarm(); }
-
- private:
- QuicNetworkBlackholeDetector* detector_;
+ void OnAlarm() override { connection_->OnNetworkBlackholeDetectorAlarm(); }
};
-class PingAlarmDelegate : public QuicAlarm::DelegateWithContext {
+class PingAlarmDelegate : public QuicConnectionAlarmDelegate {
public:
- explicit PingAlarmDelegate(QuicPingManager* ping_manager,
- QuicConnectionContext* context)
- : QuicAlarm::DelegateWithContext(context), ping_manager_(ping_manager) {}
+ using QuicConnectionAlarmDelegate::QuicConnectionAlarmDelegate;
+
PingAlarmDelegate(const PingAlarmDelegate&) = delete;
PingAlarmDelegate& operator=(const PingAlarmDelegate&) = delete;
- void OnAlarm() override { ping_manager_->OnAlarm(); }
-
- private:
- QuicPingManager* ping_manager_;
+ void OnAlarm() override { connection_->OnPingAlarm(); }
};
} // namespace
QuicConnectionAlarms::QuicConnectionAlarms(
- QuicConnection* connection, QuicConnectionContext* context,
- QuicIdleNetworkDetector* idle_network_detector,
- QuicNetworkBlackholeDetector* network_blackhole_detector,
- QuicPingManager* ping_manager, QuicAlarmFactory& alarm_factory,
+ QuicConnectionAlarmsDelegate* delegate, QuicAlarmFactory& alarm_factory,
QuicConnectionArena& arena)
: ack_alarm_(alarm_factory.CreateAlarm(
- arena.New<AckAlarmDelegate>(connection), &arena)),
+ arena.New<AckAlarmDelegate>(delegate), &arena)),
retransmission_alarm_(alarm_factory.CreateAlarm(
- arena.New<RetransmissionAlarmDelegate>(connection), &arena)),
+ arena.New<RetransmissionAlarmDelegate>(delegate), &arena)),
send_alarm_(alarm_factory.CreateAlarm(
- arena.New<SendAlarmDelegate>(connection), &arena)),
+ arena.New<SendAlarmDelegate>(delegate), &arena)),
mtu_discovery_alarm_(alarm_factory.CreateAlarm(
- arena.New<MtuDiscoveryAlarmDelegate>(connection), &arena)),
+ arena.New<MtuDiscoveryAlarmDelegate>(delegate), &arena)),
process_undecryptable_packets_alarm_(alarm_factory.CreateAlarm(
- arena.New<ProcessUndecryptablePacketsAlarmDelegate>(connection),
+ arena.New<ProcessUndecryptablePacketsAlarmDelegate>(delegate),
&arena)),
discard_previous_one_rtt_keys_alarm_(alarm_factory.CreateAlarm(
- arena.New<DiscardPreviousOneRttKeysAlarmDelegate>(connection),
- &arena)),
+ arena.New<DiscardPreviousOneRttKeysAlarmDelegate>(delegate), &arena)),
discard_zero_rtt_decryption_keys_alarm_(alarm_factory.CreateAlarm(
- arena.New<DiscardZeroRttDecryptionKeysAlarmDelegate>(connection),
+ arena.New<DiscardZeroRttDecryptionKeysAlarmDelegate>(delegate),
&arena)),
multi_port_probing_alarm_(alarm_factory.CreateAlarm(
- arena.New<MultiPortProbingAlarmDelegate>(connection), &arena)),
+ arena.New<MultiPortProbingAlarmDelegate>(delegate), &arena)),
idle_network_detector_alarm_(alarm_factory.CreateAlarm(
- arena.New<IdleDetectorAlarmDelegate>(idle_network_detector, context),
- &arena)),
+ arena.New<IdleDetectorAlarmDelegate>(delegate), &arena)),
network_blackhole_detector_alarm_(alarm_factory.CreateAlarm(
- arena.New<NetworkBlackholeDetectorAlarmDelegate>(
- network_blackhole_detector, context),
- &arena)),
+ arena.New<NetworkBlackholeDetectorAlarmDelegate>(delegate), &arena)),
ping_alarm_(alarm_factory.CreateAlarm(
- arena.New<PingAlarmDelegate>(ping_manager, context), &arena)) {}
+ arena.New<PingAlarmDelegate>(delegate), &arena)) {}
} // namespace quic
diff --git a/quiche/quic/core/quic_connection_alarms.h b/quiche/quic/core/quic_connection_alarms.h
index 303da24..b265fa1 100644
--- a/quiche/quic/core/quic_connection_alarms.h
+++ b/quiche/quic/core/quic_connection_alarms.h
@@ -9,22 +9,33 @@
#include "quiche/quic/core/quic_alarm_factory.h"
#include "quiche/quic/core/quic_arena_scoped_ptr.h"
#include "quiche/quic/core/quic_connection_context.h"
-#include "quiche/quic/core/quic_idle_network_detector.h"
-#include "quiche/quic/core/quic_network_blackhole_detector.h"
#include "quiche/quic/core/quic_one_block_arena.h"
-#include "quiche/quic/core/quic_ping_manager.h"
+#include "quiche/common/platform/api/quiche_export.h"
namespace quic {
-class QuicConnection;
+class QUICHE_EXPORT QuicConnectionAlarmsDelegate {
+ public:
+ virtual ~QuicConnectionAlarmsDelegate() = default;
+
+ virtual void OnSendAlarm() = 0;
+ virtual void OnAckAlarm() = 0;
+ virtual void OnRetransmissionAlarm() = 0;
+ virtual void OnMtuDiscoveryAlarm() = 0;
+ virtual void OnProcessUndecryptablePacketsAlarm() = 0;
+ virtual void OnDiscardPreviousOneRttKeysAlarm() = 0;
+ virtual void OnDiscardZeroRttDecryptionKeysAlarm() = 0;
+ virtual void MaybeProbeMultiPortPath() = 0;
+ virtual void OnIdleDetectorAlarm() = 0;
+ virtual void OnNetworkBlackholeDetectorAlarm() = 0;
+ virtual void OnPingAlarm() = 0;
+
+ virtual QuicConnectionContext* context() = 0;
+};
class QUICHE_EXPORT QuicConnectionAlarms {
public:
- QuicConnectionAlarms(QuicConnection* connection,
- QuicConnectionContext* context,
- QuicIdleNetworkDetector* idle_network_detector,
- QuicNetworkBlackholeDetector* network_blackhole_detector,
- QuicPingManager* ping_manager,
+ QuicConnectionAlarms(QuicConnectionAlarmsDelegate* delegate,
QuicAlarmFactory& alarm_factory,
QuicConnectionArena& arena);
diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc
index 22adb22..decb72d 100644
--- a/quiche/quic/core/quic_connection_test.cc
+++ b/quiche/quic/core/quic_connection_test.cc
@@ -17370,11 +17370,11 @@
QuicPacketCreatorPeer::SetPacketNumber(
QuicConnectionPeer::GetPacketCreator(&connection_), 1);
SendPing();
- connection_.OnRetransmissionTimeout();
+ connection_.OnRetransmissionAlarm();
EXPECT_EQ(writer_->last_ecn_sent(), ECN_NOT_ECT);
EXPECT_EQ(connection_.ecn_codepoint(), ECN_ECT1);
// On 2nd RTO, QUIC abandons ECN.
- connection_.OnRetransmissionTimeout();
+ connection_.OnRetransmissionAlarm();
EXPECT_EQ(writer_->last_ecn_sent(), ECN_NOT_ECT);
EXPECT_EQ(connection_.ecn_codepoint(), ECN_NOT_ECT);
}
@@ -17388,11 +17388,11 @@
connection_.OnInFlightEcnPacketAcked();
SendPing();
// Because an ECN packet was acked, PTOs have no effect on ECN settings.
- connection_.OnRetransmissionTimeout();
+ connection_.OnRetransmissionAlarm();
QuicEcnCodepoint expected_codepoint = ECN_ECT1;
EXPECT_EQ(writer_->last_ecn_sent(), expected_codepoint);
EXPECT_EQ(connection_.ecn_codepoint(), expected_codepoint);
- connection_.OnRetransmissionTimeout();
+ connection_.OnRetransmissionAlarm();
EXPECT_EQ(writer_->last_ecn_sent(), expected_codepoint);
EXPECT_EQ(connection_.ecn_codepoint(), expected_codepoint);
}
diff --git a/quiche/quic/core/quic_idle_network_detector_test.cc b/quiche/quic/core/quic_idle_network_detector_test.cc
index 6b5bfa8..d34d8cb 100644
--- a/quiche/quic/core/quic_idle_network_detector_test.cc
+++ b/quiche/quic/core/quic_idle_network_detector_test.cc
@@ -10,6 +10,7 @@
#include "quiche/quic/platform/api/quic_expect_bug.h"
#include "quiche/quic/platform/api/quic_flags.h"
#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/quic/test_tools/mock_quic_connection_alarms.h"
#include "quiche/quic/test_tools/quic_test_utils.h"
namespace quic {
@@ -33,17 +34,19 @@
class QuicIdleNetworkDetectorTest : public QuicTest {
public:
QuicIdleNetworkDetectorTest()
- : alarms_(nullptr, nullptr, &detector_, nullptr, nullptr, alarm_factory_,
- arena_),
+ : alarms_(&connection_alarms_delegate_, alarm_factory_, arena_),
detector_(&delegate_, clock_.Now() + QuicTimeDelta::FromSeconds(1),
&alarms_.idle_network_detector_alarm()) {
clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
alarm_ = static_cast<MockAlarmFactory::TestAlarm*>(
&alarms_.idle_network_detector_alarm());
+ ON_CALL(connection_alarms_delegate_, OnIdleDetectorAlarm())
+ .WillByDefault([&] { detector_.OnAlarm(); });
}
protected:
testing::StrictMock<MockDelegate> delegate_;
+ MockConnectionAlarmsDelegate connection_alarms_delegate_;
QuicConnectionArena arena_;
MockAlarmFactory alarm_factory_;
QuicConnectionAlarms alarms_;
diff --git a/quiche/quic/core/quic_network_blackhole_detector_test.cc b/quiche/quic/core/quic_network_blackhole_detector_test.cc
index b43796c3..cad8534 100644
--- a/quiche/quic/core/quic_network_blackhole_detector_test.cc
+++ b/quiche/quic/core/quic_network_blackhole_detector_test.cc
@@ -7,6 +7,7 @@
#include "quiche/quic/core/quic_connection_alarms.h"
#include "quiche/quic/core/quic_one_block_arena.h"
#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/quic/test_tools/mock_quic_connection_alarms.h"
#include "quiche/quic/test_tools/quic_test_utils.h"
namespace quic {
@@ -34,8 +35,7 @@
class QuicNetworkBlackholeDetectorTest : public QuicTest {
public:
QuicNetworkBlackholeDetectorTest()
- : alarms_(nullptr, nullptr, nullptr, &detector_, nullptr, alarm_factory_,
- arena_),
+ : alarms_(&connection_alarms_delegate_, alarm_factory_, arena_),
detector_(&delegate_, &alarms_.network_blackhole_detector_alarm()),
alarm_(static_cast<MockAlarmFactory::TestAlarm*>(
QuicNetworkBlackholeDetectorPeer::GetAlarm(&detector_))),
@@ -46,6 +46,8 @@
blackhole_delay_(
QuicTime::Delta::FromSeconds(kBlackholeDelayInSeconds)) {
clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
+ ON_CALL(connection_alarms_delegate_, OnNetworkBlackholeDetectorAlarm())
+ .WillByDefault([&] { detector_.OnAlarm(); });
}
protected:
@@ -56,6 +58,7 @@
}
testing::StrictMock<MockDelegate> delegate_;
+ MockConnectionAlarmsDelegate connection_alarms_delegate_;
QuicConnectionArena arena_;
MockAlarmFactory alarm_factory_;
QuicConnectionAlarms alarms_;
diff --git a/quiche/quic/core/quic_ping_manager_test.cc b/quiche/quic/core/quic_ping_manager_test.cc
index cc193b4..fa65054 100644
--- a/quiche/quic/core/quic_ping_manager_test.cc
+++ b/quiche/quic/core/quic_ping_manager_test.cc
@@ -7,6 +7,7 @@
#include "quiche/quic/core/quic_connection_alarms.h"
#include "quiche/quic/core/quic_one_block_arena.h"
#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/quic/test_tools/mock_quic_connection_alarms.h"
#include "quiche/quic/test_tools/quic_test_utils.h"
namespace quic {
@@ -38,16 +39,19 @@
class QuicPingManagerTest : public QuicTest {
public:
QuicPingManagerTest()
- : alarms_(nullptr, nullptr, nullptr, nullptr, &manager_, alarm_factory_,
- arena_),
+ : alarms_(&connection_alarms_delegate_, alarm_factory_, arena_),
manager_(Perspective::IS_CLIENT, &delegate_, &alarms_.ping_alarm()),
alarm_(static_cast<MockAlarmFactory::TestAlarm*>(
QuicPingManagerPeer::GetAlarm(&manager_))) {
clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
+ ON_CALL(connection_alarms_delegate_, OnPingAlarm()).WillByDefault([&] {
+ manager_.OnAlarm();
+ });
}
protected:
testing::StrictMock<MockDelegate> delegate_;
+ MockConnectionAlarmsDelegate connection_alarms_delegate_;
MockClock clock_;
QuicConnectionArena arena_;
MockAlarmFactory alarm_factory_;
diff --git a/quiche/quic/test_tools/mock_quic_connection_alarms.h b/quiche/quic/test_tools/mock_quic_connection_alarms.h
new file mode 100644
index 0000000..702cb8e
--- /dev/null
+++ b/quiche/quic/test_tools/mock_quic_connection_alarms.h
@@ -0,0 +1,32 @@
+// 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_TEST_TOOLS_MOCK_QUIC_CONNECTION_ALARMS_H_
+#define QUICHE_QUIC_TEST_TOOLS_MOCK_QUIC_CONNECTION_ALARMS_H_
+
+#include "quiche/quic/core/quic_connection_alarms.h"
+#include "quiche/quic/platform/api/quic_test.h"
+
+namespace quic::test {
+
+class MockConnectionAlarmsDelegate : public QuicConnectionAlarmsDelegate {
+ public:
+ MOCK_METHOD(void, OnSendAlarm, (), (override));
+ MOCK_METHOD(void, OnAckAlarm, (), (override));
+ MOCK_METHOD(void, OnRetransmissionAlarm, (), (override));
+ MOCK_METHOD(void, OnMtuDiscoveryAlarm, (), (override));
+ MOCK_METHOD(void, OnProcessUndecryptablePacketsAlarm, (), (override));
+ MOCK_METHOD(void, OnDiscardPreviousOneRttKeysAlarm, (), (override));
+ MOCK_METHOD(void, OnDiscardZeroRttDecryptionKeysAlarm, (), (override));
+ MOCK_METHOD(void, MaybeProbeMultiPortPath, (), (override));
+ MOCK_METHOD(void, OnIdleDetectorAlarm, (), (override));
+ MOCK_METHOD(void, OnNetworkBlackholeDetectorAlarm, (), (override));
+ MOCK_METHOD(void, OnPingAlarm, (), (override));
+
+ QuicConnectionContext* context() override { return nullptr; }
+};
+
+} // namespace quic::test
+
+#endif // QUICHE_QUIC_TEST_TOOLS_MOCK_QUIC_CONNECTION_ALARMS_H_
