diff --git a/quic/core/chlo_extractor.cc b/quic/core/chlo_extractor.cc
index 15a118b..355ecd7 100644
--- a/quic/core/chlo_extractor.cc
+++ b/quic/core/chlo_extractor.cc
@@ -125,7 +125,7 @@
 }
 void ChloFramerVisitor::OnCoalescedPacket(const QuicEncryptedPacket& packet) {}
 bool ChloFramerVisitor::OnStreamFrame(const QuicStreamFrame& frame) {
-  if (framer_->transport_version() >= QUIC_VERSION_47) {
+  if (QuicVersionUsesCryptoFrames(framer_->transport_version())) {
     // CHLO will be sent in CRYPTO frames in v47 and above.
     return false;
   }
@@ -139,7 +139,7 @@
 }
 
 bool ChloFramerVisitor::OnCryptoFrame(const QuicCryptoFrame& frame) {
-  if (framer_->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(framer_->transport_version())) {
     // CHLO will be in stream frames before v47.
     return false;
   }
diff --git a/quic/core/chlo_extractor_test.cc b/quic/core/chlo_extractor_test.cc
index cb5fd59..57be311 100644
--- a/quic/core/chlo_extractor_test.cc
+++ b/quic/core/chlo_extractor_test.cc
@@ -70,7 +70,8 @@
     }
     QuicFramer framer(SupportedVersions(header_.version), QuicTime::Zero(),
                       Perspective::IS_CLIENT, kQuicDefaultConnectionIdLength);
-    if (version.transport_version < QUIC_VERSION_47 || munge_stream_id) {
+    if (!QuicVersionUsesCryptoFrames(version.transport_version) ||
+        munge_stream_id) {
       QuicStreamId stream_id =
           QuicUtils::GetCryptoStreamId(version.transport_version);
       if (munge_stream_id) {
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index d439e95..61b6834 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -148,7 +148,7 @@
   ParsedQuicVersionVector version_buckets[3];
 
   for (const ParsedQuicVersion& version : all_supported_versions) {
-    if (version.transport_version < QUIC_VERSION_47) {
+    if (!QuicVersionUsesCryptoFrames(version.transport_version)) {
       version_buckets[0].push_back(version);
     } else if (version.handshake_protocol == PROTOCOL_QUIC_CRYPTO) {
       version_buckets[1].push_back(version);
@@ -2023,8 +2023,10 @@
       client_->client()->client_session());
   // In v47 and later, the crypto handshake (sent in CRYPTO frames) is not
   // subject to flow control.
-  if (client_->client()->client_session()->connection()->transport_version() <
-      QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(client_->client()
+                                       ->client_session()
+                                       ->connection()
+                                       ->transport_version())) {
     EXPECT_LT(QuicFlowControllerPeer::SendWindowSize(
                   crypto_stream->flow_controller()),
               kStreamIFCW);
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 1087493..a6dc96b 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -1109,7 +1109,7 @@
 
 TEST_P(QuicSpdySessionTestServer,
        HandshakeUnblocksFlowControlBlockedCryptoStream) {
-  if (GetParam().transport_version >= QUIC_VERSION_47) {
+  if (QuicVersionUsesCryptoFrames(GetParam().transport_version)) {
     // QUIC version 47 onwards uses CRYPTO frames for the handshake, so this
     // test doesn't make sense for those versions.
     return;
@@ -1664,13 +1664,13 @@
 
   // Lost data on cryption stream, streams 2 and 4.
   EXPECT_CALL(*stream4, HasPendingRetransmission()).WillOnce(Return(true));
-  if (connection_->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     EXPECT_CALL(*crypto_stream, HasPendingRetransmission())
         .WillOnce(Return(true));
   }
   EXPECT_CALL(*stream2, HasPendingRetransmission()).WillOnce(Return(true));
   session_.OnFrameLost(QuicFrame(frame3));
-  if (connection_->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     session_.OnFrameLost(QuicFrame(frame1));
   } else {
     QuicCryptoFrame crypto_frame(ENCRYPTION_NONE, 0, 1300);
@@ -1687,7 +1687,7 @@
   // stream go first.
   // Do not check congestion window when crypto stream has lost data.
   EXPECT_CALL(*send_algorithm, CanSend(_)).Times(0);
-  if (connection_->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     EXPECT_CALL(*crypto_stream, OnCanWrite());
     EXPECT_CALL(*crypto_stream, HasPendingRetransmission())
         .WillOnce(Return(false));
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index f991355..afa9512 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -645,7 +645,7 @@
   QuicConsumedData SendCryptoStreamData() {
     QuicStreamOffset offset = 0;
     QuicStringPiece data("chlo");
-    if (transport_version() < QUIC_VERSION_47) {
+    if (!QuicVersionUsesCryptoFrames(transport_version())) {
       return SendStreamDataWithString(
           QuicUtils::GetCryptoStreamId(transport_version()), data, offset,
           NO_FIN);
@@ -2676,7 +2676,7 @@
   // Parse the last packet and ensure it's the crypto stream frame.
   EXPECT_EQ(2u, writer_->frame_count());
   ASSERT_EQ(1u, writer_->padding_frames().size());
-  if (connection_.transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(connection_.transport_version())) {
     ASSERT_EQ(1u, writer_->stream_frames().size());
     EXPECT_EQ(QuicUtils::GetCryptoStreamId(connection_.transport_version()),
               writer_->stream_frames()[0]->stream_id);
@@ -5913,7 +5913,7 @@
     EXPECT_EQ(4u, writer_->frame_count());
     EXPECT_FALSE(writer_->stop_waiting_frames().empty());
   }
-  if (connection_.transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(connection_.transport_version())) {
     EXPECT_EQ(1u, writer_->stream_frames().size());
   } else {
     EXPECT_EQ(1u, writer_->crypto_frames().size());
@@ -5946,7 +5946,7 @@
     EXPECT_EQ(4u, writer_->frame_count());
     EXPECT_FALSE(writer_->stop_waiting_frames().empty());
   }
-  if (connection_.transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(connection_.transport_version())) {
     EXPECT_EQ(1u, writer_->stream_frames().size());
   } else {
     EXPECT_EQ(1u, writer_->crypto_frames().size());
diff --git a/quic/core/quic_crypto_server_handshaker.cc b/quic/core/quic_crypto_server_handshaker.cc
index fb24fed..0d16354 100644
--- a/quic/core/quic_crypto_server_handshaker.cc
+++ b/quic/core/quic_crypto_server_handshaker.cc
@@ -310,7 +310,7 @@
 
   QUIC_DVLOG(1) << "Server: Sending server config update: "
                 << message.DebugString();
-  if (transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(transport_version())) {
     const QuicData& data = message.GetSerialized();
     stream_->WriteOrBufferData(QuicStringPiece(data.data(), data.length()),
                                false, nullptr);
diff --git a/quic/core/quic_crypto_stream.cc b/quic/core/quic_crypto_stream.cc
index 6a941e7..c09f08a 100644
--- a/quic/core/quic_crypto_stream.cc
+++ b/quic/core/quic_crypto_stream.cc
@@ -54,14 +54,16 @@
 }
 
 void QuicCryptoStream::OnCryptoFrame(const QuicCryptoFrame& frame) {
-  QUIC_BUG_IF(session()->connection()->transport_version() < QUIC_VERSION_47)
+  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(
+      session()->connection()->transport_version()))
       << "Versions less than 47 shouldn't receive CRYPTO frames";
   EncryptionLevel level = session()->connection()->last_decrypted_level();
   substreams_[level].sequencer.OnCryptoFrame(frame);
 }
 
 void QuicCryptoStream::OnStreamFrame(const QuicStreamFrame& frame) {
-  if (session()->connection()->transport_version() >= QUIC_VERSION_47) {
+  if (QuicVersionUsesCryptoFrames(
+          session()->connection()->transport_version())) {
     QUIC_PEER_BUG
         << "Crypto data received in stream frame instead of crypto frame";
     CloseConnectionWithDetails(QUIC_INVALID_STREAM_DATA,
@@ -72,7 +74,8 @@
 
 void QuicCryptoStream::OnDataAvailable() {
   EncryptionLevel level = session()->connection()->last_decrypted_level();
-  if (session()->connection()->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(
+          session()->connection()->transport_version())) {
     // Versions less than 47 only support QUIC crypto, which ignores the
     // EncryptionLevel passed into CryptoMessageParser::ProcessInput (and
     // OnDataAvailableInSequencer).
@@ -120,7 +123,8 @@
 
 void QuicCryptoStream::WriteCryptoData(EncryptionLevel level,
                                        QuicStringPiece data) {
-  if (session()->connection()->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(
+          session()->connection()->transport_version())) {
     // The QUIC crypto handshake takes care of setting the appropriate
     // encryption level before writing data. Since that is the only handshake
     // supported in versions less than 47, |level| can be ignored here.
@@ -170,7 +174,8 @@
 }
 
 void QuicCryptoStream::NeuterUnencryptedStreamData() {
-  if (session()->connection()->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(
+          session()->connection()->transport_version())) {
     for (const auto& interval : bytes_consumed_[ENCRYPTION_NONE]) {
       QuicByteCount newly_acked_length = 0;
       send_buffer().OnStreamDataAcked(
@@ -191,7 +196,8 @@
 }
 
 void QuicCryptoStream::OnStreamDataConsumed(size_t bytes_consumed) {
-  if (session()->connection()->transport_version() >= QUIC_VERSION_47) {
+  if (QuicVersionUsesCryptoFrames(
+          session()->connection()->transport_version())) {
     QUIC_BUG << "Stream data consumed when CRYPTO frames should be in use";
   }
   if (bytes_consumed > 0) {
@@ -202,7 +208,8 @@
 }
 
 bool QuicCryptoStream::HasPendingCryptoRetransmission() {
-  if (session()->connection()->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(
+          session()->connection()->transport_version())) {
     return false;
   }
   for (EncryptionLevel level :
@@ -215,7 +222,8 @@
 }
 
 void QuicCryptoStream::WritePendingCryptoRetransmission() {
-  QUIC_BUG_IF(session()->connection()->transport_version() < QUIC_VERSION_47)
+  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(
+      session()->connection()->transport_version()))
       << "Versions less than 47 don't write CRYPTO frames";
   EncryptionLevel current_encryption_level =
       session()->connection()->encryption_level();
@@ -323,7 +331,8 @@
 }
 
 uint64_t QuicCryptoStream::crypto_bytes_read() const {
-  if (session()->connection()->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(
+          session()->connection()->transport_version())) {
     return stream_bytes_read();
   }
   return substreams_[ENCRYPTION_NONE].sequencer.NumBytesConsumed() +
@@ -339,21 +348,24 @@
                                         QuicStreamOffset offset,
                                         QuicByteCount data_length,
                                         QuicDataWriter* writer) {
-  QUIC_BUG_IF(session()->connection()->transport_version() < QUIC_VERSION_47)
+  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(
+      session()->connection()->transport_version()))
       << "Versions less than 47 don't write CRYPTO frames (2)";
   return substreams_[level].send_buffer.WriteStreamData(offset, data_length,
                                                         writer);
 }
 
 void QuicCryptoStream::OnCryptoFrameLost(QuicCryptoFrame* crypto_frame) {
-  QUIC_BUG_IF(session()->connection()->transport_version() < QUIC_VERSION_47)
+  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(
+      session()->connection()->transport_version()))
       << "Versions less than 47 don't lose CRYPTO frames";
   substreams_[crypto_frame->level].send_buffer.OnStreamDataLost(
       crypto_frame->offset, crypto_frame->data_length);
 }
 
 void QuicCryptoStream::RetransmitData(QuicCryptoFrame* crypto_frame) {
-  QUIC_BUG_IF(session()->connection()->transport_version() < QUIC_VERSION_47)
+  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(
+      session()->connection()->transport_version()))
       << "Versions less than 47 don't retransmit CRYPTO frames";
   QuicIntervalSet<QuicStreamOffset> retransmission(
       crypto_frame->offset, crypto_frame->offset + crypto_frame->data_length);
@@ -380,7 +392,8 @@
 bool QuicCryptoStream::IsFrameOutstanding(EncryptionLevel level,
                                           size_t offset,
                                           size_t length) const {
-  if (session()->connection()->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(
+          session()->connection()->transport_version())) {
     // This only happens if a client was originally configured for a version
     // greater than 45, but received a version negotiation packet and is
     // attempting to retransmit for a version less than 47. Outside of tests,
@@ -393,7 +406,8 @@
 }
 
 bool QuicCryptoStream::IsWaitingForAcks() const {
-  if (session()->connection()->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(
+          session()->connection()->transport_version())) {
     return QuicStream::IsWaitingForAcks();
   }
   for (EncryptionLevel level :
diff --git a/quic/core/quic_crypto_stream_test.cc b/quic/core/quic_crypto_stream_test.cc
index 263910b..a33b986 100644
--- a/quic/core/quic_crypto_stream_test.cc
+++ b/quic/core/quic_crypto_stream_test.cc
@@ -100,7 +100,7 @@
 }
 
 TEST_F(QuicCryptoStreamTest, ProcessRawData) {
-  if (connection_->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     stream_->OnStreamFrame(QuicStreamFrame(
         QuicUtils::GetCryptoStreamId(connection_->transport_version()),
         /*fin=*/false,
@@ -127,7 +127,7 @@
 
   EXPECT_CALL(*connection_, CloseConnection(QUIC_CRYPTO_TAGS_OUT_OF_ORDER,
                                             testing::_, testing::_));
-  if (connection_->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     stream_->OnStreamFrame(QuicStreamFrame(
         QuicUtils::GetCryptoStreamId(connection_->transport_version()),
         /*fin=*/false, /*offset=*/0, bad));
@@ -142,7 +142,7 @@
 }
 
 TEST_F(QuicCryptoStreamTest, RetransmitCryptoData) {
-  if (connection_->transport_version() >= QUIC_VERSION_47) {
+  if (QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     return;
   }
   InSequence s;
@@ -201,7 +201,7 @@
 }
 
 TEST_F(QuicCryptoStreamTest, RetransmitCryptoDataInCryptoFrames) {
-  if (connection_->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     return;
   }
   EXPECT_CALL(*connection_, SendCryptoData(_, _, _)).Times(0);
@@ -253,7 +253,7 @@
 }
 
 TEST_F(QuicCryptoStreamTest, NeuterUnencryptedStreamData) {
-  if (connection_->transport_version() >= QUIC_VERSION_47) {
+  if (QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     return;
   }
   // Send [0, 1350) in ENCRYPTION_NONE.
@@ -295,7 +295,7 @@
 }
 
 TEST_F(QuicCryptoStreamTest, NeuterUnencryptedCryptoData) {
-  if (connection_->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     return;
   }
   // Send [0, 1350) in ENCRYPTION_NONE.
@@ -338,7 +338,7 @@
 }
 
 TEST_F(QuicCryptoStreamTest, RetransmitStreamData) {
-  if (connection_->transport_version() >= QUIC_VERSION_47) {
+  if (QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     return;
   }
   InSequence s;
@@ -411,7 +411,7 @@
 }
 
 TEST_F(QuicCryptoStreamTest, RetransmitStreamDataWithCryptoFrames) {
-  if (connection_->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     return;
   }
   InSequence s;
@@ -470,7 +470,7 @@
 
 // Regression test for b/115926584.
 TEST_F(QuicCryptoStreamTest, HasUnackedCryptoData) {
-  if (connection_->transport_version() >= QUIC_VERSION_47) {
+  if (QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     return;
   }
   std::string data(1350, 'a');
@@ -499,7 +499,7 @@
 }
 
 TEST_F(QuicCryptoStreamTest, HasUnackedCryptoDataWithCryptoFrames) {
-  if (connection_->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     return;
   }
   // Send [0, 1350) in ENCRYPTION_NONE.
diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc
index ce95320..c6b1c09 100644
--- a/quic/core/quic_dispatcher.cc
+++ b/quic/core/quic_dispatcher.cc
@@ -161,7 +161,7 @@
     collector_.SaveStatelessRejectFrameData(reject);
     while (offset < reject.length()) {
       QuicFrame frame;
-      if (framer_->transport_version() < QUIC_VERSION_47) {
+      if (!QuicVersionUsesCryptoFrames(framer_->transport_version())) {
         if (!creator_.ConsumeData(
                 QuicUtils::GetCryptoStreamId(framer_->transport_version()),
                 reject.length(), offset, offset,
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index c744505..1e7fb51 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -373,7 +373,8 @@
 };
 
 TEST_F(QuicDispatcherTest, TlsClientHelloCreatesSession) {
-  if (CurrentSupportedVersions().front().transport_version < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(
+          CurrentSupportedVersions().front().transport_version)) {
     // TLS is only supported in versions 47 and greater.
     return;
   }
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 32d50c5..6505cb0 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -1043,7 +1043,7 @@
         }
         break;
       case CRYPTO_FRAME:
-        if (version_.transport_version < QUIC_VERSION_47) {
+        if (!QuicVersionUsesCryptoFrames(version_.transport_version)) {
           set_detailed_error(
               "Attempt to append CRYPTO frame in version prior to 47.");
           return RaiseError(QUIC_INTERNAL_ERROR);
@@ -2804,7 +2804,7 @@
         break;
       }
       case CRYPTO_FRAME: {
-        if (version_.transport_version < QUIC_VERSION_47) {
+        if (!QuicVersionUsesCryptoFrames(version_.transport_version)) {
           set_detailed_error("Illegal frame type.");
           return RaiseError(QUIC_INVALID_FRAME_DATA);
         }
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index c848c0a..4d2a179 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -9640,7 +9640,7 @@
   EXPECT_CALL(visitor, OnDecryptedPacket(_)).Times(1);
   EXPECT_CALL(visitor, OnError(_)).Times(0);
   EXPECT_CALL(visitor, OnStreamFrame(_)).Times(0);
-  if (framer_.version().transport_version < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(framer_.version().transport_version)) {
     EXPECT_CALL(visitor, OnStreamFrame(Truly(ExpectedStreamFrame))).Times(1);
   } else {
     EXPECT_CALL(visitor, OnCryptoFrame(_)).Times(1);
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 151fa18..98e4f4e 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -1517,7 +1517,8 @@
   QuicConnection::ScopedPacketFlusher retransmission_flusher(
       connection_, QuicConnection::SEND_ACK_IF_QUEUED);
   // Retransmit crypto data first.
-  bool uses_crypto_frames = connection_->transport_version() >= QUIC_VERSION_47;
+  bool uses_crypto_frames =
+      QuicVersionUsesCryptoFrames(connection_->transport_version());
   QuicCryptoStream* crypto_stream = GetMutableCryptoStream();
   if (uses_crypto_frames && crypto_stream->HasPendingCryptoRetransmission()) {
     SetTransmissionType(HANDSHAKE_RETRANSMISSION);
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index fba914f..6c516c6 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -1240,7 +1240,7 @@
 }
 
 TEST_P(QuicSessionTestServer, HandshakeUnblocksFlowControlBlockedCryptoStream) {
-  if (GetParam().transport_version >= QUIC_VERSION_47) {
+  if (QuicVersionUsesCryptoFrames(GetParam().transport_version)) {
     // QUIC version 47 onwards uses CRYPTO frames for the handshake, so this
     // test doesn't make sense for those versions since CRYPTO frames aren't
     // flow controlled.
@@ -1809,13 +1809,13 @@
 
   // Lost data on cryption stream, streams 2 and 4.
   EXPECT_CALL(*stream4, HasPendingRetransmission()).WillOnce(Return(true));
-  if (connection_->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     EXPECT_CALL(*crypto_stream, HasPendingRetransmission())
         .WillOnce(Return(true));
   }
   EXPECT_CALL(*stream2, HasPendingRetransmission()).WillOnce(Return(true));
   session_.OnFrameLost(QuicFrame(frame3));
-  if (connection_->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     session_.OnFrameLost(QuicFrame(frame1));
   } else {
     QuicCryptoFrame crypto_frame(ENCRYPTION_NONE, 0, 1300);
@@ -1832,7 +1832,7 @@
   // stream go first.
   // Do not check congestion window when crypto stream has lost data.
   EXPECT_CALL(*send_algorithm, CanSend(_)).Times(0);
-  if (connection_->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     EXPECT_CALL(*crypto_stream, OnCanWrite());
     EXPECT_CALL(*crypto_stream, HasPendingRetransmission())
         .WillOnce(Return(false));
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc
index 10854bf..0ec92ac 100644
--- a/quic/core/quic_utils.cc
+++ b/quic/core/quic_utils.cc
@@ -317,7 +317,7 @@
 // static
 bool QuicUtils::IsHandshakeFrame(const QuicFrame& frame,
                                  QuicTransportVersion transport_version) {
-  if (transport_version < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(transport_version)) {
     return frame.type == STREAM_FRAME &&
            frame.stream_frame.stream_id == GetCryptoStreamId(transport_version);
   } else {
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index 7ea441a..df85e16 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -119,7 +119,8 @@
       continue;
     }
     for (QuicTransportVersion version : kSupportedTransportVersions) {
-      if (protocol == PROTOCOL_TLS1_3 && version < QUIC_VERSION_47) {
+      if (protocol == PROTOCOL_TLS1_3 &&
+          !QuicVersionUsesCryptoFrames(version)) {
         // The TLS handshake is only deployable if CRYPTO frames are also used,
         // which are added in v47.
         continue;
diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index 2825c9f..9682bd1 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -341,6 +341,13 @@
   return transport_version == QUIC_VERSION_99;
 }
 
+// Returns whether |transport_version| uses CRYPTO frames for the handshake
+// instead of stream 1.
+QUIC_EXPORT_PRIVATE inline bool QuicVersionUsesCryptoFrames(
+    QuicTransportVersion transport_version) {
+  return transport_version >= QUIC_VERSION_47;
+}
+
 }  // namespace quic
 
 #endif  // QUICHE_QUIC_CORE_QUIC_VERSIONS_H_
diff --git a/quic/test_tools/crypto_test_utils.cc b/quic/test_tools/crypto_test_utils.cc
index 3b13e65..1339437 100644
--- a/quic/test_tools/crypto_test_utils.cc
+++ b/quic/test_tools/crypto_test_utils.cc
@@ -509,7 +509,8 @@
                                   Perspective perspective) {
   const QuicData& data = message.GetSerialized();
   QuicSession* session = QuicStreamPeer::session(stream);
-  if (session->connection()->transport_version() < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames(
+          session->connection()->transport_version())) {
     QuicStreamFrame frame(QuicUtils::GetCryptoStreamId(
                               session->connection()->transport_version()),
                           false, stream->crypto_bytes_read(),
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index ca2d9ff..aca0a57 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -857,7 +857,7 @@
   QuicFrames frames;
   QuicFramer framer(*versions, QuicTime::Zero(), perspective,
                     kQuicDefaultConnectionIdLength);
-  if ((*versions)[0].transport_version < QUIC_VERSION_47) {
+  if (!QuicVersionUsesCryptoFrames((*versions)[0].transport_version)) {
     QuicFrame frame(QuicStreamFrame(
         QuicUtils::GetCryptoStreamId((*versions)[0].transport_version), false,
         0, QuicStringPiece(data)));
diff --git a/quic/test_tools/simple_session_notifier.cc b/quic/test_tools/simple_session_notifier.cc
index c56831e..d1ee832 100644
--- a/quic/test_tools/simple_session_notifier.cc
+++ b/quic/test_tools/simple_session_notifier.cc
@@ -386,7 +386,7 @@
 }
 
 bool SimpleSessionNotifier::HasUnackedCryptoData() const {
-  if (connection_->transport_version() >= QUIC_VERSION_47) {
+  if (QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     for (size_t i = 0; i < NUM_ENCRYPTION_LEVELS; ++i) {
       const StreamState& state = crypto_state_[i];
       if (state.bytes_total > state.bytes_sent) {