Remove unused `handshake_mode` from ParsedQuicVersion.

PiperOrigin-RevId: 841818322

quiche/quic/core/quic_versions.cc

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()) {

quiche/quic/core/quic_versions.h

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);

quiche/quic/core/quic_versions_test.cc

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);
 }