Remove QUIC version Q099
(I took over cl/285250934 from ianswett@ to load-balance)
This CL deprecates gfe2_reloadable_flag_quic_enable_q099 false, because it is blocked and will never be enabled.
gfe-relnote: n/a (Deprecate blocked flag)
PiperOrigin-RevId: 290839787
Change-Id: I319337542735b8df2d8bf862f0c2624adf01c343
diff --git a/quic/core/crypto/crypto_utils.cc b/quic/core/crypto/crypto_utils.cc
index dc586df..09057ff 100644
--- a/quic/core/crypto/crypto_utils.cc
+++ b/quic/core/crypto/crypto_utils.cc
@@ -128,10 +128,6 @@
const uint8_t kT050Salt[] = {0x7f, 0xf5, 0x79, 0xe5, 0xac, 0xd0, 0x72,
0x91, 0x55, 0x80, 0x30, 0x4c, 0x43, 0xa2,
0x36, 0x7c, 0x60, 0x48, 0x83, 0x10};
-// Salt to use for initial obfuscators in version Q099.
-const uint8_t kQ099Salt[] = {0xc0, 0xa2, 0xee, 0x20, 0xc7, 0xe1, 0x83,
- 0x74, 0xc8, 0xa1, 0xa0, 0xc8, 0xa5, 0x21,
- 0xb5, 0x31, 0xee, 0x04, 0x7e, 0xc8};
const uint8_t* InitialSaltForVersion(const ParsedQuicVersion& version,
size_t* out_len) {
@@ -143,9 +139,6 @@
case QUIC_VERSION_50:
*out_len = QUICHE_ARRAYSIZE(kQ050Salt);
return kQ050Salt;
- case QUIC_VERSION_99:
- *out_len = QUICHE_ARRAYSIZE(kQ099Salt);
- return kQ099Salt;
case QUIC_VERSION_RESERVED_FOR_NEGOTIATION:
// It doesn't matter what salt we use for
// QUIC_VERSION_RESERVED_FOR_NEGOTIATION, but some tests try to use a
diff --git a/quic/core/quic_crypto_server_stream_test.cc b/quic/core/quic_crypto_server_stream_test.cc
index 9d78641..8e6afaf 100644
--- a/quic/core/quic_crypto_server_stream_test.cc
+++ b/quic/core/quic_crypto_server_stream_test.cc
@@ -394,11 +394,21 @@
EXPECT_CALL(*server_session_->helper(), CanAcceptClientHello(_, _, _, _, _))
.WillOnce(testing::Return(true));
+ // The methods below use a PROTOCOL_QUIC_CRYPTO version so we pick the
+ // first one from the list of supported versions.
+ 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(QUIC_VERSION_UNSUPPORTED, transport_version);
+
// Create a minimal CHLO
MockClock clock;
- QuicTransportVersion version = AllSupportedTransportVersions().front();
CryptoHandshakeMessage chlo = crypto_test_utils::GenerateDefaultInchoateCHLO(
- &clock, version, &server_crypto_config_);
+ &clock, transport_version, &server_crypto_config_);
// Send in the CHLO, and check that a callback is now pending in the
// ProofSource.
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index 1462f7e..b3ec02c 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -20,6 +20,7 @@
#include "net/third_party/quiche/src/quic/core/quic_time_wait_list_manager.h"
#include "net/third_party/quiche/src/quic/core/quic_types.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_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
@@ -942,15 +943,15 @@
VerifyVersionSupported(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO,
QuicVersionMax().transport_version));
- // Turn off version Q099.
- SetQuicReloadableFlag(quic_enable_version_q099, false);
+ // Turn off version Q050.
+ SetQuicReloadableFlag(quic_disable_version_q050, true);
VerifyVersionNotSupported(
- ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99));
+ ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_50));
- // Turn on version Q099.
- SetQuicReloadableFlag(quic_enable_version_q099, true);
+ // Turn on version Q050.
+ SetQuicReloadableFlag(quic_disable_version_q050, false);
VerifyVersionSupported(
- ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99));
+ ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_50));
}
TEST_F(QuicDispatcherTest, RejectDeprecatedVersionsWithVersionNegotiation) {
@@ -1282,7 +1283,7 @@
}
TEST_F(QuicDispatcherTest, ProcessSmallCoalescedPacket) {
- SetQuicReloadableFlag(quic_enable_version_q099, true);
+ SetQuicReloadableFlag(quic_enable_version_t099, true);
CreateTimeWaitListManager();
QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
@@ -1677,14 +1678,24 @@
QuicDispatcherTest::SetUp();
clock_ = QuicDispatcherPeer::GetHelper(dispatcher_.get())->GetClock();
- QuicTransportVersion version = AllSupportedTransportVersions().front();
+ // The methods below use a PROTOCOL_QUIC_CRYPTO version so we pick the
+ // first one from the list of supported versions.
+ 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(QUIC_VERSION_UNSUPPORTED, transport_version);
+
CryptoHandshakeMessage chlo =
- crypto_test_utils::GenerateDefaultInchoateCHLO(clock_, version,
- &crypto_config_);
+ crypto_test_utils::GenerateDefaultInchoateCHLO(
+ clock_, transport_version, &crypto_config_);
// Pass an inchoate CHLO.
crypto_test_utils::GenerateFullCHLO(
- chlo, &crypto_config_, server_addr_, client_addr_, version, clock_,
- signed_config_, QuicDispatcherPeer::GetCache(dispatcher_.get()),
+ chlo, &crypto_config_, server_addr_, client_addr_, transport_version,
+ clock_, signed_config_, QuicDispatcherPeer::GetCache(dispatcher_.get()),
&full_chlo_);
}
@@ -2100,9 +2111,8 @@
// Regression test for b/117874922.
TEST_F(BufferedPacketStoreTest, ProcessBufferedChloWithDifferentVersion) {
- // Turn off versions Q099 and T099, such that the preferred version is not
- // supported by the server.
- SetQuicReloadableFlag(quic_enable_version_q099, false);
+ // Turn off version T099, so the preferred version is not supported by the
+ // server.
SetQuicReloadableFlag(quic_enable_version_t099, false);
uint64_t last_connection_id = kMaxNumSessionsToCreate + 5;
ParsedQuicVersionVector supported_versions = CurrentSupportedVersions();
diff --git a/quic/core/quic_trace_visitor_test.cc b/quic/core/quic_trace_visitor_test.cc
index 5e77133..504d9d5 100644
--- a/quic/core/quic_trace_visitor_test.cc
+++ b/quic/core/quic_trace_visitor_test.cc
@@ -81,7 +81,7 @@
TEST_F(QuicTraceVisitorTest, Version) {
std::string version = trace_.protocol_version();
ASSERT_EQ(4u, version.size());
- EXPECT_EQ('Q', version[0]);
+ EXPECT_NE(0, version[0]);
}
// Check that basic metadata about sent packets is recorded.
diff --git a/quic/core/quic_version_manager.cc b/quic/core/quic_version_manager.cc
index 8b25ecc..35a71ae 100644
--- a/quic/core/quic_version_manager.cc
+++ b/quic/core/quic_version_manager.cc
@@ -15,8 +15,7 @@
QuicVersionManager::QuicVersionManager(
ParsedQuicVersionVector supported_versions)
- : enable_version_q099_(GetQuicReloadableFlag(quic_enable_version_q099)),
- enable_version_t099_(GetQuicReloadableFlag(quic_enable_version_t099)),
+ : enable_version_t099_(GetQuicReloadableFlag(quic_enable_version_t099)),
disable_version_q050_(GetQuicReloadableFlag(quic_disable_version_q050)),
enable_version_t050_(GetQuicReloadableFlag(quic_enable_version_t050)),
disable_version_q049_(GetQuicReloadableFlag(quic_disable_version_q049)),
@@ -45,8 +44,7 @@
void QuicVersionManager::MaybeRefilterSupportedVersions() {
static_assert(QUICHE_ARRAYSIZE(kSupportedTransportVersions) == 6u,
"Supported versions out of sync");
- if (enable_version_q099_ != GetQuicReloadableFlag(quic_enable_version_q099) ||
- enable_version_t099_ != GetQuicReloadableFlag(quic_enable_version_t099) ||
+ if (enable_version_t099_ != GetQuicReloadableFlag(quic_enable_version_t099) ||
disable_version_q050_ !=
GetQuicReloadableFlag(quic_disable_version_q050) ||
enable_version_t050_ != GetQuicReloadableFlag(quic_enable_version_t050) ||
@@ -58,7 +56,6 @@
GetQuicReloadableFlag(quic_disable_version_q046) ||
disable_version_q043_ !=
GetQuicReloadableFlag(quic_disable_version_q043)) {
- enable_version_q099_ = GetQuicReloadableFlag(quic_enable_version_q099);
enable_version_t099_ = GetQuicReloadableFlag(quic_enable_version_t099);
disable_version_q050_ = GetQuicReloadableFlag(quic_disable_version_q050);
enable_version_t050_ = GetQuicReloadableFlag(quic_enable_version_t050);
diff --git a/quic/core/quic_version_manager.h b/quic/core/quic_version_manager.h
index b7aff69..6dd363d 100644
--- a/quic/core/quic_version_manager.h
+++ b/quic/core/quic_version_manager.h
@@ -41,8 +41,6 @@
private:
// Cached value of reloadable flags.
- // quic_enable_version_q099 flag
- bool enable_version_q099_;
// quic_enable_version_t099 flag
bool enable_version_t099_;
// quic_disable_version_q050 flag
diff --git a/quic/core/quic_version_manager_test.cc b/quic/core/quic_version_manager_test.cc
index 7f3d83d..76d74fc 100644
--- a/quic/core/quic_version_manager_test.cc
+++ b/quic/core/quic_version_manager_test.cc
@@ -18,7 +18,6 @@
TEST_F(QuicVersionManagerTest, QuicVersionManager) {
static_assert(QUICHE_ARRAYSIZE(kSupportedTransportVersions) == 6u,
"Supported versions out of sync");
- SetQuicReloadableFlag(quic_enable_version_q099, false);
SetQuicReloadableFlag(quic_enable_version_t099, false);
SetQuicReloadableFlag(quic_enable_version_t050, false);
SetQuicReloadableFlag(quic_disable_version_q050, false);
@@ -45,14 +44,6 @@
EXPECT_EQ(FilterSupportedVersions(AllSupportedVersions()),
manager.GetSupportedVersions());
- SetQuicReloadableFlag(quic_enable_version_q099, true);
- expected_parsed_versions.insert(
- expected_parsed_versions.begin(),
- ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99));
- EXPECT_EQ(expected_parsed_versions, manager.GetSupportedVersions());
- EXPECT_EQ(FilterSupportedVersions(AllSupportedVersions()),
- manager.GetSupportedVersions());
-
SetQuicReloadableFlag(quic_enable_version_t099, true);
expected_parsed_versions.push_back(
ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99));
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index 10d3c61..72fd964 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -188,7 +188,8 @@
if (parsed_version.handshake_protocol == PROTOCOL_TLS1_3) {
return MakeVersionLabel(0xff, 0x00, 0x00, kQuicIetfDraftVersion);
}
- return MakeVersionLabel(proto, '0', '9', '9');
+ QUIC_BUG << "Invalid ParsedQuicVersion: Q099";
+ return 0;
case QUIC_VERSION_RESERVED_FOR_NEGOTIATION:
return CreateRandomVersionLabelForNegotiation();
default:
@@ -273,14 +274,9 @@
filtered_versions.reserve(versions.size());
for (ParsedQuicVersion version : versions) {
if (version.transport_version == QUIC_VERSION_99) {
- if (version.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
- if (GetQuicReloadableFlag(quic_enable_version_q099)) {
- filtered_versions.push_back(version);
- }
- } else {
- if (GetQuicReloadableFlag(quic_enable_version_t099)) {
- filtered_versions.push_back(version);
- }
+ if (version.handshake_protocol == PROTOCOL_TLS1_3 &&
+ GetQuicReloadableFlag(quic_enable_version_t099)) {
+ filtered_versions.push_back(version);
}
} else if (version.transport_version == QUIC_VERSION_50) {
if (version.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
@@ -522,9 +518,7 @@
static_assert(QUICHE_ARRAYSIZE(kSupportedTransportVersions) == 6u,
"Supported versions out of sync");
if (parsed_version.transport_version == QUIC_VERSION_99) {
- if (parsed_version.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
- SetQuicReloadableFlag(quic_enable_version_q099, true);
- } else {
+ if (parsed_version.handshake_protocol == PROTOCOL_TLS1_3) {
SetQuicReloadableFlag(quic_enable_version_t099, true);
}
} else if (parsed_version.transport_version == QUIC_VERSION_50) {
diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index e1165a1..5aad73b 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -155,7 +155,9 @@
case PROTOCOL_UNSUPPORTED:
return transport_version == QUIC_VERSION_UNSUPPORTED;
case PROTOCOL_QUIC_CRYPTO:
- return transport_version != QUIC_VERSION_UNSUPPORTED;
+ return transport_version != QUIC_VERSION_UNSUPPORTED &&
+ // We explicitly removed support for Q099 to reduce test load.
+ transport_version != QUIC_VERSION_99;
case PROTOCOL_TLS1_3:
// The TLS handshake is only deployable if CRYPTO frames are also used.
// We explicitly removed support for T048 and T049 to reduce test load.
@@ -314,8 +316,7 @@
static const HandshakeProtocol kSupportedHandshakeProtocols[] = {
PROTOCOL_QUIC_CRYPTO, PROTOCOL_TLS1_3};
-static const std::array<ParsedQuicVersion, 8> kSupportedVersions = {
- ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99),
+static const std::array<ParsedQuicVersion, 7> kSupportedVersions = {
ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_50),
ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_49),
ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_48),
diff --git a/quic/core/quic_versions_test.cc b/quic/core/quic_versions_test.cc
index cbaab95..f397d7e 100644
--- a/quic/core/quic_versions_test.cc
+++ b/quic/core/quic_versions_test.cc
@@ -42,8 +42,11 @@
// default case (i.e. all supported versions should be successfully converted
// to valid QuicVersionLabels).
for (size_t i = 0; i < QUICHE_ARRAYSIZE(kSupportedTransportVersions); ++i) {
- QuicTransportVersion version = kSupportedTransportVersions[i];
- EXPECT_LT(0u, QuicVersionToQuicVersionLabel(version));
+ QuicTransportVersion transport_version = kSupportedTransportVersions[i];
+ if (!ParsedQuicVersionIsValid(PROTOCOL_QUIC_CRYPTO, transport_version)) {
+ continue;
+ }
+ EXPECT_LT(0u, QuicVersionToQuicVersionLabel(transport_version));
}
}
@@ -83,16 +86,20 @@
QuicVersionLabelToQuicVersion(MakeQuicTag('3', '4', '0', 'Q')));
for (size_t i = 0; i < QUICHE_ARRAYSIZE(kSupportedTransportVersions); ++i) {
- QuicTransportVersion version = kSupportedTransportVersions[i];
+ QuicTransportVersion transport_version = kSupportedTransportVersions[i];
+ if (!ParsedQuicVersionIsValid(PROTOCOL_QUIC_CRYPTO, transport_version)) {
+ continue;
+ }
// Get the label from the version (we can loop over QuicVersions easily).
- QuicVersionLabel version_label = QuicVersionToQuicVersionLabel(version);
+ 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(version, label_to_transport_version);
+ EXPECT_EQ(transport_version, label_to_transport_version);
EXPECT_NE(QUIC_VERSION_UNSUPPORTED, label_to_transport_version);
}
}
@@ -264,7 +271,6 @@
TEST_F(QuicVersionsTest, FilterSupportedVersionsAllVersions) {
static_assert(QUICHE_ARRAYSIZE(kSupportedTransportVersions) == 6u,
"Supported versions out of sync");
- SetQuicReloadableFlag(quic_enable_version_q099, true);
SetQuicReloadableFlag(quic_enable_version_t099, true);
SetQuicReloadableFlag(quic_enable_version_t050, true);
SetQuicReloadableFlag(quic_disable_version_q050, false);
@@ -275,8 +281,6 @@
ParsedQuicVersionVector expected_parsed_versions;
expected_parsed_versions.push_back(
- ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99));
- expected_parsed_versions.push_back(
ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_50));
expected_parsed_versions.push_back(
ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_49));
@@ -299,7 +303,6 @@
TEST_F(QuicVersionsTest, FilterSupportedVersionsNo99) {
static_assert(QUICHE_ARRAYSIZE(kSupportedTransportVersions) == 6u,
"Supported versions out of sync");
- SetQuicReloadableFlag(quic_enable_version_q099, false);
SetQuicReloadableFlag(quic_enable_version_t099, false);
SetQuicReloadableFlag(quic_enable_version_t050, true);
SetQuicReloadableFlag(quic_disable_version_q050, false);
@@ -329,7 +332,6 @@
TEST_F(QuicVersionsTest, FilterSupportedVersionsNoFlags) {
static_assert(QUICHE_ARRAYSIZE(kSupportedTransportVersions) == 6u,
"Supported versions out of sync");
- SetQuicReloadableFlag(quic_enable_version_q099, false);
SetQuicReloadableFlag(quic_enable_version_t099, false);
SetQuicReloadableFlag(quic_enable_version_t050, false);
SetQuicReloadableFlag(quic_disable_version_q050, false);
@@ -429,8 +431,6 @@
TEST_F(QuicVersionsTest, QuicEnableVersion) {
static_assert(QUICHE_ARRAYSIZE(kSupportedTransportVersions) == 6u,
"Supported versions out of sync");
- ParsedQuicVersion parsed_version_q099 =
- ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99);
ParsedQuicVersion parsed_version_t099 =
ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99);
ParsedQuicVersion parsed_version_q050 =
@@ -440,13 +440,6 @@
{
QuicFlagSaver flag_saver;
- SetQuicReloadableFlag(quic_enable_version_q099, false);
- QuicEnableVersion(parsed_version_q099);
- EXPECT_TRUE(GetQuicReloadableFlag(quic_enable_version_q099));
- }
-
- {
- QuicFlagSaver flag_saver;
SetQuicReloadableFlag(quic_enable_version_t099, false);
QuicEnableVersion(parsed_version_t099);
EXPECT_TRUE(GetQuicReloadableFlag(quic_enable_version_t099));
diff --git a/quic/quartc/quartc_multiplexer_test.cc b/quic/quartc/quartc_multiplexer_test.cc
index 2a6e838..88fbf59 100644
--- a/quic/quartc/quartc_multiplexer_test.cc
+++ b/quic/quartc/quartc_multiplexer_test.cc
@@ -202,7 +202,6 @@
quic::QuartcSessionConfig())) {
quic::test::QuicEnableDefaultEnabledVersions();
// TODO(b/134175506): Remove when IETF QUIC supports receive timestamps.
- SetQuicReloadableFlag(quic_enable_version_q099, false);
SetQuicReloadableFlag(quic_enable_version_t099, false);
}
diff --git a/quic/quartc/quartc_session_test.cc b/quic/quartc/quartc_session_test.cc
index b08ccb4..d2eb9eb 100644
--- a/quic/quartc/quartc_session_test.cc
+++ b/quic/quartc/quartc_session_test.cc
@@ -56,7 +56,6 @@
void Init(bool create_client_endpoint = true) {
quic::test::QuicEnableDefaultEnabledVersions();
// TODO(b/134175506): Remove when IETF QUIC supports receive timestamps.
- SetQuicReloadableFlag(quic_enable_version_q099, false);
SetQuicReloadableFlag(quic_enable_version_t099, false);
client_transport_ =
@@ -344,7 +343,6 @@
TEST_F(QuartcSessionTest, SendReceiveMessages) {
// TODO(b/134175506): Remove when IETF QUIC supports receive timestamps.
- SetQuicReloadableFlag(quic_enable_version_q099, false);
SetQuicReloadableFlag(quic_enable_version_t099, false);
CreateClientAndServerSessions(QuartcSessionConfig());
@@ -354,7 +352,6 @@
TEST_F(QuartcSessionTest, SendReceiveQueuedMessages) {
// TODO(b/134175506): Remove when IETF QUIC supports receive timestamps.
- SetQuicReloadableFlag(quic_enable_version_q099, false);
SetQuicReloadableFlag(quic_enable_version_t099, false);
CreateClientAndServerSessions(QuartcSessionConfig());
@@ -416,7 +413,6 @@
TEST_F(QuartcSessionTest, PreSharedKeyHandshake) {
// TODO(b/134175506): Remove when IETF QUIC supports receive timestamps.
- SetQuicReloadableFlag(quic_enable_version_q099, false);
SetQuicReloadableFlag(quic_enable_version_t099, false);
QuartcSessionConfig config;
@@ -563,7 +559,6 @@
TEST_F(QuartcSessionTest, LostDatagramNotifications) {
// TODO(b/134175506): Remove when IETF QUIC supports receive timestamps.
- SetQuicReloadableFlag(quic_enable_version_q099, false);
SetQuicReloadableFlag(quic_enable_version_t099, false);
// Disable tail loss probe, otherwise test maybe flaky because dropped
diff --git a/quic/test_tools/crypto_test_utils_test.cc b/quic/test_tools/crypto_test_utils_test.cc
index 62cafe6..582568c 100644
--- a/quic/test_tools/crypto_test_utils_test.cc
+++ b/quic/test_tools/crypto_test_utils_test.cc
@@ -142,7 +142,17 @@
std::string pub_hex = "#" + quiche::QuicheTextUtils::HexEncode(
public_value, sizeof(public_value));
- QuicTransportVersion version(AllSupportedTransportVersions().front());
+ // The methods below use a PROTOCOL_QUIC_CRYPTO version so we pick the
+ // first one from the list of supported versions.
+ 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(QUIC_VERSION_UNSUPPORTED, transport_version);
+
CryptoHandshakeMessage inchoate_chlo = crypto_test_utils::CreateCHLO(
{{"PDMD", "X509"},
{"AEAD", "AESG"},
@@ -150,18 +160,19 @@
{"COPT", "SREJ"},
{"PUBS", pub_hex},
{"NONC", nonce_hex},
- {"VER\0",
- QuicVersionLabelToString(QuicVersionToQuicVersionLabel(version))}},
+ {"VER\0", QuicVersionLabelToString(
+ QuicVersionToQuicVersionLabel(transport_version))}},
kClientHelloMinimumSize);
- crypto_test_utils::GenerateFullCHLO(
- inchoate_chlo, &crypto_config, server_addr, client_addr, version, &clock,
- signed_config, &compressed_certs_cache, &full_chlo);
+ crypto_test_utils::GenerateFullCHLO(inchoate_chlo, &crypto_config,
+ server_addr, client_addr,
+ transport_version, &clock, signed_config,
+ &compressed_certs_cache, &full_chlo);
// Verify that full_chlo can pass crypto_config's verification.
ShloVerifier shlo_verifier(&crypto_config, server_addr, client_addr, &clock,
signed_config, &compressed_certs_cache);
crypto_config.ValidateClientHello(
- full_chlo, client_addr.host(), server_addr, version, &clock,
+ full_chlo, client_addr.host(), server_addr, transport_version, &clock,
signed_config, shlo_verifier.GetValidateClientHelloCallback());
}
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index b3bd2bb..e033ac5 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -894,6 +894,7 @@
if (!versions) {
versions = &supported_versions;
}
+ EXPECT_FALSE(versions->empty());
ParsedQuicVersion version = (*versions)[0];
if (QuicVersionHasLongHeaderLengths(version.transport_version) &&
version_flag) {
