Replace direct pointers and references to QuicAlarms with a QuicAlarmProxy
This will be used in the multiplexer code, where there is no QuicAlarm corresponding to any individual alarm.
PiperOrigin-RevId: 689906296
diff --git a/quiche/quic/core/quic_connection.cc b/quiche/quic/core/quic_connection.cc
index 843ef84..c2f8412 100644
--- a/quiche/quic/core/quic_connection.cc
+++ b/quiche/quic/core/quic_connection.cc
@@ -211,12 +211,12 @@
processing_ack_frame_(false),
supports_release_time_(false),
release_time_into_future_(QuicTime::Delta::Zero()),
- blackhole_detector_(this, &alarms_.network_blackhole_detector_alarm()),
+ blackhole_detector_(this, alarms_.network_blackhole_detector_alarm()),
idle_network_detector_(this, clock_->ApproximateNow(),
- &alarms_.idle_network_detector_alarm()),
+ alarms_.idle_network_detector_alarm()),
path_validator_(alarm_factory_, &arena_, this, random_generator_, clock_,
&context_),
- ping_manager_(perspective, this, &alarms_.ping_alarm()),
+ ping_manager_(perspective, this, alarms_.ping_alarm()),
multi_port_probing_interval_(kDefaultMultiPortProbingInterval),
connection_id_generator_(generator),
received_client_addresses_cache_(kMaxReceivedClientAddressSize) {
diff --git a/quiche/quic/core/quic_connection.h b/quiche/quic/core/quic_connection.h
index cbb587e..f21bc78 100644
--- a/quiche/quic/core/quic_connection.h
+++ b/quiche/quic/core/quic_connection.h
@@ -2157,40 +2157,43 @@
void GenerateNewOutgoingFlowLabel();
- 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 {
+ QuicAlarmProxy ack_alarm() { return alarms_.ack_alarm(); }
+ QuicAlarmProxy retransmission_alarm() {
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() {
+ QuicAlarmProxy send_alarm() { return alarms_.send_alarm(); }
+ QuicAlarmProxy mtu_discovery_alarm() { return alarms_.mtu_discovery_alarm(); }
+ QuicAlarmProxy 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() {
+ QuicAlarmProxy 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() {
+ QuicAlarmProxy 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() {
+ QuicAlarmProxy multi_port_probing_alarm() {
return alarms_.multi_port_probing_alarm();
}
- const QuicAlarm& multi_port_probing_alarm() const {
+
+ 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();
}
diff --git a/quiche/quic/core/quic_connection_alarms.h b/quiche/quic/core/quic_connection_alarms.h
index b265fa1..4a40ccf 100644
--- a/quiche/quic/core/quic_connection_alarms.h
+++ b/quiche/quic/core/quic_connection_alarms.h
@@ -5,11 +5,13 @@
#ifndef QUICHE_QUIC_CORE_QUIC_CONNECTION_ALARMS_H_
#define QUICHE_QUIC_CORE_QUIC_CONNECTION_ALARMS_H_
+#include "absl/base/nullability.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_connection_context.h"
#include "quiche/quic/core/quic_one_block_arena.h"
+#include "quiche/quic/core/quic_time.h"
#include "quiche/common/platform/api/quiche_export.h"
namespace quic {
@@ -33,59 +35,117 @@
virtual QuicConnectionContext* context() = 0;
};
+namespace test {
+class QuicConnectionAlarmsPeer;
+}
+
class QUICHE_EXPORT QuicConnectionAlarms {
public:
+ // Provides a QuicAlarm-like interface to an alarm contained within
+ // QuicConnectionAlarms.
+ class AlarmProxy {
+ public:
+ explicit AlarmProxy(absl::Nonnull<QuicAlarm*> alarm) : alarm_(alarm) {}
+
+ bool IsSet() const { return alarm_->IsSet(); }
+ QuicTime deadline() const { return alarm_->deadline(); }
+ bool IsPermanentlyCancelled() const {
+ return alarm_->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(); }
+
+ private:
+ friend class ::quic::test::QuicConnectionAlarmsPeer;
+
+ absl::Nonnull<QuicAlarm*> alarm_;
+ };
+ 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_;
+ };
+
QuicConnectionAlarms(QuicConnectionAlarmsDelegate* delegate,
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_;
+ AlarmProxy ack_alarm() { return AlarmProxy(ack_alarm_.get()); }
+ AlarmProxy retransmission_alarm() {
+ return AlarmProxy(retransmission_alarm_.get());
}
- QuicAlarm& discard_previous_one_rtt_keys_alarm() {
- return *discard_previous_one_rtt_keys_alarm_;
+ AlarmProxy send_alarm() { return AlarmProxy(send_alarm_.get()); }
+ AlarmProxy mtu_discovery_alarm() {
+ return AlarmProxy(mtu_discovery_alarm_.get());
}
- QuicAlarm& discard_zero_rtt_decryption_keys_alarm() {
- return *discard_zero_rtt_decryption_keys_alarm_;
+ AlarmProxy process_undecryptable_packets_alarm() {
+ return AlarmProxy(process_undecryptable_packets_alarm_.get());
}
- QuicAlarm& multi_port_probing_alarm() { return *multi_port_probing_alarm_; }
- QuicAlarm& idle_network_detector_alarm() {
- return *idle_network_detector_alarm_;
+ AlarmProxy discard_previous_one_rtt_keys_alarm() {
+ return AlarmProxy(discard_previous_one_rtt_keys_alarm_.get());
}
- QuicAlarm& network_blackhole_detector_alarm() {
- return *network_blackhole_detector_alarm_;
+ AlarmProxy discard_zero_rtt_decryption_keys_alarm() {
+ return AlarmProxy(discard_zero_rtt_decryption_keys_alarm_.get());
}
- QuicAlarm& ping_alarm() { return *ping_alarm_; }
+ 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()); }
- const QuicAlarm& ack_alarm() const { return *ack_alarm_; }
- const QuicAlarm& retransmission_alarm() const {
- return *retransmission_alarm_;
+ ConstAlarmProxy ack_alarm() const {
+ return ConstAlarmProxy(ack_alarm_.get());
}
- 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_;
+ ConstAlarmProxy retransmission_alarm() const {
+ return ConstAlarmProxy(retransmission_alarm_.get());
}
- const QuicAlarm& discard_previous_one_rtt_keys_alarm() const {
- return *discard_previous_one_rtt_keys_alarm_;
+ ConstAlarmProxy send_alarm() const {
+ return ConstAlarmProxy(send_alarm_.get());
}
- const QuicAlarm& discard_zero_rtt_decryption_keys_alarm() const {
- return *discard_zero_rtt_decryption_keys_alarm_;
+ ConstAlarmProxy mtu_discovery_alarm() const {
+ return ConstAlarmProxy(mtu_discovery_alarm_.get());
}
- const QuicAlarm& multi_port_probing_alarm() const {
- return *multi_port_probing_alarm_;
+ ConstAlarmProxy process_undecryptable_packets_alarm() const {
+ return ConstAlarmProxy(process_undecryptable_packets_alarm_.get());
}
- const QuicAlarm& idle_network_detector_alarm() const {
- return *idle_network_detector_alarm_;
+ ConstAlarmProxy discard_previous_one_rtt_keys_alarm() const {
+ return ConstAlarmProxy(discard_previous_one_rtt_keys_alarm_.get());
}
- const QuicAlarm& network_blackhole_detector_alarm() const {
- return *network_blackhole_detector_alarm_;
+ ConstAlarmProxy discard_zero_rtt_decryption_keys_alarm() const {
+ return ConstAlarmProxy(discard_zero_rtt_decryption_keys_alarm_.get());
}
- const QuicAlarm& ping_alarm() const { return *ping_alarm_; }
+ 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());
+ }
private:
// An alarm that fires when an ACK should be sent to the peer.
@@ -117,6 +177,9 @@
QuicArenaScopedPtr<QuicAlarm> ping_alarm_;
};
+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_connection_test.cc b/quiche/quic/core/quic_connection_test.cc
index ae219f3..9d5a937 100644
--- a/quiche/quic/core/quic_connection_test.cc
+++ b/quiche/quic/core/quic_connection_test.cc
@@ -427,54 +427,49 @@
.WillRepeatedly(Return(QuicBandwidth::Infinite()));
}
- TestAlarmFactory::TestAlarm* GetAckAlarm() {
- return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- &QuicConnectionPeer::GetAckAlarm(this));
+ QuicTestAlarmProxy GetAckAlarm() {
+ return QuicTestAlarmProxy(QuicConnectionPeer::GetAckAlarm(this));
}
- TestAlarmFactory::TestAlarm* GetPingAlarm() {
- return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- &QuicConnectionPeer::GetPingAlarm(this));
+ QuicTestAlarmProxy GetPingAlarm() {
+ return QuicTestAlarmProxy(QuicConnectionPeer::GetPingAlarm(this));
}
- TestAlarmFactory::TestAlarm* GetRetransmissionAlarm() {
- return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- &QuicConnectionPeer::GetRetransmissionAlarm(this));
+ QuicTestAlarmProxy GetRetransmissionAlarm() {
+ return QuicTestAlarmProxy(QuicConnectionPeer::GetRetransmissionAlarm(this));
}
- TestAlarmFactory::TestAlarm* GetSendAlarm() {
- return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- &QuicConnectionPeer::GetSendAlarm(this));
+ QuicTestAlarmProxy GetSendAlarm() {
+ return QuicTestAlarmProxy(QuicConnectionPeer::GetSendAlarm(this));
}
- TestAlarmFactory::TestAlarm* GetTimeoutAlarm() {
- return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- &QuicConnectionPeer::GetIdleNetworkDetectorAlarm(this));
+ QuicTestAlarmProxy GetTimeoutAlarm() {
+ return QuicTestAlarmProxy(
+ QuicConnectionPeer::GetIdleNetworkDetectorAlarm(this));
}
- TestAlarmFactory::TestAlarm* GetMtuDiscoveryAlarm() {
- return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- &QuicConnectionPeer::GetMtuDiscoveryAlarm(this));
+ QuicTestAlarmProxy GetMtuDiscoveryAlarm() {
+ return QuicTestAlarmProxy(QuicConnectionPeer::GetMtuDiscoveryAlarm(this));
}
- TestAlarmFactory::TestAlarm* GetProcessUndecryptablePacketsAlarm() {
- return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- &QuicConnectionPeer::GetProcessUndecryptablePacketsAlarm(this));
+ QuicTestAlarmProxy GetProcessUndecryptablePacketsAlarm() {
+ return QuicTestAlarmProxy(
+ QuicConnectionPeer::GetProcessUndecryptablePacketsAlarm(this));
}
- TestAlarmFactory::TestAlarm* GetDiscardPreviousOneRttKeysAlarm() {
- return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- &QuicConnectionPeer::GetDiscardPreviousOneRttKeysAlarm(this));
+ QuicTestAlarmProxy GetDiscardPreviousOneRttKeysAlarm() {
+ return QuicTestAlarmProxy(
+ QuicConnectionPeer::GetDiscardPreviousOneRttKeysAlarm(this));
}
- TestAlarmFactory::TestAlarm* GetDiscardZeroRttDecryptionKeysAlarm() {
- return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- &QuicConnectionPeer::GetDiscardZeroRttDecryptionKeysAlarm(this));
+ QuicTestAlarmProxy GetDiscardZeroRttDecryptionKeysAlarm() {
+ return QuicTestAlarmProxy(
+ QuicConnectionPeer::GetDiscardZeroRttDecryptionKeysAlarm(this));
}
- TestAlarmFactory::TestAlarm* GetBlackholeDetectorAlarm() {
- return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- &QuicConnectionPeer::GetBlackholeDetectorAlarm(this));
+ QuicTestAlarmProxy GetBlackholeDetectorAlarm() {
+ return QuicTestAlarmProxy(
+ QuicConnectionPeer::GetBlackholeDetectorAlarm(this));
}
TestAlarmFactory::TestAlarm* GetRetirePeerIssuedConnectionIdAlarm() {
@@ -487,9 +482,9 @@
QuicConnectionPeer::GetRetireSelfIssuedConnectionIdAlarm(this));
}
- TestAlarmFactory::TestAlarm* GetMultiPortProbingAlarm() {
- return reinterpret_cast<TestAlarmFactory::TestAlarm*>(
- &QuicConnectionPeer::GetMultiPortProbingAlarm(this));
+ QuicTestAlarmProxy GetMultiPortProbingAlarm() {
+ return QuicTestAlarmProxy(
+ QuicConnectionPeer::GetMultiPortProbingAlarm(this));
}
void PathDegradingTimeout() {
@@ -11581,8 +11576,7 @@
;
ProcessAckPacket(1, &frame);
EXPECT_TRUE(connection_.BlackholeDetectionInProgress());
- QuicAlarm* retransmission_alarm = connection_.GetRetransmissionAlarm();
- EXPECT_TRUE(retransmission_alarm->IsSet());
+ EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet());
// ACK packet 1 - 5 and 7.
QuicAckFrame frame2 =
diff --git a/quiche/quic/core/quic_idle_network_detector.cc b/quiche/quic/core/quic_idle_network_detector.cc
index 211b2e1..1d5db46 100644
--- a/quiche/quic/core/quic_idle_network_detector.cc
+++ b/quiche/quic/core/quic_idle_network_detector.cc
@@ -19,14 +19,15 @@
} // namespace
QuicIdleNetworkDetector::QuicIdleNetworkDetector(Delegate* delegate,
- QuicTime now, QuicAlarm* alarm)
+ QuicTime now,
+ QuicAlarmProxy alarm)
: delegate_(delegate),
start_time_(now),
handshake_timeout_(QuicTime::Delta::Infinite()),
time_of_last_received_packet_(now),
time_of_first_packet_sent_after_receiving_(QuicTime::Zero()),
idle_network_timeout_(QuicTime::Delta::Infinite()),
- alarm_(*alarm) {}
+ alarm_(alarm) {}
void QuicIdleNetworkDetector::OnAlarm() {
if (handshake_timeout_.IsInfinite()) {
diff --git a/quiche/quic/core/quic_idle_network_detector.h b/quiche/quic/core/quic_idle_network_detector.h
index 5661e37..d6ea7a5 100644
--- a/quiche/quic/core/quic_idle_network_detector.h
+++ b/quiche/quic/core/quic_idle_network_detector.h
@@ -7,6 +7,7 @@
#include "quiche/quic/core/quic_alarm.h"
#include "quiche/quic/core/quic_alarm_factory.h"
+#include "quiche/quic/core/quic_connection_alarms.h"
#include "quiche/quic/core/quic_one_block_arena.h"
#include "quiche/quic/core/quic_time.h"
#include "quiche/quic/platform/api/quic_export.h"
@@ -36,7 +37,8 @@
virtual void OnIdleNetworkDetected() = 0;
};
- QuicIdleNetworkDetector(Delegate* delegate, QuicTime now, QuicAlarm* alarm);
+ QuicIdleNetworkDetector(Delegate* delegate, QuicTime now,
+ QuicAlarmProxy alarm);
void OnAlarm();
@@ -104,7 +106,7 @@
// Idle network timeout. Infinite means no idle network timeout.
QuicTime::Delta idle_network_timeout_;
- QuicAlarm& alarm_;
+ QuicAlarmProxy alarm_;
bool shorter_idle_timeout_on_sent_packet_ = false;
diff --git a/quiche/quic/core/quic_idle_network_detector_test.cc b/quiche/quic/core/quic_idle_network_detector_test.cc
index d34d8cb..458bc27 100644
--- a/quiche/quic/core/quic_idle_network_detector_test.cc
+++ b/quiche/quic/core/quic_idle_network_detector_test.cc
@@ -11,6 +11,7 @@
#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_connection_peer.h"
#include "quiche/quic/test_tools/quic_test_utils.h"
namespace quic {
@@ -18,7 +19,7 @@
class QuicIdleNetworkDetectorTestPeer {
public:
- static QuicAlarm& GetAlarm(QuicIdleNetworkDetector* detector) {
+ static QuicAlarmProxy GetAlarm(QuicIdleNetworkDetector* detector) {
return detector->alarm_;
}
};
@@ -36,10 +37,9 @@
QuicIdleNetworkDetectorTest()
: alarms_(&connection_alarms_delegate_, alarm_factory_, arena_),
detector_(&delegate_, clock_.Now() + QuicTimeDelta::FromSeconds(1),
- &alarms_.idle_network_detector_alarm()) {
+ alarms_.idle_network_detector_alarm()),
+ alarm_(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(); });
}
@@ -52,7 +52,7 @@
QuicConnectionAlarms alarms_;
MockClock clock_;
QuicIdleNetworkDetector detector_;
- MockAlarmFactory::TestAlarm* alarm_;
+ QuicTestAlarmProxy alarm_;
};
TEST_F(QuicIdleNetworkDetectorTest,
diff --git a/quiche/quic/core/quic_network_blackhole_detector.cc b/quiche/quic/core/quic_network_blackhole_detector.cc
index 99e71fa..99cdd04 100644
--- a/quiche/quic/core/quic_network_blackhole_detector.cc
+++ b/quiche/quic/core/quic_network_blackhole_detector.cc
@@ -6,13 +6,14 @@
#include <algorithm>
+#include "quiche/quic/core/quic_connection_alarms.h"
#include "quiche/quic/core/quic_constants.h"
namespace quic {
QuicNetworkBlackholeDetector::QuicNetworkBlackholeDetector(Delegate* delegate,
- QuicAlarm* alarm)
- : delegate_(delegate), alarm_(*alarm) {}
+ QuicAlarmProxy alarm)
+ : delegate_(delegate), alarm_(alarm) {}
void QuicNetworkBlackholeDetector::OnAlarm() {
QuicTime next_deadline = GetEarliestDeadline();
@@ -91,7 +92,7 @@
path_mtu_reduction_deadline_});
}
-void QuicNetworkBlackholeDetector::UpdateAlarm() const {
+void QuicNetworkBlackholeDetector::UpdateAlarm() {
// If called after OnBlackholeDetected(), the alarm may have been permanently
// cancelled and is not safe to be armed again.
if (alarm_.IsPermanentlyCancelled()) {
diff --git a/quiche/quic/core/quic_network_blackhole_detector.h b/quiche/quic/core/quic_network_blackhole_detector.h
index e160a62..97b7f23 100644
--- a/quiche/quic/core/quic_network_blackhole_detector.h
+++ b/quiche/quic/core/quic_network_blackhole_detector.h
@@ -5,9 +5,7 @@
#ifndef QUICHE_QUIC_CORE_QUIC_NETWORK_BLACKHOLE_DETECTOR_H_
#define QUICHE_QUIC_CORE_QUIC_NETWORK_BLACKHOLE_DETECTOR_H_
-#include "quiche/quic/core/quic_alarm.h"
-#include "quiche/quic/core/quic_alarm_factory.h"
-#include "quiche/quic/core/quic_one_block_arena.h"
+#include "quiche/quic/core/quic_connection_alarms.h"
#include "quiche/quic/core/quic_time.h"
#include "quiche/quic/platform/api/quic_export.h"
#include "quiche/quic/platform/api/quic_flags.h"
@@ -40,7 +38,7 @@
virtual void OnPathMtuReductionDetected() = 0;
};
- QuicNetworkBlackholeDetector(Delegate* delegate, QuicAlarm* alarm);
+ QuicNetworkBlackholeDetector(Delegate* delegate, QuicAlarmProxy alarm);
// Called to stop all detections. If |permanent|, the alarm will be cancelled
// permanently and future calls to RestartDetection will be no-op.
@@ -67,7 +65,7 @@
QuicTime GetLastDeadline() const;
// Update alarm to the next deadline.
- void UpdateAlarm() const;
+ void UpdateAlarm();
Delegate* delegate_; // Not owned.
@@ -81,7 +79,7 @@
// path mtu reduction detection is in progress.
QuicTime path_mtu_reduction_deadline_ = QuicTime::Zero();
- QuicAlarm& alarm_;
+ QuicAlarmProxy alarm_;
};
} // namespace quic
diff --git a/quiche/quic/core/quic_network_blackhole_detector_test.cc b/quiche/quic/core/quic_network_blackhole_detector_test.cc
index cad8534..7849ff2 100644
--- a/quiche/quic/core/quic_network_blackhole_detector_test.cc
+++ b/quiche/quic/core/quic_network_blackhole_detector_test.cc
@@ -8,6 +8,7 @@
#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_connection_peer.h"
#include "quiche/quic/test_tools/quic_test_utils.h"
namespace quic {
@@ -15,8 +16,8 @@
class QuicNetworkBlackholeDetectorPeer {
public:
- static QuicAlarm* GetAlarm(QuicNetworkBlackholeDetector* detector) {
- return &detector->alarm_;
+ static QuicAlarmProxy GetAlarm(QuicNetworkBlackholeDetector* detector) {
+ return detector->alarm_;
}
};
@@ -36,9 +37,8 @@
public:
QuicNetworkBlackholeDetectorTest()
: alarms_(&connection_alarms_delegate_, alarm_factory_, arena_),
- detector_(&delegate_, &alarms_.network_blackhole_detector_alarm()),
- alarm_(static_cast<MockAlarmFactory::TestAlarm*>(
- QuicNetworkBlackholeDetectorPeer::GetAlarm(&detector_))),
+ detector_(&delegate_, alarms_.network_blackhole_detector_alarm()),
+ alarm_(QuicNetworkBlackholeDetectorPeer::GetAlarm(&detector_)),
path_degrading_delay_(
QuicTime::Delta::FromSeconds(kPathDegradingDelayInSeconds)),
path_mtu_reduction_delay_(
@@ -65,7 +65,7 @@
QuicNetworkBlackholeDetector detector_;
- MockAlarmFactory::TestAlarm* alarm_;
+ QuicTestAlarmProxy alarm_;
MockClock clock_;
const QuicTime::Delta path_degrading_delay_;
const QuicTime::Delta path_mtu_reduction_delay_;
diff --git a/quiche/quic/core/quic_ping_manager.cc b/quiche/quic/core/quic_ping_manager.cc
index e0c7e20..533dd10 100644
--- a/quiche/quic/core/quic_ping_manager.cc
+++ b/quiche/quic/core/quic_ping_manager.cc
@@ -6,6 +6,7 @@
#include <algorithm>
+#include "quiche/quic/core/quic_connection_alarms.h"
#include "quiche/quic/platform/api/quic_flags.h"
namespace quic {
@@ -20,8 +21,8 @@
} // namespace
QuicPingManager::QuicPingManager(Perspective perspective, Delegate* delegate,
- QuicAlarm* alarm)
- : perspective_(perspective), delegate_(delegate), alarm_(*alarm) {}
+ QuicAlarmProxy alarm)
+ : perspective_(perspective), delegate_(delegate), alarm_(alarm) {}
void QuicPingManager::SetAlarm(QuicTime now, bool should_keep_alive,
bool has_in_flight_packets) {
diff --git a/quiche/quic/core/quic_ping_manager.h b/quiche/quic/core/quic_ping_manager.h
index a62f827..3250416 100644
--- a/quiche/quic/core/quic_ping_manager.h
+++ b/quiche/quic/core/quic_ping_manager.h
@@ -7,6 +7,7 @@
#include "quiche/quic/core/quic_alarm.h"
#include "quiche/quic/core/quic_alarm_factory.h"
+#include "quiche/quic/core/quic_connection_alarms.h"
#include "quiche/quic/core/quic_constants.h"
#include "quiche/quic/core/quic_one_block_arena.h"
#include "quiche/quic/core/quic_time.h"
@@ -38,7 +39,7 @@
};
QuicPingManager(Perspective perspective, Delegate* delegate,
- QuicAlarm* alarm);
+ QuicAlarmProxy alarm);
// Called to set |alarm_|.
void SetAlarm(QuicTime now, bool should_keep_alive,
@@ -99,7 +100,7 @@
QuicTime keep_alive_deadline_ = QuicTime::Zero();
- QuicAlarm& alarm_;
+ QuicAlarmProxy alarm_;
};
} // namespace quic
diff --git a/quiche/quic/core/quic_ping_manager_test.cc b/quiche/quic/core/quic_ping_manager_test.cc
index fa65054..4b82224 100644
--- a/quiche/quic/core/quic_ping_manager_test.cc
+++ b/quiche/quic/core/quic_ping_manager_test.cc
@@ -8,6 +8,7 @@
#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_connection_peer.h"
#include "quiche/quic/test_tools/quic_test_utils.h"
namespace quic {
@@ -15,8 +16,8 @@
class QuicPingManagerPeer {
public:
- static QuicAlarm* GetAlarm(QuicPingManager* manager) {
- return &manager->alarm_;
+ static QuicAlarmProxy GetAlarm(QuicPingManager* manager) {
+ return manager->alarm_;
}
static void SetPerspective(QuicPingManager* manager,
@@ -40,9 +41,8 @@
public:
QuicPingManagerTest()
: alarms_(&connection_alarms_delegate_, alarm_factory_, arena_),
- manager_(Perspective::IS_CLIENT, &delegate_, &alarms_.ping_alarm()),
- alarm_(static_cast<MockAlarmFactory::TestAlarm*>(
- QuicPingManagerPeer::GetAlarm(&manager_))) {
+ manager_(Perspective::IS_CLIENT, &delegate_, alarms_.ping_alarm()),
+ alarm_(QuicPingManagerPeer::GetAlarm(&manager_)) {
clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
ON_CALL(connection_alarms_delegate_, OnPingAlarm()).WillByDefault([&] {
manager_.OnAlarm();
@@ -57,7 +57,7 @@
MockAlarmFactory alarm_factory_;
QuicConnectionAlarms alarms_;
QuicPingManager manager_;
- MockAlarmFactory::TestAlarm* alarm_;
+ QuicTestAlarmProxy alarm_;
};
TEST_F(QuicPingManagerTest, KeepAliveTimeout) {
