Makes the `FLAGS_` prefix implicit in calls to `GetQuicFlag()`.
This refactoring will allow us to define separate sets of flags for QUICHE in google3 vs //third_party/envoy/external_quiche. This will be necessary to import upstream Envoy PR [#22907](https://github.com/envoyproxy/envoy/pull/22907).
CL automatically created by:
```
replace_string \
'GetQuicFlag\(FLAGS_' \
'GetQuicFlag('
replace_string \
'SetQuicFlag\(FLAGS_' \
'SetQuicFlag('
```
Tested:
```
$ blaze test //third_party/quic/core/... //gfe/gfe2/quic:all //net/quic/... //third_party/castlite/agent/net/... //video/streaming/quic:all
http://sponge2/e6f39d62-e455-451e-ae09-84ebb20806b8
```
PiperOrigin-RevId: 473802782
diff --git a/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.h b/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.h
index df14e0f..de350de 100644
--- a/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.h
+++ b/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.h
@@ -29,19 +29,21 @@
#include "quiche/common/quiche_protocol_flags_list.h"
#undef QUICHE_PROTOCOL_FLAG
-inline bool GetQuicheFlagImpl(bool flag) { return flag; }
-inline int32_t GetQuicheFlagImpl(int32_t flag) { return flag; }
-inline int64_t GetQuicheFlagImpl(int64_t flag) { return flag; }
-inline uint64_t GetQuicheFlagImpl(uint64_t flag) { return flag; }
-inline double GetQuicheFlagImpl(double flag) { return flag; }
-inline std::string GetQuicheFlagImpl(const std::string& flag) { return flag; }
-#define SetQuicheFlagImpl(flag, value) ((flag) = (value))
+inline bool GetQuicheFlagImpl(bool flag) { return FLAGS_##flag; }
+inline int32_t GetQuicheFlagImpl(int32_t flag) { return FLAGS_##flag; }
+inline int64_t GetQuicheFlagImpl(int64_t flag) { return FLAGS_##flag; }
+inline uint64_t GetQuicheFlagImpl(uint64_t flag) { return FLAGS_##flag; }
+inline double GetQuicheFlagImpl(double flag) { return FLAGS_##flag; }
+inline std::string GetQuicheFlagImpl(const std::string& flag) {
+ return FLAGS_##flag;
+}
+#define SetQuicheFlagImpl(flag, value) ((FLAGS_##flag) = (value))
// ------------------------------------------------------------------------
// QUICHE feature flags implementation.
// ------------------------------------------------------------------------
-#define QUICHE_RELOADABLE_FLAG(flag) FLAGS_quic_reloadable_flag_##flag
-#define QUICHE_RESTART_FLAG(flag) FLAGS_quic_restart_flag_##flag
+#define QUICHE_RELOADABLE_FLAG(flag) quic_reloadable_flag_##flag
+#define QUICHE_RESTART_FLAG(flag) quic_restart_flag_##flag
#define GetQuicheReloadableFlagImpl(module, flag) \
GetQuicheFlag(QUICHE_RELOADABLE_FLAG(flag))
#define SetQuicheReloadableFlagImpl(module, flag, value) \
diff --git a/quiche/http2/adapter/oghttp2_session.cc b/quiche/http2/adapter/oghttp2_session.cc
index 73f4e96..44ec739 100644
--- a/quiche/http2/adapter/oghttp2_session.cc
+++ b/quiche/http2/adapter/oghttp2_session.cc
@@ -335,13 +335,15 @@
event_forwarder_([this]() { return !latched_error_; }, *this),
receive_logger_(
&event_forwarder_, TracePerspectiveAsString(options.perspective),
- [logging_enabled = GetQuicheFlag(
- FLAGS_quiche_oghttp2_debug_trace)]() { return logging_enabled; },
+ [logging_enabled = GetQuicheFlag(quiche_oghttp2_debug_trace)]() {
+ return logging_enabled;
+ },
this),
send_logger_(
TracePerspectiveAsString(options.perspective),
- [logging_enabled = GetQuicheFlag(
- FLAGS_quiche_oghttp2_debug_trace)]() { return logging_enabled; },
+ [logging_enabled = GetQuicheFlag(quiche_oghttp2_debug_trace)]() {
+ return logging_enabled;
+ },
this),
headers_handler_(*this, visitor),
noop_headers_handler_(/*listener=*/nullptr),
diff --git a/quiche/quic/core/congestion_control/bandwidth_sampler.cc b/quiche/quic/core/congestion_control/bandwidth_sampler.cc
index e216d09..fe42e08 100644
--- a/quiche/quic/core/congestion_control/bandwidth_sampler.cc
+++ b/quiche/quic/core/congestion_control/bandwidth_sampler.cc
@@ -142,7 +142,7 @@
last_acked_packet_ack_time_(QuicTime::Zero()),
is_app_limited_(true),
connection_state_map_(),
- max_tracked_packets_(GetQuicFlag(FLAGS_quic_max_tracked_packet_count)),
+ max_tracked_packets_(GetQuicFlag(quic_max_tracked_packet_count)),
unacked_packet_map_(unacked_packet_map),
max_ack_height_tracker_(max_height_tracker_window_length),
total_bytes_acked_after_last_ack_event_(0),
diff --git a/quiche/quic/core/congestion_control/bandwidth_sampler.h b/quiche/quic/core/congestion_control/bandwidth_sampler.h
index 75851e9..3ca09d1 100644
--- a/quiche/quic/core/congestion_control/bandwidth_sampler.h
+++ b/quiche/quic/core/congestion_control/bandwidth_sampler.h
@@ -177,7 +177,7 @@
// one. Stats only.
uint64_t num_ack_aggregation_epochs_ = 0;
double ack_aggregation_bandwidth_threshold_ =
- GetQuicFlag(FLAGS_quic_ack_aggregation_bandwidth_threshold);
+ GetQuicFlag(quic_ack_aggregation_bandwidth_threshold);
bool start_new_aggregation_epoch_after_full_round_ = false;
bool reduce_extra_acked_on_bandwidth_increase_ = false;
};
diff --git a/quiche/quic/core/congestion_control/bbr2_misc.h b/quiche/quic/core/congestion_control/bbr2_misc.h
index 3c85e85..078c049 100644
--- a/quiche/quic/core/congestion_control/bbr2_misc.h
+++ b/quiche/quic/core/congestion_control/bbr2_misc.h
@@ -89,7 +89,7 @@
// The minimum number of loss marking events to exit STARTUP.
int64_t startup_full_loss_count =
- GetQuicFlag(FLAGS_quic_bbr2_default_startup_full_loss_count);
+ GetQuicFlag(quic_bbr2_default_startup_full_loss_count);
// If true, always exit STARTUP on loss, even if bandwidth exceeds threshold.
// If false, exit STARTUP on loss only if bandwidth is below threshold.
@@ -125,16 +125,16 @@
// Minimum duration for BBR-native probes.
QuicTime::Delta probe_bw_probe_base_duration =
QuicTime::Delta::FromMilliseconds(
- GetQuicFlag(FLAGS_quic_bbr2_default_probe_bw_base_duration_ms));
+ GetQuicFlag(quic_bbr2_default_probe_bw_base_duration_ms));
// The upper bound of the random amount of BBR-native probes.
QuicTime::Delta probe_bw_probe_max_rand_duration =
QuicTime::Delta::FromMilliseconds(
- GetQuicFlag(FLAGS_quic_bbr2_default_probe_bw_max_rand_duration_ms));
+ GetQuicFlag(quic_bbr2_default_probe_bw_max_rand_duration_ms));
// The minimum number of loss marking events to exit the PROBE_UP phase.
int64_t probe_bw_full_loss_count =
- GetQuicFlag(FLAGS_quic_bbr2_default_probe_bw_full_loss_count);
+ GetQuicFlag(quic_bbr2_default_probe_bw_full_loss_count);
// Multiplier to get target inflight (as multiple of BDP) for PROBE_UP phase.
float probe_bw_probe_inflight_gain = 1.25;
@@ -163,7 +163,7 @@
*/
float probe_rtt_inflight_target_bdp_fraction = 0.5;
QuicTime::Delta probe_rtt_period = QuicTime::Delta::FromMilliseconds(
- GetQuicFlag(FLAGS_quic_bbr2_default_probe_rtt_period_ms));
+ GetQuicFlag(quic_bbr2_default_probe_rtt_period_ms));
QuicTime::Delta probe_rtt_duration = QuicTime::Delta::FromMilliseconds(200);
/*
@@ -172,14 +172,14 @@
// The initial value of the max ack height filter's window length.
QuicRoundTripCount initial_max_ack_height_filter_window =
- GetQuicFlag(FLAGS_quic_bbr2_default_initial_ack_height_filter_window);
+ GetQuicFlag(quic_bbr2_default_initial_ack_height_filter_window);
// Fraction of unutilized headroom to try to leave in path upon high loss.
float inflight_hi_headroom =
- GetQuicFlag(FLAGS_quic_bbr2_default_inflight_hi_headroom);
+ GetQuicFlag(quic_bbr2_default_inflight_hi_headroom);
// Estimate startup/bw probing has gone too far if loss rate exceeds this.
- float loss_threshold = GetQuicFlag(FLAGS_quic_bbr2_default_loss_threshold);
+ float loss_threshold = GetQuicFlag(quic_bbr2_default_loss_threshold);
// A common factor for multiplicative decreases. Used for adjusting
// bandwidth_lo, inflight_lo and inflight_hi upon losses.
diff --git a/quiche/quic/core/congestion_control/bbr2_simulator_test.cc b/quiche/quic/core/congestion_control/bbr2_simulator_test.cc
index d4ee77d..07f8121 100644
--- a/quiche/quic/core/congestion_control/bbr2_simulator_test.cc
+++ b/quiche/quic/core/congestion_control/bbr2_simulator_test.cc
@@ -123,7 +123,7 @@
Bbr2SimulatorTest() : simulator_(&random_) {
// Prevent the server(receiver), which only sends acks, from closing
// connection due to too many outstanding packets.
- SetQuicFlag(FLAGS_quic_max_tracked_packet_count, 1000000);
+ SetQuicFlag(quic_max_tracked_packet_count, 1000000);
}
void SetUp() override {
@@ -193,7 +193,7 @@
endpoint->connection()->clock()->Now(),
endpoint->connection()->sent_packet_manager().GetRttStats(),
GetUnackedMap(endpoint->connection()), kDefaultInitialCwndPackets,
- GetQuicFlag(FLAGS_quic_max_congestion_window), &random_,
+ GetQuicFlag(quic_max_congestion_window), &random_,
QuicConnectionPeer::GetStats(endpoint->connection()), old_sender);
QuicConnectionPeer::SetSendAlgorithm(endpoint->connection(), sender);
const int kTestMaxPacketSize = 1350;
@@ -1442,8 +1442,8 @@
// STARTUP at the end of the round even if there's enough bandwidth growth.
TEST_F(Bbr2DefaultTopologyTest, ExitStartupDueToLossB2NE) {
// Set up flags such that any loss will be considered "too high".
- SetQuicFlag(FLAGS_quic_bbr2_default_startup_full_loss_count, 0);
- SetQuicFlag(FLAGS_quic_bbr2_default_loss_threshold, 0.0);
+ SetQuicFlag(quic_bbr2_default_startup_full_loss_count, 0);
+ SetQuicFlag(quic_bbr2_default_loss_threshold, 0.0);
sender_ = SetupBbr2Sender(&sender_endpoint_, /*old_sender=*/nullptr);
@@ -1682,7 +1682,7 @@
sender_connection()->sent_packet_manager().GetRttStats(),
GetUnackedMap(sender_connection()),
kDefaultInitialCwndPackets + 1,
- GetQuicFlag(FLAGS_quic_max_congestion_window), &random_,
+ GetQuicFlag(quic_max_congestion_window), &random_,
QuicConnectionPeer::GetStats(sender_connection()));
QuicPacketNumber next_packet_number(1);
@@ -1972,9 +1972,9 @@
endpoint->connection()->sent_packet_manager().GetRttStats(),
QuicSentPacketManagerPeer::GetUnackedPacketMap(
QuicConnectionPeer::GetSentPacketManager(endpoint->connection())),
- kDefaultInitialCwndPackets,
- GetQuicFlag(FLAGS_quic_max_congestion_window), &random_,
- QuicConnectionPeer::GetStats(endpoint->connection()), nullptr);
+ kDefaultInitialCwndPackets, GetQuicFlag(quic_max_congestion_window),
+ &random_, QuicConnectionPeer::GetStats(endpoint->connection()),
+ nullptr);
// TODO(ianswett): Add dedicated tests for this option until it becomes
// the default behavior.
SetConnectionOption(sender, kBBRA);
@@ -1991,9 +1991,8 @@
endpoint->connection()->sent_packet_manager().GetRttStats(),
QuicSentPacketManagerPeer::GetUnackedPacketMap(
QuicConnectionPeer::GetSentPacketManager(endpoint->connection())),
- kDefaultInitialCwndPackets,
- GetQuicFlag(FLAGS_quic_max_congestion_window), &random_,
- QuicConnectionPeer::GetStats(endpoint->connection()));
+ kDefaultInitialCwndPackets, GetQuicFlag(quic_max_congestion_window),
+ &random_, QuicConnectionPeer::GetStats(endpoint->connection()));
QuicConnectionPeer::SetSendAlgorithm(endpoint->connection(), sender);
endpoint->RecordTrace();
return sender;
@@ -2006,8 +2005,7 @@
TcpCubicSenderBytes* sender = new TcpCubicSenderBytes(
endpoint->connection()->clock(),
endpoint->connection()->sent_packet_manager().GetRttStats(), reno,
- kDefaultInitialCwndPackets,
- GetQuicFlag(FLAGS_quic_max_congestion_window),
+ kDefaultInitialCwndPackets, GetQuicFlag(quic_max_congestion_window),
QuicConnectionPeer::GetStats(endpoint->connection()));
QuicConnectionPeer::SetSendAlgorithm(endpoint->connection(), sender);
endpoint->RecordTrace();
diff --git a/quiche/quic/core/congestion_control/bbr_sender.cc b/quiche/quic/core/congestion_control/bbr_sender.cc
index 756f32c..7abba24 100644
--- a/quiche/quic/core/congestion_control/bbr_sender.cc
+++ b/quiche/quic/core/congestion_control/bbr_sender.cc
@@ -98,7 +98,7 @@
pacing_gain_(1),
congestion_window_gain_(1),
congestion_window_gain_constant_(
- static_cast<float>(GetQuicFlag(FLAGS_quic_bbr_cwnd_gain))),
+ static_cast<float>(GetQuicFlag(quic_bbr_cwnd_gain))),
num_startup_rtts_(kRoundTripsWithoutGrowthBeforeExitingStartup),
cycle_current_offset_(0),
last_cycle_start_(QuicTime::Zero()),
@@ -603,7 +603,7 @@
bool BbrSender::ShouldExitStartupDueToLoss(
const SendTimeState& last_packet_send_state) const {
if (num_loss_events_in_round_ <
- GetQuicFlag(FLAGS_quic_bbr2_default_startup_full_loss_count) ||
+ GetQuicFlag(quic_bbr2_default_startup_full_loss_count) ||
!last_packet_send_state.is_valid) {
return false;
}
@@ -612,8 +612,7 @@
if (inflight_at_send > 0 && bytes_lost_in_round_ > 0) {
if (bytes_lost_in_round_ >
- inflight_at_send *
- GetQuicFlag(FLAGS_quic_bbr2_default_loss_threshold)) {
+ inflight_at_send * GetQuicFlag(quic_bbr2_default_loss_threshold)) {
stats_->bbr_exit_startup_due_to_loss = true;
return true;
}
diff --git a/quiche/quic/core/congestion_control/bbr_sender_test.cc b/quiche/quic/core/congestion_control/bbr_sender_test.cc
index bbdbee6..3a04ccd 100644
--- a/quiche/quic/core/congestion_control/bbr_sender_test.cc
+++ b/quiche/quic/core/congestion_control/bbr_sender_test.cc
@@ -161,7 +161,7 @@
QuicSentPacketManagerPeer::GetUnackedPacketMap(
QuicConnectionPeer::GetSentPacketManager(endpoint->connection())),
kInitialCongestionWindowPackets,
- GetQuicFlag(FLAGS_quic_max_congestion_window), &random_,
+ GetQuicFlag(quic_max_congestion_window), &random_,
QuicConnectionPeer::GetStats(endpoint->connection()));
QuicConnectionPeer::SetSendAlgorithm(endpoint->connection(), sender);
endpoint->RecordTrace();
@@ -433,14 +433,13 @@
TEST_F(BbrSenderTest, SimpleTransferAckDecimation) {
SetConnectionOption(kBSAO);
// Decrease the CWND gain so extra CWND is required with stretch acks.
- SetQuicFlag(FLAGS_quic_bbr_cwnd_gain, 1.0);
+ SetQuicFlag(quic_bbr_cwnd_gain, 1.0);
sender_ = new BbrSender(
bbr_sender_.connection()->clock()->Now(), rtt_stats_,
QuicSentPacketManagerPeer::GetUnackedPacketMap(
QuicConnectionPeer::GetSentPacketManager(bbr_sender_.connection())),
- kInitialCongestionWindowPackets,
- GetQuicFlag(FLAGS_quic_max_congestion_window), &random_,
- QuicConnectionPeer::GetStats(bbr_sender_.connection()));
+ kInitialCongestionWindowPackets, GetQuicFlag(quic_max_congestion_window),
+ &random_, QuicConnectionPeer::GetStats(bbr_sender_.connection()));
QuicConnectionPeer::SetSendAlgorithm(bbr_sender_.connection(), sender_);
CreateDefaultSetup();
diff --git a/quiche/quic/core/congestion_control/pacing_sender.cc b/quiche/quic/core/congestion_control/pacing_sender.cc
index fb3f514..e9e8643 100644
--- a/quiche/quic/core/congestion_control/pacing_sender.cc
+++ b/quiche/quic/core/congestion_control/pacing_sender.cc
@@ -88,15 +88,14 @@
// Reset lumpy_tokens_ if either application or cwnd throttles sending or
// token runs out.
lumpy_tokens_ = std::max(
- 1u, std::min(static_cast<uint32_t>(
- GetQuicFlag(FLAGS_quic_lumpy_pacing_size)),
+ 1u, std::min(static_cast<uint32_t>(GetQuicFlag(quic_lumpy_pacing_size)),
static_cast<uint32_t>(
(sender_->GetCongestionWindow() *
- GetQuicFlag(FLAGS_quic_lumpy_pacing_cwnd_fraction)) /
+ GetQuicFlag(quic_lumpy_pacing_cwnd_fraction)) /
kDefaultTCPMSS)));
if (sender_->BandwidthEstimate() <
QuicBandwidth::FromKBitsPerSecond(
- GetQuicFlag(FLAGS_quic_lumpy_pacing_min_bandwidth_kbps))) {
+ GetQuicFlag(quic_lumpy_pacing_min_bandwidth_kbps))) {
// Below 1.2Mbps, send 1 packet at once, because one full-sized packet
// is about 10ms of queueing.
lumpy_tokens_ = 1u;
diff --git a/quiche/quic/core/congestion_control/pacing_sender_test.cc b/quiche/quic/core/congestion_control/pacing_sender_test.cc
index 2bc7c94..f53f445 100644
--- a/quiche/quic/core/congestion_control/pacing_sender_test.cc
+++ b/quiche/quic/core/congestion_control/pacing_sender_test.cc
@@ -402,8 +402,8 @@
TEST_F(PacingSenderTest, LumpyPacingWithInitialBurstToken) {
// Set lumpy size to be 3, and cwnd faction to 0.5
- SetQuicFlag(FLAGS_quic_lumpy_pacing_size, 3);
- SetQuicFlag(FLAGS_quic_lumpy_pacing_cwnd_fraction, 0.5f);
+ SetQuicFlag(quic_lumpy_pacing_size, 3);
+ SetQuicFlag(quic_lumpy_pacing_cwnd_fraction, 0.5f);
// Configure pacing rate of 1 packet per 1 ms.
InitPacingRate(
10, QuicBandwidth::FromBytesAndTimeDelta(
@@ -459,8 +459,8 @@
TEST_F(PacingSenderTest, NoLumpyPacingForLowBandwidthFlows) {
// Set lumpy size to be 3, and cwnd fraction to 0.5
- SetQuicFlag(FLAGS_quic_lumpy_pacing_size, 3);
- SetQuicFlag(FLAGS_quic_lumpy_pacing_cwnd_fraction, 0.5f);
+ SetQuicFlag(quic_lumpy_pacing_size, 3);
+ SetQuicFlag(quic_lumpy_pacing_cwnd_fraction, 0.5f);
// Configure pacing rate of 1 packet per 100 ms.
QuicTime::Delta inter_packet_delay = QuicTime::Delta::FromMilliseconds(100);
@@ -522,8 +522,8 @@
TEST_F(PacingSenderTest, IdealNextPacketSendTimeWithLumpyPacing) {
// Set lumpy size to be 3, and cwnd faction to 0.5
- SetQuicFlag(FLAGS_quic_lumpy_pacing_size, 3);
- SetQuicFlag(FLAGS_quic_lumpy_pacing_cwnd_fraction, 0.5f);
+ SetQuicFlag(quic_lumpy_pacing_size, 3);
+ SetQuicFlag(quic_lumpy_pacing_cwnd_fraction, 0.5f);
// Configure pacing rate of 1 packet per millisecond.
QuicTime::Delta inter_packet_delay = QuicTime::Delta::FromMilliseconds(1);
diff --git a/quiche/quic/core/congestion_control/send_algorithm_interface.cc b/quiche/quic/core/congestion_control/send_algorithm_interface.cc
index c8c7d5b..89b1ce9 100644
--- a/quiche/quic/core/congestion_control/send_algorithm_interface.cc
+++ b/quiche/quic/core/congestion_control/send_algorithm_interface.cc
@@ -25,7 +25,7 @@
QuicConnectionStats* stats, QuicPacketCount initial_congestion_window,
SendAlgorithmInterface* old_send_algorithm) {
QuicPacketCount max_congestion_window =
- GetQuicFlag(FLAGS_quic_max_congestion_window);
+ GetQuicFlag(quic_max_congestion_window);
switch (congestion_control_type) {
case kGoogCC: // GoogCC is not supported by quic/core, fall back to BBR.
case kBBR:
diff --git a/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes_test.cc b/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes_test.cc
index 330b24b..ad56c2f 100644
--- a/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes_test.cc
+++ b/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes_test.cc
@@ -788,7 +788,7 @@
AckedPacketVector acked_packets;
LostPacketVector missing_packets;
QuicPacketCount max_congestion_window =
- GetQuicFlag(FLAGS_quic_max_congestion_window);
+ GetQuicFlag(quic_max_congestion_window);
for (uint64_t i = 1; i < max_congestion_window; ++i) {
acked_packets.clear();
acked_packets.push_back(
diff --git a/quiche/quic/core/crypto/quic_crypto_client_config.cc b/quiche/quic/core/crypto/quic_crypto_client_config.cc
index caf6c77..c9137de 100644
--- a/quiche/quic/core/crypto/quic_crypto_client_config.cc
+++ b/quiche/quic/core/crypto/quic_crypto_client_config.cc
@@ -66,7 +66,7 @@
: proof_verifier_(std::move(proof_verifier)),
session_cache_(std::move(session_cache)),
ssl_ctx_(TlsClientConnection::CreateSslCtx(
- !GetQuicFlag(FLAGS_quic_disable_client_tls_zero_rtt))) {
+ !GetQuicFlag(quic_disable_client_tls_zero_rtt))) {
QUICHE_DCHECK(proof_verifier_.get());
SetDefaults();
}
diff --git a/quiche/quic/core/http/end_to_end_test.cc b/quiche/quic/core/http/end_to_end_test.cc
index f765afe..51c0ce0 100644
--- a/quiche/quic/core/http/end_to_end_test.cc
+++ b/quiche/quic/core/http/end_to_end_test.cc
@@ -2771,7 +2771,7 @@
HalfRttResponseBlocksShloRetransmissionWithoutTokenBasedAddressValidation) {
// Turn off token based address validation to make the server get constrained
// by amplification factor during handshake.
- SetQuicFlag(FLAGS_quic_reject_retry_token_in_initial_packet, true);
+ SetQuicFlag(quic_reject_retry_token_in_initial_packet, true);
ASSERT_TRUE(Initialize());
if (!version_.SupportsAntiAmplificationLimit()) {
return;
@@ -2864,7 +2864,7 @@
TEST_P(EndToEndTest, ConnectionMigrationClientIPChanged) {
ASSERT_TRUE(Initialize());
- if (GetQuicFlag(FLAGS_quic_enforce_strict_amplification_factor)) {
+ if (GetQuicFlag(quic_enforce_strict_amplification_factor)) {
return;
}
SendSynchronousFooRequestAndCheckResponse();
@@ -2908,7 +2908,7 @@
TEST_P(EndToEndTest, IetfConnectionMigrationClientIPChangedMultipleTimes) {
ASSERT_TRUE(Initialize());
if (!GetClientConnection()->connection_migration_use_new_cid() ||
- GetQuicFlag(FLAGS_quic_enforce_strict_amplification_factor)) {
+ GetQuicFlag(quic_enforce_strict_amplification_factor)) {
return;
}
SendSynchronousFooRequestAndCheckResponse();
@@ -3020,7 +3020,7 @@
TEST_P(EndToEndTest,
ConnectionMigrationWithNonZeroConnectionIDClientIPChangedMultipleTimes) {
if (!version_.SupportsClientConnectionIds() ||
- GetQuicFlag(FLAGS_quic_enforce_strict_amplification_factor)) {
+ GetQuicFlag(quic_enforce_strict_amplification_factor)) {
ASSERT_TRUE(Initialize());
return;
}
@@ -3158,7 +3158,7 @@
ASSERT_TRUE(Initialize());
if (!version_.HasIetfQuicFrames() ||
!client_->client()->session()->connection()->validate_client_address() ||
- GetQuicFlag(FLAGS_quic_enforce_strict_amplification_factor)) {
+ GetQuicFlag(quic_enforce_strict_amplification_factor)) {
return;
}
SendSynchronousFooRequestAndCheckResponse();
@@ -4957,7 +4957,7 @@
TEST_P(EndToEndTest,
SendStatelessResetIfServerConnectionClosedLocallyAfterHandshake) {
// Prevent the connection from expiring in the time wait list.
- SetQuicFlag(FLAGS_quic_time_wait_list_seconds, 10000);
+ SetQuicFlag(quic_time_wait_list_seconds, 10000);
connect_to_server_on_initialize_ = false;
ASSERT_TRUE(Initialize());
@@ -6359,7 +6359,7 @@
}
TEST_P(EndToEndTest, KeyUpdateInitiatedByConfidentialityLimit) {
- SetQuicFlag(FLAGS_quic_key_update_confidentiality_limit, 16U);
+ SetQuicFlag(quic_key_update_confidentiality_limit, 16U);
if (!version_.UsesTls()) {
// Key Update is only supported in TLS handshake.
@@ -6385,8 +6385,8 @@
},
QuicTime::Delta::FromSeconds(5));
- for (uint64_t i = 0;
- i < GetQuicFlag(FLAGS_quic_key_update_confidentiality_limit); ++i) {
+ for (uint64_t i = 0; i < GetQuicFlag(quic_key_update_confidentiality_limit);
+ ++i) {
SendSynchronousFooRequestAndCheckResponse();
}
@@ -6406,7 +6406,7 @@
}
TEST_P(EndToEndTest, TlsResumptionEnabledOnTheFly) {
- SetQuicFlag(FLAGS_quic_disable_server_tls_resumption, true);
+ SetQuicFlag(quic_disable_server_tls_resumption, true);
ASSERT_TRUE(Initialize());
if (!version_.UsesTls()) {
@@ -6423,7 +6423,7 @@
EXPECT_FALSE(client_session->EarlyDataAccepted());
client_->Disconnect();
- SetQuicFlag(FLAGS_quic_disable_server_tls_resumption, false);
+ SetQuicFlag(quic_disable_server_tls_resumption, false);
// Send the second request. Client should still have no resumption ticket, but
// it will receive one which can be used by the next request.
@@ -6448,7 +6448,7 @@
}
TEST_P(EndToEndTest, TlsResumptionDisabledOnTheFly) {
- SetQuicFlag(FLAGS_quic_disable_server_tls_resumption, false);
+ SetQuicFlag(quic_disable_server_tls_resumption, false);
ASSERT_TRUE(Initialize());
if (!version_.UsesTls()) {
@@ -6472,7 +6472,7 @@
EXPECT_TRUE(client_session->EarlyDataAccepted());
client_->Disconnect();
- SetQuicFlag(FLAGS_quic_disable_server_tls_resumption, true);
+ SetQuicFlag(quic_disable_server_tls_resumption, true);
// Send the third request. The client should try resumption but server should
// decline it.
diff --git a/quiche/quic/core/http/http_encoder.cc b/quiche/quic/core/http/http_encoder.cc
index e36c3f5..66c8373 100644
--- a/quiche/quic/core/http/http_encoder.cc
+++ b/quiche/quic/core/http/http_encoder.cc
@@ -202,7 +202,7 @@
uint64_t frame_type;
QuicByteCount payload_length;
std::string payload;
- if (!GetQuicFlag(FLAGS_quic_enable_http3_grease_randomness)) {
+ if (!GetQuicFlag(quic_enable_http3_grease_randomness)) {
frame_type = 0x40;
payload_length = 1;
payload = "a";
diff --git a/quiche/quic/core/http/quic_send_control_stream.cc b/quiche/quic/core/http/quic_send_control_stream.cc
index 6c71740..97b27b2 100644
--- a/quiche/quic/core/http/quic_send_control_stream.cc
+++ b/quiche/quic/core/http/quic_send_control_stream.cc
@@ -56,7 +56,7 @@
// https://tools.ietf.org/html/draft-ietf-quic-http-25#section-7.2.4.1
// specifies that setting identifiers of 0x1f * N + 0x21 are reserved and
// greasing should be attempted.
- if (!GetQuicFlag(FLAGS_quic_enable_http3_grease_randomness)) {
+ if (!GetQuicFlag(quic_enable_http3_grease_randomness)) {
settings.values[0x40] = 20;
} else {
uint32_t result;
diff --git a/quiche/quic/core/http/quic_send_control_stream_test.cc b/quiche/quic/core/http/quic_send_control_stream_test.cc
index f146cee..b606934 100644
--- a/quiche/quic/core/http/quic_send_control_stream_test.cc
+++ b/quiche/quic/core/http/quic_send_control_stream_test.cc
@@ -107,7 +107,7 @@
::testing::PrintToStringParamName());
TEST_P(QuicSendControlStreamTest, WriteSettings) {
- SetQuicFlag(FLAGS_quic_enable_http3_grease_randomness, false);
+ SetQuicFlag(quic_enable_http3_grease_randomness, false);
session_.set_qpack_maximum_dynamic_table_capacity(255);
session_.set_qpack_maximum_blocked_streams(16);
session_.set_max_inbound_header_list_size(1024);
diff --git a/quiche/quic/core/http/quic_server_session_base.cc b/quiche/quic/core/http/quic_server_session_base.cc
index 8057060..4fc2aa9 100644
--- a/quiche/quic/core/http/quic_server_session_base.cc
+++ b/quiche/quic/core/http/quic_server_session_base.cc
@@ -333,7 +333,7 @@
QuicSSLConfig ssl_config = QuicSpdySession::GetSSLConfig();
ssl_config.disable_ticket_support =
- GetQuicFlag(FLAGS_quic_disable_server_tls_resumption);
+ GetQuicFlag(quic_disable_server_tls_resumption);
if (!crypto_config_ || !crypto_config_->proof_source()) {
return ssl_config;
diff --git a/quiche/quic/core/http/quic_spdy_stream.cc b/quiche/quic/core/http/quic_spdy_stream.cc
index 7859a2f..4951a81 100644
--- a/quiche/quic/core/http/quic_spdy_stream.cc
+++ b/quiche/quic/core/http/quic_spdy_stream.cc
@@ -383,7 +383,7 @@
quiche::QuicheMemSliceStorage storage(
iov, count,
session()->connection()->helper()->GetStreamSendBufferAllocator(),
- GetQuicFlag(FLAGS_quic_send_buffer_max_data_slice_size));
+ GetQuicFlag(quic_send_buffer_max_data_slice_size));
return WriteBodySlices(storage.ToSpan(), fin);
}
diff --git a/quiche/quic/core/http/quic_spdy_stream_test.cc b/quiche/quic/core/http/quic_spdy_stream_test.cc
index 6255251..4695f25 100644
--- a/quiche/quic/core/http/quic_spdy_stream_test.cc
+++ b/quiche/quic/core/http/quic_spdy_stream_test.cc
@@ -597,7 +597,7 @@
}
// Setting this flag to false causes no per-entry overhead to be included
// in the header size.
- SetQuicFlag(FLAGS_quic_header_size_limit_includes_overhead, false);
+ SetQuicFlag(quic_header_size_limit_includes_overhead, false);
Initialize(kShouldProcessData);
session_->set_max_inbound_header_list_size(40);
std::string headers =
diff --git a/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.cc b/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.cc
index b932b3d..41d64e7 100644
--- a/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.cc
+++ b/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.cc
@@ -41,7 +41,7 @@
name.size() + value.size() + kQpackEntrySizeOverhead;
const size_t uncompressed_header_bytes =
- GetQuicFlag(FLAGS_quic_header_size_limit_includes_overhead)
+ GetQuicFlag(quic_header_size_limit_includes_overhead)
? uncompressed_header_bytes_including_overhead_
: uncompressed_header_bytes_without_overhead_;
if (uncompressed_header_bytes > max_header_list_size_) {
diff --git a/quiche/quic/core/quic_buffered_packet_store.cc b/quiche/quic/core/quic_buffered_packet_store.cc
index 553d835..a84a293 100644
--- a/quiche/quic/core/quic_buffered_packet_store.cc
+++ b/quiche/quic/core/quic_buffered_packet_store.cc
@@ -91,7 +91,7 @@
QuicSocketAddress peer_address, const ParsedQuicVersion& version,
absl::optional<ParsedClientHello> parsed_chlo) {
const bool is_chlo = parsed_chlo.has_value();
- QUIC_BUG_IF(quic_bug_12410_1, !GetQuicFlag(FLAGS_quic_allow_chlo_buffering))
+ QUIC_BUG_IF(quic_bug_12410_1, !GetQuicFlag(quic_allow_chlo_buffering))
<< "Shouldn't buffer packets if disabled via flag.";
QUIC_BUG_IF(quic_bug_12410_2,
is_chlo && connections_with_chlo_.contains(connection_id))
diff --git a/quiche/quic/core/quic_connection.cc b/quiche/quic/core/quic_connection.cc
index d359c28..16c01d3 100644
--- a/quiche/quic/core/quic_connection.cc
+++ b/quiche/quic/core/quic_connection.cc
@@ -280,7 +280,7 @@
current_packet_data_(nullptr),
should_last_packet_instigate_acks_(false),
max_undecryptable_packets_(0),
- max_tracked_packets_(GetQuicFlag(FLAGS_quic_max_tracked_packet_count)),
+ max_tracked_packets_(GetQuicFlag(quic_max_tracked_packet_count)),
idle_timeout_connection_close_behavior_(
ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET),
num_rtos_for_blackhole_detection_(0),
@@ -3071,7 +3071,7 @@
if (perspective_ == Perspective::IS_SERVER &&
encryption_level_ == ENCRYPTION_INITIAL &&
last_received_packet_info_.length > packet_creator_.max_packet_length()) {
- if (GetQuicFlag(FLAGS_quic_use_lower_server_response_mtu_for_test)) {
+ if (GetQuicFlag(quic_use_lower_server_response_mtu_for_test)) {
SetMaxPacketLength(
std::min(last_received_packet_info_.length, QuicByteCount(1250)));
} else {
@@ -3758,7 +3758,7 @@
confidentiality_limit - kKeyUpdateConfidentialityLimitOffset;
}
const QuicPacketCount key_update_limit_override =
- GetQuicFlag(FLAGS_quic_key_update_confidentiality_limit);
+ GetQuicFlag(quic_key_update_confidentiality_limit);
if (key_update_limit_override) {
key_update_limit = key_update_limit_override;
}
@@ -4716,7 +4716,7 @@
if (initial_retransmittable_on_wire_timeout_.IsInfinite() ||
sent_packet_manager_.HasInFlightPackets() ||
retransmittable_on_wire_ping_count_ >
- GetQuicFlag(FLAGS_quic_max_retransmittable_on_wire_ping_count)) {
+ GetQuicFlag(quic_max_retransmittable_on_wire_ping_count)) {
if (perspective_ == Perspective::IS_CLIENT) {
// Clients send 15s PINGs to avoid NATs from timing out.
ping_alarm_->Update(clock_->ApproximateNow() + keep_alive_ping_timeout_,
@@ -4732,7 +4732,7 @@
QuicTime::Delta retransmittable_on_wire_timeout =
initial_retransmittable_on_wire_timeout_;
int max_aggressive_retransmittable_on_wire_ping_count =
- GetQuicFlag(FLAGS_quic_max_aggressive_retransmittable_on_wire_ping_count);
+ GetQuicFlag(quic_max_aggressive_retransmittable_on_wire_ping_count);
QUICHE_DCHECK_LE(0, max_aggressive_retransmittable_on_wire_ping_count);
if (consecutive_retransmittable_on_wire_ping_count_ >
max_aggressive_retransmittable_on_wire_ping_count) {
@@ -5738,11 +5738,10 @@
const QuicTime::Delta prior_max_release_time = release_time_into_future_;
release_time_into_future_ = std::max(
QuicTime::Delta::FromMilliseconds(kMinReleaseTimeIntoFutureMs),
- std::min(
- QuicTime::Delta::FromMilliseconds(
- GetQuicFlag(FLAGS_quic_max_pace_time_into_future_ms)),
- sent_packet_manager_.GetRttStats()->SmoothedOrInitialRtt() *
- GetQuicFlag(FLAGS_quic_pace_time_into_future_srtt_fraction)));
+ std::min(QuicTime::Delta::FromMilliseconds(
+ GetQuicFlag(quic_max_pace_time_into_future_ms)),
+ sent_packet_manager_.GetRttStats()->SmoothedOrInitialRtt() *
+ GetQuicFlag(quic_pace_time_into_future_srtt_fraction)));
QUIC_DVLOG(3) << "Updated max release time delay from "
<< prior_max_release_time << " to "
<< release_time_into_future_;
diff --git a/quiche/quic/core/quic_connection.h b/quiche/quic/core/quic_connection.h
index de52154..5f0fafb 100644
--- a/quiche/quic/core/quic_connection.h
+++ b/quiche/quic/core/quic_connection.h
@@ -2235,7 +2235,7 @@
bool fill_coalesced_packet_ = false;
size_t anti_amplification_factor_ =
- GetQuicFlag(FLAGS_quic_anti_amplification_factor);
+ GetQuicFlag(quic_anti_amplification_factor);
// True if AckFrequencyFrame is supported.
bool can_receive_ack_frequency_frame_ = false;
@@ -2314,7 +2314,7 @@
// If true, throttle sending if next created packet will exceed amplification
// limit.
const bool enforce_strict_amplification_factor_ =
- GetQuicFlag(FLAGS_quic_enforce_strict_amplification_factor);
+ GetQuicFlag(quic_enforce_strict_amplification_factor);
ConnectionIdGeneratorInterface& connection_id_generator_;
};
diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc
index 73300f7..fe5be6f 100644
--- a/quiche/quic/core/quic_connection_test.cc
+++ b/quiche/quic/core/quic_connection_test.cc
@@ -1720,7 +1720,7 @@
TEST_P(QuicConnectionTest, PeerIpAddressChangeAtServer) {
set_perspective(Perspective::IS_SERVER);
if (!connection_.validate_client_address() ||
- GetQuicFlag(FLAGS_quic_enforce_strict_amplification_factor)) {
+ GetQuicFlag(quic_enforce_strict_amplification_factor)) {
return;
}
QuicPacketCreatorPeer::SetSendVersionInPacket(creator_, false);
@@ -1922,7 +1922,7 @@
QuicFrames frames2;
frames2.push_back(QuicFrame(frame2_));
- if (GetQuicFlag(FLAGS_quic_enforce_strict_amplification_factor)) {
+ if (GetQuicFlag(quic_enforce_strict_amplification_factor)) {
frames2.push_back(QuicFrame(QuicPaddingFrame(-1)));
}
ProcessFramesPacketWithAddresses(frames2, kSelfAddress, kNewPeerAddress,
@@ -1946,7 +1946,7 @@
}
TEST_P(QuicConnectionTest, EffectivePeerAddressChangeAtServer) {
- if (GetQuicFlag(FLAGS_quic_enforce_strict_amplification_factor)) {
+ if (GetQuicFlag(quic_enforce_strict_amplification_factor)) {
return;
}
set_perspective(Perspective::IS_SERVER);
@@ -2132,7 +2132,7 @@
ReversePathValidationResponseReceivedFromUnexpectedPeerAddress) {
set_perspective(Perspective::IS_SERVER);
if (!connection_.connection_migration_use_new_cid() ||
- GetQuicFlag(FLAGS_quic_enforce_strict_amplification_factor)) {
+ GetQuicFlag(quic_enforce_strict_amplification_factor)) {
return;
}
QuicPacketCreatorPeer::SetSendVersionInPacket(creator_, false);
@@ -2909,7 +2909,7 @@
connection_.SetMaxPacketLength(1000);
EXPECT_EQ(1000u, connection_.max_packet_length());
- SetQuicFlag(FLAGS_quic_use_lower_server_response_mtu_for_test, true);
+ SetQuicFlag(quic_use_lower_server_response_mtu_for_test, true);
EXPECT_CALL(visitor_, OnCryptoFrame(_)).Times(::testing::AtMost(1));
EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(::testing::AtMost(1));
ProcessCryptoPacketAtLevel(1, ENCRYPTION_INITIAL);
@@ -8108,7 +8108,7 @@
// afterwards until it exceeds the default ping timeout.
TEST_P(QuicConnectionTest, BackOffRetransmittableOnWireTimeout) {
int max_aggressive_retransmittable_on_wire_ping_count = 5;
- SetQuicFlag(FLAGS_quic_max_aggressive_retransmittable_on_wire_ping_count,
+ SetQuicFlag(quic_max_aggressive_retransmittable_on_wire_ping_count,
max_aggressive_retransmittable_on_wire_ping_count);
const QuicTime::Delta initial_retransmittable_on_wire_timeout =
QuicTime::Delta::FromMilliseconds(200);
@@ -8203,7 +8203,7 @@
// after receiving new stream data.
TEST_P(QuicConnectionTest, ResetBackOffRetransmitableOnWireTimeout) {
int max_aggressive_retransmittable_on_wire_ping_count = 3;
- SetQuicFlag(FLAGS_quic_max_aggressive_retransmittable_on_wire_ping_count, 3);
+ SetQuicFlag(quic_max_aggressive_retransmittable_on_wire_ping_count, 3);
const QuicTime::Delta initial_retransmittable_on_wire_timeout =
QuicTime::Delta::FromMilliseconds(200);
connection_.set_initial_retransmittable_on_wire_timeout(
@@ -8318,7 +8318,7 @@
// the limit in FLAGS_quic_max_retransmittable_on_wire_ping_count.
TEST_P(QuicConnectionTest, RetransmittableOnWirePingLimit) {
static constexpr int kMaxRetransmittableOnWirePingCount = 3;
- SetQuicFlag(FLAGS_quic_max_retransmittable_on_wire_ping_count,
+ SetQuicFlag(quic_max_retransmittable_on_wire_ping_count,
kMaxRetransmittableOnWirePingCount);
static constexpr QuicTime::Delta initial_retransmittable_on_wire_timeout =
QuicTime::Delta::FromMilliseconds(200);
@@ -9596,7 +9596,7 @@
TEST_P(QuicConnectionTest, AntiAmplificationLimit) {
if (!connection_.version().SupportsAntiAmplificationLimit() ||
- GetQuicFlag(FLAGS_quic_enforce_strict_amplification_factor)) {
+ GetQuicFlag(quic_enforce_strict_amplification_factor)) {
return;
}
EXPECT_CALL(visitor_, OnCryptoFrame(_)).Times(AnyNumber());
@@ -9614,7 +9614,7 @@
ProcessCryptoPacketAtLevel(1, ENCRYPTION_INITIAL);
const size_t anti_amplification_factor =
- GetQuicFlag(FLAGS_quic_anti_amplification_factor);
+ GetQuicFlag(quic_anti_amplification_factor);
// Verify now packets can be sent.
for (size_t i = 1; i < anti_amplification_factor; ++i) {
EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
@@ -9653,7 +9653,7 @@
TEST_P(QuicConnectionTest, 3AntiAmplificationLimit) {
if (!connection_.version().SupportsAntiAmplificationLimit() ||
- GetQuicFlag(FLAGS_quic_enforce_strict_amplification_factor)) {
+ GetQuicFlag(quic_enforce_strict_amplification_factor)) {
return;
}
EXPECT_CALL(visitor_, OnCryptoFrame(_)).Times(AnyNumber());
@@ -9722,7 +9722,7 @@
TEST_P(QuicConnectionTest, 10AntiAmplificationLimit) {
if (!connection_.version().SupportsAntiAmplificationLimit() ||
- GetQuicFlag(FLAGS_quic_enforce_strict_amplification_factor)) {
+ GetQuicFlag(quic_enforce_strict_amplification_factor)) {
return;
}
EXPECT_CALL(visitor_, OnCryptoFrame(_)).Times(AnyNumber());
@@ -9928,7 +9928,7 @@
// EXPECT_QUIC_BUG tests are expensive so only run one instance of them.
if (!IsDefaultTestConfiguration() ||
!connection_.version().CanSendCoalescedPackets() ||
- GetQuicFlag(FLAGS_quic_enforce_strict_amplification_factor)) {
+ GetQuicFlag(quic_enforce_strict_amplification_factor)) {
return;
}
@@ -11040,7 +11040,7 @@
// Set anti amplification factor to 2, such that RetransmitDataOfSpaceIfAny
// makes no forward progress and causes infinite loop.
- SetQuicFlag(FLAGS_quic_anti_amplification_factor, 2);
+ SetQuicFlag(quic_anti_amplification_factor, 2);
ProcessCryptoPacketAtLevel(1000, ENCRYPTION_INITIAL);
EXPECT_TRUE(connection_.HasPendingAcks());
@@ -12403,7 +12403,7 @@
return;
}
- SetQuicFlag(FLAGS_quic_key_update_confidentiality_limit, 3U);
+ SetQuicFlag(quic_key_update_confidentiality_limit, 3U);
std::string error_details;
TransportParameters params;
@@ -12497,7 +12497,7 @@
}
// Set key update confidentiality limit to 1 packet.
- SetQuicFlag(FLAGS_quic_key_update_confidentiality_limit, 1U);
+ SetQuicFlag(quic_key_update_confidentiality_limit, 1U);
// Use confidentiality limit for connection close of 3 packets.
constexpr size_t kConfidentialityLimit = 3U;
@@ -14581,7 +14581,7 @@
TEST_P(QuicConnectionTest, LostDataThenGetAcknowledged) {
set_perspective(Perspective::IS_SERVER);
if (!connection_.validate_client_address() ||
- GetQuicFlag(FLAGS_quic_enforce_strict_amplification_factor)) {
+ GetQuicFlag(quic_enforce_strict_amplification_factor)) {
return;
}
@@ -15014,7 +15014,7 @@
// Regression test for b/201643321.
TEST_P(QuicConnectionTest, FailedToRetransmitShlo) {
if (!version().HasIetfQuicFrames() ||
- GetQuicFlag(FLAGS_quic_enforce_strict_amplification_factor)) {
+ GetQuicFlag(quic_enforce_strict_amplification_factor)) {
return;
}
set_perspective(Perspective::IS_SERVER);
@@ -15597,7 +15597,7 @@
EXPECT_FALSE(connection_.GetRetransmissionAlarm()->IsSet());
const size_t anti_amplification_factor =
- GetQuicFlag(FLAGS_quic_anti_amplification_factor);
+ GetQuicFlag(quic_anti_amplification_factor);
// Receives packet 1.
EXPECT_CALL(visitor_, OnCryptoFrame(_)).Times(1);
EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
@@ -15618,7 +15618,7 @@
EXPECT_LT(writer_->total_bytes_written(),
anti_amplification_factor *
QuicConnectionPeer::BytesReceivedOnDefaultPath(&connection_));
- if (GetQuicFlag(FLAGS_quic_enforce_strict_amplification_factor)) {
+ if (GetQuicFlag(quic_enforce_strict_amplification_factor)) {
// 3 connection closes which will be buffered.
EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(3);
// Verify retransmission alarm is not set.
@@ -15639,7 +15639,7 @@
QUIC_INTERNAL_ERROR, "error",
ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
EXPECT_EQ(0u, connection_.NumQueuedPackets());
- if (GetQuicFlag(FLAGS_quic_enforce_strict_amplification_factor)) {
+ if (GetQuicFlag(quic_enforce_strict_amplification_factor)) {
EXPECT_LT(writer_->total_bytes_written(),
anti_amplification_factor *
QuicConnectionPeer::BytesReceivedOnDefaultPath(&connection_));
diff --git a/quiche/quic/core/quic_crypto_handshaker.cc b/quiche/quic/core/quic_crypto_handshaker.cc
index 7ecc232..07819de 100644
--- a/quiche/quic/core/quic_crypto_handshaker.cc
+++ b/quiche/quic/core/quic_crypto_handshaker.cc
@@ -45,7 +45,7 @@
}
size_t QuicCryptoHandshaker::BufferSizeLimitForLevel(EncryptionLevel) const {
- return GetQuicFlag(FLAGS_quic_max_buffered_crypto_bytes);
+ return GetQuicFlag(quic_max_buffered_crypto_bytes);
}
#undef ENDPOINT // undef for jumbo builds
diff --git a/quiche/quic/core/quic_crypto_stream.cc b/quiche/quic/core/quic_crypto_stream.cc
index 33fb1da..7009920 100644
--- a/quiche/quic/core/quic_crypto_stream.cc
+++ b/quiche/quic/core/quic_crypto_stream.cc
@@ -151,7 +151,7 @@
// Ensure this data does not cause the send buffer for this encryption level
// to exceed its size limit.
- if (GetQuicFlag(FLAGS_quic_bounded_crypto_send_buffer)) {
+ if (GetQuicFlag(quic_bounded_crypto_send_buffer)) {
QUIC_BUG_IF(quic_crypto_stream_offset_lt_bytes_written,
offset < send_buffer->stream_bytes_written());
uint64_t current_buffer_size =
@@ -192,7 +192,7 @@
}
size_t QuicCryptoStream::BufferSizeLimitForLevel(EncryptionLevel) const {
- return GetQuicFlag(FLAGS_quic_max_buffered_crypto_bytes);
+ return GetQuicFlag(quic_max_buffered_crypto_bytes);
}
bool QuicCryptoStream::OnCryptoFrameAcked(const QuicCryptoFrame& frame,
diff --git a/quiche/quic/core/quic_crypto_stream_test.cc b/quiche/quic/core/quic_crypto_stream_test.cc
index 38550f4..cd6d3cf 100644
--- a/quiche/quic/core/quic_crypto_stream_test.cc
+++ b/quiche/quic/core/quic_crypto_stream_test.cc
@@ -660,7 +660,7 @@
return;
}
EXPECT_EQ(ENCRYPTION_INITIAL, connection_->encryption_level());
- int32_t buffer_limit = GetQuicFlag(FLAGS_quic_max_buffered_crypto_bytes);
+ int32_t buffer_limit = GetQuicFlag(quic_max_buffered_crypto_bytes);
// Write data larger than the buffer limit, when there is no existing data in
// the buffer. Data is sent rather than closing the connection.
@@ -689,7 +689,7 @@
EXPECT_TRUE(stream_->HasBufferedCryptoFrames());
// Writing an additional byte to the send buffer closes the connection.
- if (GetQuicFlag(FLAGS_quic_bounded_crypto_send_buffer)) {
+ if (GetQuicFlag(quic_bounded_crypto_send_buffer)) {
EXPECT_CALL(*connection_, CloseConnection(QUIC_INTERNAL_ERROR, _, _));
EXPECT_QUIC_BUG(
stream_->WriteCryptoData(ENCRYPTION_INITIAL, data2),
@@ -745,8 +745,7 @@
EXPECT_CALL(*connection_,
CloseConnection(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, _, _));
- std::string large_frame(2 * GetQuicFlag(FLAGS_quic_max_buffered_crypto_bytes),
- 'a');
+ std::string large_frame(2 * GetQuicFlag(quic_max_buffered_crypto_bytes), 'a');
// Set offset to 1 so that we guarantee the data gets buffered instead of
// immediately processed.
diff --git a/quiche/quic/core/quic_dispatcher.cc b/quiche/quic/core/quic_dispatcher.cc
index 69c5b51..4cdb014 100644
--- a/quiche/quic/core/quic_dispatcher.cc
+++ b/quiche/quic/core/quic_dispatcher.cc
@@ -892,7 +892,7 @@
}
ChloAlpnSniExtractor alpn_extractor;
- if (GetQuicFlag(FLAGS_quic_allow_chlo_buffering) &&
+ if (GetQuicFlag(quic_allow_chlo_buffering) &&
!ChloExtractor::Extract(packet_info.packet, packet_info.version,
config_->create_session_tag_indicators(),
&alpn_extractor,
@@ -1332,7 +1332,7 @@
void QuicDispatcher::ProcessChlo(ParsedClientHello parsed_chlo,
ReceivedPacketInfo* packet_info) {
- if (GetQuicFlag(FLAGS_quic_allow_chlo_buffering) &&
+ if (GetQuicFlag(quic_allow_chlo_buffering) &&
new_sessions_allowed_per_event_loop_ <= 0) {
// Can't create new session any more. Wait till next event loop.
QUIC_BUG_IF(quic_bug_12724_7, buffered_packets_.HasChloForConnection(
@@ -1507,15 +1507,15 @@
// Do not send a stateless reset if there are too many stateless reset
// addresses.
if (recent_stateless_reset_addresses_.size() >=
- GetQuicFlag(FLAGS_quic_max_recent_stateless_reset_addresses)) {
+ GetQuicFlag(quic_max_recent_stateless_reset_addresses)) {
QUIC_CODE_COUNT(quic_too_many_recent_reset_addresses);
return;
}
if (recent_stateless_reset_addresses_.empty()) {
clear_stateless_reset_addresses_alarm_->Update(
helper()->GetClock()->ApproximateNow() +
- QuicTime::Delta::FromMilliseconds(GetQuicFlag(
- FLAGS_quic_recent_stateless_reset_addresses_lifetime_ms)),
+ QuicTime::Delta::FromMilliseconds(
+ GetQuicFlag(quic_recent_stateless_reset_addresses_lifetime_ms)),
QuicTime::Delta::Zero());
}
recent_stateless_reset_addresses_.emplace(packet_info.peer_address);
diff --git a/quiche/quic/core/quic_dispatcher_test.cc b/quiche/quic/core/quic_dispatcher_test.cc
index 794bb39..ef3bfbd 100644
--- a/quiche/quic/core/quic_dispatcher_test.cc
+++ b/quiche/quic/core/quic_dispatcher_test.cc
@@ -1017,9 +1017,9 @@
TEST_P(QuicDispatcherTestAllVersions,
StopSendingResetOnTooManyRecentAddresses) {
- SetQuicFlag(FLAGS_quic_max_recent_stateless_reset_addresses, 2);
+ SetQuicFlag(quic_max_recent_stateless_reset_addresses, 2);
const size_t kTestLifeTimeMs = 10;
- SetQuicFlag(FLAGS_quic_recent_stateless_reset_addresses_lifetime_ms,
+ SetQuicFlag(quic_recent_stateless_reset_addresses_lifetime_ms,
kTestLifeTimeMs);
CreateTimeWaitListManager();
diff --git a/quiche/quic/core/quic_framer.cc b/quiche/quic/core/quic_framer.cc
index 9f81d06..db7100d 100644
--- a/quiche/quic/core/quic_framer.cc
+++ b/quiche/quic/core/quic_framer.cc
@@ -1375,7 +1375,7 @@
// depends on this randomness.
size_t version_index = 0;
const bool disable_randomness =
- GetQuicFlag(FLAGS_quic_disable_version_negotiation_grease_randomness);
+ GetQuicFlag(quic_disable_version_negotiation_grease_randomness);
if (!disable_randomness) {
version_index =
QuicRandom::GetInstance()->RandUint64() % (wire_versions.size() + 1);
diff --git a/quiche/quic/core/quic_framer_test.cc b/quiche/quic/core/quic_framer_test.cc
index f4fa8a8..99c29dc 100644
--- a/quiche/quic/core/quic_framer_test.cc
+++ b/quiche/quic/core/quic_framer_test.cc
@@ -7309,7 +7309,7 @@
}
TEST_P(QuicFramerTest, BuildVersionNegotiationPacket) {
- SetQuicFlag(FLAGS_quic_disable_version_negotiation_grease_randomness, true);
+ SetQuicFlag(quic_disable_version_negotiation_grease_randomness, true);
// clang-format off
unsigned char packet[] = {
// public flags (version, 8 byte connection_id)
@@ -7375,7 +7375,7 @@
return;
}
- SetQuicFlag(FLAGS_quic_disable_version_negotiation_grease_randomness, true);
+ SetQuicFlag(quic_disable_version_negotiation_grease_randomness, true);
// clang-format off
unsigned char packet[] = {
diff --git a/quiche/quic/core/quic_packet_creator.cc b/quiche/quic/core/quic_packet_creator.cc
index 3be9c40..d7949ce 100644
--- a/quiche/quic/core/quic_packet_creator.cc
+++ b/quiche/quic/core/quic_packet_creator.cc
@@ -324,7 +324,7 @@
}
CreateStreamFrame(id, data_size, offset, fin, frame);
// Explicitly disallow multi-packet CHLOs.
- if (GetQuicFlag(FLAGS_quic_enforce_single_packet_chlo) &&
+ if (GetQuicFlag(quic_enforce_single_packet_chlo) &&
StreamFrameIsClientHello(frame->stream_frame) &&
frame->stream_frame.data_length < data_size) {
const std::string error_details =
@@ -1569,7 +1569,7 @@
FlushCurrentPacket();
SendRemainingPendingPadding();
flusher_attached_ = false;
- if (GetQuicFlag(FLAGS_quic_export_write_path_stats_at_server)) {
+ if (GetQuicFlag(quic_export_write_path_stats_at_server)) {
if (!write_start_packet_number_.IsInitialized()) {
QUIC_BUG(quic_bug_10752_32)
<< ENDPOINT << "write_start_packet_number is not initialized";
diff --git a/quiche/quic/core/quic_packet_creator_test.cc b/quiche/quic/core/quic_packet_creator_test.cc
index acdd898..9bd3b2f 100644
--- a/quiche/quic/core/quic_packet_creator_test.cc
+++ b/quiche/quic/core/quic_packet_creator_test.cc
@@ -470,7 +470,7 @@
TEST_P(QuicPacketCreatorTest, CryptoStreamFramePacketPadding) {
// This test serializes crypto payloads slightly larger than a packet, which
// Causes the multi-packet ClientHello check to fail.
- SetQuicFlag(FLAGS_quic_enforce_single_packet_chlo, false);
+ SetQuicFlag(quic_enforce_single_packet_chlo, false);
// Compute the total overhead for a single frame in packet.
size_t overhead =
GetPacketHeaderOverhead(client_framer_.transport_version()) +
diff --git a/quiche/quic/core/quic_ping_manager.cc b/quiche/quic/core/quic_ping_manager.cc
index 961eb8d..1574632 100644
--- a/quiche/quic/core/quic_ping_manager.cc
+++ b/quiche/quic/core/quic_ping_manager.cc
@@ -67,8 +67,7 @@
// to SetAlarm later.
if (earliest_deadline == retransmittable_on_wire_deadline_) {
retransmittable_on_wire_deadline_ = QuicTime::Zero();
- if (GetQuicFlag(
- FLAGS_quic_max_aggressive_retransmittable_on_wire_ping_count) !=
+ if (GetQuicFlag(quic_max_aggressive_retransmittable_on_wire_ping_count) !=
0) {
++consecutive_retransmittable_on_wire_count_;
}
@@ -116,7 +115,7 @@
if (initial_retransmittable_on_wire_timeout_.IsInfinite() ||
has_in_flight_packets ||
retransmittable_on_wire_count_ >
- GetQuicFlag(FLAGS_quic_max_retransmittable_on_wire_ping_count)) {
+ GetQuicFlag(quic_max_retransmittable_on_wire_ping_count)) {
// No need to set retransmittable-on-wire timeout.
retransmittable_on_wire_deadline_ = QuicTime::Zero();
return;
@@ -127,7 +126,7 @@
QuicTime::Delta retransmittable_on_wire_timeout =
initial_retransmittable_on_wire_timeout_;
const int max_aggressive_retransmittable_on_wire_count =
- GetQuicFlag(FLAGS_quic_max_aggressive_retransmittable_on_wire_ping_count);
+ GetQuicFlag(quic_max_aggressive_retransmittable_on_wire_ping_count);
QUICHE_DCHECK_LE(0, max_aggressive_retransmittable_on_wire_count);
if (consecutive_retransmittable_on_wire_count_ >
max_aggressive_retransmittable_on_wire_count) {
diff --git a/quiche/quic/core/quic_ping_manager_test.cc b/quiche/quic/core/quic_ping_manager_test.cc
index 509022b..d9acc7a 100644
--- a/quiche/quic/core/quic_ping_manager_test.cc
+++ b/quiche/quic/core/quic_ping_manager_test.cc
@@ -172,7 +172,7 @@
TEST_F(QuicPingManagerTest, RetransmittableOnWireTimeoutExponentiallyBackOff) {
const int kMaxAggressiveRetransmittableOnWireCount = 5;
- SetQuicFlag(FLAGS_quic_max_aggressive_retransmittable_on_wire_ping_count,
+ SetQuicFlag(quic_max_aggressive_retransmittable_on_wire_ping_count,
kMaxAggressiveRetransmittableOnWireCount);
const QuicTime::Delta initial_retransmittable_on_wire_timeout =
QuicTime::Delta::FromMilliseconds(200);
@@ -257,7 +257,7 @@
TEST_F(QuicPingManagerTest,
ResetRetransmitableOnWireTimeoutExponentiallyBackOff) {
const int kMaxAggressiveRetransmittableOnWireCount = 3;
- SetQuicFlag(FLAGS_quic_max_aggressive_retransmittable_on_wire_ping_count,
+ SetQuicFlag(quic_max_aggressive_retransmittable_on_wire_ping_count,
kMaxAggressiveRetransmittableOnWireCount);
const QuicTime::Delta initial_retransmittable_on_wire_timeout =
QuicTime::Delta::FromMilliseconds(200);
@@ -338,7 +338,7 @@
TEST_F(QuicPingManagerTest, RetransmittableOnWireLimit) {
static constexpr int kMaxRetransmittableOnWirePingCount = 3;
- SetQuicFlag(FLAGS_quic_max_retransmittable_on_wire_ping_count,
+ SetQuicFlag(quic_max_retransmittable_on_wire_ping_count,
kMaxRetransmittableOnWirePingCount);
static constexpr QuicTime::Delta initial_retransmittable_on_wire_timeout =
QuicTime::Delta::FromMilliseconds(200);
@@ -386,7 +386,7 @@
TEST_F(QuicPingManagerTest, MaxRetransmittableOnWireDelayShift) {
QuicPingManagerPeer::SetPerspective(&manager_, Perspective::IS_SERVER);
const int kMaxAggressiveRetransmittableOnWireCount = 3;
- SetQuicFlag(FLAGS_quic_max_aggressive_retransmittable_on_wire_ping_count,
+ SetQuicFlag(quic_max_aggressive_retransmittable_on_wire_ping_count,
kMaxAggressiveRetransmittableOnWireCount);
const QuicTime::Delta initial_retransmittable_on_wire_timeout =
QuicTime::Delta::FromMilliseconds(200);
diff --git a/quiche/quic/core/quic_sent_packet_manager.cc b/quiche/quic/core/quic_sent_packet_manager.cc
index e6407f3..557eace 100644
--- a/quiche/quic/core/quic_sent_packet_manager.cc
+++ b/quiche/quic/core/quic_sent_packet_manager.cc
@@ -181,7 +181,7 @@
ignore_pings_ = true;
}
- using_pacing_ = !GetQuicFlag(FLAGS_quic_disable_pacing_for_perf_tests);
+ using_pacing_ = !GetQuicFlag(quic_disable_pacing_for_perf_tests);
// Configure loss detection.
if (config.HasClientRequestedIndependentOption(kILD0, perspective)) {
uber_loss_algorithm_.SetReorderingShift(kDefaultIetfLossDelayShift);
diff --git a/quiche/quic/core/quic_session.cc b/quiche/quic/core/quic_session.cc
index 8d87de1..b6b0371 100644
--- a/quiche/quic/core/quic_session.cc
+++ b/quiche/quic/core/quic_session.cc
@@ -2629,7 +2629,7 @@
bool QuicSession::ValidateToken(absl::string_view token) {
QUICHE_DCHECK_EQ(perspective_, Perspective::IS_SERVER);
- if (GetQuicFlag(FLAGS_quic_reject_retry_token_in_initial_packet)) {
+ if (GetQuicFlag(quic_reject_retry_token_in_initial_packet)) {
return false;
}
if (token.empty() || token[0] != kAddressTokenPrefix) {
diff --git a/quiche/quic/core/quic_stream.cc b/quiche/quic/core/quic_stream.cc
index 29990aa..921682d 100644
--- a/quiche/quic/core/quic_stream.cc
+++ b/quiche/quic/core/quic_stream.cc
@@ -364,7 +364,7 @@
add_random_padding_after_fin_(false),
send_buffer_(
session->connection()->helper()->GetStreamSendBufferAllocator()),
- buffered_data_threshold_(GetQuicFlag(FLAGS_quic_buffered_data_threshold)),
+ buffered_data_threshold_(GetQuicFlag(quic_buffered_data_threshold)),
is_static_(is_static),
deadline_(QuicTime::Zero()),
was_draining_(false),
diff --git a/quiche/quic/core/quic_stream_id_manager.cc b/quiche/quic/core/quic_stream_id_manager.cc
index 31ce3e8..1443211 100644
--- a/quiche/quic/core/quic_stream_id_manager.cc
+++ b/quiche/quic/core/quic_stream_id_manager.cc
@@ -96,7 +96,7 @@
}
void QuicStreamIdManager::MaybeSendMaxStreamsFrame() {
- int divisor = GetQuicFlag(FLAGS_quic_max_streams_window_divisor);
+ int divisor = GetQuicFlag(quic_max_streams_window_divisor);
if (divisor > 0) {
if ((incoming_advertised_max_streams_ - incoming_stream_count_) >
diff --git a/quiche/quic/core/quic_stream_id_manager_test.cc b/quiche/quic/core/quic_stream_id_manager_test.cc
index c0cab1d..5b13112 100644
--- a/quiche/quic/core/quic_stream_id_manager_test.cc
+++ b/quiche/quic/core/quic_stream_id_manager_test.cc
@@ -318,7 +318,7 @@
// Open and then close a number of streams to get close to the threshold of
// sending a MAX_STREAM_FRAME.
int stream_count = stream_id_manager_.incoming_initial_max_open_streams() /
- GetQuicFlag(FLAGS_quic_max_streams_window_divisor) -
+ GetQuicFlag(quic_max_streams_window_divisor) -
1;
// Should not get a control-frame transmission since the peer should have
@@ -411,7 +411,7 @@
// cause a MAX STREAMS frame to be generated.
int i =
static_cast<int>(stream_id_manager_.incoming_initial_max_open_streams() /
- GetQuicFlag(FLAGS_quic_max_streams_window_divisor));
+ GetQuicFlag(quic_max_streams_window_divisor));
QuicStreamId id =
QuicStreamIdManagerPeer::GetFirstIncomingStreamId(&stream_id_manager_);
EXPECT_CALL(delegate_, SendMaxStreams(first_advert + i, IsUnidirectional()));
diff --git a/quiche/quic/core/quic_stream_send_buffer.cc b/quiche/quic/core/quic_stream_send_buffer.cc
index c7eb188..a8657b5 100644
--- a/quiche/quic/core/quic_stream_send_buffer.cc
+++ b/quiche/quic/core/quic_stream_send_buffer.cc
@@ -63,7 +63,7 @@
// Latch the maximum data slice size.
const QuicByteCount max_data_slice_size =
- GetQuicFlag(FLAGS_quic_send_buffer_max_data_slice_size);
+ GetQuicFlag(quic_send_buffer_max_data_slice_size);
while (!data.empty()) {
auto slice_len = std::min<absl::string_view::size_type>(
data.length(), max_data_slice_size);
diff --git a/quiche/quic/core/quic_stream_send_buffer_test.cc b/quiche/quic/core/quic_stream_send_buffer_test.cc
index 7abd791..f4d6b50 100644
--- a/quiche/quic/core/quic_stream_send_buffer_test.cc
+++ b/quiche/quic/core/quic_stream_send_buffer_test.cc
@@ -41,7 +41,7 @@
quiche::QuicheMemSlice slice2(std::move(buffer2));
// `data` will be split into two BufferedSlices.
- SetQuicFlag(FLAGS_quic_send_buffer_max_data_slice_size, 1024);
+ SetQuicFlag(quic_send_buffer_max_data_slice_size, 1024);
send_buffer_.SaveStreamData(data1);
send_buffer_.SaveMemSlice(std::move(slice1));
diff --git a/quiche/quic/core/quic_stream_test.cc b/quiche/quic/core/quic_stream_test.cc
index 1bec69f..deb7c98 100644
--- a/quiche/quic/core/quic_stream_test.cc
+++ b/quiche/quic/core/quic_stream_test.cc
@@ -1108,7 +1108,7 @@
}
TEST_P(QuicStreamTest, CanWriteNewDataAfterData) {
- SetQuicFlag(FLAGS_quic_buffered_data_threshold, 100);
+ SetQuicFlag(quic_buffered_data_threshold, 100);
Initialize();
EXPECT_TRUE(stream_->CanWriteNewDataAfterData(99));
EXPECT_FALSE(stream_->CanWriteNewDataAfterData(100));
@@ -1116,7 +1116,7 @@
TEST_P(QuicStreamTest, WriteBufferedData) {
// Set buffered data low water mark to be 100.
- SetQuicFlag(FLAGS_quic_buffered_data_threshold, 100);
+ SetQuicFlag(quic_buffered_data_threshold, 100);
Initialize();
std::string data(1024, 'a');
@@ -1149,8 +1149,7 @@
// Send buffered data to make buffered data size < threshold.
QuicByteCount data_to_write =
- 3 * data.length() - 200 -
- GetQuicFlag(FLAGS_quic_buffered_data_threshold) + 1;
+ 3 * data.length() - 200 - GetQuicFlag(quic_buffered_data_threshold) + 1;
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this, data_to_write]() {
return session_->ConsumeData(stream_->id(), data_to_write, 200u, NO_FIN,
@@ -1159,9 +1158,9 @@
// Buffered data size < threshold, ask upper layer for more data.
EXPECT_CALL(*stream_, OnCanWriteNewData()).Times(1);
stream_->OnCanWrite();
- EXPECT_EQ(static_cast<uint64_t>(
- GetQuicFlag(FLAGS_quic_buffered_data_threshold) - 1),
- stream_->BufferedDataBytes());
+ EXPECT_EQ(
+ static_cast<uint64_t>(GetQuicFlag(quic_buffered_data_threshold) - 1),
+ stream_->BufferedDataBytes());
EXPECT_TRUE(stream_->CanWriteNewData());
// Flush all buffered data.
@@ -1199,8 +1198,7 @@
EXPECT_FALSE(consumed.fin_consumed);
EXPECT_EQ(data.length(), stream_->BufferedDataBytes());
- data_to_write =
- data.length() - GetQuicFlag(FLAGS_quic_buffered_data_threshold) + 1;
+ data_to_write = data.length() - GetQuicFlag(quic_buffered_data_threshold) + 1;
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this, data_to_write]() {
return session_->ConsumeData(stream_->id(), data_to_write, 0u, NO_FIN,
@@ -1209,9 +1207,9 @@
EXPECT_CALL(*stream_, OnCanWriteNewData()).Times(1);
stream_->OnCanWrite();
- EXPECT_EQ(static_cast<uint64_t>(
- GetQuicFlag(FLAGS_quic_buffered_data_threshold) - 1),
- stream_->BufferedDataBytes());
+ EXPECT_EQ(
+ static_cast<uint64_t>(GetQuicFlag(quic_buffered_data_threshold) - 1),
+ stream_->BufferedDataBytes());
EXPECT_TRUE(stream_->CanWriteNewData());
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).Times(0);
@@ -1222,7 +1220,7 @@
consumed = stream_->WriteMemSlices(storage3.ToSpan(), false);
EXPECT_EQ(data.length(), consumed.bytes_consumed);
EXPECT_FALSE(consumed.fin_consumed);
- EXPECT_EQ(data.length() + GetQuicFlag(FLAGS_quic_buffered_data_threshold) - 1,
+ EXPECT_EQ(data.length() + GetQuicFlag(quic_buffered_data_threshold) - 1,
stream_->BufferedDataBytes());
EXPECT_FALSE(stream_->CanWriteNewData());
}
@@ -1255,7 +1253,7 @@
TEST_P(QuicStreamTest, WriteMemSlices) {
// Set buffered data low water mark to be 100.
- SetQuicFlag(FLAGS_quic_buffered_data_threshold, 100);
+ SetQuicFlag(quic_buffered_data_threshold, 100);
Initialize();
constexpr QuicByteCount kDataSize = 1024;
@@ -1295,7 +1293,7 @@
EXPECT_FALSE(stream_->fin_buffered());
QuicByteCount data_to_write =
- 2 * kDataSize - 100 - GetQuicFlag(FLAGS_quic_buffered_data_threshold) + 1;
+ 2 * kDataSize - 100 - GetQuicFlag(quic_buffered_data_threshold) + 1;
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
.WillOnce(InvokeWithoutArgs([this, data_to_write]() {
return session_->ConsumeData(stream_->id(), data_to_write, 100u, NO_FIN,
@@ -1303,15 +1301,15 @@
}));
EXPECT_CALL(*stream_, OnCanWriteNewData()).Times(1);
stream_->OnCanWrite();
- EXPECT_EQ(static_cast<uint64_t>(
- GetQuicFlag(FLAGS_quic_buffered_data_threshold) - 1),
- stream_->BufferedDataBytes());
+ EXPECT_EQ(
+ static_cast<uint64_t>(GetQuicFlag(quic_buffered_data_threshold) - 1),
+ stream_->BufferedDataBytes());
// Try to write slices2 again.
EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)).Times(0);
consumed = stream_->WriteMemSlices(span2, true);
EXPECT_EQ(2048u, consumed.bytes_consumed);
EXPECT_TRUE(consumed.fin_consumed);
- EXPECT_EQ(2 * kDataSize + GetQuicFlag(FLAGS_quic_buffered_data_threshold) - 1,
+ EXPECT_EQ(2 * kDataSize + GetQuicFlag(quic_buffered_data_threshold) - 1,
stream_->BufferedDataBytes());
EXPECT_TRUE(stream_->fin_buffered());
diff --git a/quiche/quic/core/quic_time_wait_list_manager.cc b/quiche/quic/core/quic_time_wait_list_manager.cc
index a892b53..d479973 100644
--- a/quiche/quic/core/quic_time_wait_list_manager.cc
+++ b/quiche/quic/core/quic_time_wait_list_manager.cc
@@ -71,7 +71,7 @@
QuicPacketWriter* writer, Visitor* visitor, const QuicClock* clock,
QuicAlarmFactory* alarm_factory)
: time_wait_period_(QuicTime::Delta::FromSeconds(
- GetQuicFlag(FLAGS_quic_time_wait_list_seconds))),
+ GetQuicFlag(quic_time_wait_list_seconds))),
connection_id_clean_up_alarm_(
alarm_factory->CreateAlarm(new ConnectionIdCleanUpAlarm(this))),
clock_(clock),
@@ -130,8 +130,7 @@
RemoveConnectionDataFromMap(it);
}
TrimTimeWaitListIfNeeded();
- int64_t max_connections =
- GetQuicFlag(FLAGS_quic_time_wait_list_max_connections);
+ int64_t max_connections = GetQuicFlag(quic_time_wait_list_max_connections);
QUICHE_DCHECK(connection_id_map_.empty() ||
num_connections() < static_cast<size_t>(max_connections));
if (new_connection_id) {
@@ -357,7 +356,7 @@
return true;
}
if (pending_packets_queue_.size() >=
- GetQuicFlag(FLAGS_quic_time_wait_list_max_pending_packets)) {
+ GetQuicFlag(quic_time_wait_list_max_pending_packets)) {
// There are too many pending packets.
QUIC_CODE_COUNT(quic_too_many_pending_packets_in_time_wait);
return true;
@@ -456,7 +455,7 @@
void QuicTimeWaitListManager::TrimTimeWaitListIfNeeded() {
const int64_t kMaxConnections =
- GetQuicFlag(FLAGS_quic_time_wait_list_max_connections);
+ GetQuicFlag(quic_time_wait_list_max_connections);
if (kMaxConnections < 0) {
return;
}
diff --git a/quiche/quic/core/quic_time_wait_list_manager_test.cc b/quiche/quic/core/quic_time_wait_list_manager_test.cc
index 93f6d87..9567519 100644
--- a/quiche/quic/core/quic_time_wait_list_manager_test.cc
+++ b/quiche/quic/core/quic_time_wait_list_manager_test.cc
@@ -592,12 +592,12 @@
TEST_F(QuicTimeWaitListManagerTest, MaxConnectionsTest) {
// Basically, shut off time-based eviction.
- SetQuicFlag(FLAGS_quic_time_wait_list_seconds, 10000000000);
- SetQuicFlag(FLAGS_quic_time_wait_list_max_connections, 5);
+ SetQuicFlag(quic_time_wait_list_seconds, 10000000000);
+ SetQuicFlag(quic_time_wait_list_max_connections, 5);
uint64_t current_conn_id = 0;
const int64_t kMaxConnections =
- GetQuicFlag(FLAGS_quic_time_wait_list_max_connections);
+ GetQuicFlag(quic_time_wait_list_max_connections);
// Add exactly the maximum number of connections
for (int64_t i = 0; i < kMaxConnections; ++i) {
++current_conn_id;
@@ -631,9 +631,9 @@
TEST_F(QuicTimeWaitListManagerTest, ZeroMaxConnections) {
// Basically, shut off time-based eviction.
- SetQuicFlag(FLAGS_quic_time_wait_list_seconds, 10000000000);
+ SetQuicFlag(quic_time_wait_list_seconds, 10000000000);
// Keep time wait list empty.
- SetQuicFlag(FLAGS_quic_time_wait_list_max_connections, 0);
+ SetQuicFlag(quic_time_wait_list_max_connections, 0);
uint64_t current_conn_id = 0;
// Add exactly the maximum number of connections
@@ -753,7 +753,7 @@
}
TEST_F(QuicTimeWaitListManagerTest, TooManyPendingPackets) {
- SetQuicFlag(FLAGS_quic_time_wait_list_max_pending_packets, 5);
+ SetQuicFlag(quic_time_wait_list_max_pending_packets, 5);
const size_t kNumOfUnProcessablePackets = 2048;
EXPECT_CALL(visitor_, OnWriteBlocked(&time_wait_list_manager_))
.Times(testing::AnyNumber());
diff --git a/quiche/quic/core/quic_versions.cc b/quiche/quic/core/quic_versions.cc
index df43ce7..cc9065b 100644
--- a/quiche/quic/core/quic_versions.cc
+++ b/quiche/quic/core/quic_versions.cc
@@ -25,7 +25,7 @@
QuicVersionLabel CreateRandomVersionLabelForNegotiation() {
QuicVersionLabel result;
- if (!GetQuicFlag(FLAGS_quic_disable_version_negotiation_grease_randomness)) {
+ if (!GetQuicFlag(quic_disable_version_negotiation_grease_randomness)) {
QuicRandom::GetInstance()->RandBytes(&result, sizeof(result));
} else {
result = MakeVersionLabel(0xd1, 0x57, 0x38, 0x3f);
diff --git a/quiche/quic/core/quic_versions_test.cc b/quiche/quic/core/quic_versions_test.cc
index 58bab07..ff57f3f 100644
--- a/quiche/quic/core/quic_versions_test.cc
+++ b/quiche/quic/core/quic_versions_test.cc
@@ -241,7 +241,7 @@
0x0f0f0f0f);
// Make sure that disabling randomness works.
- SetQuicFlag(FLAGS_quic_disable_version_negotiation_grease_randomness, true);
+ SetQuicFlag(quic_disable_version_negotiation_grease_randomness, true);
EXPECT_EQ(0xda5a3a3au, CreateQuicVersionLabel(
ParsedQuicVersion::ReservedForNegotiation()));
}
diff --git a/quiche/quic/core/tls_server_handshaker_test.cc b/quiche/quic/core/tls_server_handshaker_test.cc
index e652f05..bdcb7d7 100644
--- a/quiche/quic/core/tls_server_handshaker_test.cc
+++ b/quiche/quic/core/tls_server_handshaker_test.cc
@@ -169,7 +169,7 @@
QuicCompressedCertsCache::kQuicCompressedCertsCacheSize),
server_id_(kServerHostname, kServerPort, false),
supported_versions_({GetParam().version}) {
- SetQuicFlag(FLAGS_quic_disable_server_tls_resumption,
+ SetQuicFlag(quic_disable_server_tls_resumption,
GetParam().disable_resumption);
client_crypto_config_ = std::make_unique<QuicCryptoClientConfig>(
crypto_test_utils::ProofVerifierForTesting(),
diff --git a/quiche/quic/test_tools/simulator/quic_endpoint_test.cc b/quiche/quic/test_tools/simulator/quic_endpoint_test.cc
index 5850a8b..c247eb5 100644
--- a/quiche/quic/test_tools/simulator/quic_endpoint_test.cc
+++ b/quiche/quic/test_tools/simulator/quic_endpoint_test.cc
@@ -104,7 +104,7 @@
.WillRepeatedly(Return(10 * kDefaultBandwidth));
EXPECT_CALL(*sender, GetCongestionWindow())
.WillRepeatedly(Return(kMaxOutgoingPacketSize *
- GetQuicFlag(FLAGS_quic_max_congestion_window)));
+ GetQuicFlag(quic_max_congestion_window)));
test::QuicConnectionPeer::SetSendAlgorithm(endpoint_a.connection(), sender);
// First transmit a small, packet-size chunk of data.
diff --git a/quiche/quic/tools/quic_spdy_client_base.cc b/quiche/quic/tools/quic_spdy_client_base.cc
index 5ffe571..a34472c 100644
--- a/quiche/quic/tools/quic_spdy_client_base.cc
+++ b/quiche/quic/tools/quic_spdy_client_base.cc
@@ -105,7 +105,7 @@
void QuicSpdyClientBase::SendRequest(const Http2HeaderBlock& headers,
absl::string_view body, bool fin) {
- if (GetQuicFlag(FLAGS_quic_client_convert_http_header_name_to_lowercase)) {
+ if (GetQuicFlag(quic_client_convert_http_header_name_to_lowercase)) {
QUIC_CODE_COUNT(quic_client_convert_http_header_name_to_lowercase);
Http2HeaderBlock sanitized_headers;
for (const auto& p : headers) {
