diff --git a/quic/core/crypto/quic_crypto_server_config_test.cc b/quic/core/crypto/quic_crypto_server_config_test.cc
index df9b904..8dd1108 100644
--- a/quic/core/crypto/quic_crypto_server_config_test.cc
+++ b/quic/core/crypto/quic_crypto_server_config_test.cc
@@ -16,6 +16,7 @@
 #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
 #include "net/third_party/quiche/src/quic/core/proto/crypto_server_config_proto.h"
 #include "net/third_party/quiche/src/quic/core/quic_time.h"
+#include "net/third_party/quiche/src/quic/core/quic_versions.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h"
@@ -482,15 +483,23 @@
   CryptoHandshakeMessage client_hello;
   QuicIpAddress client_ip;
   QuicSocketAddress server_address;
-  QuicTransportVersion version = QUIC_VERSION_99;
+  QuicTransportVersion transport_version = QUIC_VERSION_UNSUPPORTED;
+  for (const ParsedQuicVersion& version : AllSupportedVersions()) {
+    if (version.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
+      transport_version = version.transport_version;
+      break;
+    }
+  }
+  ASSERT_NE(transport_version, QUIC_VERSION_UNSUPPORTED);
   MockClock clock;
   QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config(
       new QuicSignedServerConfig);
   std::unique_ptr<ValidateClientHelloResultCallback> done_cb(
       new ValidateCallback);
   clock.AdvanceTime(QuicTime::Delta::FromSeconds(1100));
-  config_.ValidateClientHello(client_hello, client_ip, server_address, version,
-                              &clock, signed_config, std::move(done_cb));
+  config_.ValidateClientHello(client_hello, client_ip, server_address,
+                              transport_version, &clock, signed_config,
+                              std::move(done_cb));
   test_peer_.CheckConfigs({{"a", false}, {"b", true}});
 }
 
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 39fc5f5..ead192c 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -979,8 +979,7 @@
 }
 
 TEST_P(EndToEndTestWithTls, SimpleRequestResponseWithIetfDraftSupport) {
-  if (GetParam().negotiated_version.transport_version != QUIC_VERSION_99 ||
-      GetParam().negotiated_version.handshake_protocol != PROTOCOL_TLS1_3) {
+  if (!GetParam().negotiated_version.HasIetfQuicFrames()) {
     ASSERT_TRUE(Initialize());
     return;
   }
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index 5b70813..1d5305b 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -2288,8 +2288,7 @@
 
 INSTANTIATE_TEST_SUITE_P(Tests,
                          QuicSpdyStreamIncrementalConsumptionTest,
-                         ::testing::Values(ParsedQuicVersion{PROTOCOL_TLS1_3,
-                                                             QUIC_VERSION_99}),
+                         ::testing::ValuesIn(AllSupportedVersions()),
                          ::testing::PrintToStringParamName());
 
 // Test that stream bytes are consumed (by calling
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index ec45837..2248909 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -9383,11 +9383,13 @@
 
 static char kTestString[] = "At least 20 characters.";
 static QuicStreamId kTestQuicStreamId = 1;
-static bool ExpectedStreamFrame(const QuicStreamFrame& frame) {
-  return (frame.stream_id == kTestQuicStreamId ||
-          QuicUtils::IsCryptoStreamId(QUIC_VERSION_99, frame.stream_id)) &&
-         !frame.fin && frame.offset == 0 &&
-         std::string(frame.data_buffer, frame.data_length) == kTestString;
+
+MATCHER_P(ExpectedStreamFrame, version, "") {
+  return (arg.stream_id == kTestQuicStreamId ||
+          QuicUtils::IsCryptoStreamId(version.transport_version,
+                                      arg.stream_id)) &&
+         !arg.fin && arg.offset == 0 &&
+         std::string(arg.data_buffer, arg.data_length) == kTestString;
   // FIN is hard-coded false in ConstructEncryptedPacket.
   // Offset 0 is hard-coded in ConstructEncryptedPacket.
 }
@@ -9426,7 +9428,8 @@
   EXPECT_CALL(visitor, OnError(_)).Times(0);
   EXPECT_CALL(visitor, OnStreamFrame(_)).Times(0);
   if (!QuicVersionUsesCryptoFrames(framer_.version().transport_version)) {
-    EXPECT_CALL(visitor, OnStreamFrame(Truly(ExpectedStreamFrame))).Times(1);
+    EXPECT_CALL(visitor, OnStreamFrame(ExpectedStreamFrame(framer_.version())))
+        .Times(1);
   } else {
     EXPECT_CALL(visitor, OnCryptoFrame(_)).Times(1);
   }
diff --git a/quic/core/quic_stream_id_manager_test.cc b/quic/core/quic_stream_id_manager_test.cc
index b523d40..a114295 100644
--- a/quic/core/quic_stream_id_manager_test.cc
+++ b/quic/core/quic_stream_id_manager_test.cc
@@ -9,6 +9,7 @@
 
 #include "net/third_party/quiche/src/quic/core/quic_constants.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
+#include "net/third_party/quiche/src/quic/core/quic_versions.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_stream_id_manager_peer.h"
@@ -33,9 +34,14 @@
 };
 
 struct TestParams {
-  TestParams(Perspective perspective, bool is_unidirectional)
-      : perspective(perspective), is_unidirectional(is_unidirectional) {}
+  TestParams(ParsedQuicVersion version,
+             Perspective perspective,
+             bool is_unidirectional)
+      : version(version),
+        perspective(perspective),
+        is_unidirectional(is_unidirectional) {}
 
+  ParsedQuicVersion version;
   Perspective perspective;
   bool is_unidirectional;
 };
@@ -43,16 +49,22 @@
 // Used by ::testing::PrintToStringParamName().
 std::string PrintToString(const TestParams& p) {
   return quiche::QuicheStrCat(
+      ParsedQuicVersionToString(p.version), "_",
       (p.perspective == Perspective::IS_CLIENT ? "Client" : "Server"),
       (p.is_unidirectional ? "Unidirectional" : "Bidirectional"));
 }
 
 std::vector<TestParams> GetTestParams() {
   std::vector<TestParams> params;
-  for (Perspective perspective :
-       {Perspective::IS_CLIENT, Perspective::IS_SERVER}) {
-    for (bool is_unidirectional : {true, false}) {
-      params.push_back(TestParams(perspective, is_unidirectional));
+  for (const ParsedQuicVersion& version : AllSupportedVersions()) {
+    if (!version.HasIetfQuicFrames()) {
+      continue;
+    }
+    for (Perspective perspective :
+         {Perspective::IS_CLIENT, Perspective::IS_SERVER}) {
+      for (bool is_unidirectional : {true, false}) {
+        params.push_back(TestParams(version, perspective, is_unidirectional));
+      }
     }
   }
   return params;
@@ -70,7 +82,9 @@
     DCHECK(VersionHasIetfQuicFrames(transport_version()));
   }
 
-  QuicTransportVersion transport_version() const { return QUIC_VERSION_99; }
+  QuicTransportVersion transport_version() const {
+    return GetParam().version.transport_version;
+  }
 
   // Returns the stream ID for the Nth incoming stream (created by the peer)
   // of the corresponding directionality of this manager.
diff --git a/quic/core/quic_utils_test.cc b/quic/core/quic_utils_test.cc
index 1381b20..5b2186a 100644
--- a/quic/core/quic_utils_test.cc
+++ b/quic/core/quic_utils_test.cc
@@ -250,10 +250,10 @@
   EXPECT_TRUE(QuicUtils::IsConnectionIdValidForVersion(
       QuicUtils::CreateZeroConnectionId(QUIC_VERSION_43), QUIC_VERSION_43));
   EXPECT_TRUE(QuicUtils::IsConnectionIdValidForVersion(
-      QuicUtils::CreateZeroConnectionId(QUIC_VERSION_99), QUIC_VERSION_99));
+      QuicUtils::CreateZeroConnectionId(QUIC_VERSION_50), QUIC_VERSION_50));
   EXPECT_NE(QuicUtils::CreateZeroConnectionId(QUIC_VERSION_43),
             EmptyQuicConnectionId());
-  EXPECT_EQ(QuicUtils::CreateZeroConnectionId(QUIC_VERSION_99),
+  EXPECT_EQ(QuicUtils::CreateZeroConnectionId(QUIC_VERSION_50),
             EmptyQuicConnectionId());
   EXPECT_FALSE(QuicUtils::IsConnectionIdValidForVersion(EmptyQuicConnectionId(),
                                                         QUIC_VERSION_43));
diff --git a/quic/core/tls_handshaker_test.cc b/quic/core/tls_handshaker_test.cc
index 59570b1..7a5f1cb 100644
--- a/quic/core/tls_handshaker_test.cc
+++ b/quic/core/tls_handshaker_test.cc
@@ -328,19 +328,18 @@
   }
 }
 
-class TlsHandshakerTest : public QuicTest {
+class TlsHandshakerTest : public QuicTestWithParam<ParsedQuicVersion> {
  public:
   TlsHandshakerTest()
-      : client_conn_(new MockQuicConnection(
-            &conn_helper_,
-            &alarm_factory_,
-            Perspective::IS_CLIENT,
-            {ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99)})),
-        server_conn_(new MockQuicConnection(
-            &conn_helper_,
-            &alarm_factory_,
-            Perspective::IS_SERVER,
-            {ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99)})),
+      : version_(GetParam()),
+        client_conn_(new MockQuicConnection(&conn_helper_,
+                                            &alarm_factory_,
+                                            Perspective::IS_CLIENT,
+                                            {version_})),
+        server_conn_(new MockQuicConnection(&conn_helper_,
+                                            &alarm_factory_,
+                                            Perspective::IS_SERVER,
+                                            {version_})),
         client_session_(client_conn_, /*create_mock_crypto_stream=*/false),
         server_session_(server_conn_, /*create_mock_crypto_stream=*/false) {
     client_stream_ = new TestQuicCryptoClientStream(&client_session_);
@@ -394,6 +393,7 @@
     EXPECT_EQ(0, server_crypto_params.peer_signature_algorithm);
   }
 
+  ParsedQuicVersion version_;
   MockQuicConnectionHelper conn_helper_;
   MockAlarmFactory alarm_factory_;
   MockQuicConnection* client_conn_;
@@ -406,7 +406,22 @@
   TestQuicCryptoServerStream* server_stream_;
 };
 
-TEST_F(TlsHandshakerTest, CryptoHandshake) {
+std::vector<ParsedQuicVersion> AllSupportedTlsVersions() {
+  std::vector<ParsedQuicVersion> tls_versions;
+  for (const ParsedQuicVersion& version : AllSupportedVersions()) {
+    if (version.handshake_protocol == PROTOCOL_TLS1_3) {
+      tls_versions.push_back(version);
+    }
+  }
+  return tls_versions;
+}
+
+INSTANTIATE_TEST_SUITE_P(TlsHandshakerTests,
+                         TlsHandshakerTest,
+                         ::testing::ValuesIn(AllSupportedTlsVersions()),
+                         ::testing::PrintToStringParamName());
+
+TEST_P(TlsHandshakerTest, CryptoHandshake) {
   EXPECT_FALSE(client_conn_->IsHandshakeComplete());
   EXPECT_FALSE(server_conn_->IsHandshakeComplete());
 
@@ -419,7 +434,7 @@
   ExpectHandshakeSuccessful();
 }
 
-TEST_F(TlsHandshakerTest, HandshakeWithAsyncProofSource) {
+TEST_P(TlsHandshakerTest, HandshakeWithAsyncProofSource) {
   EXPECT_CALL(*client_conn_, CloseConnection(_, _, _)).Times(0);
   EXPECT_CALL(*server_conn_, CloseConnection(_, _, _)).Times(0);
   // Enable FakeProofSource to capture call to ComputeTlsSignature and run it
@@ -439,7 +454,7 @@
   ExpectHandshakeSuccessful();
 }
 
-TEST_F(TlsHandshakerTest, CancelPendingProofSource) {
+TEST_P(TlsHandshakerTest, CancelPendingProofSource) {
   EXPECT_CALL(*client_conn_, CloseConnection(_, _, _)).Times(0);
   EXPECT_CALL(*server_conn_, CloseConnection(_, _, _)).Times(0);
   // Enable FakeProofSource to capture call to ComputeTlsSignature and run it
@@ -457,7 +472,7 @@
   proof_source->InvokePendingCallback(0);
 }
 
-TEST_F(TlsHandshakerTest, HandshakeWithAsyncProofVerifier) {
+TEST_P(TlsHandshakerTest, HandshakeWithAsyncProofVerifier) {
   EXPECT_CALL(*client_conn_, CloseConnection(_, _, _)).Times(0);
   EXPECT_CALL(*server_conn_, CloseConnection(_, _, _)).Times(0);
   // Enable TestProofVerifier to capture call to VerifyCertChain and run it
@@ -479,7 +494,7 @@
   ExpectHandshakeSuccessful();
 }
 
-TEST_F(TlsHandshakerTest, ClientSendsNoSNI) {
+TEST_P(TlsHandshakerTest, ClientSendsNoSNI) {
   // Create a new client stream (and handshaker) with an empty server hostname.
   client_stream_ =
       new TestQuicCryptoClientStream(&client_session_, QuicServerId("", 443),
@@ -496,7 +511,7 @@
   EXPECT_EQ(server_stream_->crypto_negotiated_params().sni, "");
 }
 
-TEST_F(TlsHandshakerTest, ServerExtractSNI) {
+TEST_P(TlsHandshakerTest, ServerExtractSNI) {
   EXPECT_CALL(*client_conn_, CloseConnection(_, _, _)).Times(0);
   EXPECT_CALL(*server_conn_, CloseConnection(_, _, _)).Times(0);
   EXPECT_CALL(client_stream_->proof_handler(), OnProofVerifyDetailsAvailable);
@@ -507,7 +522,7 @@
   EXPECT_EQ(server_stream_->crypto_negotiated_params().sni, "test.example.com");
 }
 
-TEST_F(TlsHandshakerTest, ClientConnectionClosedOnTlsError) {
+TEST_P(TlsHandshakerTest, ClientConnectionClosedOnTlsError) {
   // Have client send ClientHello.
   client_stream_->CryptoConnect();
   EXPECT_CALL(*client_conn_, CloseConnection(QUIC_HANDSHAKE_FAILED, _, _));
@@ -527,7 +542,7 @@
   EXPECT_FALSE(client_stream_->one_rtt_keys_available());
 }
 
-TEST_F(TlsHandshakerTest, ServerConnectionClosedOnTlsError) {
+TEST_P(TlsHandshakerTest, ServerConnectionClosedOnTlsError) {
   EXPECT_CALL(*server_conn_, CloseConnection(QUIC_HANDSHAKE_FAILED, _, _));
 
   // Send a zero-length ClientHello from client to server.
@@ -545,7 +560,7 @@
   EXPECT_FALSE(server_stream_->one_rtt_keys_available());
 }
 
-TEST_F(TlsHandshakerTest, ClientNotSendingALPN) {
+TEST_P(TlsHandshakerTest, ClientNotSendingALPN) {
   client_stream_->client_handshaker()->AllowEmptyAlpnForTests();
   EXPECT_CALL(client_session_, GetAlpnsToOffer())
       .WillOnce(Return(std::vector<std::string>()));
@@ -563,7 +578,7 @@
   EXPECT_FALSE(server_stream_->encryption_established());
 }
 
-TEST_F(TlsHandshakerTest, ClientSendingBadALPN) {
+TEST_P(TlsHandshakerTest, ClientSendingBadALPN) {
   const std::string kTestBadClientAlpn = "bad-client-alpn";
   EXPECT_CALL(client_session_, GetAlpnsToOffer())
       .WillOnce(Return(std::vector<std::string>({kTestBadClientAlpn})));
@@ -581,7 +596,7 @@
   EXPECT_FALSE(server_stream_->encryption_established());
 }
 
-TEST_F(TlsHandshakerTest, ClientSendingTooManyALPNs) {
+TEST_P(TlsHandshakerTest, ClientSendingTooManyALPNs) {
   std::string long_alpn(250, 'A');
   EXPECT_CALL(client_session_, GetAlpnsToOffer())
       .WillOnce(Return(std::vector<std::string>({
@@ -597,7 +612,7 @@
   EXPECT_QUIC_BUG(client_stream_->CryptoConnect(), "Failed to set ALPN");
 }
 
-TEST_F(TlsHandshakerTest, ServerRequiresCustomALPN) {
+TEST_P(TlsHandshakerTest, ServerRequiresCustomALPN) {
   const std::string kTestAlpn = "An ALPN That Client Did Not Offer";
   EXPECT_CALL(server_session_, SelectAlpn(_))
       .WillOnce(
@@ -618,7 +633,7 @@
   EXPECT_FALSE(server_stream_->encryption_established());
 }
 
-TEST_F(TlsHandshakerTest, CustomALPNNegotiation) {
+TEST_P(TlsHandshakerTest, CustomALPNNegotiation) {
   EXPECT_CALL(*client_conn_, CloseConnection(_, _, _)).Times(0);
   EXPECT_CALL(*server_conn_, CloseConnection(_, _, _)).Times(0);
 
diff --git a/quic/core/uber_quic_stream_id_manager_test.cc b/quic/core/uber_quic_stream_id_manager_test.cc
index c04cffa..b7acc68 100644
--- a/quic/core/uber_quic_stream_id_manager_test.cc
+++ b/quic/core/uber_quic_stream_id_manager_test.cc
@@ -5,6 +5,7 @@
 #include "net/third_party/quiche/src/quic/core/uber_quic_stream_id_manager.h"
 
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
+#include "net/third_party/quiche/src/quic/core/quic_versions.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_stream_id_manager_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
@@ -16,6 +17,33 @@
 namespace test {
 namespace {
 
+struct TestParams {
+  explicit TestParams(ParsedQuicVersion version, Perspective perspective)
+      : version(version), perspective(perspective) {}
+
+  ParsedQuicVersion version;
+  Perspective perspective;
+};
+
+// Used by ::testing::PrintToStringParamName().
+std::string PrintToString(const TestParams& p) {
+  return quiche::QuicheStrCat(
+      ParsedQuicVersionToString(p.version), "_",
+      (p.perspective == Perspective::IS_CLIENT ? "client" : "server"));
+}
+
+std::vector<TestParams> GetTestParams() {
+  std::vector<TestParams> params;
+  for (const ParsedQuicVersion& version : AllSupportedVersions()) {
+    if (!version.HasIetfQuicFrames()) {
+      continue;
+    }
+    params.push_back(TestParams(version, Perspective::IS_CLIENT));
+    params.push_back(TestParams(version, Perspective::IS_SERVER));
+  }
+  return params;
+}
+
 class MockDelegate : public QuicStreamIdManager::DelegateInterface {
  public:
   MOCK_METHOD1(OnCanCreateNewOutgoingStream, void(bool unidirectional));
@@ -27,7 +55,7 @@
                void(QuicStreamCount stream_count, bool unidirectional));
 };
 
-class UberQuicStreamIdManagerTest : public QuicTestWithParam<Perspective> {
+class UberQuicStreamIdManagerTest : public QuicTestWithParam<TestParams> {
  protected:
   UberQuicStreamIdManagerTest()
       : manager_(perspective(),
@@ -63,22 +91,22 @@
   }
 
   QuicStreamId GetNthPeerInitiatedBidirectionalStreamId(int n) {
-    return ((GetParam() == Perspective::IS_SERVER)
+    return ((perspective() == Perspective::IS_SERVER)
                 ? GetNthClientInitiatedBidirectionalId(n)
                 : GetNthServerInitiatedBidirectionalId(n));
   }
   QuicStreamId GetNthPeerInitiatedUnidirectionalStreamId(int n) {
-    return ((GetParam() == Perspective::IS_SERVER)
+    return ((perspective() == Perspective::IS_SERVER)
                 ? GetNthClientInitiatedUnidirectionalId(n)
                 : GetNthServerInitiatedUnidirectionalId(n));
   }
   QuicStreamId GetNthSelfInitiatedBidirectionalStreamId(int n) {
-    return ((GetParam() == Perspective::IS_CLIENT)
+    return ((perspective() == Perspective::IS_CLIENT)
                 ? GetNthClientInitiatedBidirectionalId(n)
                 : GetNthServerInitiatedBidirectionalId(n));
   }
   QuicStreamId GetNthSelfInitiatedUnidirectionalStreamId(int n) {
-    return ((GetParam() == Perspective::IS_CLIENT)
+    return ((perspective() == Perspective::IS_CLIENT)
                 ? GetNthClientInitiatedUnidirectionalId(n)
                 : GetNthServerInitiatedUnidirectionalId(n));
   }
@@ -93,10 +121,12 @@
            ((stream_count - 1) * QuicUtils::StreamIdDelta(transport_version()));
   }
 
-  ParsedQuicVersion version() { return {PROTOCOL_TLS1_3, transport_version()}; }
-  QuicTransportVersion transport_version() { return QUIC_VERSION_99; }
+  ParsedQuicVersion version() { return GetParam().version; }
+  QuicTransportVersion transport_version() {
+    return version().transport_version;
+  }
 
-  Perspective perspective() { return GetParam(); }
+  Perspective perspective() { return GetParam().perspective; }
 
   testing::StrictMock<MockDelegate> delegate_;
   UberQuicStreamIdManager manager_;
@@ -104,8 +134,7 @@
 
 INSTANTIATE_TEST_SUITE_P(Tests,
                          UberQuicStreamIdManagerTest,
-                         ::testing::ValuesIn({Perspective::IS_CLIENT,
-                                              Perspective::IS_SERVER}),
+                         ::testing::ValuesIn(GetTestParams()),
                          ::testing::PrintToStringParamName());
 
 TEST_P(UberQuicStreamIdManagerTest, Initialization) {
diff --git a/quic/masque/masque_utils.cc b/quic/masque/masque_utils.cc
index 6ef88ae..29e254f 100644
--- a/quic/masque/masque_utils.cc
+++ b/quic/masque/masque_utils.cc
@@ -8,7 +8,16 @@
 
 ParsedQuicVersionVector MasqueSupportedVersions() {
   QuicVersionInitializeSupportForIetfDraft();
-  ParsedQuicVersion version(PROTOCOL_TLS1_3, QUIC_VERSION_99);
+  ParsedQuicVersion version = UnsupportedQuicVersion();
+  for (const ParsedQuicVersion& vers : AllSupportedVersions()) {
+    // Find the first version that supports IETF QUIC.
+    if (vers.HasIetfQuicFrames() &&
+        vers.handshake_protocol == quic::PROTOCOL_TLS1_3) {
+      version = vers;
+      break;
+    }
+  }
+  CHECK_NE(version.transport_version, QUIC_VERSION_UNSUPPORTED);
   QuicEnableVersion(version);
   return {version};
 }
diff --git a/quic/quic_transport/quic_transport_client_session_test.cc b/quic/quic_transport/quic_transport_client_session_test.cc
index b2f38f5..312b132 100644
--- a/quic/quic_transport/quic_transport_client_session_test.cc
+++ b/quic/quic_transport/quic_transport_client_session_test.cc
@@ -36,7 +36,15 @@
 }
 
 ParsedQuicVersionVector GetVersions() {
-  return {ParsedQuicVersion{PROTOCOL_TLS1_3, QUIC_VERSION_99}};
+  for (const ParsedQuicVersion& version : AllSupportedVersions()) {
+    // Find the first version that supports IETF QUIC.
+    if (version.HasIetfQuicFrames() &&
+        version.handshake_protocol == quic::PROTOCOL_TLS1_3) {
+      return {version};
+    }
+  }
+  CHECK(false);
+  return {};
 }
 
 std::string DataInStream(QuicStream* stream) {
diff --git a/quic/quic_transport/quic_transport_integration_test.cc b/quic/quic_transport/quic_transport_integration_test.cc
index cdc99a6..2da47fa 100644
--- a/quic/quic_transport/quic_transport_integration_test.cc
+++ b/quic/quic_transport/quic_transport_integration_test.cc
@@ -49,7 +49,15 @@
 }
 
 ParsedQuicVersionVector GetVersions() {
-  return {ParsedQuicVersion{PROTOCOL_TLS1_3, QUIC_VERSION_99}};
+  for (const ParsedQuicVersion& version : AllSupportedVersions()) {
+    // Find the first version that supports IETF QUIC.
+    if (version.HasIetfQuicFrames() &&
+        version.handshake_protocol == quic::PROTOCOL_TLS1_3) {
+      return {version};
+    }
+  }
+  CHECK(false);
+  return {};
 }
 
 class QuicTransportEndpointBase : public QuicEndpointBase {
diff --git a/quic/quic_transport/quic_transport_server_session_test.cc b/quic/quic_transport/quic_transport_server_session_test.cc
index dfd075e..c8ef5c7 100644
--- a/quic/quic_transport/quic_transport_server_session_test.cc
+++ b/quic/quic_transport/quic_transport_server_session_test.cc
@@ -51,7 +51,15 @@
 }
 
 ParsedQuicVersionVector GetVersions() {
-  return {ParsedQuicVersion{PROTOCOL_TLS1_3, QUIC_VERSION_99}};
+  for (const ParsedQuicVersion& version : AllSupportedVersions()) {
+    // Find the first version that supports IETF QUIC.
+    if (version.HasIetfQuicFrames() &&
+        version.handshake_protocol == quic::PROTOCOL_TLS1_3) {
+      return {version};
+    }
+  }
+  CHECK(false);
+  return {};
 }
 
 class QuicTransportServerSessionTest : public QuicTest {
diff --git a/quic/quic_transport/quic_transport_stream_test.cc b/quic/quic_transport/quic_transport_stream_test.cc
index 31e01a0..3c92101 100644
--- a/quic/quic_transport/quic_transport_stream_test.cc
+++ b/quic/quic_transport/quic_transport_stream_test.cc
@@ -24,7 +24,15 @@
 using testing::Return;
 
 ParsedQuicVersionVector GetVersions() {
-  return {ParsedQuicVersion{PROTOCOL_TLS1_3, QUIC_VERSION_99}};
+  for (const ParsedQuicVersion& version : AllSupportedVersions()) {
+    // Find the first version that supports IETF QUIC.
+    if (version.HasIetfQuicFrames() &&
+        version.handshake_protocol == quic::PROTOCOL_TLS1_3) {
+      return {version};
+    }
+  }
+  CHECK(false);
+  return {};
 }
 
 class MockQuicTransportSessionInterface : public QuicTransportSessionInterface {
diff --git a/quic/tools/quic_client_interop_test_bin.cc b/quic/tools/quic_client_interop_test_bin.cc
index e3abbd1..9745955 100644
--- a/quic/tools/quic_client_interop_test_bin.cc
+++ b/quic/tools/quic_client_interop_test_bin.cc
@@ -95,6 +95,7 @@
   void AttemptRequest(QuicSocketAddress addr,
                       std::string authority,
                       QuicServerId server_id,
+                      ParsedQuicVersion version,
                       bool test_version_negotiation,
                       bool attempt_rebind);
 
@@ -151,9 +152,9 @@
 void QuicClientInteropRunner::AttemptRequest(QuicSocketAddress addr,
                                              std::string authority,
                                              QuicServerId server_id,
+                                             ParsedQuicVersion version,
                                              bool test_version_negotiation,
                                              bool attempt_rebind) {
-  ParsedQuicVersion version(PROTOCOL_TLS1_3, QUIC_VERSION_99);
   ParsedQuicVersionVector versions = {version};
   if (test_version_negotiation) {
     versions.insert(versions.begin(), QuicVersionReservedForNegotiation());
@@ -189,7 +190,7 @@
   }
   if (test_version_negotiation && !connect_result) {
     // Failed to negotiate version, retry without version negotiation.
-    AttemptRequest(addr, authority, server_id,
+    AttemptRequest(addr, authority, server_id, version,
                    /*test_version_negotiation=*/false, attempt_rebind);
     return;
   }
@@ -235,8 +236,8 @@
         client->SendRequestAndWaitForResponse(header_block, "", /*fin=*/true);
         if (!client->connected()) {
           // Rebinding does not work, retry without attempting it.
-          AttemptRequest(addr, authority, server_id, test_version_negotiation,
-                         /*attempt_rebind=*/false);
+          AttemptRequest(addr, authority, server_id, version,
+                         test_version_negotiation, /*attempt_rebind=*/false);
           return;
         }
         InsertFeature(Feature::kRebinding);
@@ -263,7 +264,17 @@
 std::set<Feature> ServerSupport(std::string host, int port) {
   // Enable IETF version support.
   QuicVersionInitializeSupportForIetfDraft();
-  QuicEnableVersion(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99));
+  ParsedQuicVersion version = UnsupportedQuicVersion();
+  for (const ParsedQuicVersion& vers : AllSupportedVersions()) {
+    // Find the first version that supports IETF QUIC.
+    if (vers.HasIetfQuicFrames() &&
+        vers.handshake_protocol == quic::PROTOCOL_TLS1_3) {
+      version = vers;
+      break;
+    }
+  }
+  CHECK_NE(version.transport_version, QUIC_VERSION_UNSUPPORTED);
+  QuicEnableVersion(version);
 
   // Build the client, and try to connect.
   QuicSocketAddress addr =
@@ -277,7 +288,7 @@
 
   QuicClientInteropRunner runner;
 
-  runner.AttemptRequest(addr, authority, server_id,
+  runner.AttemptRequest(addr, authority, server_id, version,
                         /*test_version_negotiation=*/true,
                         /*attempt_rebind=*/true);
 
diff --git a/quic/tools/quic_toy_client.cc b/quic/tools/quic_toy_client.cc
index e790b54..8a9532d 100644
--- a/quic/tools/quic_toy_client.cc
+++ b/quic/tools/quic_toy_client.cc
@@ -187,7 +187,16 @@
   std::string quic_version_string = GetQuicFlag(FLAGS_quic_version);
   if (GetQuicFlag(FLAGS_quic_ietf_draft)) {
     quic::QuicVersionInitializeSupportForIetfDraft();
-    versions = {{quic::PROTOCOL_TLS1_3, quic::QUIC_VERSION_99}};
+    versions = {};
+    for (const ParsedQuicVersion& version : AllSupportedVersions()) {
+      // Find the first version that supports IETF QUIC.
+      if (version.HasIetfQuicFrames() &&
+          version.handshake_protocol == quic::PROTOCOL_TLS1_3) {
+        versions = {version};
+        break;
+      }
+    }
+    CHECK_EQ(versions.size(), 1u);
     quic::QuicEnableVersion(versions[0]);
 
   } else if (!quic_version_string.empty()) {
diff --git a/quic/tools/quic_toy_server.cc b/quic/tools/quic_toy_server.cc
index 45c7b1f..a23e7d9 100644
--- a/quic/tools/quic_toy_server.cc
+++ b/quic/tools/quic_toy_server.cc
@@ -62,9 +62,14 @@
   ParsedQuicVersionVector supported_versions;
   if (GetQuicFlag(FLAGS_quic_ietf_draft)) {
     QuicVersionInitializeSupportForIetfDraft();
-    supported_versions = {
-        ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99),
-        ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_DRAFT_25)};
+    for (const ParsedQuicVersion& version : AllSupportedVersions()) {
+      // Add all versions that supports IETF QUIC.
+      if (version.HasIetfQuicFrames() &&
+          version.handshake_protocol == quic::PROTOCOL_TLS1_3) {
+        supported_versions.push_back(version);
+        break;
+      }
+    }
   } else {
     supported_versions = AllSupportedVersions();
   }