Replace QUIC_VERSION_99 with QUIC_VERSION_IETF_DRAFT_27

Now that IETF drafts do not change as quickly, we no longer need a dumping ground for changes, so we're retiring QUIC_VERSION_99. The same functionality is now taken over by QUIC_VERSION_IETF_DRAFT_27.

gfe-relnote: no behavior change, protected by quic_enable_version_draft_27
PiperOrigin-RevId: 299195934
Change-Id: Ic5c7769574c1569edca3c31f1e05d867f7a5c29a
diff --git a/quic/core/crypto/crypto_utils.cc b/quic/core/crypto/crypto_utils.cc
index 8fcfbdd..b6c6b7a 100644
--- a/quic/core/crypto/crypto_utils.cc
+++ b/quic/core/crypto/crypto_utils.cc
@@ -115,8 +115,8 @@
 
 namespace {
 
-static_assert(kQuicIetfDraftVersion == 27, "Salts do not match draft version");
 // Salt from https://tools.ietf.org/html/draft-ietf-quic-tls-25#section-5.2
+// and https://tools.ietf.org/html/draft-ietf-quic-tls-27#section-5.2
 const uint8_t kDraft25InitialSalt[] = {0xc3, 0xee, 0xf7, 0x12, 0xc7, 0x2e, 0xbb,
                                        0x5a, 0x11, 0xa7, 0xd2, 0x43, 0x2b, 0xb4,
                                        0x63, 0x65, 0xbe, 0xf9, 0xf5, 0x02};
@@ -162,9 +162,8 @@
         case QUIC_VERSION_IETF_DRAFT_25:
           *out_len = QUICHE_ARRAYSIZE(kDraft25InitialSalt);
           return kDraft25InitialSalt;
-        case QUIC_VERSION_99:
-          // ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99) uses the IETF
-          // salt.
+        case QUIC_VERSION_IETF_DRAFT_27:
+          // draft-27 uses the same salt as draft-25.
           *out_len = QUICHE_ARRAYSIZE(kDraft25InitialSalt);
           return kDraft25InitialSalt;
         default:
@@ -183,7 +182,7 @@
 
 // Retry Integrity Protection Keys and Nonces.
 // https://tools.ietf.org/html/draft-ietf-quic-tls-25#section-5.8
-static_assert(kQuicIetfDraftVersion == 27, "Keys do not match draft version");
+// https://tools.ietf.org/html/draft-ietf-quic-tls-27#section-5.8
 const uint8_t kDraft25RetryIntegrityKey[] = {0x4d, 0x32, 0xec, 0xdb, 0x2a, 0x21,
                                              0x33, 0xc8, 0x41, 0xe4, 0x04, 0x3d,
                                              0xf2, 0x7d, 0x44, 0x30};
@@ -218,7 +217,8 @@
   }
   if (version ==
           ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_DRAFT_25) ||
-      version == ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99)) {
+      version ==
+          ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_DRAFT_27)) {
     *key = quiche::QuicheStringPiece(
         reinterpret_cast<const char*>(kDraft25RetryIntegrityKey),
         QUICHE_ARRAYSIZE(kDraft25RetryIntegrityKey));
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index 362ff81..7e2b470 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -1277,7 +1277,6 @@
 }
 
 TEST_P(QuicDispatcherTestAllVersions, ProcessSmallCoalescedPacket) {
-  SetQuicReloadableFlag(quic_enable_version_t099, true);
   CreateTimeWaitListManager();
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
 
@@ -2109,9 +2108,8 @@
 
 // Regression test for b/117874922.
 TEST_P(BufferedPacketStoreTest, ProcessBufferedChloWithDifferentVersion) {
-  // Turn off version T099, so the preferred version is not supported by the
-  // server.
-  SetQuicReloadableFlag(quic_enable_version_t099, false);
+  // Ensure the preferred version is not supported by the server.
+  SetQuicReloadableFlag(quic_enable_version_draft_27, false);
   uint64_t last_connection_id = kMaxNumSessionsToCreate + 5;
   ParsedQuicVersionVector supported_versions = CurrentSupportedVersions();
   for (uint64_t conn_id = 1; conn_id <= last_connection_id; ++conn_id) {
diff --git a/quic/core/quic_version_manager.cc b/quic/core/quic_version_manager.cc
index 2e32a14..1dda888 100644
--- a/quic/core/quic_version_manager.cc
+++ b/quic/core/quic_version_manager.cc
@@ -15,7 +15,8 @@
 
 QuicVersionManager::QuicVersionManager(
     ParsedQuicVersionVector supported_versions)
-    : enable_version_t099_(GetQuicReloadableFlag(quic_enable_version_t099)),
+    : enable_version_draft_27_(
+          GetQuicReloadableFlag(quic_enable_version_draft_27)),
       enable_version_draft_25_(
           GetQuicReloadableFlag(quic_enable_version_draft_25_v3)),
       disable_version_q050_(GetQuicReloadableFlag(quic_disable_version_q050)),
@@ -46,7 +47,8 @@
 void QuicVersionManager::MaybeRefilterSupportedVersions() {
   static_assert(SupportedVersions().size() == 8u,
                 "Supported versions out of sync");
-  if (enable_version_t099_ != GetQuicReloadableFlag(quic_enable_version_t099) ||
+  if (enable_version_draft_27_ !=
+          GetQuicReloadableFlag(quic_enable_version_draft_27) ||
       enable_version_draft_25_ !=
           GetQuicReloadableFlag(quic_enable_version_draft_25_v3) ||
       disable_version_q050_ !=
@@ -60,7 +62,8 @@
           GetQuicReloadableFlag(quic_disable_version_q046) ||
       disable_version_q043_ !=
           GetQuicReloadableFlag(quic_disable_version_q043)) {
-    enable_version_t099_ = GetQuicReloadableFlag(quic_enable_version_t099);
+    enable_version_draft_27_ =
+        GetQuicReloadableFlag(quic_enable_version_draft_27);
     enable_version_draft_25_ =
         GetQuicReloadableFlag(quic_enable_version_draft_25_v3);
     disable_version_q050_ = GetQuicReloadableFlag(quic_disable_version_q050);
diff --git a/quic/core/quic_version_manager.h b/quic/core/quic_version_manager.h
index 82a42f1..4d68374 100644
--- a/quic/core/quic_version_manager.h
+++ b/quic/core/quic_version_manager.h
@@ -41,8 +41,8 @@
 
  private:
   // Cached value of reloadable flags.
-  // quic_enable_version_t099 flag
-  bool enable_version_t099_;
+  // quic_enable_version_draft_27 flag
+  bool enable_version_draft_27_;
   // quic_enable_version_draft_25_v3 flag
   bool enable_version_draft_25_;
   // quic_disable_version_q050 flag
diff --git a/quic/core/quic_version_manager_test.cc b/quic/core/quic_version_manager_test.cc
index 86c5729..98dc4a3 100644
--- a/quic/core/quic_version_manager_test.cc
+++ b/quic/core/quic_version_manager_test.cc
@@ -18,7 +18,7 @@
 TEST_F(QuicVersionManagerTest, QuicVersionManager) {
   static_assert(SupportedVersions().size() == 8u,
                 "Supported versions out of sync");
-  SetQuicReloadableFlag(quic_enable_version_t099, false);
+  SetQuicReloadableFlag(quic_enable_version_draft_27, false);
   SetQuicReloadableFlag(quic_enable_version_draft_25_v3, false);
   SetQuicReloadableFlag(quic_enable_version_t050, false);
   SetQuicReloadableFlag(quic_disable_version_q050, false);
@@ -45,9 +45,9 @@
   EXPECT_EQ(FilterSupportedVersions(AllSupportedVersions()),
             manager.GetSupportedVersions());
 
-  SetQuicReloadableFlag(quic_enable_version_t099, true);
+  SetQuicReloadableFlag(quic_enable_version_draft_27, true);
   expected_parsed_versions.push_back(
-      ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99));
+      ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_DRAFT_27));
   EXPECT_EQ(expected_parsed_versions, manager.GetSupportedVersions());
   EXPECT_EQ(FilterSupportedVersions(AllSupportedVersions()),
             manager.GetSupportedVersions());
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index 9cccff9..a7450aa 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -155,7 +155,7 @@
 
 bool ParsedQuicVersion::HasVarIntTransportParams() const {
   DCHECK(IsKnown());
-  return transport_version >= QUIC_VERSION_99;
+  return transport_version >= QUIC_VERSION_IETF_DRAFT_27;
 }
 
 bool VersionHasLengthPrefixedConnectionIds(
@@ -202,11 +202,11 @@
       }
       QUIC_BUG << "QUIC_VERSION_IETF_DRAFT_25 requires TLS";
       return 0;
-    case QUIC_VERSION_99:
+    case QUIC_VERSION_IETF_DRAFT_27:
       if (parsed_version.handshake_protocol == PROTOCOL_TLS1_3) {
-        return MakeVersionLabel(0xff, 0x00, 0x00, kQuicIetfDraftVersion);
+        return MakeVersionLabel(0xff, 0x00, 0x00, 27);
       }
-      QUIC_BUG << "Invalid ParsedQuicVersion: Q099";
+      QUIC_BUG << "QUIC_VERSION_IETF_DRAFT_27 requires TLS";
       return 0;
     case QUIC_VERSION_RESERVED_FOR_NEGOTIATION:
       return CreateRandomVersionLabelForNegotiation();
@@ -280,11 +280,6 @@
       return version;
     }
   }
-  // Still recognize T099 even if flag quic_ietf_draft_version has been changed.
-  if (GetQuicReloadableFlag(quic_enable_version_t099) &&
-      version_string == "T099") {
-    return ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99);
-  }
   // Reading from the client so this should not be considered an ERROR.
   QUIC_DLOG(INFO) << "Unsupported QUIC version string: \"" << version_string
                   << "\".";
@@ -313,9 +308,9 @@
   ParsedQuicVersionVector filtered_versions;
   filtered_versions.reserve(versions.size());
   for (ParsedQuicVersion version : versions) {
-    if (version.transport_version == QUIC_VERSION_99) {
+    if (version.transport_version == QUIC_VERSION_IETF_DRAFT_27) {
       QUIC_BUG_IF(version.handshake_protocol != PROTOCOL_TLS1_3);
-      if (GetQuicReloadableFlag(quic_enable_version_t099)) {
+      if (GetQuicReloadableFlag(quic_enable_version_draft_27)) {
         filtered_versions.push_back(version);
       }
     } else if (version.transport_version == QUIC_VERSION_IETF_DRAFT_25) {
@@ -448,7 +443,7 @@
     RETURN_STRING_LITERAL(QUIC_VERSION_49);
     RETURN_STRING_LITERAL(QUIC_VERSION_50);
     RETURN_STRING_LITERAL(QUIC_VERSION_IETF_DRAFT_25);
-    RETURN_STRING_LITERAL(QUIC_VERSION_99);
+    RETURN_STRING_LITERAL(QUIC_VERSION_IETF_DRAFT_27);
     RETURN_STRING_LITERAL(QUIC_VERSION_UNSUPPORTED);
     RETURN_STRING_LITERAL(QUIC_VERSION_RESERVED_FOR_NEGOTIATION);
   }
@@ -555,9 +550,8 @@
     if (parsed_version.transport_version == QUIC_VERSION_IETF_DRAFT_25) {
       return "h3-25";
     }
-    if (parsed_version.transport_version == QUIC_VERSION_99) {
-      return "h3-" +
-             quiche::QuicheTextUtils::Uint64ToString(kQuicIetfDraftVersion);
+    if (parsed_version.transport_version == QUIC_VERSION_IETF_DRAFT_27) {
+      return "h3-27";
     }
   }
   return "h3-" + ParsedQuicVersionToString(parsed_version);
@@ -570,9 +564,9 @@
 void QuicEnableVersion(ParsedQuicVersion parsed_version) {
   static_assert(SupportedVersions().size() == 8u,
                 "Supported versions out of sync");
-  if (parsed_version.transport_version == QUIC_VERSION_99) {
+  if (parsed_version.transport_version == QUIC_VERSION_IETF_DRAFT_27) {
     QUIC_BUG_IF(parsed_version.handshake_protocol != PROTOCOL_TLS1_3);
-    SetQuicReloadableFlag(quic_enable_version_t099, true);
+    SetQuicReloadableFlag(quic_enable_version_draft_27, true);
   } else if (parsed_version.transport_version == QUIC_VERSION_IETF_DRAFT_25) {
     QUIC_BUG_IF(parsed_version.handshake_protocol != PROTOCOL_TLS1_3);
     SetQuicReloadableFlag(quic_enable_version_draft_25_v3, true);
diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index 828e73d..bb539b1 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -108,8 +108,10 @@
                          // header format from draft-ietf-quic-invariants-06.
   QUIC_VERSION_50 = 50,  // Header protection and initial obfuscators.
   QUIC_VERSION_IETF_DRAFT_25 = 70,  // draft-ietf-quic-transport-25.
-  QUIC_VERSION_99 = 99,  // Dumping ground for IETF QUIC changes which are not
-                         // yet ready for production.
+  QUIC_VERSION_IETF_DRAFT_27 = 71,  // draft-ietf-quic-transport-27.
+  // Version 99 was a dumping ground for IETF QUIC changes which were not yet
+  // yet ready for production between 2018-02 and 2020-02.
+
   // QUIC_VERSION_RESERVED_FOR_NEGOTIATION is sent over the wire as ?a?a?a?a
   // which is part of a range reserved by the IETF for version negotiation
   // testing (see the "Versions" section of draft-ietf-quic-transport).
@@ -124,9 +126,6 @@
 QUIC_EXPORT_PRIVATE std::string QuicVersionToString(
     QuicTransportVersion transport_version);
 
-// IETF draft version most closely approximated by TLS + v99.
-enum : int { kQuicIetfDraftVersion = 27 };
-
 // The crypto handshake protocols that can be used with QUIC.
 enum HandshakeProtocol {
   PROTOCOL_UNSUPPORTED,
@@ -158,8 +157,7 @@
     case PROTOCOL_QUIC_CRYPTO:
       return transport_version != QUIC_VERSION_UNSUPPORTED &&
              transport_version != QUIC_VERSION_IETF_DRAFT_25 &&
-             // We explicitly removed support for Q099 to reduce test load.
-             transport_version != QUIC_VERSION_99;
+             transport_version != QUIC_VERSION_IETF_DRAFT_27;
     case PROTOCOL_TLS1_3:
       // The TLS handshake is only deployable if CRYPTO frames are also used.
       // We explicitly removed support for T048 and T049 to reduce test load.
@@ -321,7 +319,7 @@
 // See go/new-quic-version for more details on how to roll out new versions.
 constexpr std::array<QuicTransportVersion, 7> SupportedTransportVersions() {
   return std::array<QuicTransportVersion, 7>(
-      {QUIC_VERSION_99, QUIC_VERSION_IETF_DRAFT_25, QUIC_VERSION_50,
+      {QUIC_VERSION_IETF_DRAFT_27, QUIC_VERSION_IETF_DRAFT_25, QUIC_VERSION_50,
        QUIC_VERSION_49, QUIC_VERSION_48, QUIC_VERSION_46, QUIC_VERSION_43});
 }
 
@@ -338,7 +336,7 @@
       ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_48),
       ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_46),
       ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_43),
-      ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99),
+      ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_DRAFT_27),
       ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_DRAFT_25),
       ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_50),
   });
diff --git a/quic/core/quic_versions_test.cc b/quic/core/quic_versions_test.cc
index 9c2ed74..59d7b09 100644
--- a/quic/core/quic_versions_test.cc
+++ b/quic/core/quic_versions_test.cc
@@ -269,7 +269,7 @@
 TEST_F(QuicVersionsTest, FilterSupportedVersionsAllVersions) {
   static_assert(SupportedVersions().size() == 8u,
                 "Supported versions out of sync");
-  SetQuicReloadableFlag(quic_enable_version_t099, true);
+  SetQuicReloadableFlag(quic_enable_version_draft_27, true);
   SetQuicReloadableFlag(quic_enable_version_draft_25_v3, true);
   SetQuicReloadableFlag(quic_enable_version_t050, true);
   SetQuicReloadableFlag(quic_disable_version_q050, false);
@@ -290,7 +290,7 @@
   expected_parsed_versions.push_back(
       ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_43));
   expected_parsed_versions.push_back(
-      ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99));
+      ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_DRAFT_27));
   expected_parsed_versions.push_back(
       ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_DRAFT_25));
   expected_parsed_versions.push_back(
@@ -304,7 +304,7 @@
 TEST_F(QuicVersionsTest, FilterSupportedVersionsNo99) {
   static_assert(SupportedVersions().size() == 8u,
                 "Supported versions out of sync");
-  SetQuicReloadableFlag(quic_enable_version_t099, false);
+  SetQuicReloadableFlag(quic_enable_version_draft_27, false);
   SetQuicReloadableFlag(quic_enable_version_draft_25_v3, true);
   SetQuicReloadableFlag(quic_enable_version_t050, true);
   SetQuicReloadableFlag(quic_disable_version_q050, false);
@@ -336,7 +336,7 @@
 TEST_F(QuicVersionsTest, FilterSupportedVersionsNoFlags) {
   static_assert(SupportedVersions().size() == 8u,
                 "Supported versions out of sync");
-  SetQuicReloadableFlag(quic_enable_version_t099, false);
+  SetQuicReloadableFlag(quic_enable_version_draft_27, false);
   SetQuicReloadableFlag(quic_enable_version_draft_25_v3, false);
   SetQuicReloadableFlag(quic_enable_version_t050, false);
   SetQuicReloadableFlag(quic_disable_version_q050, false);
@@ -408,7 +408,7 @@
   EXPECT_EQ(QUIC_VERSION_49, 49);
   EXPECT_EQ(QUIC_VERSION_50, 50);
   EXPECT_EQ(QUIC_VERSION_IETF_DRAFT_25, 70);
-  EXPECT_EQ(QUIC_VERSION_99, 99);
+  EXPECT_EQ(QUIC_VERSION_IETF_DRAFT_27, 71);
 }
 
 TEST_F(QuicVersionsTest, AlpnForVersion) {
@@ -424,24 +424,22 @@
       ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_50);
   ParsedQuicVersion parsed_version_draft_25 =
       ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_DRAFT_25);
-  ParsedQuicVersion parsed_version_t099 =
-      ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99);
+  ParsedQuicVersion parsed_version_draft_27 =
+      ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_DRAFT_27);
 
   EXPECT_EQ("h3-Q048", AlpnForVersion(parsed_version_q048));
   EXPECT_EQ("h3-Q049", AlpnForVersion(parsed_version_q049));
   EXPECT_EQ("h3-Q050", AlpnForVersion(parsed_version_q050));
   EXPECT_EQ("h3-T050", AlpnForVersion(parsed_version_t050));
   EXPECT_EQ("h3-25", AlpnForVersion(parsed_version_draft_25));
-  EXPECT_EQ("h3-27", AlpnForVersion(parsed_version_t099));
-  static_assert(kQuicIetfDraftVersion == 27,
-                "ALPN does not match draft version");
+  EXPECT_EQ("h3-27", AlpnForVersion(parsed_version_draft_27));
 }
 
 TEST_F(QuicVersionsTest, QuicEnableVersion) {
   static_assert(SupportedVersions().size() == 8u,
                 "Supported versions out of sync");
-  ParsedQuicVersion parsed_version_t099 =
-      ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99);
+  ParsedQuicVersion parsed_version_draft_27 =
+      ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_DRAFT_27);
   ParsedQuicVersion parsed_version_draft_25 =
       ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_DRAFT_25);
   ParsedQuicVersion parsed_version_q050 =
@@ -451,9 +449,9 @@
 
   {
     QuicFlagSaver flag_saver;
-    SetQuicReloadableFlag(quic_enable_version_t099, false);
-    QuicEnableVersion(parsed_version_t099);
-    EXPECT_TRUE(GetQuicReloadableFlag(quic_enable_version_t099));
+    SetQuicReloadableFlag(quic_enable_version_draft_27, false);
+    QuicEnableVersion(parsed_version_draft_27);
+    EXPECT_TRUE(GetQuicReloadableFlag(quic_enable_version_draft_27));
   }
 
   {
diff --git a/quic/quartc/quartc_multiplexer_test.cc b/quic/quartc/quartc_multiplexer_test.cc
index 0416e1a..fcdbe99 100644
--- a/quic/quartc/quartc_multiplexer_test.cc
+++ b/quic/quartc/quartc_multiplexer_test.cc
@@ -202,7 +202,7 @@
             quic::QuartcSessionConfig())) {
     // TODO(b/150224094): Re-enable TLS handshake.
     // TODO(b/150236522): Parametrize by QUIC version.
-    SetQuicReloadableFlag(quic_enable_version_t099, false);
+    SetQuicReloadableFlag(quic_enable_version_draft_27, false);
     SetQuicReloadableFlag(quic_enable_version_draft_25_v3, false);
     SetQuicReloadableFlag(quic_enable_version_t050, false);
   }
diff --git a/quic/quartc/quartc_session_test.cc b/quic/quartc/quartc_session_test.cc
index 4952c6a..4731205 100644
--- a/quic/quartc/quartc_session_test.cc
+++ b/quic/quartc/quartc_session_test.cc
@@ -56,7 +56,7 @@
   void Init(bool create_client_endpoint = true) {
     // TODO(b/150224094): Re-enable TLS handshake.
     // TODO(b/150236522): Parametrize by QUIC version.
-    SetQuicReloadableFlag(quic_enable_version_t099, false);
+    SetQuicReloadableFlag(quic_enable_version_draft_27, false);
     SetQuicReloadableFlag(quic_enable_version_draft_25_v3, false);
     SetQuicReloadableFlag(quic_enable_version_t050, false);
 
diff --git a/quic/quartc/test/quartc_bidi_test.cc b/quic/quartc/test/quartc_bidi_test.cc
index f51ec2b..371fbed 100644
--- a/quic/quartc/test/quartc_bidi_test.cc
+++ b/quic/quartc/test/quartc_bidi_test.cc
@@ -28,7 +28,7 @@
   QuartcBidiTest() {
     // TODO(b/150224094): Re-enable TLS handshake.
     // TODO(b/150236522): Parametrize by QUIC version.
-    SetQuicReloadableFlag(quic_enable_version_t099, false);
+    SetQuicReloadableFlag(quic_enable_version_draft_27, false);
     SetQuicReloadableFlag(quic_enable_version_draft_25_v3, false);
     SetQuicReloadableFlag(quic_enable_version_t050, false);
 
diff --git a/quic/quartc/test/quartc_peer_test.cc b/quic/quartc/test/quartc_peer_test.cc
index 58f88e3..43794a9 100644
--- a/quic/quartc/test/quartc_peer_test.cc
+++ b/quic/quartc/test/quartc_peer_test.cc
@@ -37,7 +37,7 @@
                             QuicTime::Delta::FromMilliseconds(100)) {
     // TODO(b/150224094): Re-enable TLS handshake.
     // TODO(b/150236522): Parametrize by QUIC version.
-    SetQuicReloadableFlag(quic_enable_version_t099, false);
+    SetQuicReloadableFlag(quic_enable_version_draft_27, false);
     SetQuicReloadableFlag(quic_enable_version_draft_25_v3, false);
     SetQuicReloadableFlag(quic_enable_version_t050, false);