Refactor quic_enable_version flags
In order to support our goal of enabling some QUIC versions with TLS on the GFE, we want to be able to enable some of them but not others. This CL refactors our flag code in order to do that. It also adds quic_disable_version flags for all existing versions to allow us to disable some versions on demand.
gfe-relnote: refactor never-enabled reloadable quic_enable_version flags
NO_BUG=refactor
emadomara@ please review //communication/synapse/networking/measuring_uploader/quic_uploader_client.cc
rch@ please review everything else :-)
PiperOrigin-RevId: 284641206
Change-Id: I9c5c8829fc8757b8ed3d6bd46689f9adafcb555a
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index df2b458..0cdb5c7 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -128,7 +128,6 @@
// Constructs various test permutations.
std::vector<TestParams> GetTestParams(bool use_tls_handshake) {
- QuicFlagSaver flags;
// Divide the versions into buckets in which the intra-frame format
// is compatible. When clients encounter QUIC version negotiation
// they simply retransmit all packets using the new version's
@@ -137,7 +136,6 @@
// handshake protocol). So these tests need to ensure that clients are never
// attempting to do 0-RTT across incompatible versions. Chromium only
// supports a single version at a time anyway. :)
- SetQuicReloadableFlag(quic_supports_tls_handshake, use_tls_handshake);
ParsedQuicVersionVector all_supported_versions =
FilterSupportedVersions(AllSupportedVersions());
@@ -150,6 +148,9 @@
ParsedQuicVersionVector version_buckets[3];
for (const ParsedQuicVersion& version : all_supported_versions) {
+ if (!use_tls_handshake && version.handshake_protocol == PROTOCOL_TLS1_3) {
+ continue;
+ }
if (!QuicVersionUsesCryptoFrames(version.transport_version)) {
version_buckets[0].push_back(version);
} else if (version.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
@@ -247,7 +248,6 @@
stream_factory_(nullptr),
support_server_push_(false),
expected_server_connection_id_length_(kQuicDefaultConnectionIdLength) {
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
client_supported_versions_ = GetParam().client_supported_versions;
server_supported_versions_ = GetParam().server_supported_versions;
negotiated_version_ = GetParam().negotiated_version;
diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index 9e8c749..ddf30fe 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -150,7 +150,6 @@
handshake_message_ = crypto_config_.AddDefaultConfig(
QuicRandom::GetInstance(), &clock,
QuicCryptoServerConfig::ConfigOptions());
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
session_->Initialize();
if (!GetQuicReloadableFlag(quic_version_negotiated_by_default_at_server)) {
QuicSessionPeer::GetMutableCryptoStream(session_.get())
diff --git a/quic/core/http/quic_spdy_client_session_test.cc b/quic/core/http/quic_spdy_client_session_test.cc
index 7c4d914..685ffc7 100644
--- a/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quic/core/http/quic_spdy_client_session_test.cc
@@ -84,7 +84,6 @@
QuicUtils::GetInvalidStreamId(GetParam().transport_version)),
associated_stream_id_(
QuicUtils::GetInvalidStreamId(GetParam().transport_version)) {
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
Initialize();
// Advance the time, because timers do not like uninitialized times.
connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
diff --git a/quic/core/http/quic_spdy_client_stream_test.cc b/quic/core/http/quic_spdy_client_stream_test.cc
index dd1cade..8c1501e 100644
--- a/quic/core/http/quic_spdy_client_stream_test.cc
+++ b/quic/core/http/quic_spdy_client_stream_test.cc
@@ -66,7 +66,6 @@
connection_,
&push_promise_index_),
body_("hello world") {
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
session_.Initialize();
headers_[":status"] = "200";
diff --git a/quic/core/legacy_quic_stream_id_manager_test.cc b/quic/core/legacy_quic_stream_id_manager_test.cc
index 75e381d..6a861a5 100644
--- a/quic/core/legacy_quic_stream_id_manager_test.cc
+++ b/quic/core/legacy_quic_stream_id_manager_test.cc
@@ -21,7 +21,10 @@
class LegacyQuicStreamIdManagerTest : public QuicTest {
protected:
void Initialize(Perspective perspective) {
- SetQuicReloadableFlag(quic_enable_version_99, false);
+ // LegacyQuicStreamIdManager is only used for versions < 99.
+ // TODO(b/145768765) parameterize this test by version.
+ SetQuicReloadableFlag(quic_enable_version_q099, false);
+ SetQuicReloadableFlag(quic_enable_version_t099, false);
connection_ = new MockQuicConnection(
&helper_, &alarm_factory_, perspective,
ParsedVersionOfIndex(CurrentSupportedVersions(), 0));
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 3babced..ab5a7ba 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -919,7 +919,6 @@
// Constructs various test permutations.
std::vector<TestParams> GetTestParams() {
QuicFlagSaver flags;
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
std::vector<TestParams> params;
ParsedQuicVersionVector all_supported_versions = AllSupportedVersions();
for (size_t i = 0; i < all_supported_versions.size(); ++i) {
@@ -985,7 +984,6 @@
notifier_(&connection_),
connection_close_frame_count_(0) {
QUIC_DVLOG(2) << "QuicConnectionTest(" << PrintToString(GetParam()) << ")";
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
connection_.set_defer_send_in_response_to_packets(GetParam().ack_response ==
AckResponse::kDefer);
framer_.SetInitialObfuscators(TestConnectionId());
diff --git a/quic/core/quic_crypto_client_stream_test.cc b/quic/core/quic_crypto_client_stream_test.cc
index 827cb03..2f758cc 100644
--- a/quic/core/quic_crypto_client_stream_test.cc
+++ b/quic/core/quic_crypto_client_stream_test.cc
@@ -61,7 +61,6 @@
}
void UseTlsHandshake() {
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
supported_versions_.clear();
for (ParsedQuicVersion version : AllSupportedVersions()) {
if (version.handshake_protocol != PROTOCOL_TLS1_3) {
diff --git a/quic/core/quic_crypto_server_stream_test.cc b/quic/core/quic_crypto_server_stream_test.cc
index 2f7055d..6de5433 100644
--- a/quic/core/quic_crypto_server_stream_test.cc
+++ b/quic/core/quic_crypto_server_stream_test.cc
@@ -203,7 +203,6 @@
}
TEST_P(QuicCryptoServerStreamTest, ConnectedAfterTlsHandshake) {
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
client_options_.only_tls_versions = true;
supported_versions_.clear();
for (QuicTransportVersion transport_version :
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index 0f78020..51d851d 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -415,12 +415,10 @@
};
TEST_F(QuicDispatcherTest, TlsClientHelloCreatesSession) {
- if (!QuicVersionUsesCryptoFrames(
- CurrentSupportedVersions().front().transport_version)) {
- // TLS is only supported in versions with crypto frames.
+ if (CurrentSupportedVersions().front().handshake_protocol !=
+ PROTOCOL_TLS1_3) {
return;
}
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
EXPECT_CALL(*dispatcher_,
@@ -438,12 +436,9 @@
EXPECT_CALL(*dispatcher_,
ShouldCreateOrBufferPacketForConnection(
ReceivedPacketInfoConnectionIdEquals(TestConnectionId(1))));
- ProcessPacket(
- client_address, TestConnectionId(1), true,
- ParsedQuicVersion(PROTOCOL_TLS1_3,
- CurrentSupportedVersions().front().transport_version),
- SerializeCHLO(), true, CONNECTION_ID_PRESENT, PACKET_4BYTE_PACKET_NUMBER,
- 1);
+ ProcessPacket(client_address, TestConnectionId(1), true,
+ CurrentSupportedVersions().front(), SerializeCHLO(), true,
+ CONNECTION_ID_PRESENT, PACKET_4BYTE_PACKET_NUMBER, 1);
}
TEST_F(QuicDispatcherTest, ProcessPackets) {
@@ -907,24 +902,26 @@
QuicDispatcher::kMaxReasonableInitialPacketNumber);
}
-TEST_F(QuicDispatcherTest, SupportedTransportVersionsChangeInFlight) {
- static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
- "Supported versions out of sync");
- SetQuicReloadableFlag(quic_enable_version_99, true);
+TEST_F(QuicDispatcherTest, VersionsChangeInFlight) {
+ for (ParsedQuicVersion version : AllSupportedVersions()) {
+ QuicEnableVersion(version);
+ }
+ ASSERT_EQ(AllSupportedVersions(), CurrentSupportedVersions());
VerifyVersionNotSupported(QuicVersionReservedForNegotiation());
VerifyVersionSupported(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO,
QuicVersionMin().transport_version));
- VerifyVersionSupported(QuicVersionMax());
+ VerifyVersionSupported(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO,
+ QuicVersionMax().transport_version));
- // Turn off version 99.
- SetQuicReloadableFlag(quic_enable_version_99, false);
+ // Turn off version Q099.
+ SetQuicReloadableFlag(quic_enable_version_q099, false);
VerifyVersionNotSupported(
ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99));
- // Turn on version 99.
- SetQuicReloadableFlag(quic_enable_version_99, true);
+ // Turn on version Q099.
+ SetQuicReloadableFlag(quic_enable_version_q099, true);
VerifyVersionSupported(
ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99));
}
@@ -1251,7 +1248,7 @@
}
TEST_F(QuicDispatcherTest, ProcessSmallCoalescedPacket) {
- SetQuicReloadableFlag(quic_enable_version_99, true);
+ SetQuicReloadableFlag(quic_enable_version_q099, true);
CreateTimeWaitListManager();
QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
@@ -2063,9 +2060,10 @@
// Regression test for b/117874922.
TEST_F(BufferedPacketStoreTest, ProcessBufferedChloWithDifferentVersion) {
- // Turn off version 99, such that the preferred version is not supported by
- // the server.
- SetQuicReloadableFlag(quic_enable_version_99, false);
+ // Turn off versions Q099 and T099, such that the preferred version is not
+ // supported by the server.
+ SetQuicReloadableFlag(quic_enable_version_q099, false);
+ SetQuicReloadableFlag(quic_enable_version_t099, false);
uint64_t last_connection_id = kMaxNumSessionsToCreate + 5;
ParsedQuicVersionVector supported_versions = CurrentSupportedVersions();
for (uint64_t conn_id = 1; conn_id <= last_connection_id; ++conn_id) {
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index ff9653d..13f02bc 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -582,7 +582,6 @@
start_,
Perspective::IS_SERVER,
kQuicDefaultConnectionIdLength) {
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
framer_.set_version(version_);
if (framer_.version().KnowsWhichDecrypterToUse()) {
framer_.InstallDecrypter(ENCRYPTION_INITIAL,
diff --git a/quic/core/quic_version_manager.cc b/quic/core/quic_version_manager.cc
index 95cac21..0f21f01 100644
--- a/quic/core/quic_version_manager.cc
+++ b/quic/core/quic_version_manager.cc
@@ -15,8 +15,14 @@
QuicVersionManager::QuicVersionManager(
ParsedQuicVersionVector supported_versions)
- : enable_version_99_(GetQuicReloadableFlag(quic_enable_version_99)),
- enable_tls_(GetQuicReloadableFlag(quic_supports_tls_handshake)),
+ : 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)),
+ disable_version_q049_(GetQuicReloadableFlag(quic_disable_version_q049)),
+ disable_version_q048_(GetQuicReloadableFlag(quic_disable_version_q048)),
+ disable_version_q046_(GetQuicReloadableFlag(quic_disable_version_q046)),
+ disable_version_q043_(GetQuicReloadableFlag(quic_disable_version_q043)),
allowed_supported_versions_(std::move(supported_versions)) {
static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
"Supported versions out of sync");
@@ -39,10 +45,28 @@
void QuicVersionManager::MaybeRefilterSupportedVersions() {
static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
"Supported versions out of sync");
- if (enable_version_99_ != GetQuicReloadableFlag(quic_enable_version_99) ||
- enable_tls_ != GetQuicReloadableFlag(quic_supports_tls_handshake)) {
- enable_version_99_ = GetQuicReloadableFlag(quic_enable_version_99);
- enable_tls_ = GetQuicReloadableFlag(quic_supports_tls_handshake);
+ if (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) ||
+ disable_version_q049_ !=
+ GetQuicReloadableFlag(quic_disable_version_q049) ||
+ disable_version_q048_ !=
+ GetQuicReloadableFlag(quic_disable_version_q048) ||
+ disable_version_q046_ !=
+ GetQuicReloadableFlag(quic_disable_version_q046) ||
+ disable_version_q043_ !=
+ GetQuicReloadableFlag(quic_disable_version_q043)) {
+ 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);
+ disable_version_q049_ = GetQuicReloadableFlag(quic_disable_version_q049);
+ disable_version_q048_ = GetQuicReloadableFlag(quic_disable_version_q048);
+ disable_version_q046_ = GetQuicReloadableFlag(quic_disable_version_q046);
+ disable_version_q043_ = GetQuicReloadableFlag(quic_disable_version_q043);
+
RefilterSupportedVersions();
}
}
diff --git a/quic/core/quic_version_manager.h b/quic/core/quic_version_manager.h
index e66e01f..b7aff69 100644
--- a/quic/core/quic_version_manager.h
+++ b/quic/core/quic_version_manager.h
@@ -41,10 +41,22 @@
private:
// Cached value of reloadable flags.
- // quic_enable_version_99 flag
- bool enable_version_99_;
- // quic_supports_tls_handshake flag
- bool enable_tls_;
+ // quic_enable_version_q099 flag
+ bool enable_version_q099_;
+ // quic_enable_version_t099 flag
+ bool enable_version_t099_;
+ // quic_disable_version_q050 flag
+ bool disable_version_q050_;
+ // quic_enable_version_t050 flag
+ bool enable_version_t050_;
+ // quic_disable_version_q049 flag
+ bool disable_version_q049_;
+ // quic_disable_version_q048 flag
+ bool disable_version_q048_;
+ // quic_disable_version_q046 flag
+ bool disable_version_q046_;
+ // quic_disable_version_q043 flag
+ bool disable_version_q043_;
// The list of versions that may be supported.
ParsedQuicVersionVector allowed_supported_versions_;
diff --git a/quic/core/quic_version_manager_test.cc b/quic/core/quic_version_manager_test.cc
index 2abf986..89f15ac 100644
--- a/quic/core/quic_version_manager_test.cc
+++ b/quic/core/quic_version_manager_test.cc
@@ -18,8 +18,14 @@
TEST_F(QuicVersionManagerTest, QuicVersionManager) {
static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
"Supported versions out of sync");
- SetQuicReloadableFlag(quic_enable_version_99, false);
- SetQuicReloadableFlag(quic_supports_tls_handshake, false);
+ SetQuicReloadableFlag(quic_enable_version_q099, false);
+ SetQuicReloadableFlag(quic_enable_version_t099, false);
+ SetQuicReloadableFlag(quic_enable_version_t050, false);
+ SetQuicReloadableFlag(quic_disable_version_q050, false);
+ SetQuicReloadableFlag(quic_disable_version_q049, false);
+ SetQuicReloadableFlag(quic_disable_version_q048, false);
+ SetQuicReloadableFlag(quic_disable_version_q046, false);
+ SetQuicReloadableFlag(quic_disable_version_q043, false);
QuicVersionManager manager(AllSupportedVersions());
ParsedQuicVersionVector expected_parsed_versions;
@@ -39,13 +45,27 @@
EXPECT_EQ(FilterSupportedVersions(AllSupportedVersions()),
manager.GetSupportedVersions());
- SetQuicReloadableFlag(quic_enable_version_99, true);
+ 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));
+ EXPECT_EQ(expected_parsed_versions, manager.GetSupportedVersions());
+ EXPECT_EQ(FilterSupportedVersions(AllSupportedVersions()),
+ manager.GetSupportedVersions());
+
+ SetQuicReloadableFlag(quic_enable_version_t050, true);
+ expected_parsed_versions.push_back(
+ ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_50));
+ EXPECT_EQ(expected_parsed_versions, manager.GetSupportedVersions());
+ EXPECT_EQ(FilterSupportedVersions(AllSupportedVersions()),
+ manager.GetSupportedVersions());
}
} // namespace
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index f0a943f..b034b16 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -176,13 +176,8 @@
PROTOCOL_QUIC_CRYPTO,
static_cast<QuicTransportVersion>(quic_version_number));
}
-
- std::vector<HandshakeProtocol> protocols = {PROTOCOL_QUIC_CRYPTO};
- if (GetQuicReloadableFlag(quic_supports_tls_handshake)) {
- protocols.push_back(PROTOCOL_TLS1_3);
- }
for (QuicTransportVersion version : kSupportedTransportVersions) {
- for (HandshakeProtocol handshake : protocols) {
+ for (HandshakeProtocol handshake : kSupportedHandshakeProtocols) {
const ParsedQuicVersion parsed_version =
ParsedQuicVersion(handshake, version);
if (version_string == ParsedQuicVersionToString(parsed_version)) {
@@ -191,7 +186,7 @@
}
}
// Still recognize T099 even if flag quic_ietf_draft_version has been changed.
- if (GetQuicReloadableFlag(quic_supports_tls_handshake) &&
+ if (GetQuicReloadableFlag(quic_enable_version_t099) &&
version_string == "T099") {
return ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99);
}
@@ -235,12 +230,40 @@
ParsedQuicVersionVector filtered_versions;
filtered_versions.reserve(versions.size());
for (ParsedQuicVersion version : versions) {
- if (version.handshake_protocol == PROTOCOL_TLS1_3 &&
- !GetQuicReloadableFlag(quic_supports_tls_handshake)) {
- continue;
- }
if (version.transport_version == QUIC_VERSION_99) {
- if (GetQuicReloadableFlag(quic_enable_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);
+ }
+ }
+ } else if (version.transport_version == QUIC_VERSION_50) {
+ if (version.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
+ if (!GetQuicReloadableFlag(quic_disable_version_q050)) {
+ filtered_versions.push_back(version);
+ }
+ } else {
+ if (GetQuicReloadableFlag(quic_enable_version_t050)) {
+ filtered_versions.push_back(version);
+ }
+ }
+ } else if (version.transport_version == QUIC_VERSION_49) {
+ if (!GetQuicReloadableFlag(quic_disable_version_q049)) {
+ filtered_versions.push_back(version);
+ }
+ } else if (version.transport_version == QUIC_VERSION_48) {
+ if (!GetQuicReloadableFlag(quic_disable_version_q048)) {
+ filtered_versions.push_back(version);
+ }
+ } else if (version.transport_version == QUIC_VERSION_46) {
+ if (!GetQuicReloadableFlag(quic_disable_version_q046)) {
+ filtered_versions.push_back(version);
+ }
+ } else if (version.transport_version == QUIC_VERSION_43) {
+ if (!GetQuicReloadableFlag(quic_disable_version_q043)) {
filtered_versions.push_back(version);
}
} else {
@@ -432,17 +455,31 @@
void QuicVersionInitializeSupportForIetfDraft() {
// Enable necessary flags.
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
}
void QuicEnableVersion(ParsedQuicVersion parsed_version) {
- if (parsed_version.handshake_protocol == PROTOCOL_TLS1_3) {
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
- }
static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
"Supported versions out of sync");
if (parsed_version.transport_version == QUIC_VERSION_99) {
- SetQuicReloadableFlag(quic_enable_version_99, true);
+ if (parsed_version.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
+ SetQuicReloadableFlag(quic_enable_version_q099, true);
+ } else {
+ SetQuicReloadableFlag(quic_enable_version_t099, true);
+ }
+ } else if (parsed_version.transport_version == QUIC_VERSION_50) {
+ if (parsed_version.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
+ SetQuicReloadableFlag(quic_disable_version_q050, false);
+ } else {
+ SetQuicReloadableFlag(quic_enable_version_t050, true);
+ }
+ } else if (parsed_version.transport_version == QUIC_VERSION_49) {
+ SetQuicReloadableFlag(quic_disable_version_q049, false);
+ } else if (parsed_version.transport_version == QUIC_VERSION_48) {
+ SetQuicReloadableFlag(quic_disable_version_q048, false);
+ } else if (parsed_version.transport_version == QUIC_VERSION_46) {
+ SetQuicReloadableFlag(quic_disable_version_q046, false);
+ } else if (parsed_version.transport_version == QUIC_VERSION_43) {
+ SetQuicReloadableFlag(quic_disable_version_q043, false);
}
}
diff --git a/quic/core/quic_versions_test.cc b/quic/core/quic_versions_test.cc
index 5f2d7ba..56ef26f 100644
--- a/quic/core/quic_versions_test.cc
+++ b/quic/core/quic_versions_test.cc
@@ -147,7 +147,6 @@
EXPECT_EQ(UnsupportedQuicVersion(), ParseQuicVersionString("Q046 "));
// Test a TLS version:
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
EXPECT_EQ(ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_50),
ParseQuicVersionString("T050"));
}
@@ -257,8 +256,15 @@
TEST_F(QuicVersionsTest, FilterSupportedVersionsAllVersions) {
static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
"Supported versions out of sync");
- SetQuicReloadableFlag(quic_enable_version_99, true);
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
+ SetQuicReloadableFlag(quic_enable_version_q099, true);
+ SetQuicReloadableFlag(quic_enable_version_t099, true);
+ SetQuicReloadableFlag(quic_enable_version_t050, true);
+ SetQuicReloadableFlag(quic_disable_version_q050, false);
+ SetQuicReloadableFlag(quic_disable_version_q049, false);
+ SetQuicReloadableFlag(quic_disable_version_q048, false);
+ SetQuicReloadableFlag(quic_disable_version_q046, false);
+ SetQuicReloadableFlag(quic_disable_version_q043, false);
+
ParsedQuicVersionVector expected_parsed_versions;
expected_parsed_versions.push_back(
ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99));
@@ -285,8 +291,15 @@
TEST_F(QuicVersionsTest, FilterSupportedVersionsNo99) {
static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
"Supported versions out of sync");
- SetQuicReloadableFlag(quic_enable_version_99, false);
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
+ SetQuicReloadableFlag(quic_enable_version_q099, false);
+ SetQuicReloadableFlag(quic_enable_version_t099, false);
+ SetQuicReloadableFlag(quic_enable_version_t050, true);
+ SetQuicReloadableFlag(quic_disable_version_q050, false);
+ SetQuicReloadableFlag(quic_disable_version_q049, false);
+ SetQuicReloadableFlag(quic_disable_version_q048, false);
+ SetQuicReloadableFlag(quic_disable_version_q046, false);
+ SetQuicReloadableFlag(quic_disable_version_q043, false);
+
ParsedQuicVersionVector expected_parsed_versions;
expected_parsed_versions.push_back(
ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_50));
@@ -308,8 +321,15 @@
TEST_F(QuicVersionsTest, FilterSupportedVersionsNoFlags) {
static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
"Supported versions out of sync");
- SetQuicReloadableFlag(quic_enable_version_99, false);
- SetQuicReloadableFlag(quic_supports_tls_handshake, false);
+ SetQuicReloadableFlag(quic_enable_version_q099, false);
+ SetQuicReloadableFlag(quic_enable_version_t099, false);
+ SetQuicReloadableFlag(quic_enable_version_t050, false);
+ SetQuicReloadableFlag(quic_disable_version_q050, false);
+ SetQuicReloadableFlag(quic_disable_version_q049, false);
+ SetQuicReloadableFlag(quic_disable_version_q048, false);
+ SetQuicReloadableFlag(quic_disable_version_q046, false);
+ SetQuicReloadableFlag(quic_disable_version_q043, false);
+
ParsedQuicVersionVector expected_parsed_versions;
expected_parsed_versions.push_back(
ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_50));
@@ -401,17 +421,41 @@
TEST_F(QuicVersionsTest, QuicEnableVersion) {
static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
"Supported versions out of sync");
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
+ ParsedQuicVersion parsed_version_q099 =
+ ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99);
ParsedQuicVersion parsed_version_t099 =
ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99);
- SetQuicReloadableFlag(quic_supports_tls_handshake, false);
- SetQuicReloadableFlag(quic_enable_version_99, false);
+ ParsedQuicVersion parsed_version_q050 =
+ ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_50);
+ ParsedQuicVersion parsed_version_t050 =
+ ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_50);
{
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_supports_tls_handshake));
- EXPECT_TRUE(GetQuicReloadableFlag(quic_enable_version_99));
+ EXPECT_TRUE(GetQuicReloadableFlag(quic_enable_version_t099));
+ }
+
+ {
+ QuicFlagSaver flag_saver;
+ SetQuicReloadableFlag(quic_disable_version_q050, true);
+ QuicEnableVersion(parsed_version_q050);
+ EXPECT_FALSE(GetQuicReloadableFlag(quic_disable_version_q050));
+ }
+
+ {
+ QuicFlagSaver flag_saver;
+ SetQuicReloadableFlag(quic_enable_version_t050, false);
+ QuicEnableVersion(parsed_version_t050);
+ EXPECT_TRUE(GetQuicReloadableFlag(quic_enable_version_t050));
}
}
diff --git a/quic/core/tls_handshaker.cc b/quic/core/tls_handshaker.cc
index 08b4eb9..bc09994 100644
--- a/quic/core/tls_handshaker.cc
+++ b/quic/core/tls_handshaker.cc
@@ -17,8 +17,6 @@
QuicSession* session,
SSL_CTX* /*ssl_ctx*/)
: stream_(stream), session_(session), delegate_(session) {
- QUIC_BUG_IF(!GetQuicReloadableFlag(quic_supports_tls_handshake))
- << "Attempted to create TLS handshaker when TLS is disabled";
}
TlsHandshaker::~TlsHandshaker() {}
diff --git a/quic/core/tls_handshaker_test.cc b/quic/core/tls_handshaker_test.cc
index a86b521..75f07aa 100644
--- a/quic/core/tls_handshaker_test.cc
+++ b/quic/core/tls_handshaker_test.cc
@@ -309,7 +309,6 @@
{ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99)})),
client_session_(client_conn_, /*create_mock_crypto_stream=*/false),
server_session_(server_conn_, /*create_mock_crypto_stream=*/false) {
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
client_stream_ = new TestQuicCryptoClientStream(&client_session_);
client_session_.SetCryptoStream(client_stream_);
server_stream_ =
diff --git a/quic/quartc/quartc_endpoint_test.cc b/quic/quartc/quartc_endpoint_test.cc
index 8506067..d2f9420 100644
--- a/quic/quartc/quartc_endpoint_test.cc
+++ b/quic/quartc/quartc_endpoint_test.cc
@@ -49,7 +49,11 @@
simulator_.GetRandomGenerator(),
&client_endpoint_delegate_,
QuartcSessionConfig(),
- /*serialized_server_config=*/"")) {}
+ /*serialized_server_config=*/"")) {
+ // Make sure these versions are enabled since some tests use them.
+ SetQuicReloadableFlag(quic_disable_version_q043, false);
+ SetQuicReloadableFlag(quic_disable_version_q046, false);
+ }
simulator::Simulator simulator_;
diff --git a/quic/quartc/quartc_multiplexer_test.cc b/quic/quartc/quartc_multiplexer_test.cc
index 3cc088b..9b989be 100644
--- a/quic/quartc/quartc_multiplexer_test.cc
+++ b/quic/quartc/quartc_multiplexer_test.cc
@@ -199,8 +199,10 @@
simulator_.GetRandomGenerator(),
&server_multiplexer_,
quic::QuartcSessionConfig())) {
+ quic::test::QuicEnableDefaultEnabledVersions();
// TODO(b/134175506): Remove when IETF QUIC supports receive timestamps.
- SetQuicReloadableFlag(quic_enable_version_99, false);
+ SetQuicReloadableFlag(quic_enable_version_q099, false);
+ SetQuicReloadableFlag(quic_enable_version_t099, false);
}
void Connect() {
diff --git a/quic/quartc/quartc_session_test.cc b/quic/quartc/quartc_session_test.cc
index 956073b..195baa4 100644
--- a/quic/quartc/quartc_session_test.cc
+++ b/quic/quartc/quartc_session_test.cc
@@ -51,6 +51,11 @@
~QuartcSessionTest() override {}
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_ =
std::make_unique<simulator::SimulatedQuartcPacketTransport>(
&simulator_, "client_transport", "server_transport",
@@ -336,7 +341,8 @@
TEST_F(QuartcSessionTest, SendReceiveMessages) {
// TODO(b/134175506): Remove when IETF QUIC supports receive timestamps.
- SetQuicReloadableFlag(quic_enable_version_99, false);
+ SetQuicReloadableFlag(quic_enable_version_q099, false);
+ SetQuicReloadableFlag(quic_enable_version_t099, false);
CreateClientAndServerSessions(QuartcSessionConfig());
AwaitHandshake();
@@ -345,7 +351,8 @@
TEST_F(QuartcSessionTest, SendReceiveQueuedMessages) {
// TODO(b/134175506): Remove when IETF QUIC supports receive timestamps.
- SetQuicReloadableFlag(quic_enable_version_99, false);
+ SetQuicReloadableFlag(quic_enable_version_q099, false);
+ SetQuicReloadableFlag(quic_enable_version_t099, false);
CreateClientAndServerSessions(QuartcSessionConfig());
AwaitHandshake();
@@ -406,7 +413,8 @@
TEST_F(QuartcSessionTest, PreSharedKeyHandshake) {
// TODO(b/134175506): Remove when IETF QUIC supports receive timestamps.
- SetQuicReloadableFlag(quic_enable_version_99, false);
+ SetQuicReloadableFlag(quic_enable_version_q099, false);
+ SetQuicReloadableFlag(quic_enable_version_t099, false);
QuartcSessionConfig config;
config.pre_shared_key = "foo";
@@ -552,7 +560,8 @@
TEST_F(QuartcSessionTest, LostDatagramNotifications) {
// TODO(b/134175506): Remove when IETF QUIC supports receive timestamps.
- SetQuicReloadableFlag(quic_enable_version_99, false);
+ SetQuicReloadableFlag(quic_enable_version_q099, false);
+ SetQuicReloadableFlag(quic_enable_version_t099, false);
// Disable tail loss probe, otherwise test maybe flaky because dropped
// message will be retransmitted to detect tail loss.
diff --git a/quic/quic_transport/quic_transport_client_session_test.cc b/quic/quic_transport/quic_transport_client_session_test.cc
index 17a4757..51a0eb8 100644
--- a/quic/quic_transport/quic_transport_client_session_test.cc
+++ b/quic/quic_transport/quic_transport_client_session_test.cc
@@ -57,7 +57,6 @@
Perspective::IS_CLIENT,
GetVersions()),
crypto_config_(crypto_test_utils::ProofVerifierForTesting()) {
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
CreateSession(GetTestOrigin(), "");
}
diff --git a/quic/quic_transport/quic_transport_integration_test.cc b/quic/quic_transport/quic_transport_integration_test.cc
index b8d8eae..1695a19 100644
--- a/quic/quic_transport/quic_transport_integration_test.cc
+++ b/quic/quic_transport/quic_transport_integration_test.cc
@@ -60,8 +60,6 @@
simulator, simulator->GetAlarmFactory(), &writer_,
/*owns_writer=*/false, perspective, GetVersions());
connection_->SetSelfAddress(simulator::GetAddressFromName(name));
-
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
}
};
diff --git a/quic/quic_transport/quic_transport_server_session_test.cc b/quic/quic_transport/quic_transport_server_session_test.cc
index efa668c..f99997a 100644
--- a/quic/quic_transport/quic_transport_server_session_test.cc
+++ b/quic/quic_transport/quic_transport_server_session_test.cc
@@ -67,7 +67,6 @@
KeyExchangeSource::Default()),
compressed_certs_cache_(
QuicCompressedCertsCache::kQuicCompressedCertsCacheSize) {
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
connection_.AdvanceTime(QuicTime::Delta::FromSeconds(100000));
crypto_test_utils::SetupCryptoServerConfigForTest(
helper_.GetClock(), helper_.GetRandomGenerator(), &crypto_config_);
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index 4b10826..8099c34 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -828,6 +828,21 @@
return AllSupportedTransportVersions().back();
}
+void QuicEnableDefaultEnabledVersions() {
+ if (!GetQuicReloadableFlag(quic_testonly_default_false)) {
+ // If quic_testonly_default_false is false, then we are not in a mode where
+ // all flags have been flipped to true.
+ return;
+ }
+ static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
+ "Supported versions out of sync");
+ SetQuicReloadableFlag(quic_disable_version_q050, false);
+ SetQuicReloadableFlag(quic_disable_version_q049, false);
+ SetQuicReloadableFlag(quic_disable_version_q048, false);
+ SetQuicReloadableFlag(quic_disable_version_q046, false);
+ SetQuicReloadableFlag(quic_disable_version_q043, false);
+}
+
QuicEncryptedPacket* ConstructEncryptedPacket(
QuicConnectionId destination_connection_id,
QuicConnectionId source_connection_id,
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 7919ef3..d8fbc78 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -71,6 +71,9 @@
// TODO(nharper): Remove this function when it is no longer used.
QuicTransportVersion QuicTransportVersionMin();
+// Ensures that not all versions are disabled when all flags are set to true.
+void QuicEnableDefaultEnabledVersions();
+
// Create an encrypted packet for testing.
// If versions == nullptr, uses &AllSupportedVersions().
// Note that the packet is encrypted with NullEncrypter, so to decrypt the
diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc
index a548c6c..0af12e2 100644
--- a/quic/tools/quic_simple_server_session_test.cc
+++ b/quic/tools/quic_simple_server_session_test.cc
@@ -194,7 +194,6 @@
KeyExchangeSource::Default()),
compressed_certs_cache_(
QuicCompressedCertsCache::kQuicCompressedCertsCacheSize) {
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
config_.SetMaxIncomingBidirectionalStreamsToSend(kMaxStreamsForTest);
QuicConfigPeer::SetReceivedMaxIncomingBidirectionalStreams(
&config_, kMaxStreamsForTest);
diff --git a/quic/tools/quic_toy_client.cc b/quic/tools/quic_toy_client.cc
index 4159735..30018c2 100644
--- a/quic/tools/quic_toy_client.cc
+++ b/quic/tools/quic_toy_client.cc
@@ -192,10 +192,6 @@
quic::QuicEnableVersion(versions[0]);
} else if (!quic_version_string.empty()) {
- if (quic_version_string[0] == 'T') {
- // ParseQuicVersionString checks quic_supports_tls_handshake.
- SetQuicReloadableFlag(quic_supports_tls_handshake, true);
- }
quic::ParsedQuicVersion parsed_quic_version =
quic::ParseQuicVersionString(quic_version_string);
if (parsed_quic_version.transport_version ==
