Remove many uses of QUIC_VERSION_99 in tests This will allow us to deprecate QUIC_VERSION_99 soon. gfe-relnote: n/a, test-only PiperOrigin-RevId: 297933966 Change-Id: I5f161db41d8cb159c8342e61f5ff78f450c7cf4c
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(); }