Add ParsedQuicVersion::UsesTls and UsesQuicCrypto

These convenience methods will make it easier to check
which handshake protocol is in use.

gfe-relnote: n/a, unused code
PiperOrigin-RevId: 308299975
Change-Id: I28789e8ad69ccd652dcf7351b8c61808d04cd6b0

quic/core/quic_versions.cc

diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index 2bf7c3c..bf93e83 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -158,6 +158,16 @@
   return transport_version >= QUIC_VERSION_IETF_DRAFT_27;
 }
 
+bool ParsedQuicVersion::UsesTls() const {
+  DCHECK(IsKnown());
+  return handshake_protocol == PROTOCOL_TLS1_3;
+}
+
+bool ParsedQuicVersion::UsesQuicCrypto() const {
+  DCHECK(IsKnown());
+  return handshake_protocol == PROTOCOL_QUIC_CRYPTO;
+}
+
 bool VersionHasLengthPrefixedConnectionIds(
     QuicTransportVersion transport_version) {
   DCHECK(transport_version != QUIC_VERSION_UNSUPPORTED);

quic/core/quic_versions.h

diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index f861f19..5f3a968 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -330,6 +330,12 @@
   // Returns true if this version uses variable-length integers when
   // encoding transport parameter types and lengths.
   bool HasVarIntTransportParams() const;
+
+  // Returns whether this version uses PROTOCOL_TLS1_3.
+  bool UsesTls() const;
+
+  // Returns whether this version uses PROTOCOL_QUIC_CRYPTO.
+  bool UsesQuicCrypto() const;
 };
 
 QUIC_EXPORT_PRIVATE ParsedQuicVersion UnsupportedQuicVersion();

quic/core/quic_versions_test.cc

diff --git a/quic/core/quic_versions_test.cc b/quic/core/quic_versions_test.cc
index 30a7f28..3a07221 100644
--- a/quic/core/quic_versions_test.cc
+++ b/quic/core/quic_versions_test.cc
@@ -83,6 +83,65 @@
                                         static_cast<QuicTransportVersion>(99)));
 }
 
+TEST_F(QuicVersionsTest, Features) {
+  ParsedQuicVersion parsed_version_q043 =
+      ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_43);
+  ParsedQuicVersion parsed_version_draft_27 =
+      ParsedQuicVersion(PROTOCOL_TLS1_3, QUIC_VERSION_IETF_DRAFT_27);
+
+  EXPECT_TRUE(parsed_version_q043.IsKnown());
+  EXPECT_FALSE(parsed_version_q043.KnowsWhichDecrypterToUse());
+  EXPECT_FALSE(parsed_version_q043.UsesInitialObfuscators());
+  EXPECT_FALSE(parsed_version_q043.AllowsLowFlowControlLimits());
+  EXPECT_FALSE(parsed_version_q043.HasHeaderProtection());
+  EXPECT_FALSE(parsed_version_q043.SupportsRetry());
+  EXPECT_FALSE(parsed_version_q043.HasRetryIntegrityTag());
+  EXPECT_FALSE(
+      parsed_version_q043.SendsVariableLengthPacketNumberInLongHeader());
+  EXPECT_FALSE(parsed_version_q043.AllowsVariableLengthConnectionIds());
+  EXPECT_FALSE(parsed_version_q043.SupportsClientConnectionIds());
+  EXPECT_FALSE(parsed_version_q043.HasLengthPrefixedConnectionIds());
+  EXPECT_FALSE(parsed_version_q043.SupportsAntiAmplificationLimit());
+  EXPECT_FALSE(parsed_version_q043.CanSendCoalescedPackets());
+  EXPECT_TRUE(parsed_version_q043.SupportsGoogleAltSvcFormat());
+  EXPECT_FALSE(parsed_version_q043.HasIetfInvariantHeader());
+  EXPECT_FALSE(parsed_version_q043.SupportsMessageFrames());
+  EXPECT_FALSE(parsed_version_q043.UsesHttp3());
+  EXPECT_FALSE(parsed_version_q043.HasLongHeaderLengths());
+  EXPECT_FALSE(parsed_version_q043.UsesCryptoFrames());
+  EXPECT_FALSE(parsed_version_q043.HasIetfQuicFrames());
+  EXPECT_FALSE(parsed_version_q043.HasHandshakeDone());
+  EXPECT_FALSE(parsed_version_q043.HasVarIntTransportParams());
+  EXPECT_FALSE(parsed_version_q043.UsesTls());
+  EXPECT_TRUE(parsed_version_q043.UsesQuicCrypto());
+
+  EXPECT_TRUE(parsed_version_draft_27.IsKnown());
+  EXPECT_TRUE(parsed_version_draft_27.KnowsWhichDecrypterToUse());
+  EXPECT_TRUE(parsed_version_draft_27.UsesInitialObfuscators());
+  EXPECT_TRUE(parsed_version_draft_27.AllowsLowFlowControlLimits());
+  EXPECT_TRUE(parsed_version_draft_27.HasHeaderProtection());
+  EXPECT_TRUE(parsed_version_draft_27.SupportsRetry());
+  EXPECT_TRUE(parsed_version_draft_27.HasRetryIntegrityTag());
+  EXPECT_TRUE(
+      parsed_version_draft_27.SendsVariableLengthPacketNumberInLongHeader());
+  EXPECT_TRUE(parsed_version_draft_27.AllowsVariableLengthConnectionIds());
+  EXPECT_TRUE(parsed_version_draft_27.SupportsClientConnectionIds());
+  EXPECT_TRUE(parsed_version_draft_27.HasLengthPrefixedConnectionIds());
+  EXPECT_TRUE(parsed_version_draft_27.SupportsAntiAmplificationLimit());
+  EXPECT_TRUE(parsed_version_draft_27.CanSendCoalescedPackets());
+  EXPECT_FALSE(parsed_version_draft_27.SupportsGoogleAltSvcFormat());
+  EXPECT_TRUE(parsed_version_draft_27.HasIetfInvariantHeader());
+  EXPECT_TRUE(parsed_version_draft_27.SupportsMessageFrames());
+  EXPECT_TRUE(parsed_version_draft_27.UsesHttp3());
+  EXPECT_TRUE(parsed_version_draft_27.HasLongHeaderLengths());
+  EXPECT_TRUE(parsed_version_draft_27.UsesCryptoFrames());
+  EXPECT_TRUE(parsed_version_draft_27.HasIetfQuicFrames());
+  EXPECT_TRUE(parsed_version_draft_27.HasHandshakeDone());
+  EXPECT_TRUE(parsed_version_draft_27.HasVarIntTransportParams());
+  EXPECT_TRUE(parsed_version_draft_27.UsesTls());
+  EXPECT_FALSE(parsed_version_draft_27.UsesQuicCrypto());
+}
+
 TEST_F(QuicVersionsTest, QuicVersionLabelToQuicTransportVersion) {
   // If you add a new version to the QuicTransportVersion enum you will need to
   // add a new case to QuicVersionLabelToQuicTransportVersion, otherwise this