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_