Remove unused `handshake_mode` from ParsedQuicVersion.
PiperOrigin-RevId: 841818322
diff --git a/quiche/quic/core/quic_versions.cc b/quiche/quic/core/quic_versions.cc
index 85c205d..ae883c3 100644
--- a/quiche/quic/core/quic_versions.cc
+++ b/quiche/quic/core/quic_versions.cc
@@ -60,9 +60,6 @@
} // namespace
bool ParsedQuicVersion::IsKnown() const {
- QUICHE_DCHECK(ParsedQuicVersionIsValid(handshake_protocol, transport_version))
- << QuicVersionToString(transport_version) << " "
- << HandshakeProtocolToString(handshake_protocol);
return transport_version != QUIC_VERSION_UNSUPPORTED;
}
@@ -138,8 +135,7 @@
}
QUIC_BUG(quic_bug_10589_2)
<< "Unsupported version "
- << QuicVersionToString(parsed_version.transport_version) << " "
- << HandshakeProtocolToString(parsed_version.handshake_protocol);
+ << QuicVersionToString(parsed_version.transport_version);
return 0;
}
@@ -290,9 +286,6 @@
quic_version_number <= QuicTransportVersion::QUIC_VERSION_MAX_VALUE) {
QuicTransportVersion transport_version =
static_cast<QuicTransportVersion>(quic_version_number);
- if (!ParsedQuicVersionIsValid(PROTOCOL_QUIC_CRYPTO, transport_version)) {
- return UnsupportedQuicVersion();
- }
ParsedQuicVersion version(transport_version);
if (std::find(supported_versions.begin(), supported_versions.end(),
version) != supported_versions.end()) {
diff --git a/quiche/quic/core/quic_versions.h b/quiche/quic/core/quic_versions.h
index 90fdbc8..20f7905 100644
--- a/quiche/quic/core/quic_versions.h
+++ b/quiche/quic/core/quic_versions.h
@@ -189,25 +189,8 @@
// allowed as TLS requires crypto frames which v46 does not support. Note that
// UnsupportedQuicVersion is a valid version.
QUICHE_EXPORT constexpr bool ParsedQuicVersionIsValid(
- HandshakeProtocol handshake_protocol,
QuicTransportVersion transport_version) {
- if (!TransportVersionIsValid(transport_version)) {
- return false;
- }
- switch (handshake_protocol) {
- case PROTOCOL_UNSUPPORTED:
- return transport_version == QUIC_VERSION_UNSUPPORTED;
- case PROTOCOL_QUIC_CRYPTO:
- return transport_version != QUIC_VERSION_UNSUPPORTED &&
- transport_version != QUIC_VERSION_RESERVED_FOR_NEGOTIATION &&
- transport_version != QUIC_VERSION_IETF_DRAFT_29 &&
- transport_version != QUIC_VERSION_IETF_RFC_V1 &&
- transport_version != QUIC_VERSION_IETF_RFC_V2;
- case PROTOCOL_TLS1_3:
- return transport_version != QUIC_VERSION_UNSUPPORTED &&
- VersionIsIetfQuic(transport_version);
- }
- return false;
+ return TransportVersionIsValid(transport_version);
}
QUICHE_EXPORT constexpr HandshakeProtocol HandshakeProtocolForTransportVersion(
@@ -224,43 +207,23 @@
// A parsed QUIC version label which determines that handshake protocol
// and the transport version.
struct QUICHE_EXPORT ParsedQuicVersion {
- HandshakeProtocol handshake_protocol;
QuicTransportVersion transport_version;
- constexpr explicit ParsedQuicVersion(QuicTransportVersion transport_version)
- : handshake_protocol(
- HandshakeProtocolForTransportVersion(transport_version)),
- transport_version(transport_version) {
- QUICHE_DCHECK(
- ParsedQuicVersionIsValid(handshake_protocol, transport_version))
- << QuicVersionToString(transport_version) << " "
- << HandshakeProtocolToString(handshake_protocol);
- }
+ constexpr ParsedQuicVersion(QuicTransportVersion transport_version)
+ : transport_version(transport_version) {}
constexpr ParsedQuicVersion(const ParsedQuicVersion& other)
: ParsedQuicVersion(other.transport_version) {}
ParsedQuicVersion& operator=(const ParsedQuicVersion& other) {
- QUICHE_DCHECK(ParsedQuicVersionIsValid(other.handshake_protocol,
- other.transport_version))
- << QuicVersionToString(other.transport_version) << " "
- << HandshakeProtocolToString(other.handshake_protocol);
if (this != &other) {
- handshake_protocol = other.handshake_protocol;
transport_version = other.transport_version;
}
return *this;
}
- bool operator==(const ParsedQuicVersion& other) const {
- return handshake_protocol == other.handshake_protocol &&
- transport_version == other.transport_version;
- }
-
- bool operator!=(const ParsedQuicVersion& other) const {
- return handshake_protocol != other.handshake_protocol ||
- transport_version != other.transport_version;
- }
+ bool operator==(const ParsedQuicVersion& other) const = default;
+ bool operator!=(const ParsedQuicVersion& other) const = default;
static constexpr ParsedQuicVersion RFCv2() {
return ParsedQuicVersion(QUIC_VERSION_IETF_RFC_V2);
diff --git a/quiche/quic/core/quic_versions_test.cc b/quiche/quic/core/quic_versions_test.cc
index ba0c34e..ac6c847 100644
--- a/quiche/quic/core/quic_versions_test.cc
+++ b/quiche/quic/core/quic_versions_test.cc
@@ -25,36 +25,25 @@
using ::testing::IsEmpty;
TEST(QuicVersionsTest, CreateQuicVersionLabelUnsupported) {
- EXPECT_QUIC_BUG(
- CreateQuicVersionLabel(UnsupportedQuicVersion()),
- "Unsupported version QUIC_VERSION_UNSUPPORTED PROTOCOL_UNSUPPORTED");
+ EXPECT_QUIC_BUG(CreateQuicVersionLabel(UnsupportedQuicVersion()),
+ "Unsupported version QUIC_VERSION_UNSUPPORTED");
}
TEST(QuicVersionsTest, KnownAndValid) {
for (const ParsedQuicVersion& version : AllSupportedVersions()) {
EXPECT_TRUE(version.IsKnown());
- EXPECT_TRUE(ParsedQuicVersionIsValid(version.handshake_protocol,
- version.transport_version));
+ EXPECT_TRUE(ParsedQuicVersionIsValid(version.transport_version));
}
ParsedQuicVersion unsupported = UnsupportedQuicVersion();
EXPECT_FALSE(unsupported.IsKnown());
- EXPECT_TRUE(ParsedQuicVersionIsValid(unsupported.handshake_protocol,
- unsupported.transport_version));
+ EXPECT_TRUE(ParsedQuicVersionIsValid(unsupported.transport_version));
ParsedQuicVersion reserved = QuicVersionReservedForNegotiation();
EXPECT_TRUE(reserved.IsKnown());
- EXPECT_TRUE(ParsedQuicVersionIsValid(reserved.handshake_protocol,
- reserved.transport_version));
- // Check that invalid combinations are not valid.
- EXPECT_FALSE(ParsedQuicVersionIsValid(PROTOCOL_TLS1_3, QUIC_VERSION_46));
- EXPECT_FALSE(ParsedQuicVersionIsValid(PROTOCOL_QUIC_CRYPTO,
- QUIC_VERSION_IETF_DRAFT_29));
+ EXPECT_TRUE(ParsedQuicVersionIsValid(reserved.transport_version));
// Check that deprecated versions are not valid.
- EXPECT_FALSE(ParsedQuicVersionIsValid(PROTOCOL_QUIC_CRYPTO,
- static_cast<QuicTransportVersion>(33)));
- EXPECT_FALSE(ParsedQuicVersionIsValid(PROTOCOL_QUIC_CRYPTO,
- static_cast<QuicTransportVersion>(99)));
- EXPECT_FALSE(ParsedQuicVersionIsValid(PROTOCOL_TLS1_3,
- static_cast<QuicTransportVersion>(99)));
+ EXPECT_FALSE(ParsedQuicVersionIsValid(static_cast<QuicTransportVersion>(33)));
+ EXPECT_FALSE(ParsedQuicVersionIsValid(static_cast<QuicTransportVersion>(43)));
+ EXPECT_FALSE(ParsedQuicVersionIsValid(static_cast<QuicTransportVersion>(99)));
}
TEST(QuicVersionsTest, Features) {
@@ -420,18 +409,17 @@
TEST(QuicVersionsTest, SupportedVersionsHasCorrectList) {
size_t index = 0;
- for (HandshakeProtocol handshake_protocol : SupportedHandshakeProtocols()) {
- for (int trans_vers = 255; trans_vers > 0; trans_vers--) {
- QuicTransportVersion transport_version =
- static_cast<QuicTransportVersion>(trans_vers);
- SCOPED_TRACE(index);
- if (ParsedQuicVersionIsValid(handshake_protocol, transport_version)) {
- ParsedQuicVersion version = SupportedVersions()[index];
- EXPECT_EQ(version, ParsedQuicVersion(transport_version));
- index++;
- }
+ for (int trans_vers = 255; trans_vers > 0; trans_vers--) {
+ QuicTransportVersion transport_version =
+ static_cast<QuicTransportVersion>(trans_vers);
+ SCOPED_TRACE(index);
+ if (ParsedQuicVersionIsValid(transport_version)) {
+ ParsedQuicVersion version = SupportedVersions()[index];
+ EXPECT_EQ(version, ParsedQuicVersion(transport_version));
+ index++;
}
}
+
EXPECT_EQ(SupportedVersions().size(), index);
}
