diff --git a/quic/core/crypto/crypto_utils.cc b/quic/core/crypto/crypto_utils.cc
index 3127ede..14c13fc 100644
--- a/quic/core/crypto/crypto_utils.cc
+++ b/quic/core/crypto/crypto_utils.cc
@@ -141,7 +141,7 @@
 
 const uint8_t* InitialSaltForVersion(const ParsedQuicVersion& version,
                                      size_t* out_len) {
-  static_assert(SupportedVersions().size() == 9u,
+  static_assert(SupportedVersions().size() == 7u,
                 "Supported versions out of sync with initial encryption salts");
   switch (version.handshake_protocol) {
     case PROTOCOL_QUIC_CRYPTO:
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index 01ed4fb..1d84b06 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -1085,12 +1085,38 @@
 
 TEST_P(QuicDispatcherTestOneVersion,
        RejectDeprecatedVersionsWithVersionNegotiation) {
-  static_assert(quic::SupportedVersions().size() == 9u,
+  static_assert(quic::SupportedVersions().size() == 7u,
                 "Please add deprecated versions to this test");
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
   CreateTimeWaitListManager();
 
   {
+    char packet49[kMinPacketSizeForVersionNegotiation] = {
+        0xC0, 'Q', '0', '4', '9', /*connection ID length byte*/ 0x50};
+    QuicReceivedPacket received_packet49(
+        packet49, kMinPacketSizeForVersionNegotiation, QuicTime::Zero());
+    EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _)).Times(0);
+    EXPECT_CALL(*time_wait_list_manager_,
+                SendVersionNegotiationPacket(_, _, _, _, _, _, _, _))
+        .Times(1);
+    dispatcher_->ProcessPacket(server_address_, client_address,
+                               received_packet49);
+  }
+
+  {
+    char packet48[kMinPacketSizeForVersionNegotiation] = {
+        0xC0, 'Q', '0', '4', '8', /*connection ID length byte*/ 0x50};
+    QuicReceivedPacket received_packet48(
+        packet48, kMinPacketSizeForVersionNegotiation, QuicTime::Zero());
+    EXPECT_CALL(*dispatcher_, CreateQuicSession(_, _, _, _)).Times(0);
+    EXPECT_CALL(*time_wait_list_manager_,
+                SendVersionNegotiationPacket(_, _, _, _, _, _, _, _))
+        .Times(1);
+    dispatcher_->ProcessPacket(server_address_, client_address,
+                               received_packet48);
+  }
+
+  {
     char packet47[kMinPacketSizeForVersionNegotiation] = {
         0xC0, 'Q', '0', '4', '7', /*connection ID length byte*/ 0x50};
     QuicReceivedPacket received_packet47(
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index 5a5a8fa..c610997 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -1003,7 +1003,7 @@
   // clang-format on
   unsigned char* p = packet;
   size_t p_size = QUICHE_ARRAYSIZE(packet);
-  if (framer_.transport_version() > QUIC_VERSION_43) {
+  if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -1029,7 +1029,7 @@
 }
 
 TEST_P(QuicFramerTest, PacketHeader) {
-  if (framer_.transport_version() > QUIC_VERSION_43) {
+  if (framer_.version().HasIetfInvariantHeader()) {
     return;
   }
 
@@ -1108,7 +1108,7 @@
   };
   // clang-format on
 
-  if (framer_.transport_version() <= QUIC_VERSION_43 ||
+  if (!framer_.version().HasIetfInvariantHeader() ||
       QuicVersionHasLongHeaderLengths(framer_.transport_version())) {
     return;
   }
@@ -1154,7 +1154,7 @@
 }
 
 TEST_P(QuicFramerTest, LongPacketHeaderWithBothConnectionIds) {
-  if (framer_.transport_version() <= QUIC_VERSION_43) {
+  if (!framer_.version().HasIetfInvariantHeader()) {
     // This test requires an IETF long header.
     return;
   }
@@ -1202,7 +1202,7 @@
 
   unsigned char* p = packet;
   size_t p_length = QUICHE_ARRAYSIZE(packet);
-  if (framer_.transport_version() >= QUIC_VERSION_49) {
+  if (framer_.version().HasLongHeaderLengths()) {
     p = packet49;
     p_length = QUICHE_ARRAYSIZE(packet49);
   }
@@ -1287,10 +1287,10 @@
   // clang-format on
   unsigned char* p = packet;
   size_t p_length = QUICHE_ARRAYSIZE(packet);
-  if (framer_.transport_version() >= QUIC_VERSION_49) {
+  if (framer_.version().HasLongHeaderLengths()) {
     p = packet49;
     p_length = QUICHE_ARRAYSIZE(packet49);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_length = QUICHE_ARRAYSIZE(packet46);
   }
@@ -1507,8 +1507,7 @@
   PacketFragments& fragments =
       framer_.version().HasHeaderProtection()
           ? packet_hp
-          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                            : packet);
+          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
@@ -1586,10 +1585,9 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.transport_version() >= QUIC_VERSION_49
+      framer_.version().HasLongHeaderLengths()
           ? packet49
-          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                            : packet);
+          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
@@ -1650,8 +1648,7 @@
   PacketFragments& fragments =
       framer_.version().HasHeaderProtection()
           ? packet_hp
-          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                            : packet);
+          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
@@ -1713,8 +1710,7 @@
   PacketFragments& fragments =
       framer_.version().HasHeaderProtection()
           ? packet_hp
-          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                            : packet);
+          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   if (framer_.version().HasHeaderProtection()) {
@@ -1783,8 +1779,7 @@
   PacketFragments& fragments =
       framer_.version().HasHeaderProtection()
           ? packet_hp
-          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                            : packet);
+          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   if (framer_.version().HasHeaderProtection()) {
@@ -1950,10 +1945,10 @@
 
   unsigned char* p = packet;
   size_t p_size = QUICHE_ARRAYSIZE(packet);
-  if (framer_.transport_version() >= QUIC_VERSION_49) {
+  if (framer_.version().HasLongHeaderLengths()) {
     p = packet49;
     p_size = QUICHE_ARRAYSIZE(packet49);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -2025,10 +2020,10 @@
 
   unsigned char* p = packet;
   size_t p_size = QUICHE_ARRAYSIZE(packet);
-  if (framer_.transport_version() >= QUIC_VERSION_49) {
+  if (framer_.version().HasLongHeaderLengths()) {
     p = packet49;
     p_size = QUICHE_ARRAYSIZE(packet49);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -2131,7 +2126,7 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUICHE_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -2252,8 +2247,7 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                            : packet);
+          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -2398,10 +2392,10 @@
 
   unsigned char* p = packet;
   size_t p_length = QUICHE_ARRAYSIZE(packet);
-  if (framer_.transport_version() >= QUIC_VERSION_49) {
+  if (framer_.version().HasLongHeaderLengths()) {
     p = packet49;
     p_length = QUICHE_ARRAYSIZE(packet49);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_length = QUICHE_ARRAYSIZE(packet46);
   }
@@ -2411,7 +2405,7 @@
     EXPECT_THAT(framer_.error(), IsError(QUIC_DECRYPTION_FAILURE));
     EXPECT_EQ("Unable to decrypt ENCRYPTION_ZERO_RTT header protection.",
               framer_.detailed_error());
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     // Cannot read diversification nonce.
     EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_PACKET_HEADER));
     EXPECT_EQ("Unable to read nonce.", framer_.detailed_error());
@@ -2421,7 +2415,7 @@
 }
 
 TEST_P(QuicFramerTest, StreamFrame3ByteStreamId) {
-  if (framer_.transport_version() > QUIC_VERSION_43) {
+  if (framer_.version().HasIetfInvariantHeader()) {
     // This test is nonsensical for IETF Quic.
     return;
   }
@@ -2576,8 +2570,7 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                            : packet);
+          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -2696,8 +2689,7 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                            : packet);
+          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -2896,10 +2888,10 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() >= QUIC_VERSION_49
+          : (framer_.version().HasLongHeaderLengths()
                  ? packet49
-                 : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                                   : packet));
+                 : (framer_.version().HasIetfInvariantHeader() ? packet46
+                                                               : packet));
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -2919,10 +2911,9 @@
   EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0].get());
 
-  CheckFramingBoundaries(fragments,
-                         framer_.transport_version() >= QUIC_VERSION_49
-                             ? QUIC_INVALID_PACKET_HEADER
-                             : QUIC_INVALID_STREAM_DATA);
+  CheckFramingBoundaries(fragments, framer_.version().HasLongHeaderLengths()
+                                        ? QUIC_INVALID_PACKET_HEADER
+                                        : QUIC_INVALID_STREAM_DATA);
 }
 
 TEST_P(QuicFramerTest, RejectPacket) {
@@ -2978,11 +2969,11 @@
   // clang-format on
 
   unsigned char* p = packet;
-  if (framer_.transport_version() >= QUIC_VERSION_46) {
+  if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
   }
   QuicEncryptedPacket encrypted(AsChars(p),
-                                framer_.transport_version() > QUIC_VERSION_43
+                                framer_.version().HasIetfInvariantHeader()
                                     ? QUICHE_ARRAYSIZE(packet46)
                                     : QUICHE_ARRAYSIZE(packet),
                                 false);
@@ -3019,13 +3010,12 @@
   };
   // clang-format on
 
-  QuicEncryptedPacket encrypted(framer_.transport_version() >= QUIC_VERSION_46
-                                    ? AsChars(packet46)
-                                    : AsChars(packet),
-                                framer_.transport_version() >= QUIC_VERSION_46
-                                    ? QUICHE_ARRAYSIZE(packet46)
-                                    : QUICHE_ARRAYSIZE(packet),
-                                false);
+  QuicEncryptedPacket encrypted(
+      framer_.version().HasIetfInvariantHeader() ? AsChars(packet46)
+                                                 : AsChars(packet),
+      framer_.version().HasIetfInvariantHeader() ? QUICHE_ARRAYSIZE(packet46)
+                                                 : QUICHE_ARRAYSIZE(packet),
+      false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_THAT(framer_.error(), IsQuicNoError());
@@ -3131,8 +3121,7 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                            : packet);
+          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -3245,8 +3234,7 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                            : packet);
+          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
@@ -3624,7 +3612,7 @@
 
   // clang-format on
   PacketFragments& fragments =
-      framer_.transport_version() >= QUIC_VERSION_46 ? packet46 : packet;
+      framer_.version().HasIetfInvariantHeader() ? packet46 : packet;
 
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
@@ -3733,8 +3721,7 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                            : packet);
+          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -3955,8 +3942,7 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                            : packet);
+          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
 
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
@@ -4042,8 +4028,7 @@
     return;
   }
   QuicEncryptedPacket encrypted(
-      AsChars(framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                             : packet),
+      AsChars(framer_.version().HasIetfInvariantHeader() ? packet46 : packet),
       QUICHE_ARRAYSIZE(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_TRUE(quiche::QuicheTextUtils::StartsWith(
@@ -4116,8 +4101,7 @@
     return;
   }
   QuicEncryptedPacket encrypted(
-      AsChars(framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                             : packet),
+      AsChars(framer_.version().HasIetfInvariantHeader() ? packet46 : packet),
       QUICHE_ARRAYSIZE(packet), false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_TRUE(quiche::QuicheTextUtils::StartsWith(
@@ -4169,12 +4153,12 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.transport_version() >= QUIC_VERSION_46 ? packet46 : packet;
+      framer_.version().HasIetfInvariantHeader() ? packet46 : packet;
 
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   if (GetQuicReloadableFlag(quic_do_not_accept_stop_waiting) &&
-      version_.transport_version >= QUIC_VERSION_46) {
+      framer_.version().HasIetfInvariantHeader()) {
     EXPECT_FALSE(framer_.ProcessPacket(*encrypted));
     EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_STOP_WAITING_DATA));
     EXPECT_EQ("STOP WAITING not supported in version 44+.",
@@ -4202,7 +4186,7 @@
   // The Stop Waiting frame is not in IETF QUIC
   if (VersionHasIetfQuicFrames(version_.transport_version) ||
       (GetQuicReloadableFlag(quic_do_not_accept_stop_waiting) &&
-       version_.transport_version >= QUIC_VERSION_46)) {
+       framer_.version().HasIetfInvariantHeader())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -4236,10 +4220,9 @@
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                             : packet),
-      framer_.transport_version() > QUIC_VERSION_43 ? QUICHE_ARRAYSIZE(packet46)
-                                                    : QUICHE_ARRAYSIZE(packet),
+      AsChars(framer_.version().HasIetfInvariantHeader() ? packet46 : packet),
+      framer_.version().HasIetfInvariantHeader() ? QUICHE_ARRAYSIZE(packet46)
+                                                 : QUICHE_ARRAYSIZE(packet),
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_THAT(framer_.error(), IsError(QUIC_INVALID_STOP_WAITING_DATA));
@@ -4328,8 +4311,7 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                            : packet);
+          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -4439,8 +4421,7 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                            : packet);
+          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -4572,8 +4553,7 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                            : packet);
+          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -4802,7 +4782,7 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.transport_version() >= QUIC_VERSION_46 ? packet46 : packet;
+      framer_.version().HasIetfInvariantHeader() ? packet46 : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -4875,7 +4855,7 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.transport_version() >= QUIC_VERSION_46 ? packet46 : packet;
+      framer_.version().HasIetfInvariantHeader() ? packet46 : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -5046,8 +5026,7 @@
   PacketFragments& fragments =
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
-          : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                            : packet);
+          : (framer_.version().HasIetfInvariantHeader() ? packet46 : packet);
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -5115,11 +5094,11 @@
   QuicEncryptedPacket encrypted(
       AsChars(VersionHasIetfQuicFrames(framer_.transport_version())
                   ? packet99
-                  : (framer_.transport_version() >= QUIC_VERSION_46 ? packet46
-                                                                    : packet)),
+                  : (framer_.version().HasIetfInvariantHeader() ? packet46
+                                                                : packet)),
       VersionHasIetfQuicFrames(framer_.transport_version())
           ? QUICHE_ARRAYSIZE(packet99)
-          : (framer_.transport_version() >= QUIC_VERSION_46
+          : (framer_.version().HasIetfInvariantHeader()
                  ? QUICHE_ARRAYSIZE(packet46)
                  : QUICHE_ARRAYSIZE(packet)),
       false);
@@ -5333,7 +5312,7 @@
       }
   };
   // clang-format on
-  if (framer_.transport_version() > QUIC_VERSION_43) {
+  if (framer_.version().HasIetfInvariantHeader()) {
     return;
   }
 
@@ -5388,7 +5367,7 @@
   };
   // clang-format on
 
-  if (framer_.transport_version() > QUIC_VERSION_43) {
+  if (framer_.version().HasIetfInvariantHeader()) {
     return;
   }
 
@@ -5436,7 +5415,7 @@
     'j', 'u', 'n', 'k',
   };
   // clang-format on
-  if (framer_.transport_version() > QUIC_VERSION_43) {
+  if (framer_.version().HasIetfInvariantHeader()) {
     return;
   }
 
@@ -5488,7 +5467,7 @@
       }
   };
   // clang-format on
-  if (framer_.transport_version() > QUIC_VERSION_43) {
+  if (framer_.version().HasIetfInvariantHeader()) {
     return;
   }
 
@@ -5522,7 +5501,7 @@
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   };
   // clang-format on
-  if (framer_.transport_version() <= QUIC_VERSION_43) {
+  if (!framer_.version().HasIetfInvariantHeader()) {
     return;
   }
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
@@ -5566,7 +5545,7 @@
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   };
   // clang-format on
-  if (framer_.transport_version() <= QUIC_VERSION_43) {
+  if (!framer_.version().HasIetfInvariantHeader()) {
     return;
   }
   QuicFramerPeer::SetLastSerializedServerConnectionId(&framer_,
@@ -5650,9 +5629,9 @@
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
 
   PacketFragments& fragments =
-      framer_.transport_version() >= QUIC_VERSION_49
-          ? packet49
-          : framer_.transport_version() > QUIC_VERSION_43 ? packet46 : packet;
+      framer_.version().HasLongHeaderLengths()     ? packet49
+      : framer_.version().HasIetfInvariantHeader() ? packet46
+                                                   : packet;
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       AssemblePacketFromFragments(fragments));
   EXPECT_TRUE(framer_.ProcessPacket(*encrypted));
@@ -5671,7 +5650,7 @@
 }
 
 TEST_P(QuicFramerTest, VersionNegotiationPacketServer) {
-  if (framer_.transport_version() <= QUIC_VERSION_43) {
+  if (!framer_.version().HasIetfInvariantHeader()) {
     return;
   }
 
@@ -5738,7 +5717,7 @@
   };
   // clang-format on
 
-  if (framer_.transport_version() > QUIC_VERSION_43) {
+  if (framer_.version().HasIetfInvariantHeader()) {
     return;
   }
 
@@ -5827,7 +5806,7 @@
   if (framer_.version().HasRetryIntegrityTag()) {
     p = packet_with_tag;
     p_length = QUICHE_ARRAYSIZE(packet_with_tag);
-  } else if (framer_.transport_version() >= QUIC_VERSION_49) {
+  } else if (framer_.version().HasLongHeaderLengths()) {
     p = packet49;
     p_length = QUICHE_ARRAYSIZE(packet49);
   }
@@ -5944,7 +5923,7 @@
   unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
   }
 
@@ -5960,8 +5939,8 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      framer_.transport_version() > QUIC_VERSION_43 ? QUICHE_ARRAYSIZE(packet46)
-                                                    : QUICHE_ARRAYSIZE(packet));
+      framer_.version().HasIetfInvariantHeader() ? QUICHE_ARRAYSIZE(packet46)
+                                                 : QUICHE_ARRAYSIZE(packet));
 }
 
 TEST_P(QuicFramerTest, BuildStreamFramePacketWithNewPaddingFrame) {
@@ -6068,7 +6047,7 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUICHE_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -6133,7 +6112,7 @@
   unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
   }
 
@@ -6149,8 +6128,8 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      framer_.transport_version() > QUIC_VERSION_43 ? QUICHE_ARRAYSIZE(packet46)
-                                                    : QUICHE_ARRAYSIZE(packet));
+      framer_.version().HasIetfInvariantHeader() ? QUICHE_ARRAYSIZE(packet46)
+                                                 : QUICHE_ARRAYSIZE(packet));
 }
 
 TEST_P(QuicFramerTest, Build2ByteSequenceNumberPaddingFramePacket) {
@@ -6208,7 +6187,7 @@
   unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
   }
 
@@ -6224,8 +6203,8 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      framer_.transport_version() > QUIC_VERSION_43 ? QUICHE_ARRAYSIZE(packet46)
-                                                    : QUICHE_ARRAYSIZE(packet));
+      framer_.version().HasIetfInvariantHeader() ? QUICHE_ARRAYSIZE(packet46)
+                                                 : QUICHE_ARRAYSIZE(packet));
 }
 
 TEST_P(QuicFramerTest, Build1ByteSequenceNumberPaddingFramePacket) {
@@ -6283,7 +6262,7 @@
   unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
   }
 
@@ -6299,8 +6278,8 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      framer_.transport_version() > QUIC_VERSION_43 ? QUICHE_ARRAYSIZE(packet46)
-                                                    : QUICHE_ARRAYSIZE(packet));
+      framer_.version().HasIetfInvariantHeader() ? QUICHE_ARRAYSIZE(packet46)
+                                                 : QUICHE_ARRAYSIZE(packet));
 }
 
 TEST_P(QuicFramerTest, BuildStreamFramePacket) {
@@ -6392,7 +6371,7 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUICHE_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -6405,7 +6384,7 @@
   header.destination_connection_id = FramerTestConnectionId();
   header.reset_flag = false;
   header.version_flag = true;
-  if (framer_.transport_version() > QUIC_VERSION_43) {
+  if (framer_.version().HasIetfInvariantHeader()) {
     header.long_packet_type = ZERO_RTT_PROTECTED;
   }
   header.packet_number = kPacketNumber;
@@ -6522,10 +6501,10 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUICHE_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_49) {
+  } else if (framer_.version().HasLongHeaderLengths()) {
     p = packet49;
     p_size = QUICHE_ARRAYSIZE(packet49);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -6740,10 +6719,10 @@
   // clang-format on
   unsigned char* p = packet;
   size_t p_size = QUICHE_ARRAYSIZE(packet);
-  if (framer_.transport_version() >= QUIC_VERSION_49) {
+  if (framer_.version().HasLongHeaderLengths()) {
     p = packet49;
     p_size = QUICHE_ARRAYSIZE(packet49);
-  } else if (framer_.transport_version() > QUIC_VERSION_43) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -6752,7 +6731,7 @@
   std::unique_ptr<QuicEncryptedPacket> data(
       QuicFramer::BuildVersionNegotiationPacket(
           connection_id, EmptyQuicConnectionId(),
-          framer_.transport_version() > QUIC_VERSION_43,
+          framer_.version().HasIetfInvariantHeader(),
           framer_.version().HasLengthPrefixedConnectionIds(),
           SupportedVersions(GetParam())));
   quiche::test::CompareCharArraysWithHexError(
@@ -6877,7 +6856,7 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUICHE_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -6970,7 +6949,7 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUICHE_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -7118,7 +7097,7 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUICHE_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -7427,7 +7406,7 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUICHE_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -7440,7 +7419,7 @@
 }
 
 TEST_P(QuicFramerTest, BuildNewStopWaitingPacket) {
-  if (version_.transport_version > QUIC_VERSION_43) {
+  if (framer_.version().HasIetfInvariantHeader()) {
     return;
   }
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
@@ -7565,7 +7544,7 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUICHE_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -7659,7 +7638,7 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUICHE_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -7765,7 +7744,7 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUICHE_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -7946,7 +7925,7 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUICHE_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -8160,7 +8139,7 @@
 
   unsigned char* p = packet;
   size_t p_size = QUICHE_ARRAYSIZE(packet);
-  if (framer_.transport_version() > QUIC_VERSION_43) {
+  if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -8297,7 +8276,7 @@
 
   unsigned char* p = packet;
   size_t p_size = QUICHE_ARRAYSIZE(packet);
-  if (framer_.transport_version() > QUIC_VERSION_43) {
+  if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -8384,7 +8363,7 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUICHE_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -8556,7 +8535,7 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUICHE_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -8616,7 +8595,7 @@
   unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
   }
 
@@ -8625,8 +8604,8 @@
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      framer_.transport_version() > QUIC_VERSION_43 ? QUICHE_ARRAYSIZE(packet46)
-                                                    : QUICHE_ARRAYSIZE(packet));
+      framer_.version().HasIetfInvariantHeader() ? QUICHE_ARRAYSIZE(packet46)
+                                                 : QUICHE_ARRAYSIZE(packet));
 }
 
 TEST_P(QuicFramerTest, BuildHandshakeDonePacket) {
@@ -8836,14 +8815,14 @@
   unsigned char* p = packet;
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
   }
 
   quiche::test::CompareCharArraysWithHexError(
       "constructed packet", data->data(), data->length(), AsChars(p),
-      framer_.transport_version() > QUIC_VERSION_43 ? QUICHE_ARRAYSIZE(packet46)
-                                                    : QUICHE_ARRAYSIZE(packet));
+      framer_.version().HasIetfInvariantHeader() ? QUICHE_ARRAYSIZE(packet46)
+                                                 : QUICHE_ARRAYSIZE(packet));
 }
 
 TEST_P(QuicFramerTest, BuildPublicResetPacket) {
@@ -8871,7 +8850,7 @@
   };
   // clang-format on
 
-  if (framer_.transport_version() > QUIC_VERSION_43) {
+  if (framer_.version().HasIetfInvariantHeader()) {
     return;
   }
 
@@ -8919,7 +8898,7 @@
   };
   // clang-format on
 
-  if (framer_.transport_version() > QUIC_VERSION_43) {
+  if (framer_.version().HasIetfInvariantHeader()) {
     return;
   }
 
@@ -8991,7 +8970,7 @@
   };
   // clang-format on
 
-  if (framer_.transport_version() > QUIC_VERSION_43) {
+  if (framer_.version().HasIetfInvariantHeader()) {
     return;
   }
 
@@ -9096,10 +9075,10 @@
 
   unsigned char* p = packet;
   size_t p_size = QUICHE_ARRAYSIZE(packet);
-  if (framer_.transport_version() >= QUIC_VERSION_50) {
+  if (framer_.version().HasHeaderProtection()) {
     p = packet50;
     p_size = QUICHE_ARRAYSIZE(packet50);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
   }
 
@@ -9200,10 +9179,10 @@
   unsigned char* p = packet;
   size_t p_size = QUICHE_ARRAYSIZE(packet);
   // TODO(ianswett): see todo in previous test.
-  if (framer_.transport_version() >= QUIC_VERSION_50) {
+  if (framer_.version().HasHeaderProtection()) {
     p = packet50;
     p_size = QUICHE_ARRAYSIZE(packet50);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -9535,7 +9514,7 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUICHE_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -12086,7 +12065,7 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUICHE_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
   }
 
@@ -12164,7 +12143,7 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUICHE_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -12272,7 +12251,7 @@
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUICHE_ARRAYSIZE(packet99);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_size = QUICHE_ARRAYSIZE(packet46);
   }
@@ -12793,10 +12772,10 @@
   // clang-format on
   unsigned char* p = packet;
   size_t p_length = QUICHE_ARRAYSIZE(packet);
-  if (framer_.transport_version() >= QUIC_VERSION_49) {
+  if (framer_.version().HasLongHeaderLengths()) {
     p = packet49;
     p_length = QUICHE_ARRAYSIZE(packet49);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_length = QUICHE_ARRAYSIZE(packet46);
   }
@@ -12895,10 +12874,10 @@
   // clang-format on
   unsigned char* p = packet;
   size_t p_length = QUICHE_ARRAYSIZE(packet);
-  if (framer_.transport_version() >= QUIC_VERSION_49) {
+  if (framer_.version().HasLongHeaderLengths()) {
     p = packet49;
     p_length = QUICHE_ARRAYSIZE(packet49);
-  } else if (framer_.transport_version() >= QUIC_VERSION_46) {
+  } else if (framer_.version().HasIetfInvariantHeader()) {
     p = packet46;
     p_length = QUICHE_ARRAYSIZE(packet46);
   }
@@ -13413,7 +13392,7 @@
 }
 
 TEST_P(QuicFramerTest, ClientReceivesInvalidVersion) {
-  if (framer_.transport_version() <= QUIC_VERSION_43) {
+  if (!framer_.version().HasIetfInvariantHeader()) {
     return;
   }
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
@@ -13506,7 +13485,7 @@
 }
 
 TEST_P(QuicFramerTest, MultiplePacketNumberSpaces) {
-  if (framer_.transport_version() < QUIC_VERSION_46) {
+  if (!framer_.version().HasIetfInvariantHeader()) {
     return;
   }
   framer_.EnableMultiplePacketNumberSpacesSupport();
@@ -13642,7 +13621,7 @@
 }
 
 TEST_P(QuicFramerTest, RetryPacketRejectedWithMultiplePacketNumberSpaces) {
-  if (framer_.transport_version() < QUIC_VERSION_46 ||
+  if (!framer_.version().HasIetfInvariantHeader() ||
       framer_.version().SupportsRetry()) {
     return;
   }
@@ -13804,7 +13783,7 @@
   QuicEncryptedPacket encrypted(reinterpret_cast<const char*>(packet),
                                 sizeof(packet), false);
   // Make sure we fail to parse this packet for the version under test.
-  if (framer_.transport_version() <= QUIC_VERSION_43) {
+  if (!framer_.version().HasIetfInvariantHeader()) {
     // We can only parse the connection ID with an IETF parser.
     EXPECT_FALSE(framer_.ProcessPacket(encrypted));
     return;
@@ -14136,7 +14115,7 @@
 }
 
 TEST_P(QuicFramerTest, ClientConnectionIdFromLongHeaderToClient) {
-  if (framer_.transport_version() <= QUIC_VERSION_43) {
+  if (!framer_.version().HasIetfInvariantHeader()) {
     // This test requires an IETF long header.
     return;
   }
@@ -14182,7 +14161,7 @@
   // clang-format on
   unsigned char* p = packet;
   size_t p_length = QUICHE_ARRAYSIZE(packet);
-  if (framer_.transport_version() >= QUIC_VERSION_49) {
+  if (framer_.version().HasLongHeaderLengths()) {
     p = packet49;
     p_length = QUICHE_ARRAYSIZE(packet49);
   }
@@ -14203,7 +14182,7 @@
 }
 
 TEST_P(QuicFramerTest, ClientConnectionIdFromLongHeaderToServer) {
-  if (framer_.transport_version() <= QUIC_VERSION_43) {
+  if (!framer_.version().HasIetfInvariantHeader()) {
     // This test requires an IETF long header.
     return;
   }
@@ -14247,7 +14226,7 @@
   // clang-format on
   unsigned char* p = packet;
   size_t p_length = QUICHE_ARRAYSIZE(packet);
-  if (framer_.transport_version() >= QUIC_VERSION_49) {
+  if (framer_.version().HasLongHeaderLengths()) {
     p = packet49;
     p_length = QUICHE_ARRAYSIZE(packet49);
   }
@@ -14275,7 +14254,7 @@
 }
 
 TEST_P(QuicFramerTest, ProcessAndValidateIetfConnectionIdLengthClient) {
-  if (framer_.transport_version() <= QUIC_VERSION_43) {
+  if (!framer_.version().HasIetfInvariantHeader()) {
     // This test requires an IETF long header.
     return;
   }
@@ -14313,7 +14292,7 @@
 }
 
 TEST_P(QuicFramerTest, ProcessAndValidateIetfConnectionIdLengthServer) {
-  if (framer_.transport_version() <= QUIC_VERSION_43) {
+  if (!framer_.version().HasIetfInvariantHeader()) {
     // This test requires an IETF long header.
     return;
   }
diff --git a/quic/core/quic_version_manager.cc b/quic/core/quic_version_manager.cc
index 90c4982..0563797 100644
--- a/quic/core/quic_version_manager.cc
+++ b/quic/core/quic_version_manager.cc
@@ -23,12 +23,10 @@
           GetQuicReloadableFlag(quic_disable_version_draft_25)),
       disable_version_q050_(GetQuicReloadableFlag(quic_disable_version_q050)),
       disable_version_t050_(GetQuicReloadableFlag(quic_disable_version_t050)),
-      disable_version_q049_(GetQuicReloadableFlag(quic_disable_version_q049)),
-      disable_version_q048_(GetQuicReloadableFlag(quic_disable_version_q048)),
       disable_version_q046_(GetQuicReloadableFlag(quic_disable_version_q046)),
       disable_version_q043_(GetQuicReloadableFlag(quic_disable_version_q043)),
       allowed_supported_versions_(std::move(supported_versions)) {
-  static_assert(SupportedVersions().size() == 9u,
+  static_assert(SupportedVersions().size() == 7u,
                 "Supported versions out of sync");
   RefilterSupportedVersions();
 }
@@ -58,7 +56,7 @@
 }
 
 void QuicVersionManager::MaybeRefilterSupportedVersions() {
-  static_assert(SupportedVersions().size() == 9u,
+  static_assert(SupportedVersions().size() == 7u,
                 "Supported versions out of sync");
   if (enable_version_draft_29_ !=
           GetQuicReloadableFlag(quic_enable_version_draft_29) ||
@@ -70,10 +68,6 @@
           GetQuicReloadableFlag(quic_disable_version_q050) ||
       disable_version_t050_ !=
           GetQuicReloadableFlag(quic_disable_version_t050) ||
-      disable_version_q049_ !=
-          GetQuicReloadableFlag(quic_disable_version_q049) ||
-      disable_version_q048_ !=
-          GetQuicReloadableFlag(quic_disable_version_q048) ||
       disable_version_q046_ !=
           GetQuicReloadableFlag(quic_disable_version_q046) ||
       disable_version_q043_ !=
@@ -86,8 +80,6 @@
         GetQuicReloadableFlag(quic_disable_version_draft_25);
     disable_version_q050_ = GetQuicReloadableFlag(quic_disable_version_q050);
     disable_version_t050_ = GetQuicReloadableFlag(quic_disable_version_t050);
-    disable_version_q049_ = GetQuicReloadableFlag(quic_disable_version_q049);
-    disable_version_q048_ = GetQuicReloadableFlag(quic_disable_version_q048);
     disable_version_q046_ = GetQuicReloadableFlag(quic_disable_version_q046);
     disable_version_q043_ = GetQuicReloadableFlag(quic_disable_version_q043);
 
diff --git a/quic/core/quic_version_manager.h b/quic/core/quic_version_manager.h
index e6bb8f6..d86260f 100644
--- a/quic/core/quic_version_manager.h
+++ b/quic/core/quic_version_manager.h
@@ -62,10 +62,6 @@
   bool disable_version_q050_;
   // quic_disable_version_t050 flag
   bool disable_version_t050_;
-  // quic_disable_version_q049 flag
-  bool disable_version_q049_;
-  // quic_disable_version_q048 flag
-  bool disable_version_q048_;
   // quic_disable_version_q046 flag
   bool disable_version_q046_;
   // quic_disable_version_q043 flag
diff --git a/quic/core/quic_version_manager_test.cc b/quic/core/quic_version_manager_test.cc
index 4687b79..4106f60 100644
--- a/quic/core/quic_version_manager_test.cc
+++ b/quic/core/quic_version_manager_test.cc
@@ -18,15 +18,13 @@
 class QuicVersionManagerTest : public QuicTest {};
 
 TEST_F(QuicVersionManagerTest, QuicVersionManager) {
-  static_assert(SupportedVersions().size() == 9u,
+  static_assert(SupportedVersions().size() == 7u,
                 "Supported versions out of sync");
   SetQuicReloadableFlag(quic_enable_version_draft_29, false);
   SetQuicReloadableFlag(quic_disable_version_draft_27, true);
   SetQuicReloadableFlag(quic_disable_version_draft_25, true);
   SetQuicReloadableFlag(quic_disable_version_t050, false);
   SetQuicReloadableFlag(quic_disable_version_q050, false);
-  SetQuicReloadableFlag(quic_disable_version_q049, false);
-  SetQuicReloadableFlag(quic_disable_version_q048, false);
   SetQuicReloadableFlag(quic_disable_version_q046, false);
   SetQuicReloadableFlag(quic_disable_version_q043, false);
   QuicVersionManager manager(AllSupportedVersions());
@@ -37,10 +35,6 @@
   expected_parsed_versions.push_back(
       ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_50));
   expected_parsed_versions.push_back(
-      ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_49));
-  expected_parsed_versions.push_back(
-      ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_48));
-  expected_parsed_versions.push_back(
       ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_46));
   expected_parsed_versions.push_back(
       ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_43));
@@ -52,8 +46,7 @@
   EXPECT_EQ(CurrentSupportedVersionsWithQuicCrypto(),
             manager.GetSupportedVersionsWithQuicCrypto());
   EXPECT_THAT(manager.GetSupportedAlpns(),
-              ElementsAre("h3-T050", "h3-Q050", "h3-Q049", "h3-Q048", "h3-Q046",
-                          "h3-Q043"));
+              ElementsAre("h3-T050", "h3-Q050", "h3-Q046", "h3-Q043"));
 
   SetQuicReloadableFlag(quic_enable_version_draft_29, true);
   expected_parsed_versions.insert(expected_parsed_versions.begin(),
@@ -66,8 +59,7 @@
   EXPECT_EQ(CurrentSupportedVersionsWithQuicCrypto(),
             manager.GetSupportedVersionsWithQuicCrypto());
   EXPECT_THAT(manager.GetSupportedAlpns(),
-              ElementsAre("h3-29", "h3-T050", "h3-Q050", "h3-Q049", "h3-Q048",
-                          "h3-Q046", "h3-Q043"));
+              ElementsAre("h3-29", "h3-T050", "h3-Q050", "h3-Q046", "h3-Q043"));
 
   SetQuicReloadableFlag(quic_disable_version_draft_27, false);
   expected_parsed_versions.insert(
@@ -81,8 +73,8 @@
   EXPECT_EQ(CurrentSupportedVersionsWithQuicCrypto(),
             manager.GetSupportedVersionsWithQuicCrypto());
   EXPECT_THAT(manager.GetSupportedAlpns(),
-              ElementsAre("h3-29", "h3-27", "h3-T050", "h3-Q050", "h3-Q049",
-                          "h3-Q048", "h3-Q046", "h3-Q043"));
+              ElementsAre("h3-29", "h3-27", "h3-T050", "h3-Q050", "h3-Q046",
+                          "h3-Q043"));
 
   SetQuicReloadableFlag(quic_disable_version_draft_25, false);
   expected_parsed_versions.insert(
@@ -95,7 +87,7 @@
             manager.GetSupportedVersionsWithQuicCrypto());
   EXPECT_THAT(manager.GetSupportedAlpns(),
               ElementsAre("h3-29", "h3-27", "h3-25", "h3-T050", "h3-Q050",
-                          "h3-Q049", "h3-Q048", "h3-Q046", "h3-Q043"));
+                          "h3-Q046", "h3-Q043"));
 }
 
 }  // namespace
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index 5090344..cc7e0c6 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -40,7 +40,7 @@
 }
 
 void SetVersionFlag(const ParsedQuicVersion& version, bool should_enable) {
-  static_assert(SupportedVersions().size() == 9u,
+  static_assert(SupportedVersions().size() == 7u,
                 "Supported versions out of sync");
   const bool enable = should_enable;
   const bool disable = !should_enable;
@@ -54,10 +54,6 @@
     SetQuicReloadableFlag(quic_disable_version_t050, disable);
   } else if (version == ParsedQuicVersion::Q050()) {
     SetQuicReloadableFlag(quic_disable_version_q050, disable);
-  } else if (version == ParsedQuicVersion::Q049()) {
-    SetQuicReloadableFlag(quic_disable_version_q049, disable);
-  } else if (version == ParsedQuicVersion::Q048()) {
-    SetQuicReloadableFlag(quic_disable_version_q048, disable);
   } else if (version == ParsedQuicVersion::Q046()) {
     SetQuicReloadableFlag(quic_disable_version_q046, disable);
   } else if (version == ParsedQuicVersion::Q043()) {
@@ -79,29 +75,30 @@
 
 bool ParsedQuicVersion::KnowsWhichDecrypterToUse() const {
   DCHECK(IsKnown());
-  return transport_version > QUIC_VERSION_46 ||
-         handshake_protocol == PROTOCOL_TLS1_3;
+  return transport_version > QUIC_VERSION_46;
 }
 
 bool ParsedQuicVersion::UsesInitialObfuscators() const {
   DCHECK(IsKnown());
-  return transport_version > QUIC_VERSION_49 ||
-         handshake_protocol == PROTOCOL_TLS1_3;
+  // Initial obfuscators were added in version 50.
+  return transport_version > QUIC_VERSION_46;
 }
 
 bool ParsedQuicVersion::AllowsLowFlowControlLimits() const {
   DCHECK(IsKnown());
-  return transport_version >= QUIC_VERSION_IETF_DRAFT_25 &&
-         handshake_protocol == PROTOCOL_TLS1_3;
+  // Low flow-control limits are used for all IETF versions.
+  return UsesHttp3();
 }
 
 bool ParsedQuicVersion::HasHeaderProtection() const {
   DCHECK(IsKnown());
-  return transport_version > QUIC_VERSION_49;
+  // Header protection was added in version 50.
+  return transport_version > QUIC_VERSION_46;
 }
 
 bool ParsedQuicVersion::SupportsRetry() const {
   DCHECK(IsKnown());
+  // Retry was added in version 47.
   return transport_version > QUIC_VERSION_46;
 }
 
@@ -122,7 +119,8 @@
 
 bool ParsedQuicVersion::SupportsClientConnectionIds() const {
   DCHECK(IsKnown());
-  return transport_version > QUIC_VERSION_48;
+  // Client connection IDs were added in version 49.
+  return transport_version > QUIC_VERSION_46;
 }
 
 bool ParsedQuicVersion::HasLengthPrefixedConnectionIds() const {
@@ -132,8 +130,8 @@
 
 bool ParsedQuicVersion::SupportsAntiAmplificationLimit() const {
   DCHECK(IsKnown());
-  return transport_version >= QUIC_VERSION_IETF_DRAFT_25 &&
-         handshake_protocol == PROTOCOL_TLS1_3;
+  // The anti-amplification limit is used for all IETF versions.
+  return UsesHttp3();
 }
 
 bool ParsedQuicVersion::CanSendCoalescedPackets() const {
@@ -184,11 +182,13 @@
 
 bool ParsedQuicVersion::HasVarIntTransportParams() const {
   DCHECK(IsKnown());
-  return transport_version >= QUIC_VERSION_IETF_DRAFT_27;
+  // Variable-length integer transport parameters were added in draft-27.
+  return transport_version > QUIC_VERSION_IETF_DRAFT_25;
 }
 
 bool ParsedQuicVersion::AuthenticatesHandshakeConnectionIds() const {
   DCHECK(IsKnown());
+  // Authentication of handshake connection IDs was added in draft-28.
   return transport_version > QUIC_VERSION_IETF_DRAFT_27;
 }
 
@@ -205,7 +205,8 @@
 bool VersionHasLengthPrefixedConnectionIds(
     QuicTransportVersion transport_version) {
   DCHECK(transport_version != QUIC_VERSION_UNSUPPORTED);
-  return transport_version > QUIC_VERSION_48;
+  // Length-prefixed connection IDs were added in version 49.
+  return transport_version > QUIC_VERSION_46;
 }
 
 std::ostream& operator<<(std::ostream& os, const ParsedQuicVersion& version) {
@@ -245,17 +246,13 @@
                << parsed_version.handshake_protocol;
       return 0;
   }
-  static_assert(SupportedVersions().size() == 9u,
+  static_assert(SupportedVersions().size() == 7u,
                 "Supported versions out of sync");
   switch (parsed_version.transport_version) {
     case QUIC_VERSION_43:
       return MakeVersionLabel(proto, '0', '4', '3');
     case QUIC_VERSION_46:
       return MakeVersionLabel(proto, '0', '4', '6');
-    case QUIC_VERSION_48:
-      return MakeVersionLabel(proto, '0', '4', '8');
-    case QUIC_VERSION_49:
-      return MakeVersionLabel(proto, '0', '4', '9');
     case QUIC_VERSION_50:
       return MakeVersionLabel(proto, '0', '5', '0');
     case QUIC_VERSION_IETF_DRAFT_25:
@@ -457,14 +454,6 @@
           filtered_versions.push_back(version);
         }
       }
-    } else if (version.transport_version == QUIC_VERSION_49) {
-      if (!GetQuicReloadableFlag(quic_disable_version_q049)) {
-        filtered_versions.push_back(version);
-      }
-    } else if (version.transport_version == QUIC_VERSION_48) {
-      if (!GetQuicReloadableFlag(quic_disable_version_q048)) {
-        filtered_versions.push_back(version);
-      }
     } else if (version.transport_version == QUIC_VERSION_46) {
       QUIC_BUG_IF(version.handshake_protocol != PROTOCOL_QUIC_CRYPTO);
       if (!GetQuicReloadableFlag(quic_disable_version_q046)) {
@@ -563,13 +552,11 @@
     return #x
 
 std::string QuicVersionToString(QuicTransportVersion transport_version) {
-  static_assert(SupportedTransportVersions().size() == 8u,
+  static_assert(SupportedTransportVersions().size() == 6u,
                 "Supported versions out of sync");
   switch (transport_version) {
     RETURN_STRING_LITERAL(QUIC_VERSION_43);
     RETURN_STRING_LITERAL(QUIC_VERSION_46);
-    RETURN_STRING_LITERAL(QUIC_VERSION_48);
-    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_IETF_DRAFT_27);
diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index 341d398..aaceba1 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -113,9 +113,9 @@
   QUIC_VERSION_46 = 46,  // Use IETF draft-17 header format with demultiplexing
                          // bit.
   // Version 47 added variable-length QUIC server connection IDs.
-  QUIC_VERSION_48 = 48,  // Use CRYPTO frames for the handshake.
-  QUIC_VERSION_49 = 49,  // Client connection IDs, long header lengths, IETF
-                         // header format from draft-ietf-quic-invariants-06.
+  // Version 48 added CRYPTO frames for the handshake.
+  // Version 49 added client connection IDs, long header lengths, and the IETF
+  // 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_IETF_DRAFT_27 = 71,  // draft-ietf-quic-transport-27.
@@ -135,13 +135,11 @@
 
 // This array contains QUIC transport versions which we currently support.
 // DEPRECATED. Use SupportedVersions() instead.
-constexpr std::array<QuicTransportVersion, 8> SupportedTransportVersions() {
+constexpr std::array<QuicTransportVersion, 6> SupportedTransportVersions() {
   return {QUIC_VERSION_IETF_DRAFT_29,
           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};
 }
@@ -166,7 +164,8 @@
 // instead of stream 1.
 QUIC_EXPORT_PRIVATE constexpr bool QuicVersionUsesCryptoFrames(
     QuicTransportVersion transport_version) {
-  return transport_version >= QUIC_VERSION_48;
+  // CRYPTO frames were added in version 48.
+  return transport_version > QUIC_VERSION_46;
 }
 
 // Returns whether this combination of handshake protocol and transport
@@ -202,11 +201,8 @@
              transport_version != QUIC_VERSION_IETF_DRAFT_27 &&
              transport_version != QUIC_VERSION_IETF_DRAFT_29;
     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.
       return transport_version != QUIC_VERSION_UNSUPPORTED &&
-             QuicVersionUsesCryptoFrames(transport_version) &&
-             transport_version > QUIC_VERSION_49;
+             QuicVersionUsesCryptoFrames(transport_version);
   }
   return false;
 }
@@ -271,14 +267,6 @@
     return ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_50);
   }
 
-  static constexpr ParsedQuicVersion Q049() {
-    return ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_49);
-  }
-
-  static constexpr ParsedQuicVersion Q048() {
-    return ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_48);
-  }
-
   static constexpr ParsedQuicVersion Q046() {
     return ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_46);
   }
@@ -427,12 +415,11 @@
   return {PROTOCOL_TLS1_3, PROTOCOL_QUIC_CRYPTO};
 }
 
-constexpr std::array<ParsedQuicVersion, 9> SupportedVersions() {
+constexpr std::array<ParsedQuicVersion, 7> SupportedVersions() {
   return {
       ParsedQuicVersion::Draft29(), ParsedQuicVersion::Draft27(),
       ParsedQuicVersion::Draft25(), ParsedQuicVersion::T050(),
-      ParsedQuicVersion::Q050(),    ParsedQuicVersion::Q049(),
-      ParsedQuicVersion::Q048(),    ParsedQuicVersion::Q046(),
+      ParsedQuicVersion::Q050(),    ParsedQuicVersion::Q046(),
       ParsedQuicVersion::Q043(),
   };
 }
@@ -602,7 +589,8 @@
 // Returns true if |transport_version| supports MESSAGE frames.
 QUIC_EXPORT_PRIVATE constexpr bool VersionSupportsMessageFrames(
     QuicTransportVersion transport_version) {
-  return transport_version >= QUIC_VERSION_46;
+  // MESSAGE frames were added in version 45.
+  return transport_version > QUIC_VERSION_43;
 }
 
 // If true, HTTP/3 instead of gQUIC will be used at the HTTP layer.
@@ -623,14 +611,15 @@
 // length field as defined by IETF QUIC draft-13 and later.
 QUIC_EXPORT_PRIVATE constexpr bool QuicVersionHasLongHeaderLengths(
     QuicTransportVersion transport_version) {
-  return transport_version >= QUIC_VERSION_49;
+  // Long header lengths were added in version 49.
+  return transport_version > QUIC_VERSION_46;
 }
 
 // Returns whether |transport_version| makes use of IETF QUIC
 // frames or not.
 QUIC_EXPORT_PRIVATE constexpr bool VersionHasIetfQuicFrames(
     QuicTransportVersion transport_version) {
-  return transport_version >= QUIC_VERSION_IETF_DRAFT_25;
+  return VersionUsesHttp3(transport_version);
 }
 
 // Returns whether this version supports long header 8-bit encoded
diff --git a/quic/core/quic_versions_test.cc b/quic/core/quic_versions_test.cc
index c7ebb82..8569007 100644
--- a/quic/core/quic_versions_test.cc
+++ b/quic/core/quic_versions_test.cc
@@ -210,8 +210,6 @@
             ParseQuicVersionLabel(MakeVersionLabel('Q', '0', '4', '3')));
   EXPECT_EQ(ParsedQuicVersion::Q046(),
             ParseQuicVersionLabel(MakeVersionLabel('Q', '0', '4', '6')));
-  EXPECT_EQ(ParsedQuicVersion::Q048(),
-            ParseQuicVersionLabel(MakeVersionLabel('Q', '0', '4', '8')));
   EXPECT_EQ(ParsedQuicVersion::Q050(),
             ParseQuicVersionLabel(MakeVersionLabel('Q', '0', '5', '0')));
   EXPECT_EQ(ParsedQuicVersion::T050(),
@@ -224,7 +222,6 @@
             ParseQuicVersionString("QUIC_VERSION_46"));
   EXPECT_EQ(ParsedQuicVersion::Q046(), ParseQuicVersionString("46"));
   EXPECT_EQ(ParsedQuicVersion::Q046(), ParseQuicVersionString("Q046"));
-  EXPECT_EQ(ParsedQuicVersion::Q048(), ParseQuicVersionString("Q048"));
   EXPECT_EQ(ParsedQuicVersion::Q050(), ParseQuicVersionString("Q050"));
   EXPECT_EQ(ParsedQuicVersion::Q050(), ParseQuicVersionString("50"));
   EXPECT_EQ(ParsedQuicVersion::Q050(), ParseQuicVersionString("h3-Q050"));
@@ -325,8 +322,6 @@
             CreateQuicVersionLabel(ParsedQuicVersion::Q043()));
   EXPECT_EQ(MakeVersionLabel('Q', '0', '4', '6'),
             CreateQuicVersionLabel(ParsedQuicVersion::Q046()));
-  EXPECT_EQ(MakeVersionLabel('Q', '0', '4', '8'),
-            CreateQuicVersionLabel(ParsedQuicVersion::Q048()));
   EXPECT_EQ(MakeVersionLabel('Q', '0', '5', '0'),
             CreateQuicVersionLabel(ParsedQuicVersion::Q050()));
 
@@ -493,12 +488,10 @@
 // yet a typo was made in doing the #defines and it was caught
 // only in some test far removed from here... Better safe than sorry.
 TEST_F(QuicVersionsTest, CheckTransportVersionNumbersForTypos) {
-  static_assert(SupportedTransportVersions().size() == 8u,
+  static_assert(SupportedTransportVersions().size() == 6u,
                 "Supported versions out of sync");
   EXPECT_EQ(QUIC_VERSION_43, 43);
   EXPECT_EQ(QUIC_VERSION_46, 46);
-  EXPECT_EQ(QUIC_VERSION_48, 48);
-  EXPECT_EQ(QUIC_VERSION_49, 49);
   EXPECT_EQ(QUIC_VERSION_50, 50);
   EXPECT_EQ(QUIC_VERSION_IETF_DRAFT_25, 70);
   EXPECT_EQ(QUIC_VERSION_IETF_DRAFT_27, 71);
@@ -506,17 +499,13 @@
 }
 
 TEST_F(QuicVersionsTest, AlpnForVersion) {
-  static_assert(SupportedVersions().size() == 9u,
+  static_assert(SupportedVersions().size() == 7u,
                 "Supported versions out of sync");
-  ParsedQuicVersion parsed_version_q048 = ParsedQuicVersion::Q048();
-  ParsedQuicVersion parsed_version_q049 = ParsedQuicVersion::Q049();
   ParsedQuicVersion parsed_version_q050 = ParsedQuicVersion::Q050();
   ParsedQuicVersion parsed_version_t050 = ParsedQuicVersion::T050();
   ParsedQuicVersion parsed_version_draft_25 = ParsedQuicVersion::Draft25();
   ParsedQuicVersion parsed_version_draft_27 = ParsedQuicVersion::Draft27();
 
-  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));
diff --git a/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc b/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc
index 9b5d64d..a35919e 100644
--- a/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc
+++ b/quic/test_tools/fuzzing/quic_framer_process_data_packet_fuzzer.cc
@@ -60,7 +60,6 @@
   const QuicTransportVersion transport_versions[] = {
       quic::QUIC_VERSION_43,
       quic::QUIC_VERSION_46,
-      quic::QUIC_VERSION_48,
   };
 
   return ParsedQuicVersion(