gfe-relnote: Disable QUIC version 44. Protected by gfe2_reloadable_flag_quic_disable_version_44.
PiperOrigin-RevId: 253275364
Change-Id: I2e1fdb88ed00f543b3324bfe9613b65cbdad564c
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index 9817ea4..0a694a3 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -207,7 +207,8 @@
time_wait_list_manager_(nullptr),
session1_(nullptr),
session2_(nullptr),
- store_(nullptr) {}
+ store_(nullptr),
+ connection_id_(1) {}
void SetUp() override {
dispatcher_->InitializeWithWriter(new MockPacketWriter());
@@ -366,6 +367,37 @@
void MarkSession1Deleted() { session1_ = nullptr; }
+ void VerifyVersionSupported(ParsedQuicVersion version) {
+ QuicConnectionId connection_id = TestConnectionId(++connection_id_);
+ QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
+ EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address,
+ QuicStringPiece("hq"), _))
+ .WillOnce(testing::Return(CreateSession(
+ dispatcher_.get(), config_, connection_id, client_address,
+ &mock_helper_, &mock_alarm_factory_, &crypto_config_,
+ QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
+ EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
+ ProcessUdpPacket(_, _, _))
+ .WillOnce(WithArg<2>(
+ Invoke([this, connection_id](const QuicEncryptedPacket& packet) {
+ ValidatePacket(connection_id, packet);
+ })));
+ EXPECT_CALL(*dispatcher_,
+ ShouldCreateOrBufferPacketForConnection(connection_id, _));
+ ProcessPacket(client_address, connection_id, true, version, SerializeCHLO(),
+ CONNECTION_ID_PRESENT, PACKET_4BYTE_PACKET_NUMBER, 1);
+ }
+
+ void VerifyVersionNotSupported(ParsedQuicVersion version) {
+ QuicConnectionId connection_id = TestConnectionId(++connection_id_);
+ QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
+ EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address,
+ QuicStringPiece("hq"), _))
+ .Times(0);
+ ProcessPacket(client_address, connection_id, true, version, SerializeCHLO(),
+ CONNECTION_ID_PRESENT, PACKET_4BYTE_PACKET_NUMBER, 1);
+ }
+
MockQuicConnectionHelper mock_helper_;
MockAlarmFactory mock_alarm_factory_;
QuicConfig config_;
@@ -378,6 +410,7 @@
TestQuicSpdyServerSession* session2_;
std::map<QuicConnectionId, std::list<std::string>> data_connection_map_;
QuicBufferedPacketStore* store_;
+ uint64_t connection_id_;
};
TEST_F(QuicDispatcherTest, TlsClientHelloCreatesSession) {
@@ -877,122 +910,45 @@
static_assert(QUIC_ARRAYSIZE(kSupportedTransportVersions) == 6u,
"Supported versions out of sync");
SetQuicReloadableFlag(quic_disable_version_39, false);
+ SetQuicReloadableFlag(quic_disable_version_44, false);
SetQuicReloadableFlag(quic_enable_version_47, true);
SetQuicReloadableFlag(quic_enable_version_99, true);
- QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
- uint64_t conn_id = 1;
- QuicConnectionId connection_id = TestConnectionId(conn_id);
- EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address,
- QuicStringPiece("hq"), _))
- .Times(0);
- ProcessPacket(client_address, connection_id, true,
- QuicVersionReservedForNegotiation(), SerializeCHLO(),
- CONNECTION_ID_PRESENT, PACKET_4BYTE_PACKET_NUMBER, 1);
- connection_id = TestConnectionId(++conn_id);
- EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address,
- QuicStringPiece("hq"), _))
- .WillOnce(testing::Return(CreateSession(
- dispatcher_.get(), config_, connection_id, client_address,
- &mock_helper_, &mock_alarm_factory_, &crypto_config_,
- QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
- EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
- ProcessUdpPacket(_, _, _))
- .WillOnce(WithArg<2>(
- Invoke([this, connection_id](const QuicEncryptedPacket& packet) {
- ValidatePacket(connection_id, packet);
- })));
- EXPECT_CALL(*dispatcher_,
- ShouldCreateOrBufferPacketForConnection(connection_id, _));
- ProcessPacket(client_address, connection_id, true,
- ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO,
- QuicVersionMin().transport_version),
- SerializeCHLO(), CONNECTION_ID_PRESENT,
- PACKET_4BYTE_PACKET_NUMBER, 1);
- connection_id = TestConnectionId(++conn_id);
- EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address,
- QuicStringPiece("hq"), _))
- .WillOnce(testing::Return(CreateSession(
- dispatcher_.get(), config_, connection_id, client_address,
- &mock_helper_, &mock_alarm_factory_, &crypto_config_,
- QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
- EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
- ProcessUdpPacket(_, _, _))
- .WillOnce(WithArg<2>(
- Invoke([this, connection_id](const QuicEncryptedPacket& packet) {
- ValidatePacket(connection_id, packet);
- })));
- EXPECT_CALL(*dispatcher_,
- ShouldCreateOrBufferPacketForConnection(connection_id, _));
- ProcessPacket(client_address, connection_id, true, QuicVersionMax(),
- SerializeCHLO(), CONNECTION_ID_PRESENT,
- PACKET_4BYTE_PACKET_NUMBER, 1);
+ VerifyVersionNotSupported(QuicVersionReservedForNegotiation());
+
+ VerifyVersionSupported(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO,
+ QuicVersionMin().transport_version));
+ VerifyVersionSupported(QuicVersionMax());
// Turn off version 47.
SetQuicReloadableFlag(quic_enable_version_47, false);
- connection_id = TestConnectionId(++conn_id);
- EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address,
- QuicStringPiece("hq"), _))
- .Times(0);
- ProcessPacket(client_address, connection_id, true,
- ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_47),
- SerializeCHLO(), CONNECTION_ID_PRESENT,
- PACKET_4BYTE_PACKET_NUMBER, 1);
+ VerifyVersionNotSupported(
+ ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_47));
// Turn on version 47.
SetQuicReloadableFlag(quic_enable_version_47, true);
- connection_id = TestConnectionId(++conn_id);
- EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address,
- QuicStringPiece("hq"), _))
- .WillOnce(testing::Return(CreateSession(
- dispatcher_.get(), config_, connection_id, client_address,
- &mock_helper_, &mock_alarm_factory_, &crypto_config_,
- QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
- EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
- ProcessUdpPacket(_, _, _))
- .WillOnce(WithArg<2>(
- Invoke([this, connection_id](const QuicEncryptedPacket& packet) {
- ValidatePacket(connection_id, packet);
- })));
- EXPECT_CALL(*dispatcher_,
- ShouldCreateOrBufferPacketForConnection(connection_id, _));
- ProcessPacket(client_address, connection_id, true,
- ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_47),
- SerializeCHLO(), CONNECTION_ID_PRESENT,
- PACKET_4BYTE_PACKET_NUMBER, 1);
+ VerifyVersionSupported(
+ ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_47));
+
+ // Turn off version 44.
+ SetQuicReloadableFlag(quic_disable_version_44, true);
+ VerifyVersionNotSupported(
+ ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_44));
+
+ // Turn on version 44.
+ SetQuicReloadableFlag(quic_disable_version_44, false);
+ VerifyVersionSupported(
+ ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_44));
// Turn off version 39.
SetQuicReloadableFlag(quic_disable_version_39, true);
- connection_id = TestConnectionId(++conn_id);
- EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address,
- QuicStringPiece("hq"), _))
- .Times(0);
- ProcessPacket(client_address, connection_id, true,
- ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_39),
- SerializeCHLO(), CONNECTION_ID_PRESENT,
- PACKET_4BYTE_PACKET_NUMBER, 1);
+ VerifyVersionNotSupported(
+ ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_39));
// Turn on version 39.
SetQuicReloadableFlag(quic_disable_version_39, false);
- connection_id = TestConnectionId(++conn_id);
- EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address,
- QuicStringPiece("hq"), _))
- .WillOnce(testing::Return(CreateSession(
- dispatcher_.get(), config_, connection_id, client_address,
- &mock_helper_, &mock_alarm_factory_, &crypto_config_,
- QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
- EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
- ProcessUdpPacket(_, _, _))
- .WillOnce(WithArg<2>(
- Invoke([this, connection_id](const QuicEncryptedPacket& packet) {
- ValidatePacket(connection_id, packet);
- })));
- EXPECT_CALL(*dispatcher_,
- ShouldCreateOrBufferPacketForConnection(connection_id, _));
- ProcessPacket(client_address, connection_id, true,
- ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_39),
- SerializeCHLO(), CONNECTION_ID_PRESENT,
- PACKET_4BYTE_PACKET_NUMBER, 1);
+ VerifyVersionSupported(
+ ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_39));
}
// Verify the stopgap test: Packets with truncated connection IDs should be
diff --git a/quic/core/quic_version_manager.cc b/quic/core/quic_version_manager.cc
index 045e38c..8886afb 100644
--- a/quic/core/quic_version_manager.cc
+++ b/quic/core/quic_version_manager.cc
@@ -16,6 +16,7 @@
ParsedQuicVersionVector supported_versions)
: enable_version_99_(GetQuicReloadableFlag(quic_enable_version_99)),
enable_version_47_(GetQuicReloadableFlag(quic_enable_version_47)),
+ disable_version_44_(GetQuicReloadableFlag(quic_disable_version_44)),
disable_version_39_(GetQuicReloadableFlag(quic_disable_version_39)),
enable_tls_(GetQuicFlag(FLAGS_quic_supports_tls_handshake)),
allowed_supported_versions_(std::move(supported_versions)) {
@@ -38,10 +39,12 @@
void QuicVersionManager::MaybeRefilterSupportedVersions() {
if (enable_version_99_ != GetQuicReloadableFlag(quic_enable_version_99) ||
enable_version_47_ != GetQuicReloadableFlag(quic_enable_version_47) ||
+ disable_version_44_ != GetQuicReloadableFlag(quic_disable_version_44) ||
disable_version_39_ != GetQuicReloadableFlag(quic_disable_version_39) ||
enable_tls_ != GetQuicFlag(FLAGS_quic_supports_tls_handshake)) {
enable_version_99_ = GetQuicReloadableFlag(quic_enable_version_99);
enable_version_47_ = GetQuicReloadableFlag(quic_enable_version_47);
+ disable_version_44_ = GetQuicReloadableFlag(quic_disable_version_44);
disable_version_39_ = GetQuicReloadableFlag(quic_disable_version_39);
enable_tls_ = GetQuicFlag(FLAGS_quic_supports_tls_handshake);
RefilterSupportedVersions();
diff --git a/quic/core/quic_version_manager.h b/quic/core/quic_version_manager.h
index 71a285a..c87c092 100644
--- a/quic/core/quic_version_manager.h
+++ b/quic/core/quic_version_manager.h
@@ -42,6 +42,8 @@
bool enable_version_99_;
// quic_enable_version_47 flag
bool enable_version_47_;
+ // quic_disable_version_44 flag
+ bool disable_version_44_;
// quic_disable_version_39 flag
bool disable_version_39_;
// quic_supports_tls_handshake flag
diff --git a/quic/core/quic_version_manager_test.cc b/quic/core/quic_version_manager_test.cc
index cf3ff5a..0716ca9 100644
--- a/quic/core/quic_version_manager_test.cc
+++ b/quic/core/quic_version_manager_test.cc
@@ -20,17 +20,22 @@
"Supported versions out of sync");
SetQuicReloadableFlag(quic_enable_version_99, false);
SetQuicReloadableFlag(quic_enable_version_47, false);
+ SetQuicReloadableFlag(quic_disable_version_44, true);
SetQuicReloadableFlag(quic_disable_version_39, true);
QuicVersionManager manager(AllSupportedVersions());
EXPECT_EQ(FilterSupportedTransportVersions(AllSupportedTransportVersions()),
manager.GetSupportedTransportVersions());
- EXPECT_EQ(QuicTransportVersionVector(
- {QUIC_VERSION_46, QUIC_VERSION_44, QUIC_VERSION_43}),
+ EXPECT_EQ(QuicTransportVersionVector({QUIC_VERSION_46, QUIC_VERSION_43}),
manager.GetSupportedTransportVersions());
SetQuicReloadableFlag(quic_disable_version_39, false);
+ EXPECT_EQ(QuicTransportVersionVector(
+ {QUIC_VERSION_46, QUIC_VERSION_43, QUIC_VERSION_39}),
+ manager.GetSupportedTransportVersions());
+
+ SetQuicReloadableFlag(quic_disable_version_44, false);
EXPECT_EQ(QuicTransportVersionVector({QUIC_VERSION_46, QUIC_VERSION_44,
QUIC_VERSION_43, QUIC_VERSION_39}),
manager.GetSupportedTransportVersions());
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index 87f34de..ecb6bd5 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -237,6 +237,10 @@
if (GetQuicReloadableFlag(quic_enable_version_47)) {
filtered_versions.push_back(version);
}
+ } else if (version.transport_version == QUIC_VERSION_44) {
+ if (!GetQuicReloadableFlag(quic_disable_version_44)) {
+ filtered_versions.push_back(version);
+ }
} else if (version.transport_version == QUIC_VERSION_39) {
if (!GetQuicReloadableFlag(quic_disable_version_39)) {
filtered_versions.push_back(version);
diff --git a/quic/core/quic_versions_test.cc b/quic/core/quic_versions_test.cc
index 6809ba1..8d3d7dd 100644
--- a/quic/core/quic_versions_test.cc
+++ b/quic/core/quic_versions_test.cc
@@ -282,6 +282,7 @@
TEST_F(QuicVersionsTest, FilterSupportedTransportVersionsAllVersions) {
QuicTransportVersionVector all_versions = AllSupportedTransportVersions();
SetQuicReloadableFlag(quic_disable_version_39, false);
+ SetQuicReloadableFlag(quic_disable_version_44, false);
SetQuicReloadableFlag(quic_enable_version_47, true);
SetQuicReloadableFlag(quic_enable_version_99, true);
ParsedQuicVersionVector parsed_versions;
@@ -304,6 +305,7 @@
TEST_F(QuicVersionsTest, FilterSupportedTransportVersionsNo99) {
QuicTransportVersionVector all_versions = AllSupportedTransportVersions();
SetQuicReloadableFlag(quic_disable_version_39, false);
+ SetQuicReloadableFlag(quic_disable_version_44, false);
SetQuicReloadableFlag(quic_enable_version_47, true);
SetQuicReloadableFlag(quic_enable_version_99, false);
ParsedQuicVersionVector parsed_versions;
@@ -326,6 +328,7 @@
TEST_F(QuicVersionsTest, FilterSupportedTransportVersionsNo47) {
QuicTransportVersionVector all_versions = AllSupportedTransportVersions();
SetQuicReloadableFlag(quic_disable_version_39, false);
+ SetQuicReloadableFlag(quic_disable_version_44, false);
SetQuicReloadableFlag(quic_enable_version_47, false);
SetQuicReloadableFlag(quic_enable_version_99, false);
ParsedQuicVersionVector parsed_versions;
@@ -344,9 +347,32 @@
ASSERT_EQ(expected_parsed_versions, FilterSupportedVersions(parsed_versions));
}
+TEST_F(QuicVersionsTest, FilterSupportedTransportVersionsNo44) {
+ QuicTransportVersionVector all_versions = AllSupportedTransportVersions();
+ SetQuicReloadableFlag(quic_disable_version_39, false);
+ SetQuicReloadableFlag(quic_disable_version_44, true);
+ SetQuicReloadableFlag(quic_enable_version_47, false);
+ SetQuicReloadableFlag(quic_enable_version_99, false);
+ ParsedQuicVersionVector parsed_versions;
+ for (QuicTransportVersion version : all_versions) {
+ parsed_versions.push_back(ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, version));
+ }
+ QuicTransportVersionVector expected_versions = {
+ QUIC_VERSION_46, QUIC_VERSION_43, QUIC_VERSION_39};
+ ParsedQuicVersionVector expected_parsed_versions;
+ for (QuicTransportVersion version : expected_versions) {
+ expected_parsed_versions.push_back(
+ ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, version));
+ }
+
+ ASSERT_EQ(expected_versions, FilterSupportedTransportVersions(all_versions));
+ ASSERT_EQ(expected_parsed_versions, FilterSupportedVersions(parsed_versions));
+}
+
TEST_F(QuicVersionsTest, FilterSupportedTransportVersionsNo39) {
QuicTransportVersionVector all_versions = AllSupportedTransportVersions();
SetQuicReloadableFlag(quic_disable_version_39, true);
+ SetQuicReloadableFlag(quic_disable_version_44, false);
SetQuicReloadableFlag(quic_enable_version_47, false);
SetQuicReloadableFlag(quic_enable_version_99, false);
ParsedQuicVersionVector parsed_versions;
@@ -462,6 +488,7 @@
ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_99);
SetQuicFlag(FLAGS_quic_supports_tls_handshake, false);
SetQuicReloadableFlag(quic_disable_version_39, false);
+ SetQuicReloadableFlag(quic_disable_version_44, false);
SetQuicReloadableFlag(quic_enable_version_47, false);
SetQuicReloadableFlag(quic_enable_version_99, false);
