diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 603cd48..194d5ce 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -135,7 +135,7 @@
   // handshake protocol). So these tests need to ensure that clients are never
   // attempting to do 0-RTT across incompatible versions. Chromium only
   // supports a single version at a time anyway. :)
-  FLAGS_quic_supports_tls_handshake = use_tls_handshake;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, use_tls_handshake);
   ParsedQuicVersionVector all_supported_versions =
       FilterSupportedVersions(AllSupportedVersions());
 
@@ -286,7 +286,7 @@
         support_server_push_(false),
         override_connection_id_(nullptr),
         expected_connection_id_length_(kQuicDefaultConnectionIdLength) {
-    FLAGS_quic_supports_tls_handshake = true;
+    SetQuicFlag(&FLAGS_quic_supports_tls_handshake, true);
     SetQuicRestartFlag(quic_no_server_conn_ver_negotiation2, true);
     SetQuicReloadableFlag(quic_no_client_conn_ver_negotiation, true);
     client_supported_versions_ = GetParam().client_supported_versions;
diff --git a/quic/core/quic_crypto_client_stream_test.cc b/quic/core/quic_crypto_client_stream_test.cc
index 5839477..a321ec2 100644
--- a/quic/core/quic_crypto_client_stream_test.cc
+++ b/quic/core/quic_crypto_client_stream_test.cc
@@ -97,7 +97,7 @@
 }
 
 TEST_F(QuicCryptoClientStreamTest, ConnectedAfterTlsHandshake) {
-  FLAGS_quic_supports_tls_handshake = true;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, true);
   supported_versions_.clear();
   for (QuicTransportVersion transport_version :
        AllSupportedTransportVersions()) {
diff --git a/quic/core/quic_crypto_server_stream_test.cc b/quic/core/quic_crypto_server_stream_test.cc
index 660c588..6a4eaf9 100644
--- a/quic/core/quic_crypto_server_stream_test.cc
+++ b/quic/core/quic_crypto_server_stream_test.cc
@@ -215,7 +215,7 @@
 }
 
 TEST_P(QuicCryptoServerStreamTest, ConnectedAfterTlsHandshake) {
-  FLAGS_quic_supports_tls_handshake = true;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, true);
   client_options_.only_tls_versions = true;
   supported_versions_.clear();
   for (QuicTransportVersion transport_version :
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index 1e646af..f280717 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -380,7 +380,7 @@
     // TLS is only supported in versions 47 and greater.
     return;
   }
-  FLAGS_quic_supports_tls_handshake = true;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, true);
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
 
   EXPECT_CALL(*dispatcher_,
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index 92232ba..a5f1f41 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -32,7 +32,7 @@
     : handshake_protocol(handshake_protocol),
       transport_version(transport_version) {
   if (handshake_protocol == PROTOCOL_TLS1_3 &&
-      !FLAGS_quic_supports_tls_handshake) {
+      !GetQuicFlag(FLAGS_quic_supports_tls_handshake)) {
     QUIC_BUG << "TLS use attempted when not enabled";
   }
 }
@@ -104,7 +104,7 @@
 
 ParsedQuicVersion ParseQuicVersionLabel(QuicVersionLabel version_label) {
   std::vector<HandshakeProtocol> protocols = {PROTOCOL_QUIC_CRYPTO};
-  if (FLAGS_quic_supports_tls_handshake) {
+  if (GetQuicFlag(FLAGS_quic_supports_tls_handshake)) {
     protocols.push_back(PROTOCOL_TLS1_3);
   }
   for (QuicTransportVersion version : kSupportedTransportVersions) {
@@ -134,7 +134,7 @@
   }
 
   std::vector<HandshakeProtocol> protocols = {PROTOCOL_QUIC_CRYPTO};
-  if (FLAGS_quic_supports_tls_handshake) {
+  if (GetQuicFlag(FLAGS_quic_supports_tls_handshake)) {
     protocols.push_back(PROTOCOL_TLS1_3);
   }
   for (QuicTransportVersion version : kSupportedTransportVersions) {
@@ -147,7 +147,8 @@
     }
   }
   // Still recognize T099 even if flag quic_ietf_draft_version has been changed.
-  if (FLAGS_quic_supports_tls_handshake && version_string == "T099") {
+  if (GetQuicFlag(FLAGS_quic_supports_tls_handshake) &&
+      version_string == "T099") {
     return ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99);
   }
   // Reading from the client so this should not be considered an ERROR.
@@ -167,7 +168,8 @@
 ParsedQuicVersionVector AllSupportedVersions() {
   ParsedQuicVersionVector supported_versions;
   for (HandshakeProtocol protocol : kSupportedHandshakeProtocols) {
-    if (protocol == PROTOCOL_TLS1_3 && !FLAGS_quic_supports_tls_handshake) {
+    if (protocol == PROTOCOL_TLS1_3 &&
+        !GetQuicFlag(FLAGS_quic_supports_tls_handshake)) {
       continue;
     }
     for (QuicTransportVersion version : kSupportedTransportVersions) {
diff --git a/quic/core/quic_versions_test.cc b/quic/core/quic_versions_test.cc
index b04db0c..4201e43 100644
--- a/quic/core/quic_versions_test.cc
+++ b/quic/core/quic_versions_test.cc
@@ -116,11 +116,11 @@
   }
 
   // Test a TLS version:
-  FLAGS_quic_supports_tls_handshake = true;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, true);
   QuicTag tls_tag = MakeQuicTag('3', '4', '0', 'T');
   EXPECT_EQ(PROTOCOL_TLS1_3, QuicVersionLabelToHandshakeProtocol(tls_tag));
 
-  FLAGS_quic_supports_tls_handshake = false;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, false);
   if (QUIC_DLOG_INFO_IS_ON()) {
     EXPECT_QUIC_LOG_CALL_CONTAINS(log, INFO,
                                   "Unsupported QuicVersionLabel version: T043")
@@ -142,7 +142,7 @@
             ParseQuicVersionLabel(MakeVersionLabel('Q', '0', '4', '7')));
 
   // Test a TLS version:
-  FLAGS_quic_supports_tls_handshake = true;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, true);
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_39),
             ParseQuicVersionLabel(MakeVersionLabel('T', '0', '3', '9')));
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_43),
@@ -154,7 +154,7 @@
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_47),
             ParseQuicVersionLabel(MakeVersionLabel('T', '0', '4', '7')));
 
-  FLAGS_quic_supports_tls_handshake = false;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, false);
   EXPECT_EQ(UnsupportedQuicVersion(),
             ParseQuicVersionLabel(MakeVersionLabel('T', '0', '3', '5')));
   EXPECT_EQ(UnsupportedQuicVersion(),
@@ -188,7 +188,7 @@
   EXPECT_EQ(UnsupportedQuicVersion(), ParseQuicVersionString("Q047 "));
 
   // Test a TLS version:
-  FLAGS_quic_supports_tls_handshake = true;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, true);
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_39),
             ParseQuicVersionString("T039"));
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_43),
@@ -200,7 +200,7 @@
   EXPECT_EQ(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_47),
             ParseQuicVersionString("T047"));
 
-  FLAGS_quic_supports_tls_handshake = false;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, false);
   EXPECT_EQ(UnsupportedQuicVersion(), ParseQuicVersionString("T035"));
   EXPECT_EQ(UnsupportedQuicVersion(), ParseQuicVersionString("T039"));
   EXPECT_EQ(UnsupportedQuicVersion(), ParseQuicVersionString("T043"));
@@ -228,7 +228,7 @@
                 ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_47)));
 
   // Test a TLS version:
-  FLAGS_quic_supports_tls_handshake = true;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, true);
   EXPECT_EQ(MakeVersionLabel('T', '0', '3', '9'),
             CreateQuicVersionLabel(
                 ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_39)));
@@ -245,7 +245,7 @@
             CreateQuicVersionLabel(
                 ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_47)));
 
-  FLAGS_quic_supports_tls_handshake = false;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, false);
   EXPECT_EQ(UnsupportedQuicVersion(),
             ParseQuicVersionLabel(MakeVersionLabel('T', '0', '3', '5')));
   EXPECT_EQ(UnsupportedQuicVersion(),
@@ -323,7 +323,7 @@
 
   // Make sure that all supported versions are present in
   // ParsedQuicVersionToString.
-  FLAGS_quic_supports_tls_handshake = true;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, true);
   for (QuicTransportVersion transport_version : kSupportedTransportVersions) {
     for (HandshakeProtocol protocol : kSupportedHandshakeProtocols) {
       EXPECT_NE("0", ParsedQuicVersionToString(
@@ -557,14 +557,14 @@
 }
 
 TEST_F(QuicVersionsTest, AlpnForVersion) {
-  FLAGS_quic_supports_tls_handshake = true;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, true);
   ParsedQuicVersion parsed_version_q047 =
       ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_47);
   ParsedQuicVersion parsed_version_t047 =
       ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_47);
   ParsedQuicVersion parsed_version_t099 =
       ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99);
-  FLAGS_quic_supports_tls_handshake = false;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, false);
 
   EXPECT_EQ("h3-google-Q047", AlpnForVersion(parsed_version_q047));
   EXPECT_EQ("h3-google-T047", AlpnForVersion(parsed_version_t047));
@@ -572,10 +572,10 @@
 }
 
 TEST_F(QuicVersionsTest, InitializeSupportForIetfDraft) {
-  FLAGS_quic_supports_tls_handshake = true;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, true);
   ParsedQuicVersion parsed_version_t099 =
       ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99);
-  FLAGS_quic_supports_tls_handshake = false;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, false);
   EXPECT_EQ(MakeVersionLabel('T', '0', '9', '9'),
             CreateQuicVersionLabel(parsed_version_t099));
   EXPECT_EQ("h3-google-T099", AlpnForVersion(parsed_version_t099));
@@ -584,10 +584,10 @@
   EXPECT_EQ(MakeVersionLabel('T', '0', '9', '9'),
             CreateQuicVersionLabel(parsed_version_t099));
   EXPECT_EQ("h3-google-T099", AlpnForVersion(parsed_version_t099));
-  EXPECT_FALSE(FLAGS_quic_supports_tls_handshake);
+  EXPECT_FALSE(GetQuicFlag(FLAGS_quic_supports_tls_handshake));
 
   QuicVersionInitializeSupportForIetfDraft(18);
-  EXPECT_TRUE(FLAGS_quic_supports_tls_handshake);
+  EXPECT_TRUE(GetQuicFlag(FLAGS_quic_supports_tls_handshake));
   EXPECT_EQ(MakeVersionLabel(0xff, 0, 0, 18),
             CreateQuicVersionLabel(parsed_version_t099));
   EXPECT_EQ("h3-18", AlpnForVersion(parsed_version_t099));
@@ -599,14 +599,14 @@
 }
 
 TEST_F(QuicVersionsTest, QuicEnableVersion) {
-  FLAGS_quic_supports_tls_handshake = true;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, true);
   ParsedQuicVersion parsed_version_q047 =
       ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_47);
   ParsedQuicVersion parsed_version_t047 =
       ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_47);
   ParsedQuicVersion parsed_version_t099 =
       ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99);
-  FLAGS_quic_supports_tls_handshake = false;
+  SetQuicFlag(&FLAGS_quic_supports_tls_handshake, false);
   SetQuicReloadableFlag(quic_disable_version_39, false);
   SetQuicReloadableFlag(quic_enable_version_43, true);
   SetQuicReloadableFlag(quic_enable_version_44, true);
@@ -615,17 +615,17 @@
   SetQuicReloadableFlag(quic_enable_version_99, false);
 
   QuicEnableVersion(parsed_version_q047);
-  EXPECT_FALSE(FLAGS_quic_supports_tls_handshake);
+  EXPECT_FALSE(GetQuicFlag(FLAGS_quic_supports_tls_handshake));
   EXPECT_TRUE(GetQuicReloadableFlag(quic_enable_version_47));
   EXPECT_FALSE(GetQuicReloadableFlag(quic_enable_version_99));
 
   QuicEnableVersion(parsed_version_t047);
-  EXPECT_TRUE(FLAGS_quic_supports_tls_handshake);
+  EXPECT_TRUE(GetQuicFlag(FLAGS_quic_supports_tls_handshake));
   EXPECT_TRUE(GetQuicReloadableFlag(quic_enable_version_47));
   EXPECT_FALSE(GetQuicReloadableFlag(quic_enable_version_99));
 
   QuicEnableVersion(parsed_version_t099);
-  EXPECT_TRUE(FLAGS_quic_supports_tls_handshake);
+  EXPECT_TRUE(GetQuicFlag(FLAGS_quic_supports_tls_handshake));
   EXPECT_TRUE(GetQuicReloadableFlag(quic_enable_version_47));
   EXPECT_TRUE(GetQuicReloadableFlag(quic_enable_version_99));
 }