diff --git a/quic/core/crypto/quic_crypto_client_config.cc b/quic/core/crypto/quic_crypto_client_config.cc
index 1026781..e968e86 100644
--- a/quic/core/crypto/quic_crypto_client_config.cc
+++ b/quic/core/crypto/quic_crypto_client_config.cc
@@ -498,8 +498,7 @@
   QUIC_BUG_IF(!QuicUtils::IsConnectionIdValidForVersion(
       connection_id, preferred_version.transport_version))
       << "FillClientHello: attempted to use connection ID " << connection_id
-      << " which is invalid with version "
-      << QuicVersionToString(preferred_version.transport_version);
+      << " which is invalid with version " << preferred_version;
 
   FillInchoateClientHello(server_id, preferred_version, cached, rand,
                           /* demand_x509_proof= */ true, out_params, out);
diff --git a/quic/core/crypto/quic_crypto_client_config_test.cc b/quic/core/crypto/quic_crypto_client_config_test.cc
index d7625cd..abdaa41 100644
--- a/quic/core/crypto/quic_crypto_client_config_test.cc
+++ b/quic/core/crypto/quic_crypto_client_config_test.cc
@@ -486,10 +486,12 @@
       new QuicCryptoNegotiatedParameters);
   std::string error;
   QuicCryptoClientConfig config(crypto_test_utils::ProofVerifierForTesting());
-  EXPECT_THAT(config.ProcessRejection(rej, QuicWallTime::FromUNIXSeconds(0),
-                                      AllSupportedTransportVersions().front(),
-                                      "", &cached, out_params, &error),
-              IsQuicNoError());
+  EXPECT_THAT(
+      config.ProcessRejection(
+          rej, QuicWallTime::FromUNIXSeconds(0),
+          AllSupportedVersionsWithQuicCrypto().front().transport_version, "",
+          &cached, out_params, &error),
+      IsQuicNoError());
   EXPECT_FALSE(cached.has_server_nonce());
 }
 
@@ -506,10 +508,12 @@
       new QuicCryptoNegotiatedParameters);
   std::string error;
   QuicCryptoClientConfig config(crypto_test_utils::ProofVerifierForTesting());
-  EXPECT_THAT(config.ProcessRejection(rej, QuicWallTime::FromUNIXSeconds(0),
-                                      AllSupportedTransportVersions().front(),
-                                      "", &cached, out_params, &error),
-              IsQuicNoError());
+  EXPECT_THAT(
+      config.ProcessRejection(
+          rej, QuicWallTime::FromUNIXSeconds(0),
+          AllSupportedVersionsWithQuicCrypto().front().transport_version, "",
+          &cached, out_params, &error),
+      IsQuicNoError());
   cached.SetProofValid();
   EXPECT_FALSE(cached.IsComplete(QuicWallTime::FromUNIXSeconds(long_ttl)));
   EXPECT_FALSE(
diff --git a/quic/core/crypto/quic_crypto_server_config.cc b/quic/core/crypto/quic_crypto_server_config.cc
index b929dcc..3995c58 100644
--- a/quic/core/crypto/quic_crypto_server_config.cc
+++ b/quic/core/crypto/quic_crypto_server_config.cc
@@ -742,7 +742,7 @@
       context->connection_id(), context->transport_version()))
       << "ProcessClientHelloAfterGetProof: attempted to use connection ID "
       << context->connection_id() << " which is invalid with version "
-      << QuicVersionToString(context->transport_version());
+      << context->version();
 
   if (found_error) {
     context->Fail(QUIC_HANDSHAKE_FAILED, "Failed to get proof");
@@ -830,7 +830,7 @@
       << "ProcessClientHelloAfterCalculateSharedKeys:"
          " attempted to use connection ID "
       << context->connection_id() << " which is invalid with version "
-      << QuicVersionToString(context->transport_version());
+      << context->version();
 
   if (found_error) {
     // If we are already using the fallback config, or there is no fallback
diff --git a/quic/core/http/quic_spdy_client_session_test.cc b/quic/core/http/quic_spdy_client_session_test.cc
index 5444c9d..93d3e58 100644
--- a/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quic/core/http/quic_spdy_client_session_test.cc
@@ -230,10 +230,7 @@
 
 std::string ParamNameFormatter(
     const testing::TestParamInfo<QuicSpdyClientSessionTest::ParamType>& info) {
-  const ParsedQuicVersion& version = info.param;
-  return quiche::QuicheStrCat(
-      QuicVersionToString(version.transport_version), "_",
-      HandshakeProtocolToString(version.handshake_protocol));
+  return ParsedQuicVersionToString(info.param);
 }
 
 INSTANTIATE_TEST_SUITE_P(Tests,
@@ -583,7 +580,7 @@
       QuicConnectionPeer::GetFramer(connection_), destination_connection_id);
   bool version_flag = false;
   QuicConnectionIdIncluded scid_included = CONNECTION_ID_ABSENT;
-  if (VersionHasIetfInvariantHeader(version.transport_version)) {
+  if (version.HasIetfInvariantHeader()) {
     version_flag = true;
     source_connection_id = destination_connection_id;
     scid_included = CONNECTION_ID_PRESENT;
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index f864140..c8c4960 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -323,8 +323,7 @@
       peer_max_packet_size_(kDefaultMaxPacketSizeTransportParam),
       largest_received_packet_size_(0),
       write_error_occurred_(false),
-      no_stop_waiting_frames_(
-          VersionHasIetfInvariantHeader(transport_version())),
+      no_stop_waiting_frames_(version().HasIetfInvariantHeader()),
       consecutive_num_packets_with_no_retransmittable_frames_(0),
       max_consecutive_num_packets_with_no_retransmittable_frames_(
           kMaxConsecutiveNonRetransmittablePackets),
@@ -373,8 +372,7 @@
   QUIC_BUG_IF(!QuicUtils::IsConnectionIdValidForVersion(server_connection_id,
                                                         transport_version()))
       << "QuicConnection: attempted to use server connection ID "
-      << server_connection_id << " which is invalid with version "
-      << QuicVersionToString(transport_version());
+      << server_connection_id << " which is invalid with version " << version();
   framer_.set_visitor(this);
   stats_.connection_creation_time = clock_->ApproximateNow();
   // TODO(ianswett): Supply the NetworkChangeVisitor as a constructor argument
@@ -857,7 +855,7 @@
   // here.  (Check for a bug regression.)
   DCHECK_EQ(server_connection_id_, packet.connection_id);
   DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
-  DCHECK(!VersionHasIetfInvariantHeader(transport_version()));
+  DCHECK(!version().HasIetfInvariantHeader());
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnPublicResetPacket(packet);
   }
@@ -1940,7 +1938,7 @@
     const QuicIetfStatelessResetPacket& /*packet*/) {
   // TODO(fayang): Add OnAuthenticatedIetfStatelessResetPacket to
   // debug_visitor_.
-  DCHECK(VersionHasIetfInvariantHeader(transport_version()));
+  DCHECK(version().HasIetfInvariantHeader());
   DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
   if (!visitor_->ValidateStatelessReset(last_packet_destination_address_,
                                         last_packet_source_address_)) {
@@ -2538,7 +2536,7 @@
   if (!version_negotiated_) {
     if (perspective_ == Perspective::IS_CLIENT) {
       DCHECK(!header.version_flag || header.form != GOOGLE_QUIC_PACKET);
-      if (!VersionHasIetfInvariantHeader(framer_.transport_version())) {
+      if (!version().HasIetfInvariantHeader()) {
         // If the client gets a packet without the version flag from the server
         // it should stop sending version since the version negotiation is done.
         // IETF QUIC stops sending version once encryption level switches to
@@ -3347,7 +3345,7 @@
       break;
     default:
       // We can't send an error as the socket is presumably borked.
-      if (VersionHasIetfInvariantHeader(transport_version())) {
+      if (version().HasIetfInvariantHeader()) {
         QUIC_CODE_COUNT(quic_tear_down_local_connection_on_write_error_ietf);
       } else {
         QUIC_CODE_COUNT(
@@ -3381,7 +3379,7 @@
     // loop here.
     // TODO(ianswett): This is actually an internal error, not an
     // encryption failure.
-    if (VersionHasIetfInvariantHeader(transport_version())) {
+    if (version().HasIetfInvariantHeader()) {
       QUIC_CODE_COUNT(
           quic_tear_down_local_connection_on_serialized_packet_ietf);
     } else {
@@ -3408,7 +3406,7 @@
                                           const std::string& error_details) {
   // The packet creator or generator encountered an unrecoverable error: tear
   // down local connection state immediately.
-  if (VersionHasIetfInvariantHeader(transport_version())) {
+  if (version().HasIetfInvariantHeader()) {
     QUIC_CODE_COUNT(
         quic_tear_down_local_connection_on_unrecoverable_error_ietf);
   } else {
@@ -4875,7 +4873,7 @@
   }
   if (framer_.HasEncrypterOfEncryptionLevel(ENCRYPTION_ZERO_RTT)) {
     if (encryption_level_ != ENCRYPTION_ZERO_RTT) {
-      if (VersionHasIetfInvariantHeader(transport_version())) {
+      if (version().HasIetfInvariantHeader()) {
         QUIC_CODE_COUNT(quic_wrong_encryption_level_connection_close_ietf);
       } else {
         QUIC_CODE_COUNT(quic_wrong_encryption_level_connection_close);
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 52d4d84..b3dc2d8 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -574,8 +574,7 @@
          {AckResponse::kDefer, AckResponse::kImmediate}) {
       params.push_back(
           TestParams(all_supported_versions[i], ack_response, true));
-      if (!VersionHasIetfInvariantHeader(
-              all_supported_versions[i].transport_version)) {
+      if (!all_supported_versions[i].HasIetfInvariantHeader()) {
         params.push_back(
             TestParams(all_supported_versions[i], ack_response, false));
       }
@@ -659,7 +658,7 @@
         QuicConnectionPeer::GetFramer(&connection_), connection_id_);
     QuicFramerPeer::SetLastWrittenPacketNumberLength(
         QuicConnectionPeer::GetFramer(&connection_), packet_number_length_);
-    if (VersionHasIetfInvariantHeader(version().transport_version)) {
+    if (version().HasIetfInvariantHeader()) {
       EXPECT_TRUE(QuicConnectionPeer::GetNoStopWaitingFrames(&connection_));
     } else {
       QuicConnectionPeer::SetNoStopWaitingFrames(&connection_,
@@ -1118,7 +1117,7 @@
   QuicPacketHeader ConstructPacketHeader(uint64_t number,
                                          EncryptionLevel level) {
     QuicPacketHeader header;
-    if (VersionHasIetfInvariantHeader(peer_framer_.transport_version()) &&
+    if (peer_framer_.version().HasIetfInvariantHeader() &&
         level < ENCRYPTION_FORWARD_SECURE) {
       // Set long header type accordingly.
       header.version_flag = true;
@@ -1142,7 +1141,7 @@
       header.destination_connection_id = connection_id_;
       header.destination_connection_id_included = connection_id_included_;
     }
-    if (VersionHasIetfInvariantHeader(peer_framer_.transport_version()) &&
+    if (peer_framer_.version().HasIetfInvariantHeader() &&
         peer_framer_.perspective() == Perspective::IS_SERVER) {
       header.destination_connection_id_included = CONNECTION_ID_ABSENT;
       if (header.version_flag) {
@@ -1192,12 +1191,12 @@
     if (peer_framer_.perspective() == Perspective::IS_SERVER) {
       header.source_connection_id = connection_id_;
       header.destination_connection_id_included = CONNECTION_ID_ABSENT;
-      if (!VersionHasIetfInvariantHeader(peer_framer_.transport_version())) {
+      if (!peer_framer_.version().HasIetfInvariantHeader()) {
         header.source_connection_id_included = CONNECTION_ID_PRESENT;
       }
     } else {
       header.destination_connection_id = connection_id_;
-      if (VersionHasIetfInvariantHeader(peer_framer_.transport_version())) {
+      if (peer_framer_.version().HasIetfInvariantHeader()) {
         header.destination_connection_id_included = CONNECTION_ID_ABSENT;
       }
     }
@@ -2455,8 +2454,7 @@
   // switched to ENCRYPTION_FORWARD_SECURE in SendStreamDataToPeer.
   EXPECT_CALL(*send_algorithm_,
               OnPacketSent(_, _, _,
-                           VersionHasIetfInvariantHeader(
-                               GetParam().version.transport_version)
+                           GetParam().version.HasIetfInvariantHeader()
                                ? packet_size
                                : packet_size - kQuicVersionSize,
                            _))
@@ -2674,7 +2672,7 @@
 }
 
 TEST_P(QuicConnectionTest, LeastUnackedLower) {
-  if (VersionHasIetfInvariantHeader(GetParam().version.transport_version)) {
+  if (GetParam().version.HasIetfInvariantHeader()) {
     return;
   }
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
@@ -3493,8 +3491,7 @@
   // switched to ENCRYPTION_FORWARD_SECURE in SendStreamDataToPeer.
   EXPECT_CALL(*send_algorithm_,
               OnPacketSent(_, _, _,
-                           VersionHasIetfInvariantHeader(
-                               GetParam().version.transport_version)
+                           GetParam().version.HasIetfInvariantHeader()
                                ? packet_size
                                : packet_size - kQuicVersionSize,
                            _));
@@ -5800,7 +5797,7 @@
 
 TEST_P(QuicConnectionTest, LoopThroughSendingPacketsWithTruncation) {
   set_perspective(Perspective::IS_SERVER);
-  if (!VersionHasIetfInvariantHeader(GetParam().version.transport_version)) {
+  if (!GetParam().version.HasIetfInvariantHeader()) {
     // For IETF QUIC, encryption level will be switched to FORWARD_SECURE in
     // SendStreamDataWithString.
     QuicPacketCreatorPeer::SetSendVersionInPacket(creator_, false);
@@ -5826,7 +5823,7 @@
   EXPECT_EQ(payload.size(),
             connection_.SendStreamDataWithString(3, payload, 1350, NO_FIN)
                 .bytes_consumed);
-  if (VersionHasIetfInvariantHeader(connection_.transport_version())) {
+  if (connection_.version().HasIetfInvariantHeader()) {
     // Short header packets sent from server omit connection ID already, and
     // stream offset size increases from 0 to 2.
     EXPECT_EQ(non_truncated_packet_size, writer_->last_packet_size() - 2);
@@ -6457,7 +6454,7 @@
 }
 
 TEST_P(QuicConnectionTest, PublicReset) {
-  if (VersionHasIetfInvariantHeader(GetParam().version.transport_version)) {
+  if (GetParam().version.HasIetfInvariantHeader()) {
     return;
   }
   QuicPublicResetPacket header;
@@ -6476,7 +6473,7 @@
 }
 
 TEST_P(QuicConnectionTest, IetfStatelessReset) {
-  if (!VersionHasIetfInvariantHeader(GetParam().version.transport_version)) {
+  if (!GetParam().version.HasIetfInvariantHeader()) {
     return;
   }
   const QuicUint128 kTestStatelessResetToken = 1010101;
@@ -6544,7 +6541,7 @@
 }
 
 TEST_P(QuicConnectionTest, MissingPacketsBeforeLeastUnacked) {
-  if (VersionHasIetfInvariantHeader(GetParam().version.transport_version)) {
+  if (GetParam().version.HasIetfInvariantHeader()) {
     return;
   }
   // Set the packet number of the ack packet to be least unacked (4).
@@ -6567,7 +6564,7 @@
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       QuicFramer::BuildVersionNegotiationPacket(
           connection_id_, EmptyQuicConnectionId(),
-          VersionHasIetfInvariantHeader(connection_.transport_version()),
+          connection_.version().HasIetfInvariantHeader(),
           connection_.version().HasLengthPrefixedConnectionIds(), versions));
   std::unique_ptr<QuicReceivedPacket> received(
       ConstructReceivedPacket(*encrypted, QuicTime::Zero()));
@@ -6590,7 +6587,7 @@
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       QuicFramer::BuildVersionNegotiationPacket(
           connection_id_, EmptyQuicConnectionId(),
-          VersionHasIetfInvariantHeader(connection_.transport_version()),
+          connection_.version().HasIetfInvariantHeader(),
           connection_.version().HasLengthPrefixedConnectionIds(),
           AllSupportedVersions()));
   std::unique_ptr<QuicReceivedPacket> received(
@@ -6647,9 +6644,7 @@
   // For IETF QUIC, version is not included as the encryption level switches to
   // FORWARD_SECURE in SendStreamDataWithString.
   size_t save_on_version =
-      VersionHasIetfInvariantHeader(GetParam().version.transport_version)
-          ? 0
-          : kQuicVersionSize;
+      GetParam().version.HasIetfInvariantHeader() ? 0 : kQuicVersionSize;
   EXPECT_EQ(3 * first_packet_size + 2 * second_packet_size - save_on_version,
             stats.bytes_sent);
   EXPECT_EQ(5u, stats.packets_sent);
@@ -6666,12 +6661,12 @@
   if (peer_framer_.perspective() == Perspective::IS_SERVER) {
     header.source_connection_id = connection_id_;
     header.destination_connection_id_included = CONNECTION_ID_ABSENT;
-    if (!VersionHasIetfInvariantHeader(peer_framer_.transport_version())) {
+    if (!peer_framer_.version().HasIetfInvariantHeader()) {
       header.source_connection_id_included = CONNECTION_ID_PRESENT;
     }
   } else {
     header.destination_connection_id = connection_id_;
-    if (VersionHasIetfInvariantHeader(peer_framer_.transport_version())) {
+    if (peer_framer_.version().HasIetfInvariantHeader()) {
       header.destination_connection_id_included = CONNECTION_ID_ABSENT;
     }
   }
@@ -6779,7 +6774,7 @@
 TEST_P(QuicConnectionTest, OnPacketHeaderDebugVisitor) {
   QuicPacketHeader header;
   header.packet_number = QuicPacketNumber(1);
-  if (VersionHasIetfInvariantHeader(GetParam().version.transport_version)) {
+  if (GetParam().version.HasIetfInvariantHeader()) {
     header.form = IETF_QUIC_LONG_HEADER_PACKET;
   }
 
diff --git a/quic/core/quic_crypto_stream_test.cc b/quic/core/quic_crypto_stream_test.cc
index c67a5dc..5593e53 100644
--- a/quic/core/quic_crypto_stream_test.cc
+++ b/quic/core/quic_crypto_stream_test.cc
@@ -576,20 +576,22 @@
 
 // Regression test for bugfix of GetPacketHeaderSize.
 TEST_F(QuicCryptoStreamTest, CryptoMessageFramingOverhead) {
-  for (auto version : AllSupportedTransportVersions()) {
+  for (const ParsedQuicVersion& version :
+       AllSupportedVersionsWithQuicCrypto()) {
     SCOPED_TRACE(version);
     QuicByteCount expected_overhead = 48;
-    if (VersionHasIetfInvariantHeader(version)) {
+    if (version.HasIetfInvariantHeader()) {
       expected_overhead += 4;
     }
-    if (QuicVersionHasLongHeaderLengths(version)) {
+    if (version.HasLongHeaderLengths()) {
       expected_overhead += 3;
     }
-    if (VersionHasLengthPrefixedConnectionIds(version)) {
+    if (version.HasLengthPrefixedConnectionIds()) {
       expected_overhead += 1;
     }
-    EXPECT_EQ(expected_overhead, QuicCryptoStream::CryptoMessageFramingOverhead(
-                                     version, TestConnectionId()));
+    EXPECT_EQ(expected_overhead,
+              QuicCryptoStream::CryptoMessageFramingOverhead(
+                  version.transport_version, TestConnectionId()));
   }
 }
 
diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc
index 148c73b..3e0846c 100644
--- a/quic/core/quic_dispatcher.cc
+++ b/quic/core/quic_dispatcher.cc
@@ -749,7 +749,7 @@
     action = QuicTimeWaitListManager::SEND_CONNECTION_CLOSE_PACKETS;
   } else {
     if (!connection->IsHandshakeComplete()) {
-      if (!VersionHasIetfInvariantHeader(connection->transport_version())) {
+      if (!connection->version().HasIetfInvariantHeader()) {
         QUIC_CODE_COUNT(gquic_add_to_time_wait_list_with_handshake_failed);
       } else {
         QUIC_CODE_COUNT(quic_v44_add_to_time_wait_list_with_handshake_failed);
@@ -759,7 +759,7 @@
       // QUIC_HANDSHAKE_FAILED and adds the connection to the time wait list.
       StatelesslyTerminateConnection(
           connection->connection_id(),
-          VersionHasIetfInvariantHeader(connection->transport_version())
+          connection->version().HasIetfInvariantHeader()
               ? IETF_QUIC_LONG_HEADER_PACKET
               : GOOGLE_QUIC_PACKET,
           /*version_flag=*/true,
@@ -778,7 +778,7 @@
   time_wait_list_manager_->AddConnectionIdToTimeWait(
       it->first, action,
       TimeWaitConnectionInfo(
-          VersionHasIetfInvariantHeader(connection->transport_version()),
+          connection->version().HasIetfInvariantHeader(),
           connection->termination_packets(),
           connection->sent_packet_manager().GetRttStats()->smoothed_rtt()));
   session_map_.erase(it);
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index be14a0b..4862d35 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -887,8 +887,7 @@
                                    char* buffer,
                                    size_t packet_length,
                                    EncryptionLevel level) {
-  QUIC_BUG_IF(header.version_flag &&
-              VersionHasIetfInvariantHeader(transport_version()) &&
+  QUIC_BUG_IF(header.version_flag && version().HasIetfInvariantHeader() &&
               header.long_packet_type == RETRY && !frames.empty())
       << "IETF RETRY packets cannot contain frames " << header;
   QuicDataWriter writer(packet_length, buffer);
@@ -1439,8 +1438,7 @@
 
   bool packet_has_ietf_packet_header = false;
   if (infer_packet_header_type_from_version_) {
-    packet_has_ietf_packet_header =
-        VersionHasIetfInvariantHeader(version_.transport_version);
+    packet_has_ietf_packet_header = version_.HasIetfInvariantHeader();
   } else if (!reader.IsDoneReading()) {
     uint8_t type = reader.PeekByte();
     packet_has_ietf_packet_header = QuicUtils::IsIetfPacketHeader(type);
@@ -2085,7 +2083,7 @@
 bool QuicFramer::AppendPacketHeader(const QuicPacketHeader& header,
                                     QuicDataWriter* writer,
                                     size_t* length_field_offset) {
-  if (VersionHasIetfInvariantHeader(transport_version())) {
+  if (version().HasIetfInvariantHeader()) {
     return AppendIetfPacketHeader(header, writer, length_field_offset);
   }
   QUIC_DVLOG(1) << ENDPOINT << "Appending header: " << header;
@@ -2126,7 +2124,7 @@
           server_connection_id, transport_version()))
           << "AppendPacketHeader: attempted to use connection ID "
           << server_connection_id << " which is invalid with version "
-          << QuicVersionToString(transport_version());
+          << version();
 
       public_flags |= PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID;
       if (perspective_ == Perspective::IS_CLIENT) {
@@ -2189,8 +2187,7 @@
   QUIC_BUG_IF(!QuicUtils::IsConnectionIdValidForVersion(server_connection_id,
                                                         transport_version()))
       << "AppendIetfPacketHeader: attempted to use connection ID "
-      << server_connection_id << " which is invalid with version "
-      << QuicVersionToString(transport_version());
+      << server_connection_id << " which is invalid with version " << version();
   if (!AppendIetfHeaderTypeByte(header, writer)) {
     return false;
   }
@@ -2715,12 +2712,12 @@
     std::string detailed_error;
     QuicErrorCode parse_result = QuicFramer::ParsePublicHeader(
         reader, expected_destination_connection_id_length,
-        VersionHasIetfInvariantHeader(version_.transport_version),
-        &header->type_byte, &header->form, &header->version_flag,
-        &has_length_prefix, &version_label, &header->version,
-        &header->destination_connection_id, &header->source_connection_id,
-        &header->long_packet_type, &header->retry_token_length_length,
-        &header->retry_token, &detailed_error);
+        version_.HasIetfInvariantHeader(), &header->type_byte, &header->form,
+        &header->version_flag, &has_length_prefix, &version_label,
+        &header->version, &header->destination_connection_id,
+        &header->source_connection_id, &header->long_packet_type,
+        &header->retry_token_length_length, &header->retry_token,
+        &detailed_error);
     if (parse_result != QUIC_NO_ERROR) {
       set_detailed_error(detailed_error);
       return false;
@@ -5618,7 +5615,7 @@
 bool QuicFramer::AppendStopWaitingFrame(const QuicPacketHeader& header,
                                         const QuicStopWaitingFrame& frame,
                                         QuicDataWriter* writer) {
-  DCHECK(!VersionHasIetfInvariantHeader(version_.transport_version));
+  DCHECK(!version_.HasIetfInvariantHeader());
   DCHECK(frame.least_unacked.IsInitialized());
   DCHECK_GE(header.packet_number, frame.least_unacked);
   const uint64_t least_unacked_delta =
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index 04eca30..dfaf811 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -1362,11 +1362,10 @@
   const QuicErrorCode parse_error = QuicFramer::ParsePublicHeader(
       &reader, kQuicDefaultConnectionIdLength,
       /*ietf_format=*/
-      VersionHasIetfInvariantHeader(framer_.transport_version()), &first_byte,
-      &format, &version_present, &has_length_prefix, &version_label,
-      &parsed_version, &destination_connection_id, &source_connection_id,
-      &long_packet_type, &retry_token_length_length, &retry_token,
-      &detailed_error);
+      framer_.version().HasIetfInvariantHeader(), &first_byte, &format,
+      &version_present, &has_length_prefix, &version_label, &parsed_version,
+      &destination_connection_id, &source_connection_id, &long_packet_type,
+      &retry_token_length_length, &retry_token, &detailed_error);
   EXPECT_THAT(parse_error, IsQuicNoError());
   EXPECT_EQ("", detailed_error);
   EXPECT_EQ(p[0], first_byte);
@@ -1379,7 +1378,7 @@
   EXPECT_EQ(EmptyQuicConnectionId(), source_connection_id);
   EXPECT_EQ(VARIABLE_LENGTH_INTEGER_LENGTH_0, retry_token_length_length);
   EXPECT_EQ(absl::string_view(), retry_token);
-  if (VersionHasIetfInvariantHeader(framer_.transport_version())) {
+  if (framer_.version().HasIetfInvariantHeader()) {
     EXPECT_EQ(IETF_QUIC_LONG_HEADER_PACKET, format);
     EXPECT_EQ(HANDSHAKE, long_packet_type);
   } else {
@@ -2763,7 +2762,7 @@
   // If IETF frames are in use then we must also have the IETF
   // header invariants.
   if (VersionHasIetfQuicFrames(framer_.transport_version())) {
-    DCHECK(VersionHasIetfInvariantHeader(framer_.transport_version()));
+    DCHECK(framer_.version().HasIetfInvariantHeader());
   }
 
   SetDecrypterLevel(ENCRYPTION_ZERO_RTT);
diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc
index e1e3478..a9d95b3 100644
--- a/quic/core/quic_packet_creator.cc
+++ b/quic/core/quic_packet_creator.cc
@@ -221,7 +221,7 @@
 // maximum packet size if we stop sending version before it is serialized.
 void QuicPacketCreator::StopSendingVersion() {
   DCHECK(send_version_in_packet_);
-  DCHECK(!VersionHasIetfInvariantHeader(framer_->transport_version()));
+  DCHECK(!version().HasIetfInvariantHeader());
   send_version_in_packet_ = false;
   if (packet_size_ > 0) {
     DCHECK_LT(kQuicVersionSize, packet_size_);
@@ -1785,7 +1785,7 @@
 }
 
 bool QuicPacketCreator::IncludeVersionInHeader() const {
-  if (VersionHasIetfInvariantHeader(framer_->transport_version())) {
+  if (version().HasIetfInvariantHeader()) {
     return packet_.encryption_level < ENCRYPTION_FORWARD_SECURE;
   }
   return send_version_in_packet_;
@@ -1908,7 +1908,7 @@
 }
 
 bool QuicPacketCreator::HasIetfLongHeader() const {
-  return VersionHasIetfInvariantHeader(framer_->transport_version()) &&
+  return version().HasIetfInvariantHeader() &&
          packet_.encryption_level < ENCRYPTION_FORWARD_SECURE;
 }
 
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index 91dbf24..e2154c1 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -102,7 +102,7 @@
                     SimpleDataProducer* producer)
       : QuicPacketCreator(connection_id, framer, delegate),
         producer_(producer),
-        version_(framer->transport_version()) {}
+        version_(framer->version()) {}
 
   bool ConsumeDataToFillCurrentPacket(QuicStreamId id,
                                       const struct iovec* iov,
@@ -125,7 +125,7 @@
   }
 
   void StopSendingVersion() {
-    if (VersionHasIetfInvariantHeader(version_)) {
+    if (version_.HasIetfInvariantHeader()) {
       set_encryption_level(ENCRYPTION_FORWARD_SECURE);
       return;
     }
@@ -133,7 +133,7 @@
   }
 
   SimpleDataProducer* producer_;
-  QuicTransportVersion version_;
+  ParsedQuicVersion version_;
 };
 
 class QuicPacketCreatorTest : public QuicTestWithParam<TestParams> {
@@ -1166,7 +1166,7 @@
 }
 
 TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthLeastAwaiting) {
-  if (VersionHasIetfInvariantHeader(creator_.transport_version()) &&
+  if (creator_.version().HasIetfInvariantHeader() &&
       !GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
     EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
               QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
@@ -1204,7 +1204,7 @@
 
 TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthCwnd) {
   QuicPacketCreatorPeer::SetPacketNumber(&creator_, 1);
-  if (VersionHasIetfInvariantHeader(creator_.transport_version()) &&
+  if (creator_.version().HasIetfInvariantHeader() &&
       !GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
     EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
               QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
@@ -1238,7 +1238,7 @@
 
 TEST_P(QuicPacketCreatorTest, SkipNPacketNumbers) {
   QuicPacketCreatorPeer::SetPacketNumber(&creator_, 1);
-  if (VersionHasIetfInvariantHeader(creator_.transport_version()) &&
+  if (creator_.version().HasIetfInvariantHeader() &&
       !GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
     EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
               QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
@@ -3230,7 +3230,7 @@
 
   for (size_t i = 1; i < 10; i++) {
     creator_.SetServerConnectionIdLength(i);
-    if (VersionHasIetfInvariantHeader(framer_.transport_version())) {
+    if (framer_.version().HasIetfInvariantHeader()) {
       EXPECT_EQ(PACKET_0BYTE_CONNECTION_ID,
                 creator_.GetDestinationConnectionIdLength());
     } else {
diff --git a/quic/core/quic_received_packet_manager_test.cc b/quic/core/quic_received_packet_manager_test.cc
index c8d1638..41de03c 100644
--- a/quic/core/quic_received_packet_manager_test.cc
+++ b/quic/core/quic_received_packet_manager_test.cc
@@ -41,28 +41,7 @@
 const QuicTime::Delta kDelayedAckTime =
     QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
 
-struct TestParams {
-  explicit TestParams(QuicTransportVersion version) : version(version) {}
-
-  QuicTransportVersion version;
-};
-
-// Used by ::testing::PrintToStringParamName().
-std::string PrintToString(const TestParams& p) {
-  return QuicVersionToString(p.version);
-}
-
-std::vector<TestParams> GetTestParams() {
-  std::vector<TestParams> params;
-  QuicTransportVersionVector all_supported_versions =
-      AllSupportedTransportVersions();
-  for (size_t i = 0; i < all_supported_versions.size(); ++i) {
-    params.push_back(TestParams(all_supported_versions[i]));
-  }
-  return params;
-}
-
-class QuicReceivedPacketManagerTest : public QuicTestWithParam<TestParams> {
+class QuicReceivedPacketManagerTest : public QuicTest {
  protected:
   QuicReceivedPacketManagerTest() : received_manager_(&stats_) {
     clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
@@ -108,12 +87,7 @@
   QuicReceivedPacketManager received_manager_;
 };
 
-INSTANTIATE_TEST_SUITE_P(QuicReceivedPacketManagerTest,
-                         QuicReceivedPacketManagerTest,
-                         ::testing::ValuesIn(GetTestParams()),
-                         ::testing::PrintToStringParamName());
-
-TEST_P(QuicReceivedPacketManagerTest, DontWaitForPacketsBefore) {
+TEST_F(QuicReceivedPacketManagerTest, DontWaitForPacketsBefore) {
   QuicPacketHeader header;
   header.packet_number = QuicPacketNumber(2u);
   received_manager_.RecordPacketReceived(header, QuicTime::Zero());
@@ -126,7 +100,7 @@
   EXPECT_TRUE(received_manager_.IsAwaitingPacket(QuicPacketNumber(6u)));
 }
 
-TEST_P(QuicReceivedPacketManagerTest, GetUpdatedAckFrame) {
+TEST_F(QuicReceivedPacketManagerTest, GetUpdatedAckFrame) {
   QuicPacketHeader header;
   header.packet_number = QuicPacketNumber(2u);
   QuicTime two_ms = QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(2);
@@ -168,7 +142,7 @@
   EXPECT_EQ(2u, ack.ack_frame->received_packet_times.size());
 }
 
-TEST_P(QuicReceivedPacketManagerTest, UpdateReceivedConnectionStats) {
+TEST_F(QuicReceivedPacketManagerTest, UpdateReceivedConnectionStats) {
   EXPECT_FALSE(received_manager_.ack_frame_updated());
   RecordPacketReceipt(1);
   EXPECT_TRUE(received_manager_.ack_frame_updated());
@@ -181,7 +155,7 @@
   EXPECT_EQ(1u, stats_.packets_reordered);
 }
 
-TEST_P(QuicReceivedPacketManagerTest, LimitAckRanges) {
+TEST_F(QuicReceivedPacketManagerTest, LimitAckRanges) {
   received_manager_.set_max_ack_ranges(10);
   EXPECT_FALSE(received_manager_.ack_frame_updated());
   for (int i = 0; i < 100; ++i) {
@@ -203,7 +177,7 @@
   }
 }
 
-TEST_P(QuicReceivedPacketManagerTest, IgnoreOutOfOrderTimestamps) {
+TEST_F(QuicReceivedPacketManagerTest, IgnoreOutOfOrderTimestamps) {
   EXPECT_FALSE(received_manager_.ack_frame_updated());
   RecordPacketReceipt(1, QuicTime::Zero());
   EXPECT_TRUE(received_manager_.ack_frame_updated());
@@ -215,7 +189,7 @@
   EXPECT_EQ(2u, received_manager_.ack_frame().received_packet_times.size());
 }
 
-TEST_P(QuicReceivedPacketManagerTest, HasMissingPackets) {
+TEST_F(QuicReceivedPacketManagerTest, HasMissingPackets) {
   EXPECT_QUIC_BUG(received_manager_.PeerFirstSendingPacketNumber(),
                   "No packets have been received yet");
   RecordPacketReceipt(4, QuicTime::Zero());
@@ -236,7 +210,7 @@
   EXPECT_FALSE(received_manager_.HasMissingPackets());
 }
 
-TEST_P(QuicReceivedPacketManagerTest, OutOfOrderReceiptCausesAckSent) {
+TEST_F(QuicReceivedPacketManagerTest, OutOfOrderReceiptCausesAckSent) {
   EXPECT_FALSE(HasPendingAck());
 
   RecordPacketReceipt(3, clock_.ApproximateNow());
@@ -269,7 +243,7 @@
   CheckAckTimeout(clock_.ApproximateNow());
 }
 
-TEST_P(QuicReceivedPacketManagerTest, OutOfOrderReceiptCausesAckSent1Ack) {
+TEST_F(QuicReceivedPacketManagerTest, OutOfOrderReceiptCausesAckSent1Ack) {
   QuicReceivedPacketManagerPeer::SetOneImmediateAck(&received_manager_, true);
   EXPECT_FALSE(HasPendingAck());
 
@@ -303,7 +277,7 @@
   CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
 }
 
-TEST_P(QuicReceivedPacketManagerTest, OutOfOrderAckReceiptCausesNoAck) {
+TEST_F(QuicReceivedPacketManagerTest, OutOfOrderAckReceiptCausesNoAck) {
   EXPECT_FALSE(HasPendingAck());
 
   RecordPacketReceipt(2, clock_.ApproximateNow());
@@ -315,7 +289,7 @@
   EXPECT_FALSE(HasPendingAck());
 }
 
-TEST_P(QuicReceivedPacketManagerTest, AckReceiptCausesAckSend) {
+TEST_F(QuicReceivedPacketManagerTest, AckReceiptCausesAckSend) {
   EXPECT_FALSE(HasPendingAck());
 
   RecordPacketReceipt(1, clock_.ApproximateNow());
@@ -342,7 +316,7 @@
   EXPECT_FALSE(HasPendingAck());
 }
 
-TEST_P(QuicReceivedPacketManagerTest, AckSentEveryNthPacket) {
+TEST_F(QuicReceivedPacketManagerTest, AckSentEveryNthPacket) {
   EXPECT_FALSE(HasPendingAck());
   received_manager_.set_ack_frequency(3);
 
@@ -358,7 +332,7 @@
   }
 }
 
-TEST_P(QuicReceivedPacketManagerTest, AckDecimationReducesAcks) {
+TEST_F(QuicReceivedPacketManagerTest, AckDecimationReducesAcks) {
   EXPECT_FALSE(HasPendingAck());
 
   // Start ack decimation from 10th packet.
@@ -391,7 +365,7 @@
   CheckAckTimeout(clock_.ApproximateNow());
 }
 
-TEST_P(QuicReceivedPacketManagerTest, SendDelayedAckDecimation) {
+TEST_F(QuicReceivedPacketManagerTest, SendDelayedAckDecimation) {
   EXPECT_FALSE(HasPendingAck());
   // The ack time should be based on min_rtt * 1/4, since it's less than the
   // default delayed ack time.
@@ -422,7 +396,7 @@
   CheckAckTimeout(clock_.ApproximateNow());
 }
 
-TEST_P(QuicReceivedPacketManagerTest, SendDelayedAckDecimationMin1ms) {
+TEST_F(QuicReceivedPacketManagerTest, SendDelayedAckDecimationMin1ms) {
   if (!GetQuicReloadableFlag(quic_ack_delay_alarm_granularity)) {
     return;
   }
@@ -458,7 +432,7 @@
   CheckAckTimeout(clock_.ApproximateNow());
 }
 
-TEST_P(QuicReceivedPacketManagerTest,
+TEST_F(QuicReceivedPacketManagerTest,
        SendDelayedAckDecimationUnlimitedAggregation) {
   EXPECT_FALSE(HasPendingAck());
   QuicConfig config;
@@ -499,7 +473,7 @@
   CheckAckTimeout(ack_time);
 }
 
-TEST_P(QuicReceivedPacketManagerTest, SendDelayedAckDecimationEighthRtt) {
+TEST_F(QuicReceivedPacketManagerTest, SendDelayedAckDecimationEighthRtt) {
   EXPECT_FALSE(HasPendingAck());
   QuicReceivedPacketManagerPeer::SetAckDecimationDelay(&received_manager_,
                                                        0.125);
diff --git a/quic/core/quic_time_wait_list_manager_test.cc b/quic/core/quic_time_wait_list_manager_test.cc
index 34c2b1e..8e69dc3 100644
--- a/quic/core/quic_time_wait_list_manager_test.cc
+++ b/quic/core/quic_time_wait_list_manager_test.cc
@@ -164,8 +164,7 @@
       std::vector<std::unique_ptr<QuicEncryptedPacket>>* packets) {
     time_wait_list_manager_.AddConnectionIdToTimeWait(
         connection_id, action,
-        TimeWaitConnectionInfo(
-            VersionHasIetfInvariantHeader(version.transport_version), packets));
+        TimeWaitConnectionInfo(version.HasIetfInvariantHeader(), packets));
   }
 
   bool IsConnectionIdInTimeWait(QuicConnectionId connection_id) {
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index 05b9918..af6bd18 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -326,24 +326,22 @@
     return UnsupportedQuicVersion();
   }
   int quic_version_number = 0;
+  const ParsedQuicVersionVector supported_versions = AllSupportedVersions();
   if (absl::SimpleAtoi(version_string, &quic_version_number) &&
       quic_version_number > 0) {
     QuicTransportVersion transport_version =
         static_cast<QuicTransportVersion>(quic_version_number);
-    bool transport_version_is_supported = false;
-    for (QuicTransportVersion transport_vers : SupportedTransportVersions()) {
-      if (transport_vers == transport_version) {
-        transport_version_is_supported = true;
-        break;
-      }
-    }
-    if (!transport_version_is_supported ||
-        !ParsedQuicVersionIsValid(PROTOCOL_QUIC_CRYPTO, transport_version)) {
+    if (!ParsedQuicVersionIsValid(PROTOCOL_QUIC_CRYPTO, transport_version)) {
       return UnsupportedQuicVersion();
     }
-    return ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, transport_version);
+    ParsedQuicVersion version(PROTOCOL_QUIC_CRYPTO, transport_version);
+    if (std::find(supported_versions.begin(), supported_versions.end(),
+                  version) != supported_versions.end()) {
+      return version;
+    }
+    return UnsupportedQuicVersion();
   }
-  for (const ParsedQuicVersion& version : AllSupportedVersions()) {
+  for (const ParsedQuicVersion& version : supported_versions) {
     if (version_string == ParsedQuicVersionToString(version) ||
         version_string == AlpnForVersion(version) ||
         (version.handshake_protocol == PROTOCOL_QUIC_CRYPTO &&
@@ -351,13 +349,13 @@
       return version;
     }
   }
-    for (const ParsedQuicVersion& version : AllSupportedVersions()) {
-      if (version.UsesHttp3() &&
-          version_string ==
-              QuicVersionLabelToString(CreateQuicVersionLabel(version))) {
-        return version;
-      }
+  for (const ParsedQuicVersion& version : supported_versions) {
+    if (version.UsesHttp3() &&
+        version_string ==
+            QuicVersionLabelToString(CreateQuicVersionLabel(version))) {
+      return version;
     }
+  }
   // Reading from the client so this should not be considered an ERROR.
   QUIC_DLOG(INFO) << "Unsupported QUIC version string: \"" << version_string
                   << "\".";
@@ -383,10 +381,14 @@
 }
 
 QuicTransportVersionVector AllSupportedTransportVersions() {
-  constexpr auto supported_transport_versions = SupportedTransportVersions();
-  QuicTransportVersionVector supported_versions(
-      supported_transport_versions.begin(), supported_transport_versions.end());
-  return supported_versions;
+  QuicTransportVersionVector transport_versions;
+  for (const ParsedQuicVersion& version : AllSupportedVersions()) {
+    if (std::find(transport_versions.begin(), transport_versions.end(),
+                  version.transport_version) == transport_versions.end()) {
+      transport_versions.push_back(version.transport_version);
+    }
+  }
+  return transport_versions;
 }
 
 ParsedQuicVersionVector AllSupportedVersions() {
@@ -432,19 +434,6 @@
   return filtered_versions;
 }
 
-QuicTransportVersionVector VersionOfIndex(
-    const QuicTransportVersionVector& versions,
-    int index) {
-  QuicTransportVersionVector version;
-  int version_count = versions.size();
-  if (index >= 0 && index < version_count) {
-    version.push_back(versions[index]);
-  } else {
-    version.push_back(QUIC_VERSION_UNSUPPORTED);
-  }
-  return version;
-}
-
 ParsedQuicVersionVector ParsedVersionOfIndex(
     const ParsedQuicVersionVector& versions,
     int index) {
@@ -458,22 +447,6 @@
   return version;
 }
 
-QuicTransportVersionVector ParsedVersionsToTransportVersions(
-    const ParsedQuicVersionVector& versions) {
-  QuicTransportVersionVector transport_versions;
-  transport_versions.resize(versions.size());
-  for (size_t i = 0; i < versions.size(); ++i) {
-    transport_versions[i] = versions[i].transport_version;
-  }
-  return transport_versions;
-}
-
-QuicVersionLabel QuicVersionToQuicVersionLabel(
-    QuicTransportVersion transport_version) {
-  return CreateQuicVersionLabel(
-      ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, transport_version));
-}
-
 std::string QuicVersionLabelToString(QuicVersionLabel version_label) {
   return QuicTagToString(quiche::QuicheEndian::HostToNet32(version_label));
 }
@@ -497,23 +470,11 @@
   return result;
 }
 
-QuicTransportVersion QuicVersionLabelToQuicVersion(
-    QuicVersionLabel version_label) {
-  return ParseQuicVersionLabel(version_label).transport_version;
-}
-
-HandshakeProtocol QuicVersionLabelToHandshakeProtocol(
-    QuicVersionLabel version_label) {
-  return ParseQuicVersionLabel(version_label).handshake_protocol;
-}
-
 #define RETURN_STRING_LITERAL(x) \
   case x:                        \
     return #x
 
 std::string QuicVersionToString(QuicTransportVersion transport_version) {
-  static_assert(SupportedTransportVersions().size() == 5u,
-                "Supported versions out of sync");
   switch (transport_version) {
     RETURN_STRING_LITERAL(QUIC_VERSION_43);
     RETURN_STRING_LITERAL(QUIC_VERSION_46);
diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index 60d50bf..003424d 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -26,6 +26,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/base/macros.h"
 #include "absl/strings/string_view.h"
 #include "net/third_party/quiche/src/quic/core/quic_tag.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
@@ -134,16 +135,6 @@
   QUIC_VERSION_RESERVED_FOR_NEGOTIATION = 999,
 };
 
-// This array contains QUIC transport versions which we currently support.
-// DEPRECATED. Use SupportedVersions() instead.
-constexpr std::array<QuicTransportVersion, 5> SupportedTransportVersions() {
-  return {QUIC_VERSION_IETF_DRAFT_29,
-          QUIC_VERSION_51,
-          QUIC_VERSION_50,
-          QUIC_VERSION_46,
-          QUIC_VERSION_43};
-}
-
 // Helper function which translates from a QuicTransportVersion to a string.
 // Returns strings corresponding to enum names (e.g. QUIC_VERSION_6).
 QUIC_EXPORT_PRIVATE std::string QuicVersionToString(
@@ -177,18 +168,20 @@
 QUIC_EXPORT_PRIVATE constexpr bool ParsedQuicVersionIsValid(
     HandshakeProtocol handshake_protocol,
     QuicTransportVersion transport_version) {
-  bool transport_version_is_valid =
-      transport_version == QUIC_VERSION_UNSUPPORTED ||
-      transport_version == QUIC_VERSION_RESERVED_FOR_NEGOTIATION;
-  if (!transport_version_is_valid) {
-    // Iterators are not constexpr in C++14 which Chrome uses.
-    constexpr auto supported_transport_versions = SupportedTransportVersions();
-    for (size_t i = 0; i < supported_transport_versions.size(); ++i) {
-      const QuicTransportVersion& trans_vers = supported_transport_versions[i];
-      if (trans_vers == transport_version) {
-        transport_version_is_valid = true;
-        break;
-      }
+  bool transport_version_is_valid = false;
+  constexpr QuicTransportVersion valid_transport_versions[] = {
+      QUIC_VERSION_IETF_DRAFT_29,
+      QUIC_VERSION_51,
+      QUIC_VERSION_50,
+      QUIC_VERSION_46,
+      QUIC_VERSION_43,
+      QUIC_VERSION_RESERVED_FOR_NEGOTIATION,
+      QUIC_VERSION_UNSUPPORTED,
+  };
+  for (size_t i = 0; i < ABSL_ARRAYSIZE(valid_transport_versions); ++i) {
+    if (transport_version == valid_transport_versions[i]) {
+      transport_version_is_valid = true;
+      break;
     }
   }
   if (!transport_version_is_valid) {
@@ -424,16 +417,11 @@
     std::ostream& os,
     const QuicTransportVersionVector& transport_versions);
 
-// Returns a vector of QUIC versions in kSupportedTransportVersions.
-QUIC_EXPORT_PRIVATE QuicTransportVersionVector AllSupportedTransportVersions();
-
-// Returns a vector of QUIC versions that is the cartesian product of
-// kSupportedTransportVersions and kSupportedHandshakeProtocols.
+// Returns a vector of supported QUIC versions.
 QUIC_EXPORT_PRIVATE ParsedQuicVersionVector AllSupportedVersions();
 
-// Returns a vector of QUIC versions that is the cartesian product of
-// kSupportedTransportVersions and kSupportedHandshakeProtocols, with any
-// versions disabled by flags excluded.
+// Returns a vector of supported QUIC versions, with any versions disabled by
+// flags excluded.
 QUIC_EXPORT_PRIVATE ParsedQuicVersionVector CurrentSupportedVersions();
 
 // Returns a vector of QUIC versions from |versions| which exclude any versions
@@ -462,22 +450,10 @@
 QUIC_EXPORT_PRIVATE ParsedQuicVersionVector CurrentSupportedVersionsWithTls();
 
 // Returns QUIC version of |index| in result of |versions|. Returns
-// QUIC_VERSION_UNSUPPORTED if |index| is out of bounds.
-QUIC_EXPORT_PRIVATE QuicTransportVersionVector
-VersionOfIndex(const QuicTransportVersionVector& versions, int index);
-
-// Returns QUIC version of |index| in result of |versions|. Returns
 // UnsupportedQuicVersion() if |index| is out of bounds.
 QUIC_EXPORT_PRIVATE ParsedQuicVersionVector
 ParsedVersionOfIndex(const ParsedQuicVersionVector& versions, int index);
 
-// Returns a vector of QuicTransportVersions corresponding to just the transport
-// versions in |versions|. If the input vector contains multiple parsed versions
-// with different handshake protocols (but the same transport version), that
-// transport version will appear in the resulting vector multiple times.
-QUIC_EXPORT_PRIVATE QuicTransportVersionVector
-ParsedVersionsToTransportVersions(const ParsedQuicVersionVector& versions);
-
 // QuicVersionLabel is written to and read from the wire, but we prefer to use
 // the more readable ParsedQuicVersion at other levels.
 // Helper function which translates from a QuicVersionLabel to a
@@ -498,6 +474,10 @@
 ParseQuicVersionVectorString(absl::string_view versions_string);
 
 // Constructs a QuicVersionLabel from the provided ParsedQuicVersion.
+// QuicVersionLabel is written to and read from the wire, but we prefer to use
+// the more readable ParsedQuicVersion at other levels.
+// Helper function which translates from a ParsedQuicVersion to a
+// QuicVersionLabel. Returns 0 if |parsed_version| is unsupported.
 QUIC_EXPORT_PRIVATE QuicVersionLabel
 CreateQuicVersionLabel(ParsedQuicVersion parsed_version);
 
@@ -506,13 +486,6 @@
 QUIC_EXPORT_PRIVATE QuicVersionLabelVector
 CreateQuicVersionLabelVector(const ParsedQuicVersionVector& versions);
 
-// QuicVersionLabel is written to and read from the wire, but we prefer to use
-// the more readable QuicTransportVersion at other levels.
-// Helper function which translates from a QuicTransportVersion to a
-// QuicVersionLabel. Returns 0 if |version| is unsupported.
-QUIC_EXPORT_PRIVATE QuicVersionLabel
-QuicVersionToQuicVersionLabel(QuicTransportVersion transport_version);
-
 // Helper function which translates from a QuicVersionLabel to a string.
 QUIC_EXPORT_PRIVATE std::string QuicVersionLabelToString(
     QuicVersionLabel version_label);
@@ -533,21 +506,15 @@
                                         std::numeric_limits<size_t>::max());
 }
 
-// Returns appropriate QuicTransportVersion from a QuicVersionLabel.
-// Returns QUIC_VERSION_UNSUPPORTED if |version_label| cannot be understood.
-QUIC_EXPORT_PRIVATE QuicTransportVersion
-QuicVersionLabelToQuicVersion(QuicVersionLabel version_label);
-
-// Returns the HandshakeProtocol used with the given |version_label|, returning
-// PROTOCOL_UNSUPPORTED if it is unknown.
-QUIC_EXPORT_PRIVATE HandshakeProtocol
-QuicVersionLabelToHandshakeProtocol(QuicVersionLabel version_label);
-
 // Helper function which translates from a ParsedQuicVersion to a string.
 // Returns strings corresponding to the on-the-wire tag.
 QUIC_EXPORT_PRIVATE std::string ParsedQuicVersionToString(
     ParsedQuicVersion version);
 
+// Returns a vector of supported QUIC transport versions. DEPRECATED, use
+// AllSupportedVersions instead.
+QUIC_EXPORT_PRIVATE QuicTransportVersionVector AllSupportedTransportVersions();
+
 // Returns comma separated list of string representations of
 // QuicTransportVersion enum values in the supplied |versions| vector.
 QUIC_EXPORT_PRIVATE std::string QuicTransportVersionVectorToString(
diff --git a/quic/core/quic_versions_test.cc b/quic/core/quic_versions_test.cc
index fe4e227..f0f0801 100644
--- a/quic/core/quic_versions_test.cc
+++ b/quic/core/quic_versions_test.cc
@@ -26,32 +26,7 @@
   }
 };
 
-TEST_F(QuicVersionsTest, QuicVersionToQuicVersionLabel) {
-  // If you add a new version to the QuicTransportVersion enum you will need to
-  // add a new case to QuicVersionToQuicVersionLabel, otherwise this test will
-  // fail.
-
-  // Any logs would indicate an unsupported version which we don't expect.
-  CREATE_QUIC_MOCK_LOG(log);
-  EXPECT_QUIC_LOG_CALL(log).Times(0);
-  log.StartCapturingLogs();
-
-  // Explicitly test a specific version.
-  EXPECT_EQ(MakeQuicTag('3', '4', '0', 'Q'),
-            QuicVersionToQuicVersionLabel(QUIC_VERSION_43));
-
-  // Loop over all supported versions and make sure that we never hit the
-  // default case (i.e. all supported versions should be successfully converted
-  // to valid QuicVersionLabels).
-  for (QuicTransportVersion transport_version : SupportedTransportVersions()) {
-    if (!ParsedQuicVersionIsValid(PROTOCOL_QUIC_CRYPTO, transport_version)) {
-      continue;
-    }
-    EXPECT_LT(0u, QuicVersionToQuicVersionLabel(transport_version));
-  }
-}
-
-TEST_F(QuicVersionsTest, QuicVersionToQuicVersionLabelUnsupported) {
+TEST_F(QuicVersionsTest, CreateQuicVersionLabelUnsupported) {
   EXPECT_QUIC_BUG(
       CreateQuicVersionLabel(UnsupportedQuicVersion()),
       "Unsupported version QUIC_VERSION_UNSUPPORTED PROTOCOL_UNSUPPORTED");
@@ -143,63 +118,6 @@
   EXPECT_FALSE(parsed_version_draft_29.UsesQuicCrypto());
 }
 
-TEST_F(QuicVersionsTest, QuicVersionLabelToQuicTransportVersion) {
-  // If you add a new version to the QuicTransportVersion enum you will need to
-  // add a new case to QuicVersionLabelToQuicTransportVersion, otherwise this
-  // test will fail.
-
-  // Any logs would indicate an unsupported version which we don't expect.
-  CREATE_QUIC_MOCK_LOG(log);
-  EXPECT_QUIC_LOG_CALL(log).Times(0);
-  log.StartCapturingLogs();
-
-  // Explicitly test specific versions.
-  EXPECT_EQ(QUIC_VERSION_43,
-            QuicVersionLabelToQuicVersion(MakeQuicTag('3', '4', '0', 'Q')));
-
-  for (QuicTransportVersion transport_version : SupportedTransportVersions()) {
-    if (!ParsedQuicVersionIsValid(PROTOCOL_QUIC_CRYPTO, transport_version)) {
-      continue;
-    }
-
-    // Get the label from the version (we can loop over QuicVersions easily).
-    QuicVersionLabel version_label =
-        QuicVersionToQuicVersionLabel(transport_version);
-    EXPECT_LT(0u, version_label);
-
-    // Now try converting back.
-    QuicTransportVersion label_to_transport_version =
-        QuicVersionLabelToQuicVersion(version_label);
-    EXPECT_EQ(transport_version, label_to_transport_version);
-    EXPECT_NE(QUIC_VERSION_UNSUPPORTED, label_to_transport_version);
-  }
-}
-
-TEST_F(QuicVersionsTest, QuicVersionLabelToQuicVersionUnsupported) {
-  CREATE_QUIC_MOCK_LOG(log);
-  if (QUIC_DLOG_INFO_IS_ON()) {
-    EXPECT_QUIC_LOG_CALL_CONTAINS(log, INFO,
-                                  "Unsupported QuicVersionLabel version: EKAF")
-        .Times(1);
-  }
-  log.StartCapturingLogs();
-
-  EXPECT_EQ(QUIC_VERSION_UNSUPPORTED,
-            QuicVersionLabelToQuicVersion(MakeQuicTag('F', 'A', 'K', 'E')));
-}
-
-TEST_F(QuicVersionsTest, QuicVersionLabelToHandshakeProtocol) {
-  CREATE_QUIC_MOCK_LOG(log);
-  EXPECT_QUIC_LOG_CALL(log).Times(0);
-  log.StartCapturingLogs();
-
-  for (const ParsedQuicVersion& version : AllSupportedVersions()) {
-    QuicVersionLabel version_label = CreateQuicVersionLabel(version);
-    EXPECT_EQ(version.handshake_protocol,
-              QuicVersionLabelToHandshakeProtocol(version_label));
-  }
-}
-
 TEST_F(QuicVersionsTest, ParseQuicVersionLabel) {
   EXPECT_EQ(ParsedQuicVersion::Q043(),
             ParseQuicVersionLabel(MakeVersionLabel('Q', '0', '4', '3')));
@@ -378,9 +296,9 @@
             QuicTransportVersionVectorToString(versions_vector));
 
   // Make sure that all supported versions are present in QuicVersionToString.
-  for (QuicTransportVersion transport_version : SupportedTransportVersions()) {
+  for (const ParsedQuicVersion& version : AllSupportedVersions()) {
     EXPECT_NE("QUIC_VERSION_UNSUPPORTED",
-              QuicVersionToString(transport_version));
+              QuicVersionToString(version.transport_version));
   }
 
   std::ostringstream os;
@@ -444,19 +362,6 @@
             FilterSupportedVersions(AllSupportedVersions()));
 }
 
-TEST_F(QuicVersionsTest, LookUpVersionByIndex) {
-  QuicTransportVersionVector all_versions = {QUIC_VERSION_43};
-  int version_count = all_versions.size();
-  for (int i = -5; i <= version_count + 1; ++i) {
-    QuicTransportVersionVector index = VersionOfIndex(all_versions, i);
-    if (i >= 0 && i < version_count) {
-      EXPECT_EQ(all_versions[i], index[0]);
-    } else {
-      EXPECT_EQ(QUIC_VERSION_UNSUPPORTED, index[0]);
-    }
-  }
-}
-
 TEST_F(QuicVersionsTest, LookUpParsedVersionByIndex) {
   ParsedQuicVersionVector all_versions = AllSupportedVersions();
   int version_count = all_versions.size();
@@ -470,21 +375,11 @@
   }
 }
 
-TEST_F(QuicVersionsTest, ParsedVersionsToTransportVersions) {
-  ParsedQuicVersionVector all_versions = AllSupportedVersions();
-  QuicTransportVersionVector transport_versions =
-      ParsedVersionsToTransportVersions(all_versions);
-  ASSERT_EQ(all_versions.size(), transport_versions.size());
-  for (size_t i = 0; i < all_versions.size(); ++i) {
-    EXPECT_EQ(transport_versions[i], all_versions[i].transport_version);
-  }
-}
-
 // This test may appear to be so simplistic as to be unnecessary,
 // 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() == 5u,
+  static_assert(SupportedVersions().size() == 5u,
                 "Supported versions out of sync");
   EXPECT_EQ(QUIC_VERSION_43, 43);
   EXPECT_EQ(QUIC_VERSION_46, 46);
@@ -516,18 +411,18 @@
 TEST_F(QuicVersionsTest, ReservedForNegotiation) {
   EXPECT_EQ(QUIC_VERSION_RESERVED_FOR_NEGOTIATION,
             QuicVersionReservedForNegotiation().transport_version);
-  // QUIC_VERSION_RESERVED_FOR_NEGOTIATION MUST NOT be added to
-  // kSupportedTransportVersions.
-  for (QuicTransportVersion transport_version : SupportedTransportVersions()) {
-    EXPECT_NE(QUIC_VERSION_RESERVED_FOR_NEGOTIATION, transport_version);
+  // QUIC_VERSION_RESERVED_FOR_NEGOTIATION MUST NOT be supported.
+  for (const ParsedQuicVersion& version : AllSupportedVersions()) {
+    EXPECT_NE(QUIC_VERSION_RESERVED_FOR_NEGOTIATION, version.transport_version);
   }
 }
 
 TEST_F(QuicVersionsTest, SupportedVersionsHasCorrectList) {
   size_t index = 0;
   for (HandshakeProtocol handshake_protocol : SupportedHandshakeProtocols()) {
-    for (QuicTransportVersion transport_version :
-         SupportedTransportVersions()) {
+    for (int trans_vers = 255; trans_vers > 0; trans_vers--) {
+      QuicTransportVersion transport_version =
+          static_cast<QuicTransportVersion>(trans_vers);
       SCOPED_TRACE(index);
       if (ParsedQuicVersionIsValid(handshake_protocol, transport_version)) {
         ParsedQuicVersion version = SupportedVersions()[index];
diff --git a/quic/test_tools/crypto_test_utils.cc b/quic/test_tools/crypto_test_utils.cc
index 960f1d9..8303487 100644
--- a/quic/test_tools/crypto_test_utils.cc
+++ b/quic/test_tools/crypto_test_utils.cc
@@ -452,7 +452,7 @@
   bool ok = false;
   proof_source->GetProof(
       server_address, client_address, "", "",
-      AllSupportedTransportVersions().front(), "",
+      AllSupportedVersionsWithQuicCrypto().front().transport_version, "",
       std::unique_ptr<ProofSource::Callback>(new Callback(&ok, &chain)));
   if (!ok || chain->certs.empty()) {
     DCHECK(false) << "Proof generation failed";
@@ -814,7 +814,8 @@
        {"PUBS", GenerateClientPublicValuesHex().c_str()},
        {"NONC", GenerateClientNonceHex(clock, crypto_config).c_str()},
        {"VER\0", QuicVersionLabelToString(
-           QuicVersionToQuicVersionLabel(version)).c_str()}},
+           CreateQuicVersionLabel(
+            ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, version))).c_str()}},
       kClientHelloMinimumSize);
   // clang-format on
 }
diff --git a/quic/test_tools/crypto_test_utils_test.cc b/quic/test_tools/crypto_test_utils_test.cc
index 0769da4..e12814b 100644
--- a/quic/test_tools/crypto_test_utils_test.cc
+++ b/quic/test_tools/crypto_test_utils_test.cc
@@ -165,8 +165,9 @@
        {"COPT", "SREJ"},
        {"PUBS", pub_hex},
        {"NONC", nonce_hex},
-       {"VER\0", QuicVersionLabelToString(
-                     QuicVersionToQuicVersionLabel(transport_version))}},
+       {"VER\0",
+        QuicVersionLabelToString(CreateQuicVersionLabel(
+            ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, transport_version)))}},
       kClientHelloMinimumSize);
 
   crypto_test_utils::GenerateFullCHLO(inchoate_chlo, &crypto_config,
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 2ceef38..a5f7b74 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
@@ -48,7 +48,7 @@
 
 PacketHeaderFormat ConsumePacketHeaderFormat(FuzzedDataProvider* provider,
                                              ParsedQuicVersion version) {
-  if (!VersionHasIetfInvariantHeader(version.transport_version)) {
+  if (!version.HasIetfInvariantHeader()) {
     return quic::GOOGLE_QUIC_PACKET;
   }
   return provider->ConsumeBool() ? quic::IETF_QUIC_LONG_HEADER_PACKET
diff --git a/quic/tools/quic_packet_printer_bin.cc b/quic/tools/quic_packet_printer_bin.cc
index f7e05e5..1332cff 100644
--- a/quic/tools/quic_packet_printer_bin.cc
+++ b/quic/tools/quic_packet_printer_bin.cc
@@ -270,13 +270,10 @@
   quic::QuicTime start(quic::QuicTime::Zero());
   quic::QuicFramer framer(versions, start, perspective,
                           quic::kQuicDefaultConnectionIdLength);
-  if (!GetQuicFlag(FLAGS_quic_version).empty()) {
-    for (const quic::ParsedQuicVersion& version : versions) {
-      if (quic::QuicVersionToString(version.transport_version) ==
-          GetQuicFlag(FLAGS_quic_version)) {
-        framer.set_version(version);
-      }
-    }
+  const quic::ParsedQuicVersion& version =
+      quic::ParseQuicVersionString(GetQuicFlag(FLAGS_quic_version));
+  if (version != quic::ParsedQuicVersion::Unsupported()) {
+    framer.set_version(version);
   }
   quic::QuicPacketPrinter visitor(&framer);
   framer.set_visitor(&visitor);