diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 01213d9..fa60c96 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -1473,8 +1473,9 @@
   server_config_.SetMaxIncomingBidirectionalStreamsToSend(
       kServerMaxIncomingDynamicStreams);
   ASSERT_TRUE(Initialize());
-  if (GetParam().negotiated_version.transport_version == QUIC_VERSION_99) {
-    // Do not run this test for version 99/IETF QUIC. Note that the test needs
+  if (VersionHasIetfQuicFrames(
+          GetParam().negotiated_version.transport_version)) {
+    // Do not run this test for /IETF QUIC. Note that the test needs
     // to be here, after calling Initialize(), because all tests end up calling
     // EndToEndTest::TearDown(), which asserts that Initialize has been called
     // and then proceeds to tear things down -- which fails if they are not
@@ -1532,7 +1533,8 @@
   // returned by max_allowed... by 2 to remove the static streams from the
   // count.
   size_t client_max_open_outgoing_bidirectional_streams =
-      client_session->connection()->transport_version() == QUIC_VERSION_99
+      VersionHasIetfQuicFrames(
+          client_session->connection()->transport_version())
           ? QuicSessionPeer::v99_streamid_manager(client_session)
                     ->max_allowed_outgoing_bidirectional_streams() -
                 QuicSessionPeer::v99_bidirectional_stream_id_manager(
@@ -1541,7 +1543,8 @@
           : QuicSessionPeer::GetStreamIdManager(client_session)
                 ->max_open_outgoing_streams();
   size_t client_max_open_outgoing_unidirectional_streams =
-      client_session->connection()->transport_version() == QUIC_VERSION_99
+      VersionHasIetfQuicFrames(
+          client_session->connection()->transport_version())
           ? QuicSessionPeer::v99_streamid_manager(client_session)
                     ->max_allowed_outgoing_unidirectional_streams() -
                 QuicSessionPeer::v99_unidirectional_stream_id_manager(
@@ -1556,13 +1559,15 @@
   server_thread_->Pause();
   QuicSession* server_session = GetServerSession();
   size_t server_max_open_outgoing_bidirectional_streams =
-      server_session->connection()->transport_version() == QUIC_VERSION_99
+      VersionHasIetfQuicFrames(
+          server_session->connection()->transport_version())
           ? QuicSessionPeer::v99_streamid_manager(server_session)
                 ->max_allowed_outgoing_bidirectional_streams()
           : QuicSessionPeer::GetStreamIdManager(server_session)
                 ->max_open_outgoing_streams();
   size_t server_max_open_outgoing_unidirectional_streams =
-      server_session->connection()->transport_version() == QUIC_VERSION_99
+      VersionHasIetfQuicFrames(
+          server_session->connection()->transport_version())
           ? QuicSessionPeer::v99_streamid_manager(server_session)
                     ->max_allowed_outgoing_unidirectional_streams() -
                 QuicSessionPeer::v99_unidirectional_stream_id_manager(
@@ -3765,7 +3770,7 @@
 TEST_P(EndToEndTest, SimpleStopSendingTest) {
   const uint16_t kStopSendingTestCode = 123;
   ASSERT_TRUE(Initialize());
-  if (negotiated_version_.transport_version != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(negotiated_version_.transport_version)) {
     return;
   }
   QuicSession* client_session = client_->client()->client_session();
@@ -3959,7 +3964,7 @@
 TEST_P(EndToEndTest, TooBigStreamIdClosesConnection) {
   // Has to be before version test, see EndToEndTest::TearDown()
   ASSERT_TRUE(Initialize());
-  if (negotiated_version_.transport_version != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(negotiated_version_.transport_version)) {
     // Only runs for IETF QUIC.
     return;
   }
diff --git a/quic/core/http/quic_server_session_base.cc b/quic/core/http/quic_server_session_base.cc
index 683793d..8670e29 100644
--- a/quic/core/http/quic_server_session_base.cc
+++ b/quic/core/http/quic_server_session_base.cc
@@ -224,7 +224,7 @@
   }
 
   if (!GetQuicReloadableFlag(quic_use_common_stream_check) &&
-      connection()->transport_version() != QUIC_VERSION_99) {
+      !VersionHasIetfQuicFrames(connection()->transport_version())) {
     if (GetNumOpenOutgoingStreams() >=
         stream_id_manager().max_open_outgoing_streams()) {
       QUIC_VLOG(1) << "No more streams should be created. "
@@ -248,7 +248,7 @@
   }
 
   if (!GetQuicReloadableFlag(quic_use_common_stream_check) &&
-      connection()->transport_version() != QUIC_VERSION_99) {
+      !VersionHasIetfQuicFrames(connection()->transport_version())) {
     if (GetNumOpenOutgoingStreams() >=
         stream_id_manager().max_open_outgoing_streams()) {
       QUIC_VLOG(1) << "No more streams should be created. "
diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index a0ce23e..410161e 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -178,7 +178,7 @@
   // expects needed to ensure that the STOP_SENDING worked as expected.
   void InjectStopSendingFrame(QuicStreamId stream_id,
                               QuicRstStreamErrorCode rst_stream_code) {
-    if (transport_version() != QUIC_VERSION_99) {
+    if (!VersionHasIetfQuicFrames(transport_version())) {
       // Only needed for version 99/IETF QUIC. Noop otherwise.
       return;
     }
@@ -239,7 +239,7 @@
                           GetNthClientInitiatedBidirectionalId(0),
                           QUIC_ERROR_PROCESSING_STREAM, 0);
   EXPECT_CALL(owner_, OnRstStreamReceived(_)).Times(1);
-  if (transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     // For non-version 99, the RESET_STREAM will do the full close.
     // Set up expects accordingly.
     EXPECT_CALL(*connection_, SendControlFrame(_));
@@ -270,7 +270,7 @@
                           GetNthClientInitiatedBidirectionalId(0),
                           QUIC_ERROR_PROCESSING_STREAM, 0);
   EXPECT_CALL(owner_, OnRstStreamReceived(_)).Times(1);
-  if (transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     // For non-version 99, the RESET_STREAM will do the full close.
     // Set up expects accordingly.
     EXPECT_CALL(*connection_, SendControlFrame(_));
@@ -312,7 +312,7 @@
                          GetNthClientInitiatedBidirectionalId(0),
                          QUIC_ERROR_PROCESSING_STREAM, 0);
   EXPECT_CALL(owner_, OnRstStreamReceived(_)).Times(1);
-  if (transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     // For non-version 99, the RESET_STREAM will do the full close.
     // Set up expects accordingly.
     EXPECT_CALL(*connection_, SendControlFrame(_));
@@ -348,7 +348,7 @@
   // client FIN/RST is lost.
 
   session_->OnConfigNegotiated();
-  if (transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     // The slightly increased stream limit is set during config negotiation.  It
     // is either an increase of 10 over negotiated limit, or a fixed percentage
     // scaling, whichever is larger. Test both before continuing.
@@ -366,7 +366,7 @@
     stream_id += QuicUtils::StreamIdDelta(connection_->transport_version());
   }
 
-  if (transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     // Open more streams: server should accept slightly more than the limit.
     // Excess streams are for non-version-99 only.
     for (size_t i = 0; i < kMaxStreamsMinimumIncrement; ++i) {
@@ -378,7 +378,7 @@
   // Now violate the server's internal stream limit.
   stream_id += QuicUtils::StreamIdDelta(connection_->transport_version());
 
-  if (transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     // For non-version 99, QUIC responds to an attempt to exceed the stream
     // limit by resetting the stream.
     EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
@@ -412,7 +412,7 @@
       QuicUtils::StreamIdDelta(connection_->transport_version());
   const int kLimitingStreamId =
       GetNthClientInitiatedBidirectionalId(kAvailableStreamLimit + 1);
-  if (transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     // This exceeds the stream limit. In versions other than 99
     // this is allowed. Version 99 hews to the IETF spec and does
     // not allow it.
diff --git a/quic/core/http/quic_spdy_client_session.cc b/quic/core/http/quic_spdy_client_session.cc
index 9be0936..ee81dcf 100644
--- a/quic/core/http/quic_spdy_client_session.cc
+++ b/quic/core/http/quic_spdy_client_session.cc
@@ -53,7 +53,7 @@
     return false;
   }
   if (!GetQuicReloadableFlag(quic_use_common_stream_check) &&
-      connection()->transport_version() != QUIC_VERSION_99) {
+      !VersionHasIetfQuicFrames(connection()->transport_version())) {
     if (GetNumOpenOutgoingStreams() >=
         stream_id_manager().max_open_outgoing_streams()) {
       QUIC_DLOG(INFO) << "Failed to create a new outgoing stream. "
@@ -138,7 +138,7 @@
   }
   if (QuicUtils::IsClientInitiatedStreamId(connection()->transport_version(),
                                            id) ||
-      (connection()->transport_version() == QUIC_VERSION_99 &&
+      (VersionHasIetfQuicFrames(connection()->transport_version()) &&
        QuicUtils::IsBidirectionalStreamId(id))) {
     QUIC_LOG(WARNING) << "Received invalid push stream id " << id;
     connection()->CloseConnection(
diff --git a/quic/core/http/quic_spdy_client_session_test.cc b/quic/core/http/quic_spdy_client_session_test.cc
index bfde618..02c4a14 100644
--- a/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quic/core/http/quic_spdy_client_session_test.cc
@@ -142,7 +142,7 @@
   }
 
   void CompleteCryptoHandshake(uint32_t server_max_incoming_streams) {
-    if (connection_->transport_version() == QUIC_VERSION_99) {
+    if (VersionHasIetfQuicFrames(connection_->transport_version())) {
       EXPECT_CALL(*connection_, SendControlFrame(_))
           .Times(testing::AnyNumber())
           .WillRepeatedly(Invoke(
@@ -152,7 +152,7 @@
     QuicCryptoClientStream* stream = static_cast<QuicCryptoClientStream*>(
         session_->GetMutableCryptoStream());
     QuicConfig config = DefaultQuicConfig();
-    if (connection_->transport_version() == QUIC_VERSION_99) {
+    if (VersionHasIetfQuicFrames(connection_->transport_version())) {
       config.SetMaxIncomingUnidirectionalStreamsToSend(
           server_max_incoming_streams);
       config.SetMaxIncomingBidirectionalStreamsToSend(
@@ -259,7 +259,7 @@
   stream = session_->CreateOutgoingBidirectionalStream();
   EXPECT_FALSE(stream);
 
-  if (GetParam().transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
     if (VersionLacksHeadersStream(GetParam().transport_version)) {
       EXPECT_EQ(1u,
                 QuicSessionPeer::v99_bidirectional_stream_id_manager(&*session_)
@@ -305,7 +305,7 @@
                                            QUIC_RST_ACKNOWLEDGEMENT, 0));
   // Check that a new one can be created.
   EXPECT_EQ(0u, session_->GetNumOpenOutgoingStreams());
-  if (GetParam().transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
     // In V99 the stream limit increases only if we get a MAX_STREAMS
     // frame; pretend we got one.
 
@@ -322,7 +322,7 @@
   }
   stream = session_->CreateOutgoingBidirectionalStream();
   EXPECT_NE(nullptr, stream);
-  if (GetParam().transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
     // Ensure that we have/have had three open streams: two test streams and the
     // header stream.
     QuicStreamCount expected_stream_count = 3;
@@ -355,7 +355,7 @@
   QuicSpdyClientStream* stream = session_->CreateOutgoingBidirectionalStream();
   ASSERT_NE(nullptr, stream);
 
-  if (GetParam().transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
     // For v99, trying to open a stream and failing due to lack
     // of stream ids will result in a STREAMS_BLOCKED. Make
     // sure we get one. Also clear out the frame because if it's
@@ -394,7 +394,7 @@
   // The stream is now complete from the client's perspective, and it should
   // be able to create a new outgoing stream.
   EXPECT_EQ(0u, session_->GetNumOpenOutgoingStreams());
-  if (GetParam().transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
     // Note that this is to be the second stream created, hence
     // the stream count is 3 (the two streams created as a part of
     // the test plus the header stream, internally created).
@@ -409,7 +409,7 @@
   }
   stream = session_->CreateOutgoingBidirectionalStream();
   EXPECT_NE(nullptr, stream);
-  if (GetParam().transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
     // Ensure that we have/have had three open streams: two test streams and the
     // header stream.
     QuicStreamCount expected_stream_count = 3;
@@ -480,7 +480,7 @@
 }
 
 TEST_P(QuicSpdyClientSessionTest, GoAwayReceived) {
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     return;
   }
   CompleteCryptoHandshake();
@@ -874,7 +874,7 @@
 
 TEST_P(QuicSpdyClientSessionTest,
        TryToCreateServerInitiatedBidirectionalStream) {
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_STREAM_ID, _, _));
   } else {
     EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
diff --git a/quic/core/http/quic_spdy_server_stream_base_test.cc b/quic/core/http/quic_spdy_server_stream_base_test.cc
index 4e1aa1b..15638ca 100644
--- a/quic/core/http/quic_spdy_server_stream_base_test.cc
+++ b/quic/core/http/quic_spdy_server_stream_base_test.cc
@@ -59,7 +59,7 @@
 
   EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
 
-  if (session_.connection()->transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(session_.connection()->transport_version())) {
     EXPECT_CALL(session_, SendRstStream(_, QUIC_RST_ACKNOWLEDGEMENT, _))
         .Times(1);
   } else {
@@ -76,7 +76,7 @@
   QuicRstStreamFrame rst_frame(kInvalidControlFrameId, stream_->id(),
                                QUIC_STREAM_CANCELLED, 1234);
   stream_->OnStreamReset(rst_frame);
-  if (session_.connection()->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(session_.connection()->transport_version())) {
     // Create and inject a STOP SENDING frame to complete the close
     // of the stream. This is only needed for version 99/IETF QUIC.
     QuicStopSendingFrame stop_sending(
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index ce4d5a9..5b926db 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -176,7 +176,7 @@
     // Enforce the limit on the number of open streams.
     if (GetNumOpenIncomingStreams() + 1 >
             max_open_incoming_bidirectional_streams() &&
-        connection()->transport_version() != QUIC_VERSION_99) {
+        !VersionHasIetfQuicFrames(connection()->transport_version())) {
       connection()->CloseConnection(
           QUIC_TOO_MANY_OPEN_STREAMS, "Too many streams!",
           ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
@@ -320,7 +320,7 @@
   }
 
   void CloseStream(QuicStreamId id) {
-    if (!IsVersion99()) {
+    if (!VersionHasIetfQuicFrames(transport_version())) {
       EXPECT_CALL(*connection_, SendControlFrame(_))
           .WillOnce(Invoke(&session_, &TestSession::ClearControlFrame));
     } else {
@@ -338,8 +338,6 @@
     return connection_->transport_version();
   }
 
-  bool IsVersion99() const { return transport_version() == QUIC_VERSION_99; }
-
   QuicStreamId GetNthClientInitiatedBidirectionalId(int n) {
     return GetNthClientInitiatedBidirectionalStreamId(transport_version(), n);
   }
@@ -368,7 +366,7 @@
     // needs to do the stream count where #1 is 0/1/2/3, and not
     // take into account that stream 0 is special.
     QuicStreamId id =
-        ((stream_count - 1) * QuicUtils::StreamIdDelta(QUIC_VERSION_99));
+        ((stream_count - 1) * QuicUtils::StreamIdDelta(transport_version()));
     if (!bidirectional) {
       id |= 0x2;
     }
@@ -478,7 +476,7 @@
 }
 
 TEST_P(QuicSpdySessionTestServer, MaximumAvailableOpenedStreams) {
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // For IETF QUIC, we should be able to obtain the max allowed
     // stream ID, the next ID should fail. Since the actual limit
     // is not the number of open streams, we allocate the max and the max+2.
@@ -535,7 +533,7 @@
   // A stream ID which is too large to create.
   stream_id2 = GetNthClientInitiatedBidirectionalId(
       2 * session_.MaxAvailableBidirectionalStreams() + 4);
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_STREAM_ID, _, _));
   } else {
     EXPECT_CALL(*connection_,
@@ -547,7 +545,7 @@
 TEST_P(QuicSpdySessionTestServer, ManyAvailableStreams) {
   // When max_open_streams_ is 200, should be able to create 200 streams
   // out-of-order, that is, creating the one with the largest stream ID first.
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     QuicSessionPeer::SetMaxOpenIncomingBidirectionalStreams(&session_, 200);
   } else {
     QuicSessionPeer::SetMaxOpenIncomingStreams(&session_, 200);
@@ -688,7 +686,7 @@
 }
 
 TEST_P(QuicSpdySessionTestServer, OnCanWriteBundlesStreams) {
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     EXPECT_CALL(*connection_, SendControlFrame(_))
         .WillRepeatedly(Invoke(
             this, &QuicSpdySessionTestServer::ClearMaxStreamsControlFrame));
@@ -957,7 +955,7 @@
 }
 
 TEST_P(QuicSpdySessionTestServer, SendGoAway) {
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // GoAway frames are not in version 99
     return;
   }
@@ -981,7 +979,7 @@
 }
 
 TEST_P(QuicSpdySessionTestServer, DoNotSendGoAwayTwice) {
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // TODO(b/118808809): Enable this test for version 99 when GOAWAY is
     // supported.
     return;
@@ -994,7 +992,7 @@
 }
 
 TEST_P(QuicSpdySessionTestServer, InvalidGoAway) {
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // TODO(b/118808809): Enable this test for version 99 when GOAWAY is
     // supported.
     return;
@@ -1016,7 +1014,7 @@
 
   EXPECT_CALL(*connection_,
               SendConnectivityProbingResponsePacket(new_peer_address));
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // Need to explicitly do this to emulate the reception of a PathChallenge,
     // which stores its payload for use in generating the response.
     connection_->OnPathChallengeFrame(
@@ -1045,7 +1043,7 @@
   EXPECT_EQ(1u, session_.GetNumOpenIncomingStreams());
 
   EXPECT_CALL(*connection_, SendControlFrame(_));
-  if (!IsVersion99()) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     // For version99, OnStreamReset gets called because of the STOP_SENDING,
     // below. EXPECT the call there.
     EXPECT_CALL(*connection_,
@@ -1059,7 +1057,7 @@
   // Create and inject a STOP_SENDING frame. In GOOGLE QUIC, receiving a
   // RST_STREAM frame causes a two-way close. For IETF QUIC, RST_STREAM causes a
   // one-way close.
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // Only needed for version 99/IETF QUIC.
     QuicStopSendingFrame stop_sending(
         kInvalidControlFrameId, GetNthClientInitiatedBidirectionalId(0),
@@ -1182,7 +1180,7 @@
   EXPECT_FALSE(headers_stream->flow_controller()->IsBlocked());
   EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
   EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     EXPECT_CALL(*connection_, SendControlFrame(_))
         .WillOnce(Invoke(&session_, &TestSession::ClearControlFrame));
   } else {
@@ -1311,7 +1309,7 @@
   EXPECT_CALL(*connection_, SendControlFrame(_))
       .Times(2)
       .WillRepeatedly(Invoke(&session_, &TestSession::ClearControlFrame));
-  if (!IsVersion99()) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     // For version99 the call to OnStreamReset happens as a result of receiving
     // the STOP_SENDING, so set up the EXPECT there.
     EXPECT_CALL(*connection_, OnStreamReset(stream->id(), _));
@@ -1322,7 +1320,7 @@
   // Create and inject a STOP_SENDING frame. In GOOGLE QUIC, receiving a
   // RST_STREAM frame causes a two-way close. For IETF QUIC, RST_STREAM causes a
   // one-way close.
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // Only needed for version 99/IETF QUIC.
     QuicStopSendingFrame stop_sending(
         kInvalidControlFrameId, stream->id(),
@@ -1539,7 +1537,7 @@
   // with a FIN or RST then we send an RST to refuse streams for versions other
   // than version 99. In version 99 the connection gets closed.
   const QuicStreamId kMaxStreams = 5;
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     QuicSessionPeer::SetMaxOpenIncomingBidirectionalStreams(&session_,
                                                             kMaxStreams);
   } else {
@@ -1566,7 +1564,7 @@
     QuicStreamFrame data1(i, false, 0, QuicStringPiece("HT"));
     session_.OnStreamFrame(data1);
     // EXPECT_EQ(1u, session_.GetNumOpenStreams());
-    if (!IsVersion99()) {
+    if (!VersionHasIetfQuicFrames(transport_version())) {
       EXPECT_CALL(*connection_, SendControlFrame(_))
           .WillOnce(Invoke(&session_, &TestSession::ClearControlFrame));
     } else {
@@ -1582,7 +1580,7 @@
     session_.CloseStream(i);
   }
   // Try and open a stream that exceeds the limit.
-  if (!IsVersion99()) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     // On versions other than 99, opening such a stream results in a
     // RST_STREAM.
     EXPECT_CALL(*connection_, SendControlFrame(_)).Times(1);
@@ -1607,7 +1605,7 @@
   // Verify that a draining stream (which has received a FIN but not consumed
   // it) does not count against the open quota (because it is closed from the
   // protocol point of view).
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // Version 99 will result in a MAX_STREAMS frame as streams are consumed
     // (via the OnStreamFrame call) and then released (via
     // StreamDraining). Eventually this node will believe that the peer is
@@ -1619,7 +1617,7 @@
   }
   EXPECT_CALL(*connection_, OnStreamReset(_, QUIC_REFUSED_STREAM)).Times(0);
   const QuicStreamId kMaxStreams = 5;
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     QuicSessionPeer::SetMaxOpenIncomingBidirectionalStreams(&session_,
                                                             kMaxStreams);
   } else {
diff --git a/quic/core/quic_config.cc b/quic/core/quic_config.cc
index 0914809..2423023 100644
--- a/quic/core/quic_config.cc
+++ b/quic/core/quic_config.cc
@@ -702,9 +702,9 @@
   silent_close_.ToHandshakeMessage(out);
   // Do not need a version check here, max...bi... will encode
   // as "MIDS" -- the max initial dynamic streams tag -- if
-  // doing some version other than IETF QUIC/V99.
+  // doing some version other than IETF QUIC.
   max_incoming_bidirectional_streams_.ToHandshakeMessage(out);
-  if (transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version)) {
     max_incoming_unidirectional_streams_.ToHandshakeMessage(out);
   }
   bytes_for_connection_id_.ToHandshakeMessage(out);
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index a7733cb..e48480c 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -1560,7 +1560,7 @@
     // This node is not a client (is a server) AND the received packet was
     // NOT connectivity-probing. If the packet had PATH CHALLENGES, send
     // appropriate RESPONSE. Then deal with possible peer migration.
-    if (transport_version() == QUIC_VERSION_99 &&
+    if (VersionHasIetfQuicFrames(transport_version()) &&
         !received_path_challenge_payloads_.empty()) {
       // If a PATH CHALLENGE was in a "Padded PING (or PATH CHALLENGE)"
       // then it is taken care of above. This handles the case where a PATH
@@ -3117,7 +3117,7 @@
       new QuicConnectionCloseFrame(error, details);
   // If version99/IETF QUIC set the close type. Default close type is Google
   // QUIC.
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     frame->close_type = IETF_QUIC_TRANSPORT_CONNECTION_CLOSE;
   }
   packet_generator_.ConsumeRetransmittableControlFrame(QuicFrame(frame));
@@ -3590,7 +3590,7 @@
                   << server_connection_id_;
 
   OwningSerializedPacketPointer probing_packet;
-  if (transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     // Non-IETF QUIC, generate a padded ping regardless of whether this is a
     // request or a response.
     probing_packet = packet_generator_.SerializeConnectivityProbingPacket();
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index 601dad9..dc97b07 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -1497,7 +1497,7 @@
   // provided in constructor.
   const bool no_version_negotiation_;
 
-  // Payload of most recently transmitted QUIC_VERSION_99 connectivity
+  // Payload of most recently transmitted IETF QUIC connectivity
   // probe packet (the PATH_CHALLENGE payload). This implementation transmits
   // only one PATH_CHALLENGE per connectivity probe, so only one
   // QuicPathFrameBuffer is needed.
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 243c13a..4cc121b 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -1396,7 +1396,7 @@
   }
 
   OwningSerializedPacketPointer ConstructProbingPacket() {
-    if (version().transport_version == QUIC_VERSION_99) {
+    if (VersionHasIetfQuicFrames(version().transport_version)) {
       QuicPathFrameBuffer payload = {
           {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xfe}};
       return QuicPacketCreatorPeer::
@@ -1428,8 +1428,8 @@
     header.packet_number = QuicPacketNumber(number);
 
     QuicConnectionCloseFrame qccf(QUIC_PEER_GOING_AWAY);
-    if (peer_framer_.transport_version() == QUIC_VERSION_99) {
-      // Default close-type is Google QUIC. If doing IETF/V99 then
+    if (VersionHasIetfQuicFrames(peer_framer_.transport_version())) {
+      // Default close-type is Google QUIC. If doing IETF QUIC then
       // set close type to be IETF CC/T.
       qccf.close_type = IETF_QUIC_TRANSPORT_CONNECTION_CLOSE;
     }
@@ -1862,7 +1862,7 @@
   // Process a padded PING or PATH CHALLENGE packet with no peer address change
   // on server side will be ignored.
   OwningSerializedPacketPointer probing_packet;
-  if (version().transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(version().transport_version)) {
     QuicPathFrameBuffer payload = {
         {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xfe}};
     probing_packet =
@@ -6660,7 +6660,7 @@
 }
 
 TEST_P(QuicConnectionTest, GoAway) {
-  if (GetParam().version.transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(GetParam().version.transport_version)) {
     // GoAway is not available in version 99.
     return;
   }
@@ -6868,8 +6868,8 @@
   header.version_flag = false;
 
   QuicConnectionCloseFrame qccf(QUIC_PEER_GOING_AWAY);
-  if (peer_framer_.transport_version() == QUIC_VERSION_99) {
-    // Default close-type is Google QUIC. If doing IETF/V99 then
+  if (VersionHasIetfQuicFrames(peer_framer_.transport_version())) {
+    // Default close-type is Google QUIC. If doing IETF QUIC then
     // set close type to be IETF CC/T.
     qccf.close_type = IETF_QUIC_TRANSPORT_CONNECTION_CLOSE;
   }
@@ -8054,7 +8054,7 @@
 // Test to check that the path challenge/path response logic works
 // correctly. This test is only for version-99
 TEST_P(QuicConnectionTest, PathChallengeResponse) {
-  if (connection_.version().transport_version != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(connection_.version().transport_version)) {
     return;
   }
   // First check if we can probe from server to client and back
@@ -8195,7 +8195,7 @@
 }
 
 TEST_P(QuicConnectionTest, AcceptPacketNumberZero) {
-  if (version().transport_version != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(version().transport_version)) {
     return;
   }
   // Set first_sending_packet_number to be 0 to allow successfully processing
@@ -8480,7 +8480,7 @@
   EXPECT_EQ(Perspective::IS_CLIENT, connection_.perspective());
   std::unique_ptr<QuicConnectionCloseFrame> connection_close_frame(
       new QuicConnectionCloseFrame(QUIC_INTERNAL_ERROR));
-  if (connection_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_.transport_version())) {
     connection_close_frame->close_type = IETF_QUIC_TRANSPORT_CONNECTION_CLOSE;
   }
   // Received 2 packets.
diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc
index 1025ed1..9b59aa5 100644
--- a/quic/core/quic_dispatcher.cc
+++ b/quic/core/quic_dispatcher.cc
@@ -134,7 +134,7 @@
                        bool ietf_quic) {
     QuicConnectionCloseFrame* frame =
         new QuicConnectionCloseFrame(error_code, error_details);
-    if (framer_.transport_version() == QUIC_VERSION_99) {
+    if (VersionHasIetfQuicFrames(framer_.transport_version())) {
       frame->close_type = IETF_QUIC_TRANSPORT_CONNECTION_CLOSE;
     }
 
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 6446ef8..836b4bf 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -498,7 +498,7 @@
                                          QuicStreamOffset offset,
                                          bool last_frame_in_packet,
                                          QuicPacketLength data_length) {
-  if (version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(version)) {
     return kQuicFrameTypeSize + QuicDataWriter::GetVarInt62Len(stream_id) +
            (last_frame_in_packet
                 ? 0
@@ -532,7 +532,7 @@
 size_t QuicFramer::GetMinAckFrameSize(
     QuicTransportVersion version,
     QuicPacketNumberLength largest_observed_length) {
-  if (version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(version)) {
     // The minimal ack frame consists of the following four fields: Largest
     // Acknowledged, ACK Delay, ACK Block Count, and First ACK Block. Minimum
     // size of each is 1 byte.
@@ -554,7 +554,7 @@
 // static
 size_t QuicFramer::GetRstStreamFrameSize(QuicTransportVersion version,
                                          const QuicRstStreamFrame& frame) {
-  if (version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(version)) {
     return QuicDataWriter::GetVarInt62Len(frame.stream_id) +
            QuicDataWriter::GetVarInt62Len(frame.byte_offset) +
            kQuicFrameTypeSize + kQuicIetfQuicErrorCodeSize;
@@ -567,8 +567,8 @@
 size_t QuicFramer::GetConnectionCloseFrameSize(
     QuicTransportVersion version,
     const QuicConnectionCloseFrame& frame) {
-  if (version != QUIC_VERSION_99) {
-    // Not version 99/IETF QUIC, return Google QUIC CONNECTION CLOSE frame size.
+  if (!VersionHasIetfQuicFrames(version)) {
+    // Not IETF QUIC, return Google QUIC CONNECTION CLOSE frame size.
     return kQuicFrameTypeSize + kQuicErrorCodeSize +
            kQuicErrorDetailsLengthSize +
            TruncatedErrorStringSize(frame.error_details);
@@ -601,7 +601,7 @@
 size_t QuicFramer::GetWindowUpdateFrameSize(
     QuicTransportVersion version,
     const QuicWindowUpdateFrame& frame) {
-  if (version != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(version)) {
     return kQuicFrameTypeSize + kQuicMaxStreamIdSize + kQuicMaxStreamOffsetSize;
   }
   if (frame.stream_id == QuicUtils::GetInvalidStreamId(version)) {
@@ -619,9 +619,10 @@
 // static
 size_t QuicFramer::GetMaxStreamsFrameSize(QuicTransportVersion version,
                                           const QuicMaxStreamsFrame& frame) {
-  if (version != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(version)) {
     QUIC_BUG << "In version " << version
-             << " - not 99 - and tried to serialize MaxStreams Frame.";
+             << ", which does not support IETF Frames, and tried to serialize "
+                "MaxStreams Frame.";
   }
   return kQuicFrameTypeSize +
          QuicDataWriter::GetVarInt62Len(frame.stream_count);
@@ -631,9 +632,10 @@
 size_t QuicFramer::GetStreamsBlockedFrameSize(
     QuicTransportVersion version,
     const QuicStreamsBlockedFrame& frame) {
-  if (version != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(version)) {
     QUIC_BUG << "In version " << version
-             << " - not 99 - and tried to serialize StreamsBlocked Frame.";
+             << ", which does not support IETF frames, and tried to serialize "
+                "StreamsBlocked Frame.";
   }
 
   return kQuicFrameTypeSize +
@@ -643,7 +645,7 @@
 // static
 size_t QuicFramer::GetBlockedFrameSize(QuicTransportVersion version,
                                        const QuicBlockedFrame& frame) {
-  if (version != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(version)) {
     return kQuicFrameTypeSize + kQuicMaxStreamIdSize;
   }
   if (frame.stream_id == QuicUtils::GetInvalidStreamId(version)) {
@@ -690,7 +692,7 @@
       return GetMinGoAwayFrameSize() +
              TruncatedErrorStringSize(frame.goaway_frame->reason_phrase);
     case WINDOW_UPDATE_FRAME:
-      // For version 99, this could be either a MAX DATA or MAX STREAM DATA.
+      // For IETF QUIC, this could be either a MAX DATA or MAX STREAM DATA.
       // GetWindowUpdateFrameSize figures this out and returns the correct
       // length.
       return GetWindowUpdateFrameSize(version, *frame.window_update_frame);
@@ -909,7 +911,7 @@
     return 0;
   }
 
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     if (AppendIetfFrames(frames, &writer) == 0) {
       return 0;
     }
@@ -999,36 +1001,36 @@
         break;
       case NEW_CONNECTION_ID_FRAME:
         set_detailed_error(
-            "Attempt to append NEW_CONNECTION_ID frame and not in version 99.");
+            "Attempt to append NEW_CONNECTION_ID frame and not in IETF QUIC.");
         return RaiseError(QUIC_INTERNAL_ERROR);
       case RETIRE_CONNECTION_ID_FRAME:
         set_detailed_error(
-            "Attempt to append RETIRE_CONNECTION_ID frame and not in version "
-            "99.");
+            "Attempt to append RETIRE_CONNECTION_ID frame and not in IETF "
+            "QUIC.");
         return RaiseError(QUIC_INTERNAL_ERROR);
       case NEW_TOKEN_FRAME:
         set_detailed_error(
-            "Attempt to append NEW_TOKEN_ID frame and not in version 99.");
+            "Attempt to append NEW_TOKEN_ID frame and not in IETF QUIC.");
         return RaiseError(QUIC_INTERNAL_ERROR);
       case MAX_STREAMS_FRAME:
         set_detailed_error(
-            "Attempt to append MAX_STREAMS frame and not in version 99.");
+            "Attempt to append MAX_STREAMS frame and not in IETF QUIC.");
         return RaiseError(QUIC_INTERNAL_ERROR);
       case STREAMS_BLOCKED_FRAME:
         set_detailed_error(
-            "Attempt to append STREAMS_BLOCKED frame and not in version 99.");
+            "Attempt to append STREAMS_BLOCKED frame and not in IETF QUIC.");
         return RaiseError(QUIC_INTERNAL_ERROR);
       case PATH_RESPONSE_FRAME:
         set_detailed_error(
-            "Attempt to append PATH_RESPONSE frame and not in version 99.");
+            "Attempt to append PATH_RESPONSE frame and not in IETF QUIC.");
         return RaiseError(QUIC_INTERNAL_ERROR);
       case PATH_CHALLENGE_FRAME:
         set_detailed_error(
-            "Attempt to append PATH_CHALLENGE frame and not in version 99.");
+            "Attempt to append PATH_CHALLENGE frame and not in IETF QUIC.");
         return RaiseError(QUIC_INTERNAL_ERROR);
       case STOP_SENDING_FRAME:
         set_detailed_error(
-            "Attempt to append STOP_SENDING frame and not in version 99.");
+            "Attempt to append STOP_SENDING frame and not in IETF QUIC.");
         return RaiseError(QUIC_INTERNAL_ERROR);
       case MESSAGE_FRAME:
         if (!AppendMessageFrameAndTypeByte(*frame.message_frame,
@@ -1095,7 +1097,7 @@
         break;
       case STOP_WAITING_FRAME:
         set_detailed_error(
-            "Attempt to append STOP WAITING frame in version 99.");
+            "Attempt to append STOP WAITING frame in IETF QUIC.");
         return RaiseError(QUIC_INTERNAL_ERROR);
       case MTU_DISCOVERY_FRAME:
         // MTU discovery frames are serialized as ping frames.
@@ -1118,7 +1120,7 @@
         }
         break;
       case GOAWAY_FRAME:
-        set_detailed_error("Attempt to append GOAWAY frame in version 99.");
+        set_detailed_error("Attempt to append GOAWAY frame in IETF QUIC.");
         return RaiseError(QUIC_INTERNAL_ERROR);
       case WINDOW_UPDATE_FRAME:
         // Depending on whether there is a stream ID or not, will be either a
@@ -1243,7 +1245,7 @@
     QuicPathFrameBuffer* payload,
     QuicRandom* randomizer,
     EncryptionLevel level) {
-  if (version_.transport_version != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(version_.transport_version)) {
     QUIC_BUG << "Attempt to build a PATH_CHALLENGE Connectivity Probing "
                 "packet and not doing IETF QUIC";
     return 0;
@@ -1276,7 +1278,7 @@
         << "Attempt to generate connectivity response with no request payloads";
     return 0;
   }
-  if (version_.transport_version != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(version_.transport_version)) {
     QUIC_BUG << "Attempt to build a PATH_RESPONSE Connectivity Probing "
                 "packet and not doing IETF QUIC";
     return 0;
@@ -1897,7 +1899,7 @@
   }
 
   // Handle the payload.
-  if (version_.transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(version_.transport_version)) {
     if (!ProcessIetfFrameData(&reader, *header)) {
       DCHECK_NE(QUIC_NO_ERROR, error_);  // ProcessIetfFrameData sets the error.
       DCHECK_NE("", detailed_error_);
@@ -2770,8 +2772,9 @@
 
 bool QuicFramer::ProcessFrameData(QuicDataReader* reader,
                                   const QuicPacketHeader& header) {
-  DCHECK_NE(QUIC_VERSION_99, version_.transport_version)
-      << "Version 99 negotiated, but not processing frames as version 99.";
+  DCHECK(!VersionHasIetfQuicFrames(version_.transport_version))
+      << "IETF QUIC Framing negotiated but attempting to process frames as "
+         "non-IETF QUIC.";
   if (reader->IsDoneReading()) {
     set_detailed_error("Packet has no frames.");
     return RaiseError(QUIC_MISSING_PAYLOAD);
@@ -2995,9 +2998,10 @@
 
 bool QuicFramer::ProcessIetfFrameData(QuicDataReader* reader,
                                       const QuicPacketHeader& header) {
-  DCHECK_EQ(QUIC_VERSION_99, version_.transport_version)
-      << "Attempt to process frames as IETF frames but version is "
-      << version_.transport_version << ", not 99.";
+  DCHECK(VersionHasIetfQuicFrames(version_.transport_version))
+      << "Attempt to process frames as IETF frames but version ("
+      << version_.transport_version << ") does not support IETF Framing.";
+
   if (reader->IsDoneReading()) {
     set_detailed_error("Packet has no frames.");
     return RaiseError(QUIC_MISSING_PAYLOAD);
@@ -3984,8 +3988,8 @@
 
 bool QuicFramer::ProcessBlockedFrame(QuicDataReader* reader,
                                      QuicBlockedFrame* frame) {
-  DCHECK_NE(QUIC_VERSION_99, version_.transport_version)
-      << "Attempt to process non-IETF frames but version is 99";
+  DCHECK(!VersionHasIetfQuicFrames(version_.transport_version))
+      << "Attempt to process non-IETF QUIC frames in an IETF QUIC version.";
 
   if (!reader->ReadUInt32(&frame->stream_id)) {
     set_detailed_error("Unable to read stream_id.");
@@ -4621,7 +4625,7 @@
   DCHECK(!ack.packets.Empty());
   size_t ack_size = 0;
 
-  if (version_.transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(version_.transport_version)) {
     return GetIetfAckFrameSize(ack);
   }
   AckFrameInfo ack_info = GetAckFrameInfo(ack);
@@ -4698,7 +4702,7 @@
 bool QuicFramer::AppendTypeByte(const QuicFrame& frame,
                                 bool last_frame_in_packet,
                                 QuicDataWriter* writer) {
-  if (version_.transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(version_.transport_version)) {
     return AppendIetfTypeByte(frame, last_frame_in_packet, writer);
   }
   uint8_t type_byte = 0;
@@ -4714,36 +4718,35 @@
       break;
     case NEW_CONNECTION_ID_FRAME:
       set_detailed_error(
-          "Attempt to append NEW_CONNECTION_ID frame and not in version 99.");
+          "Attempt to append NEW_CONNECTION_ID frame and not in IETF QUIC.");
       return RaiseError(QUIC_INTERNAL_ERROR);
     case RETIRE_CONNECTION_ID_FRAME:
       set_detailed_error(
-          "Attempt to append RETIRE_CONNECTION_ID frame and not in version "
-          "99.");
+          "Attempt to append RETIRE_CONNECTION_ID frame and not in IETF QUIC.");
       return RaiseError(QUIC_INTERNAL_ERROR);
     case NEW_TOKEN_FRAME:
       set_detailed_error(
-          "Attempt to append NEW_TOKEN frame and not in version 99.");
+          "Attempt to append NEW_TOKEN frame and not in IETF QUIC.");
       return RaiseError(QUIC_INTERNAL_ERROR);
     case MAX_STREAMS_FRAME:
       set_detailed_error(
-          "Attempt to append MAX_STREAMS frame and not in version 99.");
+          "Attempt to append MAX_STREAMS frame and not in IETF QUIC.");
       return RaiseError(QUIC_INTERNAL_ERROR);
     case STREAMS_BLOCKED_FRAME:
       set_detailed_error(
-          "Attempt to append STREAMS_BLOCKED frame and not in version 99.");
+          "Attempt to append STREAMS_BLOCKED frame and not in IETF QUIC.");
       return RaiseError(QUIC_INTERNAL_ERROR);
     case PATH_RESPONSE_FRAME:
       set_detailed_error(
-          "Attempt to append PATH_RESPONSE frame and not in version 99.");
+          "Attempt to append PATH_RESPONSE frame and not in IETF QUIC.");
       return RaiseError(QUIC_INTERNAL_ERROR);
     case PATH_CHALLENGE_FRAME:
       set_detailed_error(
-          "Attempt to append PATH_CHALLENGE frame and not in version 99.");
+          "Attempt to append PATH_CHALLENGE frame and not in IETF QUIC.");
       return RaiseError(QUIC_INTERNAL_ERROR);
     case STOP_SENDING_FRAME:
       set_detailed_error(
-          "Attempt to append STOP_SENDING frame and not in version 99.");
+          "Attempt to append STOP_SENDING frame and not in IETF QUIC.");
       return RaiseError(QUIC_INTERNAL_ERROR);
     case MESSAGE_FRAME:
       return true;
@@ -4782,7 +4785,7 @@
       break;
     case GOAWAY_FRAME:
       set_detailed_error(
-          "Attempt to create non-version-99 GOAWAY frame in version 99.");
+          "Attempt to create non-IETF QUIC GOAWAY frame in IETF QUIC.");
       return RaiseError(QUIC_INTERNAL_ERROR);
     case WINDOW_UPDATE_FRAME:
       // Depending on whether there is a stream ID or not, will be either a
@@ -4804,7 +4807,7 @@
       break;
     case STOP_WAITING_FRAME:
       set_detailed_error(
-          "Attempt to append type byte of STOP WAITING frame in version 99.");
+          "Attempt to append type byte of STOP WAITING frame in IETF QUIC.");
       return RaiseError(QUIC_INTERNAL_ERROR);
     case PING_FRAME:
       type_byte = IETF_PING;
@@ -4922,7 +4925,7 @@
 bool QuicFramer::AppendStreamFrame(const QuicStreamFrame& frame,
                                    bool no_stream_frame_length,
                                    QuicDataWriter* writer) {
-  if (version_.transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(version_.transport_version)) {
     return AppendIetfStreamFrame(frame, no_stream_frame_length, writer);
   }
   if (!AppendStreamId(GetStreamIdSize(frame.stream_id), frame.stream_id,
@@ -5083,7 +5086,7 @@
 
 bool QuicFramer::AppendAckFrameAndTypeByte(const QuicAckFrame& frame,
                                            QuicDataWriter* writer) {
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     return AppendIetfAckFrameAndTypeByte(frame, writer);
   }
 
@@ -5499,7 +5502,7 @@
 
 bool QuicFramer::AppendRstStreamFrame(const QuicRstStreamFrame& frame,
                                       QuicDataWriter* writer) {
-  if (version_.transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(version_.transport_version)) {
     return AppendIetfResetStreamFrame(frame, writer);
   }
   if (!writer->WriteUInt32(frame.stream_id)) {
@@ -5521,7 +5524,7 @@
 bool QuicFramer::AppendConnectionCloseFrame(
     const QuicConnectionCloseFrame& frame,
     QuicDataWriter* writer) {
-  if (version_.transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(version_.transport_version)) {
     return AppendIetfConnectionCloseFrame(frame, writer);
   }
   uint32_t error_code = static_cast<uint32_t>(frame.quic_error_code);
@@ -5564,7 +5567,7 @@
 
 bool QuicFramer::AppendBlockedFrame(const QuicBlockedFrame& frame,
                                     QuicDataWriter* writer) {
-  if (version_.transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(version_.transport_version)) {
     if (frame.stream_id == QuicUtils::GetInvalidStreamId(transport_version())) {
       return AppendIetfBlockedFrame(frame, writer);
     }
@@ -6063,7 +6066,7 @@
 
 uint8_t QuicFramer::GetStreamFrameTypeByte(const QuicStreamFrame& frame,
                                            bool last_frame_in_packet) const {
-  if (version_.transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(version_.transport_version)) {
     return GetIetfStreamFrameTypeByte(frame, last_frame_in_packet);
   }
   uint8_t type_byte = 0;
@@ -6093,7 +6096,7 @@
 uint8_t QuicFramer::GetIetfStreamFrameTypeByte(
     const QuicStreamFrame& frame,
     bool last_frame_in_packet) const {
-  DCHECK_EQ(QUIC_VERSION_99, version_.transport_version);
+  DCHECK(VersionHasIetfQuicFrames(version_.transport_version));
   uint8_t type_byte = IETF_STREAM;
   if (!last_frame_in_packet) {
     type_byte |= IETF_STREAM_FRAME_LEN_BIT;
diff --git a/quic/core/quic_framer.h b/quic/core/quic_framer.h
index 9b9c48f..578cfcf 100644
--- a/quic/core/quic_framer.h
+++ b/quic/core/quic_framer.h
@@ -559,15 +559,6 @@
     data_producer_ = data_producer;
   }
 
-  // Returns true if we are doing IETF-formatted packets.
-  // In the future this could encompass a wide variety of
-  // versions. Doing the test by name ("ietf format") rather
-  // than version number localizes the version/ietf-ness binding
-  // to this method.
-  bool is_ietf_format() {
-    return version_.transport_version == QUIC_VERSION_99;
-  }
-
   QuicTime creation_time() const { return creation_time_; }
 
   QuicPacketNumber first_sending_packet_number() const {
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index 7bc054e..d1a2055 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -1906,7 +1906,7 @@
 
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
@@ -2061,7 +2061,7 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.transport_version() == QUIC_VERSION_99
+      VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
           : (framer_.transport_version() > QUIC_VERSION_44
                  ? packet46
@@ -2091,7 +2091,7 @@
 TEST_P(QuicFramerTest, EmptyStreamFrame) {
   // Only the IETF QUIC spec explicitly says that empty
   // stream frames are supported.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -2431,7 +2431,7 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.transport_version() == QUIC_VERSION_99
+      VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
           : (framer_.transport_version() > QUIC_VERSION_44
                  ? packet46
@@ -2583,7 +2583,7 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.transport_version() == QUIC_VERSION_99
+      VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
           : (framer_.transport_version() > QUIC_VERSION_44
                  ? packet46
@@ -2611,6 +2611,12 @@
 }
 
 TEST_P(QuicFramerTest, StreamFrameWithVersion) {
+  // If IETF frames are in use then we must also have the IETF
+  // header invariants.
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
+    DCHECK(VersionHasIetfInvariantHeader(framer_.transport_version()));
+  }
+
   SetDecrypterLevel(ENCRYPTION_ZERO_RTT);
   // clang-format off
   PacketFragments packet = {
@@ -2769,7 +2775,7 @@
           : VARIABLE_LENGTH_INTEGER_LENGTH_0;
 
   PacketFragments& fragments =
-      framer_.transport_version() == QUIC_VERSION_99
+      VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
           : (framer_.transport_version() > QUIC_VERSION_44
                  ? packet46
@@ -3070,7 +3076,7 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.transport_version() == QUIC_VERSION_99
+      VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
           : (framer_.transport_version() > QUIC_VERSION_44
                  ? packet46
@@ -3214,7 +3220,7 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.transport_version() == QUIC_VERSION_99
+      VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
           : (framer_.transport_version() > QUIC_VERSION_44
                  ? packet46
@@ -3230,7 +3236,7 @@
 // and handles the case where the third ack block's gap is larger than the
 // available space in the ack range.
 TEST_P(QuicFramerTest, ThirdAckBlockUnderflowGap) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // for now, only v99
     return;
   }
@@ -3288,7 +3294,7 @@
 // and handles the case where the third ack block's length is larger than the
 // available space in the ack range.
 TEST_P(QuicFramerTest, ThirdAckBlockUnderflowAck) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // for now, only v99
     return;
   }
@@ -3344,7 +3350,7 @@
 // around to 0x3fffffff ffffffff... Make sure we detect this
 // condition.
 TEST_P(QuicFramerTest, AckBlockUnderflowGapWrap) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // for now, only v99
     return;
   }
@@ -3394,7 +3400,7 @@
 // As AckBlockUnderflowGapWrap, but in this test, it's the ack
 // component of the ack-block that causes the wrap, not the gap.
 TEST_P(QuicFramerTest, AckBlockUnderflowAckWrap) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // for now, only v99
     return;
   }
@@ -3443,7 +3449,7 @@
 
 // An ack block that acks the entire range, 1...0x3fffffffffffffff
 TEST_P(QuicFramerTest, AckBlockAcksEverything) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // for now, only v99
     return;
   }
@@ -3498,7 +3504,7 @@
 //    additional ack blocks.
 //
 TEST_P(QuicFramerTest, AckFrameFirstAckBlockLengthZero) {
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     // Not applicable to version 99 -- first ack block contains the
     // number of packets that preceed the largest_acked packet.
     // A value of 0 means no packets preceed --- that the block's
@@ -3762,7 +3768,7 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.transport_version() == QUIC_VERSION_99
+      VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
           : (framer_.transport_version() > QUIC_VERSION_44
                  ? packet46
@@ -4054,7 +4060,7 @@
 
   // clang-format on
   PacketFragments& fragments =
-      framer_.transport_version() == QUIC_VERSION_99
+      VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
           : (framer_.transport_version() > QUIC_VERSION_44
                  ? packet46
@@ -4079,7 +4085,7 @@
   EXPECT_EQ(kSmallLargestObserved, LargestAcked(frame));
   ASSERT_EQ(4254u, frame.packets.NumPacketsSlow());
   EXPECT_EQ(4u, frame.packets.NumIntervals());
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     EXPECT_EQ(0u, frame.received_packet_times.size());
   } else {
     EXPECT_EQ(2u, frame.received_packet_times.size());
@@ -4165,7 +4171,7 @@
       0x10, 0x32, 0x54, 0x76,
   };
   // clang-format on
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   QuicEncryptedPacket encrypted(
@@ -4269,7 +4275,7 @@
       0x10, 0x32,
   };
   // clang-format on
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   QuicEncryptedPacket encrypted(
@@ -4284,7 +4290,7 @@
 }
 
 TEST_P(QuicFramerTest, NewStopWaitingFrame) {
-  if (version_.transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(version_.transport_version)) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -4377,7 +4383,7 @@
 }
 
 TEST_P(QuicFramerTest, InvalidNewStopWaitingFrame) {
-  if (version_.transport_version == QUIC_VERSION_99 ||
+  if (VersionHasIetfQuicFrames(version_.transport_version) ||
       (GetQuicReloadableFlag(quic_do_not_accept_stop_waiting) &&
        version_.transport_version >= QUIC_VERSION_44)) {
     return;
@@ -4542,7 +4548,7 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.transport_version() == QUIC_VERSION_99
+      VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
           : (framer_.transport_version() > QUIC_VERSION_44
                  ? packet46
@@ -4683,7 +4689,7 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.transport_version() == QUIC_VERSION_99
+      VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
           : (framer_.transport_version() > QUIC_VERSION_44
                  ? packet46
@@ -4703,7 +4709,7 @@
   EXPECT_EQ(0x11u, static_cast<unsigned>(
                        visitor_.connection_close_frame_.quic_error_code));
   EXPECT_EQ("because I can", visitor_.connection_close_frame_.error_details);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     EXPECT_EQ(0x1234u,
               visitor_.connection_close_frame_.transport_close_frame_type);
   }
@@ -4715,7 +4721,7 @@
 
 // Test the CONNECTION_CLOSE/Application variant.
 TEST_P(QuicFramerTest, ApplicationCloseFrame) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This frame does not exist in versions other than 99.
     return;
   }
@@ -4775,7 +4781,7 @@
 }
 
 TEST_P(QuicFramerTest, GoAwayFrame) {
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This frame is not supported in version 99.
     return;
   }
@@ -4900,7 +4906,7 @@
 }
 
 TEST_P(QuicFramerTest, WindowUpdateFrame) {
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This frame is not in version 99, see MaxDataFrame and MaxStreamDataFrame
     // for Version 99 equivalents.
     return;
@@ -4996,7 +5002,7 @@
 }
 
 TEST_P(QuicFramerTest, MaxDataFrame) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This frame is available only in version 99.
     return;
   }
@@ -5040,7 +5046,7 @@
 }
 
 TEST_P(QuicFramerTest, MaxStreamDataFrame) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This frame available only in version 99.
     return;
   }
@@ -5165,7 +5171,7 @@
   // clang-format on
 
   PacketFragments& fragments =
-      framer_.transport_version() == QUIC_VERSION_99
+      VersionHasIetfQuicFrames(framer_.transport_version())
           ? packet99
           : (framer_.transport_version() > QUIC_VERSION_44
                  ? packet46
@@ -5181,14 +5187,14 @@
       *encrypted, !kIncludeVersion, !kIncludeDiversificationNonce,
       PACKET_8BYTE_CONNECTION_ID, PACKET_0BYTE_CONNECTION_ID));
 
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     EXPECT_EQ(kStreamOffset, visitor_.blocked_frame_.offset);
   } else {
     EXPECT_EQ(0u, visitor_.blocked_frame_.offset);
   }
   EXPECT_EQ(kStreamId, visitor_.blocked_frame_.stream_id);
 
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     CheckFramingBoundaries(fragments, QUIC_INVALID_STREAM_BLOCKED_DATA);
   } else {
     CheckFramingBoundaries(fragments, QUIC_INVALID_BLOCKED_DATA);
@@ -5248,14 +5254,14 @@
   // clang-format on
 
   QuicEncryptedPacket encrypted(
-      AsChars(framer_.transport_version() == QUIC_VERSION_99
+      AsChars(VersionHasIetfQuicFrames(framer_.transport_version())
                   ? packet99
                   : (framer_.transport_version() > QUIC_VERSION_44
                          ? packet46
                          : framer_.transport_version() > QUIC_VERSION_43
                                ? packet44
                                : packet)),
-      framer_.transport_version() == QUIC_VERSION_99
+      VersionHasIetfQuicFrames(framer_.transport_version())
           ? QUIC_ARRAYSIZE(packet99)
           : (framer_.transport_version() > QUIC_VERSION_44
                  ? QUIC_ARRAYSIZE(packet46)
@@ -5903,7 +5909,7 @@
   // clang-format on
 
   unsigned char* p = packet;
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
     p = packet46;
@@ -6055,7 +6061,7 @@
 
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
@@ -6137,7 +6143,7 @@
   // clang-format on
 
   unsigned char* p = packet;
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
     p = packet46;
@@ -6227,7 +6233,7 @@
   // clang-format on
 
   unsigned char* p = packet;
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
     p = packet46;
@@ -6317,7 +6323,7 @@
   // clang-format on
 
   unsigned char* p = packet;
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
     p = packet46;
@@ -6448,7 +6454,7 @@
 
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
@@ -6575,7 +6581,7 @@
 
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
@@ -6882,7 +6888,7 @@
   // clang-format on
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
@@ -6999,7 +7005,7 @@
   // clang-format on
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
@@ -7189,7 +7195,7 @@
   // clang-format on
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
@@ -7594,7 +7600,7 @@
   // clang-format on
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
@@ -7663,7 +7669,7 @@
 
   QuicRstStreamFrame rst_frame;
   rst_frame.stream_id = kStreamId;
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     rst_frame.ietf_error_code = 0x01;
   } else {
     rst_frame.error_code = static_cast<QuicRstStreamErrorCode>(0x05060708);
@@ -7754,7 +7760,7 @@
 
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
@@ -7779,7 +7785,7 @@
   header.packet_number = kPacketNumber;
 
   QuicConnectionCloseFrame close_frame;
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     close_frame.transport_error_code =
         static_cast<QuicIetfTransportErrorCodes>(0x11);
     close_frame.transport_close_frame_type = 0x05;
@@ -7881,7 +7887,7 @@
 
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
@@ -7908,7 +7914,7 @@
   header.packet_number = kPacketNumber;
 
   QuicConnectionCloseFrame close_frame;
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     close_frame.transport_error_code = PROTOCOL_VIOLATION;  // value is 0x0a
     EXPECT_EQ(0u, close_frame.transport_close_frame_type);
     close_frame.close_type = IETF_QUIC_TRANSPORT_CONNECTION_CLOSE;
@@ -8120,7 +8126,7 @@
 
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
@@ -8139,7 +8145,7 @@
 }
 
 TEST_P(QuicFramerTest, BuildApplicationCloseFramePacket) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // Versions other than 99 do not have ApplicationClose
     return;
   }
@@ -8190,7 +8196,7 @@
 }
 
 TEST_P(QuicFramerTest, BuildTruncatedApplicationCloseFramePacket) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // Versions other than 99 do not have this frame.
     return;
   }
@@ -8268,7 +8274,7 @@
 }
 
 TEST_P(QuicFramerTest, BuildGoAwayPacket) {
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This frame type is not supported in version 99.
     return;
   }
@@ -8376,7 +8382,7 @@
 }
 
 TEST_P(QuicFramerTest, BuildTruncatedGoAwayPacket) {
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This frame type is not supported in version 99.
     return;
   }
@@ -8655,7 +8661,7 @@
 
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
@@ -8671,7 +8677,7 @@
 }
 
 TEST_P(QuicFramerTest, BuildMaxStreamDataPacket) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This frame is available only in this version.
     return;
   }
@@ -8716,7 +8722,7 @@
 }
 
 TEST_P(QuicFramerTest, BuildMaxDataPacket) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This frame is available only in this version.
     return;
   }
@@ -8768,8 +8774,8 @@
   header.packet_number = kPacketNumber;
 
   QuicBlockedFrame blocked_frame;
-  if (framer_.transport_version() == QUIC_VERSION_99) {
-    // For V99, the stream ID must be <invalid> for the frame
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
+    // For IETF QUIC, the stream ID must be <invalid> for the frame
     // to be a BLOCKED frame. if it's valid, it will be a
     // STREAM_BLOCKED frame.
     blocked_frame.stream_id =
@@ -8844,7 +8850,7 @@
 
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
@@ -8920,7 +8926,7 @@
   // clang-format on
 
   unsigned char* p = packet;
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
     p = packet46;
@@ -9016,7 +9022,7 @@
   // clang-format on
 
   unsigned char* p = packet45;
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
     p = packet46;
@@ -9104,7 +9110,7 @@
 
   unsigned char* p = packet;
   size_t packet_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     packet_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
@@ -9131,7 +9137,7 @@
 // Test that the path challenge connectivity probing packet is serialized
 // correctly as a padded PATH CHALLENGE packet.
 TEST_P(QuicFramerTest, BuildPaddedPathChallengePacket) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
 
@@ -9186,7 +9192,7 @@
 // packet. Also generates packets with 1 and 3 PATH_RESPONSES in them to
 // exercised the single- and multiple- payload cases.
 TEST_P(QuicFramerTest, BuildPathResponsePacket1ResponseUnpadded) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
 
@@ -9230,7 +9236,7 @@
 }
 
 TEST_P(QuicFramerTest, BuildPathResponsePacket1ResponsePadded) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
 
@@ -9276,7 +9282,7 @@
 }
 
 TEST_P(QuicFramerTest, BuildPathResponsePacket3ResponsesUnpadded) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
 
@@ -9327,7 +9333,7 @@
 }
 
 TEST_P(QuicFramerTest, BuildPathResponsePacket3ResponsesPadded) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
 
@@ -9444,7 +9450,7 @@
   ASSERT_TRUE(data != nullptr);
 
   unsigned char* p = packet;
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
     p = packet46;
@@ -9827,6 +9833,7 @@
 
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
+  // TODO(ianswett): see todo in previous test.
   if (framer_.transport_version() == QUIC_VERSION_99) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
@@ -9852,7 +9859,7 @@
 }
 
 TEST_P(QuicFramerTest, AckTruncationLargePacket) {
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This test is not applicable to this version; the range count is
     // effectively unlimited
     return;
@@ -9892,7 +9899,7 @@
 }
 
 TEST_P(QuicFramerTest, AckTruncationSmallPacket) {
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This test is not applicable to this version; the range count is
     // effectively unlimited
     return;
@@ -9933,7 +9940,7 @@
 }
 
 TEST_P(QuicFramerTest, CleanTruncation) {
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This test is not applicable to this version; the range count is
     // effectively unlimited
     return;
@@ -10143,7 +10150,7 @@
 
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
@@ -10379,7 +10386,7 @@
   // clang-format on
 
   unsigned char* p = packet;
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
     p = packet46;
@@ -10395,7 +10402,7 @@
 
 TEST_P(QuicFramerTest, IetfBlockedFrame) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -10437,7 +10444,7 @@
 
 TEST_P(QuicFramerTest, BuildIetfBlockedPacket) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
 
@@ -10478,7 +10485,7 @@
 
 TEST_P(QuicFramerTest, IetfStreamBlockedFrame) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -10523,7 +10530,7 @@
 
 TEST_P(QuicFramerTest, BuildIetfStreamBlockedPacket) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
 
@@ -10566,7 +10573,7 @@
 
 TEST_P(QuicFramerTest, BiDiMaxStreamsFrame) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -10608,7 +10615,7 @@
 
 TEST_P(QuicFramerTest, UniDiMaxStreamsFrame) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -10649,7 +10656,7 @@
 
 TEST_P(QuicFramerTest, ServerUniDiMaxStreamsFrame) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -10691,7 +10698,7 @@
 
 TEST_P(QuicFramerTest, ClientUniDiMaxStreamsFrame) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -10738,7 +10745,7 @@
 // client- initiated.
 TEST_P(QuicFramerTest, BiDiMaxStreamsFrameTooBig) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -10776,7 +10783,7 @@
 
 TEST_P(QuicFramerTest, ClientBiDiMaxStreamsFrameTooBig) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -10815,7 +10822,7 @@
 
 TEST_P(QuicFramerTest, ServerUniDiMaxStreamsFrameTooBig) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -10854,7 +10861,7 @@
 
 TEST_P(QuicFramerTest, ClientUniDiMaxStreamsFrameTooBig) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -10894,7 +10901,7 @@
 // Specifically test that count==0 is accepted.
 TEST_P(QuicFramerTest, MaxStreamsFrameZeroCount) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -10921,7 +10928,7 @@
 
 TEST_P(QuicFramerTest, ServerBiDiStreamsBlockedFrame) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -10964,7 +10971,7 @@
 
 TEST_P(QuicFramerTest, BiDiStreamsBlockedFrame) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -11007,7 +11014,7 @@
 
 TEST_P(QuicFramerTest, UniDiStreamsBlockedFrame) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -11049,7 +11056,7 @@
 
 TEST_P(QuicFramerTest, ClientUniDiStreamsBlockedFrame) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -11094,7 +11101,7 @@
 // initiated; the logic does not take these into account.
 TEST_P(QuicFramerTest, StreamsBlockedFrameTooBig) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -11129,7 +11136,7 @@
 // Specifically test that count==0 is accepted.
 TEST_P(QuicFramerTest, StreamsBlockedFrameZeroCount) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
 
@@ -11173,7 +11180,7 @@
 
 TEST_P(QuicFramerTest, BuildBiDiStreamsBlockedPacket) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
 
@@ -11215,7 +11222,7 @@
 
 TEST_P(QuicFramerTest, BuildUniStreamsBlockedPacket) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
 
@@ -11257,7 +11264,7 @@
 
 TEST_P(QuicFramerTest, BuildBiDiMaxStreamsPacket) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
 
@@ -11299,7 +11306,7 @@
 
 TEST_P(QuicFramerTest, BuildUniDiMaxStreamsPacket) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
 
@@ -11343,7 +11350,7 @@
 }
 
 TEST_P(QuicFramerTest, NewConnectionIdFrame) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This frame is only for version 99.
     return;
   }
@@ -11399,7 +11406,7 @@
 }
 
 TEST_P(QuicFramerTest, NewConnectionIdFrameVariableLength) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This frame is only for version 99.
     return;
   }
@@ -11457,7 +11464,7 @@
 // Verifies that parsing a NEW_CONNECTION_ID frame with a length above the
 // specified maximum fails.
 TEST_P(QuicFramerTest, InvalidLongNewConnectionIdFrame) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // The NEW_CONNECTION_ID frame is only for version 99.
     return;
   }
@@ -11499,7 +11506,7 @@
 }
 
 TEST_P(QuicFramerTest, BuildNewConnectionIdFramePacket) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This frame is only for version 99.
     return;
   }
@@ -11551,7 +11558,7 @@
 }
 
 TEST_P(QuicFramerTest, NewTokenFrame) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This frame is only for version 99.
     return;
   }
@@ -11600,7 +11607,7 @@
 }
 
 TEST_P(QuicFramerTest, BuildNewTokenFramePacket) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This frame is only for version 99.
     return;
   }
@@ -11646,7 +11653,7 @@
 
 TEST_P(QuicFramerTest, IetfStopSendingFrame) {
   // This test is only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -11691,7 +11698,7 @@
 
 TEST_P(QuicFramerTest, BuildIetfStopSendingPacket) {
   // This test is only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
 
@@ -11734,7 +11741,7 @@
 
 TEST_P(QuicFramerTest, IetfPathChallengeFrame) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -11777,7 +11784,7 @@
 
 TEST_P(QuicFramerTest, BuildIetfPathChallengePacket) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
 
@@ -11817,7 +11824,7 @@
 
 TEST_P(QuicFramerTest, IetfPathResponseFrame) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -11860,7 +11867,7 @@
 
 TEST_P(QuicFramerTest, BuildIetfPathResponsePacket) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
 
@@ -11908,7 +11915,7 @@
   std::string error_detail(2048, 'e');
   QuicConnectionCloseFrame connection_close(QUIC_NETWORK_IDLE_TIMEOUT,
                                             error_detail);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     connection_close.close_type = IETF_QUIC_TRANSPORT_CONNECTION_CLOSE;
   }
 
@@ -11934,7 +11941,7 @@
       QuicFramer::GetRetransmittableControlFrameSize(
           framer_.transport_version(), QuicFrame(&blocked)));
 
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
 
@@ -11982,7 +11989,7 @@
 // This only for version 99.
 TEST_P(QuicFramerTest, IetfFrameTypeEncodingErrorUnknown1Byte) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -12014,7 +12021,7 @@
 
 TEST_P(QuicFramerTest, IetfFrameTypeEncodingErrorUnknown2Bytes) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -12047,7 +12054,7 @@
 
 TEST_P(QuicFramerTest, IetfFrameTypeEncodingErrorUnknown4Bytes) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -12080,7 +12087,7 @@
 
 TEST_P(QuicFramerTest, IetfFrameTypeEncodingErrorUnknown8Bytes) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -12116,7 +12123,7 @@
 // Look at the frame-type encoded in 2, 4, and 8 bytes.
 TEST_P(QuicFramerTest, IetfFrameTypeEncodingErrorKnown2Bytes) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -12149,7 +12156,7 @@
 
 TEST_P(QuicFramerTest, IetfFrameTypeEncodingErrorKnown4Bytes) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -12182,7 +12189,7 @@
 
 TEST_P(QuicFramerTest, IetfFrameTypeEncodingErrorKnown8Bytes) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -12218,7 +12225,7 @@
 // Just look at 2-byte encoding.
 TEST_P(QuicFramerTest, IetfFrameTypeEncodingErrorKnown2BytesAllTypes) {
   // This test only for version 99.
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     return;
   }
   SetDecrypterLevel(ENCRYPTION_FORWARD_SECURE);
@@ -12618,7 +12625,7 @@
 }
 
 TEST_P(QuicFramerTest, RetireConnectionIdFrame) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This frame is only for version 99.
     return;
   }
@@ -12663,7 +12670,7 @@
 }
 
 TEST_P(QuicFramerTest, BuildRetireConnectionIdFramePacket) {
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     // This frame is only for version 99.
     return;
   }
@@ -12789,7 +12796,7 @@
 
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
@@ -12890,7 +12897,7 @@
 
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
@@ -13031,7 +13038,7 @@
 
   unsigned char* p = packet;
   size_t p_size = QUIC_ARRAYSIZE(packet);
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     p = packet99;
     p_size = QUIC_ARRAYSIZE(packet99);
   } else if (framer_.transport_version() > QUIC_VERSION_44) {
@@ -13044,7 +13051,7 @@
 
   QuicEncryptedPacket encrypted(AsChars(p), p_size, false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     EXPECT_EQ(framer_.detailed_error(),
               "Underflow with ack block length 6 latest ack block end is 5.");
   } else {
diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc
index eb0596f..b29dacb 100644
--- a/quic/core/quic_packet_creator.cc
+++ b/quic/core/quic_packet_creator.cc
@@ -545,7 +545,7 @@
   if (!has_trailing_stream_frame) {
     return 0;
   }
-  if (framer_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_->transport_version())) {
     return QuicDataWriter::GetVarInt62Len(
         queued_frames_.back().stream_frame.data_length);
   }
@@ -651,7 +651,7 @@
 
 OwningSerializedPacketPointer
 QuicPacketCreator::SerializeConnectivityProbingPacket() {
-  QUIC_BUG_IF(framer_->transport_version() == QUIC_VERSION_99)
+  QUIC_BUG_IF(VersionHasIetfQuicFrames(framer_->transport_version()))
       << "Must not be version 99 to serialize padded ping connectivity probe";
   QuicPacketHeader header;
   // FillPacketHeader increments packet_number_.
@@ -684,7 +684,7 @@
 OwningSerializedPacketPointer
 QuicPacketCreator::SerializePathChallengeConnectivityProbingPacket(
     QuicPathFrameBuffer* payload) {
-  QUIC_BUG_IF(framer_->transport_version() != QUIC_VERSION_99)
+  QUIC_BUG_IF(!VersionHasIetfQuicFrames(framer_->transport_version()))
       << "Must be version 99 to serialize path challenge connectivity probe, "
          "is version "
       << framer_->transport_version();
@@ -720,7 +720,7 @@
 QuicPacketCreator::SerializePathResponseConnectivityProbingPacket(
     const QuicDeque<QuicPathFrameBuffer>& payloads,
     const bool is_padded) {
-  QUIC_BUG_IF(framer_->transport_version() != QUIC_VERSION_99)
+  QUIC_BUG_IF(!VersionHasIetfQuicFrames(framer_->transport_version()))
       << "Must be version 99 to serialize path response connectivity probe, is "
          "version "
       << framer_->transport_version();
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index bc30af9..3a4978c 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -576,7 +576,7 @@
 
 TEST_P(QuicPacketCreatorTest, SerializeConnectionClose) {
   QuicConnectionCloseFrame frame(QUIC_NO_ERROR, "error");
-  if (GetParam().version.transport_version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(GetParam().version.transport_version)) {
     frame.close_type = IETF_QUIC_TRANSPORT_CONNECTION_CLOSE;
   }
 
@@ -832,7 +832,7 @@
     creator_.set_encryption_level(level);
 
     OwningSerializedPacketPointer encrypted;
-    if (GetParam().version.transport_version == QUIC_VERSION_99) {
+    if (VersionHasIetfQuicFrames(GetParam().version.transport_version)) {
       QuicPathFrameBuffer payload = {
           {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xfe}};
       encrypted =
@@ -847,7 +847,7 @@
       EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
       EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
       EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-      if (GetParam().version.transport_version == QUIC_VERSION_99) {
+      if (VersionHasIetfQuicFrames(GetParam().version.transport_version)) {
         EXPECT_CALL(framer_visitor_, OnPathChallengeFrame(_));
         EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
       } else {
@@ -863,7 +863,7 @@
 }
 
 TEST_P(QuicPacketCreatorTest, SerializePathChallengeProbePacket) {
-  if (GetParam().version.transport_version != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(GetParam().version.transport_version)) {
     return;
   }
   QuicPathFrameBuffer payload = {
@@ -894,7 +894,7 @@
 }
 
 TEST_P(QuicPacketCreatorTest, SerializePathResponseProbePacket1PayloadPadded) {
-  if (GetParam().version.transport_version != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(GetParam().version.transport_version)) {
     return;
   }
   QuicPathFrameBuffer payload0 = {
@@ -928,7 +928,7 @@
 
 TEST_P(QuicPacketCreatorTest,
        SerializePathResponseProbePacket1PayloadUnPadded) {
-  if (GetParam().version.transport_version != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(GetParam().version.transport_version)) {
     return;
   }
   QuicPathFrameBuffer payload0 = {
@@ -960,7 +960,7 @@
 }
 
 TEST_P(QuicPacketCreatorTest, SerializePathResponseProbePacket2PayloadsPadded) {
-  if (GetParam().version.transport_version != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(GetParam().version.transport_version)) {
     return;
   }
   QuicPathFrameBuffer payload0 = {
@@ -997,7 +997,7 @@
 
 TEST_P(QuicPacketCreatorTest,
        SerializePathResponseProbePacket2PayloadsUnPadded) {
-  if (GetParam().version.transport_version != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(GetParam().version.transport_version)) {
     return;
   }
   QuicPathFrameBuffer payload0 = {
@@ -1032,7 +1032,7 @@
 }
 
 TEST_P(QuicPacketCreatorTest, SerializePathResponseProbePacket3PayloadsPadded) {
-  if (GetParam().version.transport_version != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(GetParam().version.transport_version)) {
     return;
   }
   QuicPathFrameBuffer payload0 = {
@@ -1072,7 +1072,7 @@
 
 TEST_P(QuicPacketCreatorTest,
        SerializePathResponseProbePacket3PayloadsUnpadded) {
-  if (GetParam().version.transport_version != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(GetParam().version.transport_version)) {
     return;
   }
   QuicPathFrameBuffer payload0 = {
diff --git a/quic/core/quic_packet_generator_test.cc b/quic/core/quic_packet_generator_test.cc
index 6f3f8f3..de2c927 100644
--- a/quic/core/quic_packet_generator_test.cc
+++ b/quic/core/quic_packet_generator_test.cc
@@ -980,7 +980,7 @@
   // Send some data and a control frame
   MakeIOVector("quux", &iov_);
   generator_.ConsumeData(3, &iov_, 1u, iov_.iov_len, 0, NO_FIN);
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     generator_.ConsumeRetransmittableControlFrame(
         QuicFrame(CreateGoAwayFrame()),
         /*bundle_ack=*/false);
@@ -1002,7 +1002,7 @@
   } else {
     contents.num_ack_frames = 1;
   }
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     contents.num_goaway_frames = 1;
   } else {
     contents.num_goaway_frames = 0;
@@ -1060,7 +1060,7 @@
       generator_.ConsumeData(3, &iov_, 1u, iov_.iov_len, 0, FIN);
   EXPECT_EQ(data_len, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     generator_.ConsumeRetransmittableControlFrame(
         QuicFrame(CreateGoAwayFrame()),
         /*bundle_ack=*/false);
@@ -1084,7 +1084,7 @@
 
   // The second should have the remainder of the stream data.
   PacketContents contents2;
-  if (framer_.transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
     contents2.num_goaway_frames = 1;
   } else {
     contents2.num_goaway_frames = 0;
@@ -1313,7 +1313,7 @@
   delegate_.SetCanWriteAnything();
 
   OwningSerializedPacketPointer probing_packet;
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     QuicPathFrameBuffer payload = {
         {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xfe}};
     probing_packet =
@@ -1326,7 +1326,7 @@
       probing_packet->encrypted_buffer, probing_packet->encrypted_length)));
 
   EXPECT_EQ(2u, simple_framer_.num_frames());
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     EXPECT_EQ(1u, simple_framer_.path_challenge_frames().size());
   } else {
     EXPECT_EQ(1u, simple_framer_.ping_frames().size());
@@ -1464,7 +1464,7 @@
   QuicStringPiece error_details(buf, 2000);
   QuicConnectionCloseFrame* frame = new QuicConnectionCloseFrame(
       QUIC_PACKET_WRITE_ERROR, std::string(error_details));
-  if (framer_.transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(framer_.transport_version())) {
     frame->close_type = IETF_QUIC_TRANSPORT_CONNECTION_CLOSE;
   }
   generator_.ConsumeRetransmittableControlFrame(QuicFrame(frame),
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index be6a2b3..efa3144 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -119,7 +119,7 @@
     QuicStreamId id =
         QuicUtils::GetCryptoStreamId(connection_->transport_version());
     largest_static_stream_id_ = std::max(id, largest_static_stream_id_);
-    if (connection_->transport_version() == QUIC_VERSION_99) {
+    if (VersionHasIetfQuicFrames(connection_->transport_version())) {
       v99_streamid_manager_.RegisterStaticStream(id, false);
     }
   }
@@ -139,7 +139,7 @@
       << " vs: " << largest_static_stream_id_;
   largest_static_stream_id_ = std::max(id, largest_static_stream_id_);
 
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     v99_streamid_manager_.RegisterStaticStream(id, false);
   }
 }
@@ -149,7 +149,7 @@
   DCHECK(eliminate_static_stream_map_);
   QuicStreamId stream_id = stream->id();
   dynamic_stream_map_[stream_id] = std::move(stream);
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     v99_streamid_manager_.RegisterStaticStream(stream_id,
                                                stream_already_counted);
   }
@@ -242,7 +242,7 @@
   // could not call OnStopSending... This is just a check that is good when
   // both a new protocol and a new implementation of that protocol are both
   // being developed.
-  DCHECK_EQ(QUIC_VERSION_99, connection_->transport_version());
+  DCHECK(VersionHasIetfQuicFrames(connection_->transport_version()));
 
   QuicStreamId stream_id = frame.stream_id;
   // If Stream ID is invalid then close the connection.
@@ -746,14 +746,14 @@
   if (connection()->connected()) {
     // Only send if still connected.
     if (close_write_side_only) {
-      DCHECK_EQ(QUIC_VERSION_99, connection_->transport_version());
+      DCHECK(VersionHasIetfQuicFrames(connection_->transport_version()));
       // Send a RST_STREAM frame.
       control_frame_manager_.WriteOrBufferRstStream(id, error, bytes_written);
     } else {
       // Send a RST_STREAM frame plus, if version 99, an IETF
       // QUIC STOP_SENDING frame. Both sre sent to emulate
       // the two-way close that Google QUIC's RST_STREAM does.
-      if (connection_->transport_version() == QUIC_VERSION_99) {
+      if (VersionHasIetfQuicFrames(connection_->transport_version())) {
         QuicConnection::ScopedPacketFlusher flusher(
             connection(), QuicConnection::SEND_ACK_IF_QUEUED);
         control_frame_manager_.WriteOrBufferRstStream(id, error, bytes_written);
@@ -773,7 +773,7 @@
     CloseStreamInner(id, true);
     return;
   }
-  DCHECK_EQ(QUIC_VERSION_99, connection_->transport_version());
+  DCHECK(VersionHasIetfQuicFrames(connection_->transport_version()));
 
   DynamicStreamMap::iterator it = dynamic_stream_map_.find(id);
   if (it != dynamic_stream_map_.end()) {
@@ -798,7 +798,7 @@
 void QuicSession::SendGoAway(QuicErrorCode error_code,
                              const std::string& reason) {
   // GOAWAY frame is not supported in v99.
-  DCHECK_NE(QUIC_VERSION_99, connection_->transport_version());
+  DCHECK(!VersionHasIetfQuicFrames(connection_->transport_version()));
   if (goaway_sent_) {
     return;
   }
@@ -907,7 +907,7 @@
       --num_draining_incoming_streams_;
     }
     draining_streams_.erase(stream_id);
-  } else if (connection_->transport_version() == QUIC_VERSION_99) {
+  } else if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     // Stream was not draining, but we did have a fin or rst, so we can now
     // free the stream ID if version 99.
     if (had_fin_or_rst) {
@@ -918,7 +918,7 @@
   stream->OnClose();
 
   if (!stream_was_draining && !IsIncomingStream(stream_id) && had_fin_or_rst &&
-      connection_->transport_version() != QUIC_VERSION_99) {
+      !VersionHasIetfQuicFrames(connection_->transport_version())) {
     // Streams that first became draining already called OnCanCreate...
     // This covers the case where the stream went directly to being closed.
     OnCanCreateNewOutgoingStream();
@@ -943,7 +943,7 @@
 
   --num_dynamic_incoming_streams_;
 
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     v99_streamid_manager_.OnStreamClosed(stream_id);
   }
 
@@ -977,10 +977,10 @@
   locally_closed_streams_highest_offset_.erase(it);
   if (IsIncomingStream(stream_id)) {
     --num_locally_closed_incoming_streams_highest_offset_;
-    if (connection_->transport_version() == QUIC_VERSION_99) {
+    if (VersionHasIetfQuicFrames(connection_->transport_version())) {
       v99_streamid_manager_.OnStreamClosed(stream_id);
     }
-  } else if (connection_->transport_version() != QUIC_VERSION_99) {
+  } else if (!VersionHasIetfQuicFrames(connection_->transport_version())) {
     OnCanCreateNewOutgoingStream();
   }
 }
@@ -1000,7 +1000,7 @@
 void QuicSession::OnConfigNegotiated() {
   connection_->SetFromConfig(config_);
 
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     uint32_t max_streams = 0;
     if (config_.HasReceivedMaxIncomingBidirectionalStreams()) {
       max_streams = config_.ReceivedMaxIncomingBidirectionalStreams();
@@ -1051,7 +1051,7 @@
     config_.SetStatelessResetTokenToSend(GetStatelessResetToken());
   }
 
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     v99_streamid_manager_.SetMaxOpenIncomingBidirectionalStreams(
         config_.GetMaxIncomingBidirectionalStreamsToSend());
     v99_streamid_manager_.SetMaxOpenIncomingUnidirectionalStreams(
@@ -1251,21 +1251,21 @@
 }
 
 QuicStreamId QuicSession::GetNextOutgoingBidirectionalStreamId() {
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     return v99_streamid_manager_.GetNextOutgoingBidirectionalStreamId();
   }
   return stream_id_manager_.GetNextOutgoingStreamId();
 }
 
 QuicStreamId QuicSession::GetNextOutgoingUnidirectionalStreamId() {
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     return v99_streamid_manager_.GetNextOutgoingUnidirectionalStreamId();
   }
   return stream_id_manager_.GetNextOutgoingStreamId();
 }
 
 bool QuicSession::CanOpenNextOutgoingBidirectionalStream() {
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     return v99_streamid_manager_.CanOpenNextOutgoingBidirectionalStream();
   }
   return stream_id_manager_.CanOpenNextOutgoingStream(
@@ -1273,7 +1273,7 @@
 }
 
 bool QuicSession::CanOpenNextOutgoingUnidirectionalStream() {
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     return v99_streamid_manager_.CanOpenNextOutgoingUnidirectionalStream();
   }
   return stream_id_manager_.CanOpenNextOutgoingStream(
@@ -1301,7 +1301,7 @@
     if (IsIncomingStream(stream_id)) {
       ++num_draining_incoming_streams_;
     }
-    if (connection_->transport_version() == QUIC_VERSION_99) {
+    if (VersionHasIetfQuicFrames(connection_->transport_version())) {
       v99_streamid_manager_.OnStreamClosed(stream_id);
     }
   }
@@ -1313,7 +1313,7 @@
 
 bool QuicSession::MaybeIncreaseLargestPeerStreamId(
     const QuicStreamId stream_id) {
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     return v99_streamid_manager_.MaybeIncreaseLargestPeerStreamId(stream_id);
   }
   return stream_id_manager_.MaybeIncreaseLargestPeerStreamId(stream_id);
@@ -1371,7 +1371,7 @@
     return nullptr;
   }
 
-  if (connection_->transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(connection_->transport_version())) {
     // TODO(fayang): Let LegacyQuicStreamIdManager count open streams and make
     // CanOpenIncomingStream interface cosistent with that of v99.
     if (!stream_id_manager_.CanOpenIncomingStream(
@@ -1387,7 +1387,7 @@
 
 void QuicSession::set_largest_peer_created_stream_id(
     QuicStreamId largest_peer_created_stream_id) {
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     v99_streamid_manager_.SetLargestPeerCreatedStreamId(
         largest_peer_created_stream_id);
     return;
@@ -1404,7 +1404,7 @@
     return false;
   }
 
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     return !v99_streamid_manager_.IsAvailableStream(id);
   }
 
@@ -1531,21 +1531,21 @@
 }
 
 size_t QuicSession::MaxAvailableBidirectionalStreams() const {
-  if (connection()->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection()->transport_version())) {
     return v99_streamid_manager_.GetMaxAllowdIncomingBidirectionalStreams();
   }
   return stream_id_manager_.MaxAvailableStreams();
 }
 
 size_t QuicSession::MaxAvailableUnidirectionalStreams() const {
-  if (connection()->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection()->transport_version())) {
     return v99_streamid_manager_.GetMaxAllowdIncomingUnidirectionalStreams();
   }
   return stream_id_manager_.MaxAvailableStreams();
 }
 
 bool QuicSession::IsIncomingStream(QuicStreamId id) const {
-  if (connection()->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection()->transport_version())) {
     return v99_streamid_manager_.IsIncomingStream(id);
   }
   return stream_id_manager_.IsIncomingStream(id);
@@ -1930,14 +1930,14 @@
 void QuicSession::OnCanCreateNewOutgoingStream() {}
 
 QuicStreamId QuicSession::next_outgoing_bidirectional_stream_id() const {
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     return v99_streamid_manager_.next_outgoing_bidirectional_stream_id();
   }
   return stream_id_manager_.next_outgoing_stream_id();
 }
 
 QuicStreamId QuicSession::next_outgoing_unidirectional_stream_id() const {
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     return v99_streamid_manager_.next_outgoing_unidirectional_stream_id();
   }
   return stream_id_manager_.next_outgoing_stream_id();
@@ -1952,14 +1952,14 @@
 }
 
 size_t QuicSession::max_open_incoming_bidirectional_streams() const {
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     return v99_streamid_manager_.GetMaxAllowdIncomingBidirectionalStreams();
   }
   return stream_id_manager_.max_open_incoming_streams();
 }
 
 size_t QuicSession::max_open_incoming_unidirectional_streams() const {
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     return v99_streamid_manager_.GetMaxAllowdIncomingUnidirectionalStreams();
   }
   return stream_id_manager_.max_open_incoming_streams();
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 584593a..0d9af18 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -185,7 +185,7 @@
     // Enforce the limit on the number of open streams.
     if (GetNumOpenIncomingStreams() + 1 >
             max_open_incoming_bidirectional_streams() &&
-        connection()->transport_version() != QUIC_VERSION_99) {
+        !VersionHasIetfQuicFrames(connection()->transport_version())) {
       // No need to do this test for version 99; it's done by
       // QuicSession::GetOrCreateDynamicStream.
       connection()->CloseConnection(
@@ -357,7 +357,7 @@
   }
 
   void CloseStream(QuicStreamId id) {
-    if (session_.connection()->transport_version() == QUIC_VERSION_99 &&
+    if (VersionHasIetfQuicFrames(session_.connection()->transport_version()) &&
         QuicUtils::GetStreamType(id, session_.perspective(),
                                  session_.IsIncomingStream(id)) ==
             READ_UNIDIRECTIONAL) {
@@ -366,7 +366,8 @@
       EXPECT_CALL(*connection_, OnStreamReset(_, _)).Times(0);
     } else {
       // Verify reset IS sent for BIDIRECTIONAL streams.
-      if (session_.connection()->transport_version() == QUIC_VERSION_99) {
+      if (VersionHasIetfQuicFrames(
+              session_.connection()->transport_version())) {
         // Once for the RST_STREAM, Once for the STOP_SENDING
         EXPECT_CALL(*connection_, SendControlFrame(_))
             .Times(2)
@@ -417,7 +418,7 @@
     // needs to do the stream count where #1 is 0/1/2/3, and not
     // take into account that stream 0 is special.
     QuicStreamId id =
-        ((stream_count - 1) * QuicUtils::StreamIdDelta(QUIC_VERSION_99));
+        ((stream_count - 1) * QuicUtils::StreamIdDelta(transport_version()));
     if (!bidirectional) {
       id |= 0x2;
     }
@@ -563,7 +564,7 @@
 }
 
 TEST_P(QuicSessionTestServer, MaxAvailableBidirectionalStreams) {
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     EXPECT_EQ(session_.max_open_incoming_bidirectional_streams(),
               session_.MaxAvailableBidirectionalStreams());
   } else {
@@ -576,7 +577,7 @@
 }
 
 TEST_P(QuicSessionTestServer, MaxAvailableUnidirectionalStreams) {
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     EXPECT_EQ(session_.max_open_incoming_unidirectional_streams(),
               session_.MaxAvailableUnidirectionalStreams());
   } else {
@@ -681,8 +682,8 @@
   // A stream ID which is too large to create.
   stream_id2 = GetNthClientInitiatedBidirectionalId(
       session_.MaxAvailableBidirectionalStreams() + 2);
-  if (transport_version() == QUIC_VERSION_99) {
-    // V99 terminates the connection with invalid stream id
+  if (VersionHasIetfQuicFrames(transport_version())) {
+    // IETF QUIC terminates the connection with invalid stream id
     EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_STREAM_ID, _, _));
   } else {
     // other versions terminate the connection with
@@ -700,8 +701,8 @@
   // A stream ID which is too large to create.
   stream_id2 = GetNthClientInitiatedUnidirectionalId(
       session_.MaxAvailableUnidirectionalStreams() + 2);
-  if (transport_version() == QUIC_VERSION_99) {
-    // V99 terminates the connection with invalid stream id
+  if (VersionHasIetfQuicFrames(transport_version())) {
+    // IETF QUIC terminates the connection with invalid stream id
     EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_STREAM_ID, _, _));
   } else {
     // other versions terminate the connection with
@@ -715,7 +716,7 @@
 TEST_P(QuicSessionTestServer, ManyAvailableBidirectionalStreams) {
   // When max_open_streams_ is 200, should be able to create 200 streams
   // out-of-order, that is, creating the one with the largest stream ID first.
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     QuicSessionPeer::SetMaxOpenIncomingBidirectionalStreams(&session_, 200);
     // Smaller limit on unidirectional streams to help detect crossed wires.
     QuicSessionPeer::SetMaxOpenIncomingUnidirectionalStreams(&session_, 50);
@@ -732,7 +733,7 @@
   EXPECT_NE(nullptr, session_.GetOrCreateDynamicStream(
                          GetNthClientInitiatedBidirectionalId(199)));
 
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // If IETF QUIC, check to make sure that creating bidirectional
     // streams does not mess up the unidirectional streams.
     stream_id = GetNthClientInitiatedUnidirectionalId(0);
@@ -758,7 +759,7 @@
 TEST_P(QuicSessionTestServer, ManyAvailableUnidirectionalStreams) {
   // When max_open_streams_ is 200, should be able to create 200 streams
   // out-of-order, that is, creating the one with the largest stream ID first.
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     QuicSessionPeer::SetMaxOpenIncomingUnidirectionalStreams(&session_, 200);
     // Smaller limit on unidirectional streams to help detect crossed wires.
     QuicSessionPeer::SetMaxOpenIncomingBidirectionalStreams(&session_, 50);
@@ -774,7 +775,7 @@
   EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
   EXPECT_NE(nullptr, session_.GetOrCreateDynamicStream(
                          GetNthClientInitiatedUnidirectionalId(199)));
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // If IETF QUIC, check to make sure that creating unidirectional
     // streams does not mess up the bidirectional streams.
     stream_id = GetNthClientInitiatedBidirectionalId(0);
@@ -1170,7 +1171,7 @@
 }
 
 TEST_P(QuicSessionTestServer, SendGoAway) {
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // GoAway frames are not in version 99
     return;
   }
@@ -1194,7 +1195,7 @@
 }
 
 TEST_P(QuicSessionTestServer, DoNotSendGoAwayTwice) {
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // TODO(b/118808809): Enable this test for version 99 when GOAWAY is
     // supported.
     return;
@@ -1207,7 +1208,7 @@
 }
 
 TEST_P(QuicSessionTestServer, InvalidGoAway) {
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // TODO(b/118808809): Enable this test for version 99 when GOAWAY is
     // supported.
     return;
@@ -1235,7 +1236,7 @@
       .WillOnce(Invoke(
           connection_,
           &MockQuicConnection::ReallySendConnectivityProbingResponsePacket));
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // Need to explicitly do this to emulate the reception of a PathChallenge,
     // which stores its payload for use in generating the response.
     connection_->OnPathChallengeFrame(
@@ -1248,9 +1249,9 @@
 
 // Same as above, but check that if there are two PATH_CHALLENGE frames in the
 // packet, the response has both of them AND we do not do migration.  This for
-// V99 only.
+// IETF QUIC only.
 TEST_P(QuicSessionTestServer, ServerReplyToConnectivityProbes) {
-  if (transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     return;
   }
   if (GetParam().handshake_protocol == PROTOCOL_TLS1_3) {
@@ -1472,10 +1473,10 @@
   QuicRstStreamFrame rst_frame(kInvalidControlFrameId, stream->id(),
                                QUIC_STREAM_CANCELLED, kByteOffset);
   session_.OnRstStream(rst_frame);
-  if (transport_version() == QUIC_VERSION_99) {
-    // The test is predicated on the stream being fully closed. For V99, the
-    // RST_STREAM only does one side (the read side from the perspective of the
-    // node receiving the RST_STREAM). This is needed to fully close the
+  if (VersionHasIetfQuicFrames(transport_version())) {
+    // The test is predicated on the stream being fully closed. For IETF QUIC,
+    // the RST_STREAM only does one side (the read side from the perspective of
+    // the node receiving the RST_STREAM). This is needed to fully close the
     // stream and therefore fulfill all of the expects.
     QuicStopSendingFrame frame(kInvalidControlFrameId, stream->id(),
                                QUIC_STREAM_CANCELLED);
@@ -1650,10 +1651,10 @@
 
 TEST_P(QuicSessionTestServer, TooManyUnfinishedStreamsCauseServerRejectStream) {
   // If a buggy/malicious peer creates too many streams that are not ended
-  // with a FIN or RST then we send an RST to refuse streams. For V99 the
+  // with a FIN or RST then we send an RST to refuse streams. For IETF QUIC the
   // connection is closed.
   const QuicStreamId kMaxStreams = 5;
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     QuicSessionPeer::SetMaxOpenIncomingBidirectionalStreams(&session_,
                                                             kMaxStreams);
   } else {
@@ -1669,7 +1670,7 @@
     QuicStreamFrame data1(i, false, 0, QuicStringPiece("HT"));
     session_.OnStreamFrame(data1);
     // EXPECT_EQ(1u, session_.GetNumOpenStreams());
-    if (transport_version() == QUIC_VERSION_99) {
+    if (VersionHasIetfQuicFrames(transport_version())) {
       // Expect two control frames, RST STREAM and STOP SENDING
       EXPECT_CALL(*connection_, SendControlFrame(_))
           .Times(2)
@@ -1685,7 +1686,7 @@
     session_.CloseStream(i);
   }
 
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     EXPECT_CALL(
         *connection_,
         CloseConnection(QUIC_INVALID_STREAM_ID,
@@ -1728,7 +1729,7 @@
 }
 
 TEST_P(QuicSessionTestServer, PendingStreams) {
-  if (connection_->transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     return;
   }
   session_.set_uses_pending_streams(true);
@@ -1745,7 +1746,7 @@
 }
 
 TEST_P(QuicSessionTestServer, RstPendingStreams) {
-  if (connection_->transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     return;
   }
   session_.set_uses_pending_streams(true);
@@ -1774,16 +1775,16 @@
   // Verify that a draining stream (which has received a FIN but not consumed
   // it) does not count against the open quota (because it is closed from the
   // protocol point of view).
-  if (transport_version() == QUIC_VERSION_99) {
-    // On v99, we will expect to see a MAX_STREAMS go out when there are not
-    // enough streams to create the next one.
+  if (VersionHasIetfQuicFrames(transport_version())) {
+    // On IETF QUIC, we will expect to see a MAX_STREAMS go out when there are
+    // not enough streams to create the next one.
     EXPECT_CALL(*connection_, SendControlFrame(_)).Times(1);
   } else {
     EXPECT_CALL(*connection_, SendControlFrame(_)).Times(0);
   }
   EXPECT_CALL(*connection_, OnStreamReset(_, QUIC_REFUSED_STREAM)).Times(0);
   const QuicStreamId kMaxStreams = 5;
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     QuicSessionPeer::SetMaxOpenIncomingBidirectionalStreams(&session_,
                                                             kMaxStreams);
   } else {
@@ -1908,7 +1909,7 @@
 
   QuicRstStreamFrame rst1(kInvalidControlFrameId, stream2->id(),
                           QUIC_ERROR_PROCESSING_STREAM, 0);
-  if (transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     EXPECT_CALL(session_, OnCanCreateNewOutgoingStream()).Times(1);
   }
   session_.OnRstStream(rst1);
@@ -1934,7 +1935,7 @@
   // Just for the RST_STREAM
   EXPECT_CALL(*connection_, SendControlFrame(_))
       .WillOnce(Invoke(&session_, &TestSession::ClearControlFrame));
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     EXPECT_CALL(*connection_,
                 OnStreamReset(stream2->id(), QUIC_STREAM_CANCELLED));
   } else {
@@ -1943,10 +1944,10 @@
   }
   stream2->OnStreamReset(rst_frame);
 
-  if (transport_version() == QUIC_VERSION_99) {
-    // The test is predicated on the stream being fully closed. For V99, the
-    // RST_STREAM only does one side (the read side from the perspective of the
-    // node receiving the RST_STREAM). This is needed to fully close the
+  if (VersionHasIetfQuicFrames(transport_version())) {
+    // The test is predicated on the stream being fully closed. For IETF QUIC,
+    // the RST_STREAM only does one side (the read side from the perspective of
+    // the node receiving the RST_STREAM). This is needed to fully close the
     // stream and therefore fulfill all of the expects.
     QuicStopSendingFrame frame(kInvalidControlFrameId, stream2->id(),
                                QUIC_STREAM_CANCELLED);
@@ -1957,7 +1958,7 @@
   EXPECT_EQ(stream2->id(), session_.closed_streams()->front()->id());
 
   TestStream* stream4 = session_.CreateOutgoingBidirectionalStream();
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // Once for the RST_STREAM, once for the STOP_SENDING
     EXPECT_CALL(*connection_, SendControlFrame(_))
         .Times(2)
@@ -1971,7 +1972,7 @@
   stream4->WriteOrBufferData(body, false, nullptr);
   // Note well: Reset() actually closes the stream in both directions. For
   // GOOGLE QUIC it sends a RST_STREAM (which does a 2-way close), for IETF
-  // QUIC/V99 it sends both a RST_STREAM and a STOP_SENDING (each of which
+  // QUIC it sends both a RST_STREAM and a STOP_SENDING (each of which
   // closes in only one direction).
   stream4->Reset(QUIC_STREAM_CANCELLED);
   EXPECT_FALSE(QuicContainsKey(session_.zombie_streams(), stream4->id()));
@@ -2155,7 +2156,7 @@
   // yet, so an RST is sent.
   EXPECT_CALL(*stream, OnCanWrite())
       .WillOnce(Invoke(stream, &QuicStream::OnClose));
-  if (transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // Once for the RST_STREAM, once for the STOP_SENDING
     EXPECT_CALL(*connection_, SendControlFrame(_))
         .Times(2)
@@ -2382,8 +2383,8 @@
 // properly and that nothing in the call path interferes with the check.
 // First test make sure that streams with ids below the limit are accepted.
 TEST_P(QuicSessionTestServer, NewStreamIdBelowLimit) {
-  if (transport_version() != QUIC_VERSION_99) {
-    // Applicable only to V99
+  if (!VersionHasIetfQuicFrames(transport_version())) {
+    // Applicable only to IETF QUIC
     return;
   }
   QuicStreamId bidirectional_stream_id = StreamCountToId(
@@ -2412,8 +2413,8 @@
 
 // Accept a stream with an ID that equals the limit.
 TEST_P(QuicSessionTestServer, NewStreamIdAtLimit) {
-  if (transport_version() != QUIC_VERSION_99) {
-    // Applicable only to V99
+  if (!VersionHasIetfQuicFrames(transport_version())) {
+    // Applicable only to IETF QUIC
     return;
   }
   QuicStreamId bidirectional_stream_id = StreamCountToId(
@@ -2437,8 +2438,8 @@
 
 // Close the connection if the id exceeds the limit.
 TEST_P(QuicSessionTestServer, NewStreamIdAboveLimit) {
-  if (transport_version() != QUIC_VERSION_99) {
-    // Applicable only to V99
+  if (!VersionHasIetfQuicFrames(transport_version())) {
+    // Applicable only to IETF QUIC
     return;
   }
   QuicStreamId bidirectional_stream_id = StreamCountToId(
@@ -2471,8 +2472,8 @@
 // Check that the OnStopSendingFrame upcall handles bad input properly
 // First test checks that invalid stream ids are handled.
 TEST_P(QuicSessionTestServer, OnStopSendingInputInvalidStreamId) {
-  if (transport_version() != QUIC_VERSION_99) {
-    // Applicable only to V99
+  if (!VersionHasIetfQuicFrames(transport_version())) {
+    // Applicable only to IETF QUIC
     return;
   }
   // Check that "invalid" stream ids are rejected.
@@ -2488,8 +2489,8 @@
 // Second test, streams in the static stream map are not subject to
 // STOP_SENDING; it's ignored.
 TEST_P(QuicSessionTestServer, OnStopSendingInputStaticStreams) {
-  if (transport_version() != QUIC_VERSION_99) {
-    // Applicable only to V99
+  if (!VersionHasIetfQuicFrames(transport_version())) {
+    // Applicable only to IETF QUIC
     return;
   }
   QuicStreamId stream_id = 0;
@@ -2514,8 +2515,8 @@
 // Third test, if stream id specifies a closed stream:
 // return true and do not close the connection.
 TEST_P(QuicSessionTestServer, OnStopSendingInputClosedStream) {
-  if (transport_version() != QUIC_VERSION_99) {
-    // Applicable only to V99
+  if (!VersionHasIetfQuicFrames(transport_version())) {
+    // Applicable only to IETF QUIC
     return;
   }
 
@@ -2534,8 +2535,8 @@
 // Fourth test, if stream id specifies a nonexistent stream, return false and
 // close the connection
 TEST_P(QuicSessionTestServer, OnStopSendingInputNonExistentStream) {
-  if (transport_version() != QUIC_VERSION_99) {
-    // Applicable only to V99
+  if (!VersionHasIetfQuicFrames(transport_version())) {
+    // Applicable only to IETF QUIC
     return;
   }
 
@@ -2551,8 +2552,8 @@
 
 // For a valid stream, ensure that all works
 TEST_P(QuicSessionTestServer, OnStopSendingInputValidStream) {
-  if (transport_version() != QUIC_VERSION_99) {
-    // Applicable only to V99
+  if (!VersionHasIetfQuicFrames(transport_version())) {
+    // Applicable only to IETF QUIC
     return;
   }
 
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index 55e910c..6ebda29 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -260,7 +260,8 @@
       buffered_data_threshold_(GetQuicFlag(FLAGS_quic_buffered_data_threshold)),
       is_static_(is_static),
       deadline_(QuicTime::Zero()),
-      type_(session->connection()->transport_version() == QUIC_VERSION_99 &&
+      type_(VersionHasIetfQuicFrames(
+                session->connection()->transport_version()) &&
                     type != CRYPTO
                 ? QuicUtils::GetStreamType(id_,
                                            perspective_,
@@ -387,7 +388,7 @@
   stream_error_ = frame.error_code;
   // Google QUIC closes both sides of the stream in response to a
   // RESET_STREAM, IETF QUIC closes only the read side.
-  if (transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     CloseWriteSide();
   }
   CloseReadSide();
@@ -1119,7 +1120,7 @@
 }
 
 void QuicStream::SendStopSending(uint16_t code) {
-  if (transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     // If the connection is not version 99, do nothing.
     // Do not QUIC_BUG or anything; the application really does not need to know
     // what version the connection is in.
diff --git a/quic/core/quic_stream_id_manager.cc b/quic/core/quic_stream_id_manager.cc
index 7eaa91d..793ee6c 100644
--- a/quic/core/quic_stream_id_manager.cc
+++ b/quic/core/quic_stream_id_manager.cc
@@ -229,7 +229,7 @@
 }
 
 bool QuicStreamIdManager::CanOpenNextOutgoingStream() {
-  DCHECK_EQ(QUIC_VERSION_99, transport_version());
+  DCHECK(VersionHasIetfQuicFrames(transport_version()));
   if (outgoing_stream_count_ < outgoing_max_streams_) {
     return true;
   }
diff --git a/quic/core/quic_stream_id_manager_test.cc b/quic/core/quic_stream_id_manager_test.cc
index 107f472..9f5969e 100644
--- a/quic/core/quic_stream_id_manager_test.cc
+++ b/quic/core/quic_stream_id_manager_test.cc
@@ -161,7 +161,7 @@
     // needs to do the stream count where #1 is 0/1/2/3, and not
     // take into account that stream 0 is special.
     QuicStreamId id =
-        ((stream_count - 1) * QuicUtils::StreamIdDelta(QUIC_VERSION_99));
+        ((stream_count - 1) * QuicUtils::StreamIdDelta(transport_version()));
     if (IsUnidi()) {
       id |= 0x2;
     }
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index d11a7a4..4c5dac7 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -1621,7 +1621,7 @@
   EXPECT_FALSE(stream_->write_side_closed());
   EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream_));
   // Expect to actually see a stop sending if and only if we are in version 99.
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     EXPECT_CALL(*session_, SendStopSending(kStopSendingCode, stream_->id()))
         .Times(1);
   } else {
@@ -1645,7 +1645,7 @@
   QuicRstStreamFrame rst_frame(kInvalidControlFrameId, stream_->id(),
                                QUIC_STREAM_CANCELLED, 1234);
   stream_->OnStreamReset(rst_frame);
-  if (connection_->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     // Version 99/IETF QUIC should close just the read side.
     EXPECT_TRUE(QuicStreamPeer::read_side_closed(stream_));
     EXPECT_FALSE(stream_->write_side_closed());
@@ -1660,7 +1660,7 @@
 // If not V99, the test is a noop (no STOP_SENDING in Google QUIC).
 TEST_P(QuicStreamTest, OnStopSendingReadOrReadWrite) {
   Initialize();
-  if (connection_->transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(connection_->transport_version())) {
     return;
   }
 
@@ -1678,7 +1678,7 @@
 // SendOnlyRstStream must only send a RESET_STREAM (no bundled STOP_SENDING).
 TEST_P(QuicStreamTest, SendOnlyRstStream) {
   Initialize();
-  if (connection_->transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(connection_->transport_version())) {
     return;
   }
 
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc
index 955e82f..88ffa38 100644
--- a/quic/core/quic_utils.cc
+++ b/quic/core/quic_utils.cc
@@ -377,8 +377,9 @@
 
 // static
 QuicStreamId QuicUtils::GetInvalidStreamId(QuicTransportVersion version) {
-  return version == QUIC_VERSION_99 ? std::numeric_limits<QuicStreamId>::max()
-                                    : 0;
+  return VersionHasIetfQuicFrames(version)
+             ? std::numeric_limits<QuicStreamId>::max()
+             : 0;
 }
 
 // static
@@ -413,7 +414,7 @@
   if (id == GetInvalidStreamId(version)) {
     return false;
   }
-  return version == QUIC_VERSION_99 ? id % 2 == 0 : id % 2 != 0;
+  return VersionHasIetfQuicFrames(version) ? id % 2 == 0 : id % 2 != 0;
 }
 
 // static
@@ -422,7 +423,7 @@
   if (id == GetInvalidStreamId(version)) {
     return false;
   }
-  return version == QUIC_VERSION_99 ? id % 2 != 0 : id % 2 == 0;
+  return VersionHasIetfQuicFrames(version) ? id % 2 != 0 : id % 2 == 0;
 }
 
 // static
@@ -459,14 +460,14 @@
 
 // static
 QuicStreamId QuicUtils::StreamIdDelta(QuicTransportVersion version) {
-  return version == QUIC_VERSION_99 ? 4 : 2;
+  return VersionHasIetfQuicFrames(version) ? 4 : 2;
 }
 
 // static
 QuicStreamId QuicUtils::GetFirstBidirectionalStreamId(
     QuicTransportVersion version,
     Perspective perspective) {
-  if (version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(version)) {
     return perspective == Perspective::IS_CLIENT ? 0 : 1;
   } else if (QuicVersionUsesCryptoFrames(version)) {
     return perspective == Perspective::IS_CLIENT ? 1 : 2;
@@ -478,7 +479,7 @@
 QuicStreamId QuicUtils::GetFirstUnidirectionalStreamId(
     QuicTransportVersion version,
     Perspective perspective) {
-  if (version == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(version)) {
     return perspective == Perspective::IS_CLIENT ? 2 : 3;
   } else if (QuicVersionUsesCryptoFrames(version)) {
     return perspective == Perspective::IS_CLIENT ? 1 : 2;
diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index 59005cd..678e067 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -416,6 +416,13 @@
 QUIC_EXPORT_PRIVATE bool VersionLacksHeadersStream(
     QuicTransportVersion transport_version);
 
+// Returns whether |transport_version| makes use of IETF QUIC
+// frames or not.
+QUIC_EXPORT_PRIVATE inline bool VersionHasIetfQuicFrames(
+    QuicTransportVersion transport_version) {
+  return transport_version >= QUIC_VERSION_99;
+}
+
 // Returns the ALPN string to use in TLS for this version of QUIC.
 QUIC_EXPORT_PRIVATE std::string AlpnForVersion(
     ParsedQuicVersion parsed_version);
diff --git a/quic/core/uber_quic_stream_id_manager_test.cc b/quic/core/uber_quic_stream_id_manager_test.cc
index a2498b0..291f63b 100644
--- a/quic/core/uber_quic_stream_id_manager_test.cc
+++ b/quic/core/uber_quic_stream_id_manager_test.cc
@@ -37,26 +37,26 @@
   }
 
   QuicStreamId GetNthClientInitiatedBidirectionalId(int n) {
-    return QuicUtils::GetFirstBidirectionalStreamId(
-               connection_->transport_version(), Perspective::IS_CLIENT) +
+    return QuicUtils::GetFirstBidirectionalStreamId(transport_version(),
+                                                    Perspective::IS_CLIENT) +
            kV99StreamIdIncrement * n;
   }
 
   QuicStreamId GetNthClientInitiatedUnidirectionalId(int n) {
-    return QuicUtils::GetFirstUnidirectionalStreamId(
-               connection_->transport_version(), Perspective::IS_CLIENT) +
+    return QuicUtils::GetFirstUnidirectionalStreamId(transport_version(),
+                                                     Perspective::IS_CLIENT) +
            kV99StreamIdIncrement * n;
   }
 
   QuicStreamId GetNthServerInitiatedBidirectionalId(int n) {
-    return QuicUtils::GetFirstBidirectionalStreamId(
-               connection_->transport_version(), Perspective::IS_SERVER) +
+    return QuicUtils::GetFirstBidirectionalStreamId(transport_version(),
+                                                    Perspective::IS_SERVER) +
            kV99StreamIdIncrement * n;
   }
 
   QuicStreamId GetNthServerInitiatedUnidirectionalId(int n) {
-    return QuicUtils::GetFirstUnidirectionalStreamId(
-               connection_->transport_version(), Perspective::IS_SERVER) +
+    return QuicUtils::GetFirstUnidirectionalStreamId(transport_version(),
+                                                     Perspective::IS_SERVER) +
            kV99StreamIdIncrement * n;
   }
 
@@ -86,10 +86,14 @@
                                Perspective perspective,
                                bool bidirectional) {
     return ((bidirectional) ? QuicUtils::GetFirstBidirectionalStreamId(
-                                  QUIC_VERSION_99, perspective)
+                                  transport_version(), perspective)
                             : QuicUtils::GetFirstUnidirectionalStreamId(
-                                  QUIC_VERSION_99, perspective)) +
-           ((stream_count - 1) * QuicUtils::StreamIdDelta(QUIC_VERSION_99));
+                                  transport_version(), perspective)) +
+           ((stream_count - 1) * QuicUtils::StreamIdDelta(transport_version()));
+  }
+
+  QuicTransportVersion transport_version() {
+    return connection_->transport_version();
   }
 
   MockQuicConnectionHelper helper_;
diff --git a/quic/test_tools/quic_packet_creator_peer.cc b/quic/test_tools/quic_packet_creator_peer.cc
index c5dd747..e7af2d5 100644
--- a/quic/test_tools/quic_packet_creator_peer.cc
+++ b/quic/test_tools/quic_packet_creator_peer.cc
@@ -19,7 +19,7 @@
 void QuicPacketCreatorPeer::SetSendVersionInPacket(
     QuicPacketCreator* creator,
     bool send_version_in_packet) {
-  if (creator->framer_->transport_version() != QUIC_VERSION_99) {
+  if (!VersionHasIetfQuicFrames(creator->framer_->transport_version())) {
     creator->send_version_in_packet_ = send_version_in_packet;
     return;
   }
diff --git a/quic/test_tools/quic_session_peer.cc b/quic/test_tools/quic_session_peer.cc
index 60133cf..3d4c9f3 100644
--- a/quic/test_tools/quic_session_peer.cc
+++ b/quic/test_tools/quic_session_peer.cc
@@ -27,7 +27,7 @@
 // static
 void QuicSessionPeer::SetNextOutgoingBidirectionalStreamId(QuicSession* session,
                                                            QuicStreamId id) {
-  if (session->connection()->transport_version() == QUIC_VERSION_99) {
+  if (VersionHasIetfQuicFrames(session->connection()->transport_version())) {
     session->v99_streamid_manager_.bidirectional_stream_id_manager_
         .next_outgoing_stream_id_ = id;
     return;
@@ -38,8 +38,8 @@
 // static
 void QuicSessionPeer::SetMaxOpenIncomingStreams(QuicSession* session,
                                                 uint32_t max_streams) {
-  if (session->connection()->transport_version() == QUIC_VERSION_99) {
-    QUIC_BUG << "SetmaxOpenIncomingStreams deprecated for IETF QUIC/V99";
+  if (VersionHasIetfQuicFrames(session->connection()->transport_version())) {
+    QUIC_BUG << "SetmaxOpenIncomingStreams deprecated for IETF QUIC";
     session->v99_streamid_manager_.SetMaxOpenIncomingUnidirectionalStreams(
         max_streams);
     session->v99_streamid_manager_.SetMaxOpenIncomingBidirectionalStreams(
@@ -53,9 +53,9 @@
 void QuicSessionPeer::SetMaxOpenIncomingBidirectionalStreams(
     QuicSession* session,
     uint32_t max_streams) {
-  DCHECK_EQ(QUIC_VERSION_99, session->connection()->transport_version())
+  DCHECK(VersionHasIetfQuicFrames(session->connection()->transport_version()))
       << "SetmaxOpenIncomingBidirectionalStreams not supported for Google "
-         "QUIC/not-V99";
+         "QUIC";
   session->v99_streamid_manager_.SetMaxOpenIncomingBidirectionalStreams(
       max_streams);
 }
@@ -63,9 +63,9 @@
 void QuicSessionPeer::SetMaxOpenIncomingUnidirectionalStreams(
     QuicSession* session,
     uint32_t max_streams) {
-  DCHECK_EQ(QUIC_VERSION_99, session->connection()->transport_version())
+  DCHECK(VersionHasIetfQuicFrames(session->connection()->transport_version()))
       << "SetmaxOpenIncomingUnidirectionalStreams not supported for Google "
-         "QUIC/not-V99";
+         "QUIC";
   session->v99_streamid_manager_.SetMaxOpenIncomingUnidirectionalStreams(
       max_streams);
 }
@@ -73,8 +73,8 @@
 // static
 void QuicSessionPeer::SetMaxOpenOutgoingStreams(QuicSession* session,
                                                 uint32_t max_streams) {
-  if (session->connection()->transport_version() == QUIC_VERSION_99) {
-    QUIC_BUG << "SetmaxOpenOutgoingStreams deprecated for IETF QUIC/V99";
+  if (VersionHasIetfQuicFrames(session->connection()->transport_version())) {
+    QUIC_BUG << "SetmaxOpenOutgoingStreams deprecated for IETF QUIC";
     session->v99_streamid_manager_.SetMaxOpenOutgoingUnidirectionalStreams(
         max_streams);
     session->v99_streamid_manager_.SetMaxOpenOutgoingBidirectionalStreams(
@@ -88,9 +88,9 @@
 void QuicSessionPeer::SetMaxOpenOutgoingBidirectionalStreams(
     QuicSession* session,
     uint32_t max_streams) {
-  DCHECK_EQ(QUIC_VERSION_99, session->connection()->transport_version())
+  DCHECK(VersionHasIetfQuicFrames(session->connection()->transport_version()))
       << "SetmaxOpenOutgoingBidirectionalStreams not supported for Google "
-         "QUIC/not-V99";
+         "QUIC";
   session->v99_streamid_manager_.SetMaxOpenOutgoingBidirectionalStreams(
       max_streams);
 }
@@ -98,9 +98,9 @@
 void QuicSessionPeer::SetMaxOpenOutgoingUnidirectionalStreams(
     QuicSession* session,
     uint32_t max_streams) {
-  DCHECK_EQ(QUIC_VERSION_99, session->connection()->transport_version())
+  DCHECK(VersionHasIetfQuicFrames(session->connection()->transport_version()))
       << "SetmaxOpenOutgoingUnidirectionalStreams not supported for Google "
-         "QUIC/not-V99";
+         "QUIC";
   session->v99_streamid_manager_.SetMaxOpenOutgoingUnidirectionalStreams(
       max_streams);
 }
@@ -192,8 +192,10 @@
 
 // static
 bool QuicSessionPeer::IsStreamAvailable(QuicSession* session, QuicStreamId id) {
-  if (session->connection()->transport_version() == QUIC_VERSION_99) {
-    if (id % QuicUtils::StreamIdDelta(QUIC_VERSION_99) < 2) {
+  if (VersionHasIetfQuicFrames(session->connection()->transport_version())) {
+    if (id % QuicUtils::StreamIdDelta(
+                 session->connection()->transport_version()) <
+        2) {
       return QuicContainsKey(
           session->v99_streamid_manager_.bidirectional_stream_id_manager_
               .available_streams_,
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index 100f4e9..dbfca44 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -1185,7 +1185,7 @@
                                Perspective perspective,
                                bool is_incoming,
                                StreamType default_type) {
-  return version == QUIC_VERSION_99
+  return VersionHasIetfQuicFrames(version)
              ? QuicUtils::GetStreamType(id, perspective, is_incoming)
              : default_type;
 }
diff --git a/quic/tools/quic_simple_server_session.cc b/quic/tools/quic_simple_server_session.cc
index d2945e3..247e263 100644
--- a/quic/tools/quic_simple_server_session.cc
+++ b/quic/tools/quic_simple_server_session.cc
@@ -149,7 +149,7 @@
     // Since PromisedStreamInfo are queued in sequence, the corresponding
     // index for it in promised_streams_ can be calculated.
     QuicStreamId next_stream_id = next_outgoing_unidirectional_stream_id();
-    if (connection()->transport_version() == QUIC_VERSION_99) {
+    if (VersionHasIetfQuicFrames(connection()->transport_version())) {
       DCHECK(!QuicUtils::IsBidirectionalStreamId(frame.stream_id));
     }
     DCHECK_GE(frame.stream_id, next_stream_id);
diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc
index 457f3fa..1304021 100644
--- a/quic/tools/quic_simple_server_session_test.cc
+++ b/quic/tools/quic_simple_server_session_test.cc
@@ -232,7 +232,7 @@
         ->OnSuccessfulVersionNegotiation(supported_versions.front());
     visitor_ = QuicConnectionPeer::GetVisitor(connection_);
 
-    if (IsVersion99()) {
+    if (VersionHasIetfQuicFrames(transport_version())) {
       EXPECT_CALL(*connection_, SendControlFrame(_))
           .WillRepeatedly(Invoke(
               this, &QuicSimpleServerSessionTest::ClearMaxStreamsControlFrame));
@@ -250,8 +250,8 @@
         connection_->transport_version(), n);
   }
 
-  bool IsVersion99() const {
-    return connection_->transport_version() == QUIC_VERSION_99;
+  QuicTransportVersion transport_version() const {
+    return connection_->transport_version();
   }
 
   void InjectStopSending(QuicStreamId stream_id,
@@ -259,7 +259,7 @@
     // Create and inject a STOP_SENDING frame. In GOOGLE QUIC, receiving a
     // RST_STREAM frame causes a two-way close. For IETF QUIC, RST_STREAM causes
     // a one-way close.
-    if (!IsVersion99()) {
+    if (!VersionHasIetfQuicFrames(transport_version())) {
       // Only needed for version 99/IETF QUIC.
       return;
     }
@@ -305,7 +305,7 @@
                           QUIC_ERROR_PROCESSING_STREAM, 0);
   EXPECT_CALL(owner_, OnRstStreamReceived(_)).Times(1);
   EXPECT_CALL(*connection_, SendControlFrame(_));
-  if (!IsVersion99()) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     // For version 99, this is covered in InjectStopSending()
     EXPECT_CALL(*connection_,
                 OnStreamReset(GetNthClientInitiatedBidirectionalId(0),
@@ -333,7 +333,7 @@
                           GetNthClientInitiatedBidirectionalId(0),
                           QUIC_ERROR_PROCESSING_STREAM, 0);
   EXPECT_CALL(owner_, OnRstStreamReceived(_)).Times(1);
-  if (!IsVersion99()) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     EXPECT_CALL(*connection_, SendControlFrame(_));
     // For version 99, this is covered in InjectStopSending()
     EXPECT_CALL(*connection_,
@@ -374,7 +374,7 @@
                          GetNthClientInitiatedBidirectionalId(0),
                          QUIC_ERROR_PROCESSING_STREAM, 0);
   EXPECT_CALL(owner_, OnRstStreamReceived(_)).Times(1);
-  if (!IsVersion99()) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     EXPECT_CALL(*connection_, SendControlFrame(_));
     // For version 99, this is covered in InjectStopSending()
     EXPECT_CALL(*connection_,
@@ -575,7 +575,7 @@
         ->OnSuccessfulVersionNegotiation(supported_versions.front());
     // Needed to make new session flow control window and server push work.
 
-    if (IsVersion99()) {
+    if (VersionHasIetfQuicFrames(transport_version())) {
       EXPECT_CALL(*connection_, SendControlFrame(_))
           .WillRepeatedly(Invoke(this, &QuicSimpleServerSessionServerPushTest::
                                            ClearMaxStreamsControlFrame));
@@ -761,7 +761,7 @@
           QuicConsumedData(kStreamFlowControlWindowSize - offset, false)));
   EXPECT_CALL(*session_, SendBlocked(next_out_going_stream_id));
 
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // The PromisePushedResources call, above, will have used all available
     // stream ids.  For version 99, stream ids are not made available until
     // a MAX_STREAMS frame is received. This emulates the reception of one.
@@ -792,7 +792,7 @@
   // Having two extra resources to be send later. One of them will be reset, so
   // when opened stream become close, only one will become open.
   size_t num_resources = kMaxStreamsForTest + 2;
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // V99 will send out a STREAMS_BLOCKED frame when it tries to exceed the
     // limit. This will clear the frames so that they do not block the later
     // rst-stream frame.
@@ -860,7 +860,7 @@
           QuicConsumedData(kStreamFlowControlWindowSize - offset, false)));
   EXPECT_CALL(*session_, SendBlocked(stream_not_reset));
 
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // The PromisePushedResources call, above, will have used all available
     // stream ids.  For version 99, stream ids are not made available until
     // a MAX_STREAMS frame is received. This emulates the reception of one.
@@ -879,7 +879,7 @@
        CloseStreamToHandleMorePromisedStream) {
   MaybeConsumeHeadersStreamData();
   size_t num_resources = kMaxStreamsForTest + 1;
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // V99 will send out a stream-id-blocked frame when the we desired to exceed
     // the limit. This will clear the frames so that they do not block the later
     // rst-stream frame.
@@ -901,7 +901,7 @@
   QuicStreamId stream_got_reset = GetNthServerInitiatedUnidirectionalId(1);
   EXPECT_CALL(owner_, OnRstStreamReceived(_)).Times(1);
   EXPECT_CALL(*connection_, SendControlFrame(_));
-  if (!IsVersion99()) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     // For version 99, this is covered in InjectStopSending()
     EXPECT_CALL(*connection_,
                 OnStreamReset(stream_got_reset, QUIC_RST_ACKNOWLEDGEMENT));
@@ -935,7 +935,7 @@
   EXPECT_CALL(*session_, SendBlocked(stream_to_open));
   QuicRstStreamFrame rst(kInvalidControlFrameId, stream_got_reset,
                          QUIC_STREAM_CANCELLED, 0);
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     // The PromisePushedResources call, above, will have used all available
     // stream ids.  For version 99, stream ids are not made available until
     // a MAX_STREAMS frame is received. This emulates the reception of one.
diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc
index 9ce38fb..7e4af32 100644
--- a/quic/tools/quic_simple_server_stream_test.cc
+++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -99,7 +99,7 @@
                                 crypto_config,
                                 compressed_certs_cache,
                                 quic_simple_server_backend) {
-    if (connection->transport_version() == QUIC_VERSION_99) {
+    if (VersionHasIetfQuicFrames(connection->transport_version())) {
       QuicSessionPeer::SetMaxOpenIncomingUnidirectionalStreams(
           this, kMaxStreamsForTest);
       QuicSessionPeer::SetMaxOpenIncomingBidirectionalStreams(
@@ -217,10 +217,6 @@
     return (*stream_->mutable_headers())[key].as_string();
   }
 
-  bool IsVersion99() const {
-    return connection_->transport_version() == QUIC_VERSION_99;
-  }
-
   bool HasFrameHeader() const {
     return VersionHasDataFrameHeader(connection_->transport_version());
   }
@@ -684,7 +680,7 @@
   QuicRstStreamFrame rst_frame(kInvalidControlFrameId, stream_->id(),
                                QUIC_STREAM_CANCELLED, 1234);
   stream_->OnStreamReset(rst_frame);
-  if (IsVersion99()) {
+  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     // For V99 receiving a RST_STREAM causes a 1-way close; the test requires
     // a full close. A CloseWriteSide closes the other half of the stream.
     // Everything should then work properly.