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) {