diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 991dae3..f4cba6c 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -666,7 +666,7 @@
   }
   EXPECT_EQ(expected_num_client_hellos,
             client_->client()->GetNumSentClientHellos());
-  if (VersionUsesQpack(GetClientConnection()->transport_version())) {
+  if (VersionUsesHttp3(GetClientConnection()->transport_version())) {
     EXPECT_TRUE(QuicSpdySessionPeer::GetSendControlStream(GetClientSession()));
     EXPECT_TRUE(
         QuicSpdySessionPeer::GetReceiveControlStream(GetClientSession()));
@@ -1650,7 +1650,7 @@
 
   client_->SendCustomSynchronousRequest(headers, body);
 
-  if (VersionUsesQpack(client_->client()
+  if (VersionUsesHttp3(client_->client()
                            ->client_session()
                            ->connection()
                            ->transport_version())) {
@@ -2314,7 +2314,7 @@
   }
   // When stream type is enabled, control streams will send settings and
   // contribute to flow control windows, so this expectation is no longer valid.
-  if (!VersionHasStreamType(transport_version)) {
+  if (!VersionUsesHttp3(transport_version)) {
     EXPECT_EQ(kSessionIFCW, QuicFlowControllerPeer::SendWindowSize(
                                 GetClientSession()->flow_controller()));
   }
@@ -2324,7 +2324,7 @@
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
 
   // No headers stream in IETF QUIC.
-  if (VersionUsesQpack(transport_version)) {
+  if (VersionUsesHttp3(transport_version)) {
     return;
   }
 
@@ -2359,7 +2359,7 @@
   const QuicTransportVersion version =
       client_session->connection()->transport_version();
 
-  if (VersionUsesQpack(version)) {
+  if (VersionUsesHttp3(version)) {
     // Make sure that the client has received the initial SETTINGS frame, which
     // is sent in the first packet on the control stream.
     while (!QuicSpdySessionPeer::GetReceiveControlStream(client_session)) {
@@ -2379,7 +2379,7 @@
   ExpectFlowControlsSynced(client_session, server_session);
 
   // Check control streams.
-  if (VersionUsesQpack(version)) {
+  if (VersionUsesHttp3(version)) {
     ExpectFlowControlsSynced(
         QuicSpdySessionPeer::GetReceiveControlStream(client_session),
         QuicSpdySessionPeer::GetSendControlStream(server_session));
@@ -2396,7 +2396,7 @@
   }
 
   // Check headers stream.
-  if (!VersionHasStreamType(version)) {
+  if (!VersionUsesHttp3(version)) {
     SpdyFramer spdy_framer(SpdyFramer::ENABLE_COMPRESSION);
     SpdySettingsIR settings_frame;
     settings_frame.AddSetting(SETTINGS_MAX_HEADER_LIST_SIZE,
@@ -2530,7 +2530,7 @@
   // Size of headers on the request stream.  Zero if headers are sent on the
   // header stream.
   size_t header_size = 0;
-  if (VersionUsesQpack(client_->client()
+  if (VersionUsesHttp3(client_->client()
                            ->client_session()
                            ->connection()
                            ->transport_version())) {
@@ -3204,7 +3204,7 @@
   EXPECT_EQ(kBody, client_->SendSynchronousRequest(
                        "https://example.com/push_example"));
   QuicStreamSequencer* sequencer;
-  if (!VersionUsesQpack(client_->client()
+  if (!VersionUsesHttp3(client_->client()
                             ->client_session()
                             ->connection()
                             ->transport_version())) {
@@ -3225,7 +3225,7 @@
     QUIC_DVLOG(1) << "response body " << response_body;
     EXPECT_EQ(expected_body, response_body);
   }
-  if (!VersionUsesQpack(client_->client()
+  if (!VersionUsesHttp3(client_->client()
                             ->client_session()
                             ->connection()
                             ->transport_version())) {
@@ -3523,7 +3523,7 @@
   // PUSH_PROMISE, its headers stream's sequencer buffer should be released.
   ASSERT_TRUE(Initialize());
   client_->SendSynchronousRequest("/foo");
-  if (VersionUsesQpack(client_->client()
+  if (VersionUsesHttp3(client_->client()
                            ->client_session()
                            ->connection()
                            ->transport_version())) {
diff --git a/quic/core/http/quic_headers_stream_test.cc b/quic/core/http/quic_headers_stream_test.cc
index 5019d95..a9779c8 100644
--- a/quic/core/http/quic_headers_stream_test.cc
+++ b/quic/core/http/quic_headers_stream_test.cc
@@ -172,7 +172,7 @@
   std::vector<TestParams> params;
   ParsedQuicVersionVector all_supported_versions = AllSupportedVersions();
   for (size_t i = 0; i < all_supported_versions.size(); ++i) {
-    if (VersionUsesQpack(all_supported_versions[i].transport_version)) {
+    if (VersionUsesHttp3(all_supported_versions[i].transport_version)) {
       continue;
     }
     for (Perspective p : {Perspective::IS_SERVER, Perspective::IS_CLIENT}) {
diff --git a/quic/core/http/quic_receive_control_stream_test.cc b/quic/core/http/quic_receive_control_stream_test.cc
index abb5d5e..73b30b3 100644
--- a/quic/core/http/quic_receive_control_stream_test.cc
+++ b/quic/core/http/quic_receive_control_stream_test.cc
@@ -52,7 +52,7 @@
   std::vector<TestParams> params;
   ParsedQuicVersionVector all_supported_versions = AllSupportedVersions();
   for (const auto& version : AllSupportedVersions()) {
-    if (!VersionHasStreamType(version.transport_version)) {
+    if (!VersionUsesHttp3(version.transport_version)) {
       continue;
     }
     for (Perspective p : {Perspective::IS_SERVER, Perspective::IS_CLIENT}) {
diff --git a/quic/core/http/quic_send_control_stream_test.cc b/quic/core/http/quic_send_control_stream_test.cc
index 89b8883..a06a319 100644
--- a/quic/core/http/quic_send_control_stream_test.cc
+++ b/quic/core/http/quic_send_control_stream_test.cc
@@ -52,7 +52,7 @@
   std::vector<TestParams> params;
   ParsedQuicVersionVector all_supported_versions = AllSupportedVersions();
   for (const auto& version : AllSupportedVersions()) {
-    if (!VersionHasStreamType(version.transport_version)) {
+    if (!VersionUsesHttp3(version.transport_version)) {
       continue;
     }
     for (Perspective p : {Perspective::IS_SERVER, Perspective::IS_CLIENT}) {
diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index bc10fa2..c7ab623 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -499,7 +499,7 @@
   const std::string serving_region = "not a real region";
   session_->set_serving_region(serving_region);
 
-  if (!VersionUsesQpack(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     session_->UnregisterStreamPriority(
         QuicUtils::GetHeadersStreamId(connection_->transport_version()),
         /*is_static=*/true);
@@ -509,7 +509,7 @@
       new MockQuicCryptoServerStream(&crypto_config_, &compressed_certs_cache_,
                                      session_.get(), &stream_helper_);
   QuicServerSessionBasePeer::SetCryptoStream(session_.get(), crypto_stream);
-  if (!VersionUsesQpack(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     session_->RegisterStreamPriority(
         QuicUtils::GetHeadersStreamId(connection_->transport_version()),
         /*is_static=*/true,
@@ -532,7 +532,7 @@
       &bandwidth_recorder, max_bandwidth_estimate_kbytes_per_second,
       max_bandwidth_estimate_timestamp);
   // Queue up some pending data.
-  if (!VersionUsesQpack(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     session_->MarkConnectionLevelWriteBlocked(
         QuicUtils::GetHeadersStreamId(connection_->transport_version()));
   } else {
diff --git a/quic/core/http/quic_spdy_client_session_base.cc b/quic/core/http/quic_spdy_client_session_base.cc
index a9f7156..1690df7 100644
--- a/quic/core/http/quic_spdy_client_session_base.cc
+++ b/quic/core/http/quic_spdy_client_session_base.cc
@@ -199,7 +199,7 @@
   // ToDo: Consider implementing logic to send a new MAX_PUSH_ID frame to allow
   // another stream to be promised.
   promised_by_id_.erase(promised->id());
-  if (!VersionUsesQpack(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     headers_stream()->MaybeReleaseSequencerBuffer();
   }
 }
@@ -220,7 +220,7 @@
 void QuicSpdyClientSessionBase::CloseStreamInner(QuicStreamId stream_id,
                                                  bool locally_reset) {
   QuicSpdySession::CloseStreamInner(stream_id, locally_reset);
-  if (!VersionUsesQpack(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     headers_stream()->MaybeReleaseSequencerBuffer();
   }
 }
diff --git a/quic/core/http/quic_spdy_client_session_test.cc b/quic/core/http/quic_spdy_client_session_test.cc
index 88e8688..7fe28f2 100644
--- a/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quic/core/http/quic_spdy_client_session_test.cc
@@ -421,7 +421,7 @@
 
   // Initialize H/3 control stream.
   QuicStreamId id;
-  if (VersionUsesQpack(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     id = GetNthServerInitiatedUnidirectionalStreamId(
         connection_->transport_version(), 3);
     char type[] = {0x00};
@@ -451,7 +451,7 @@
 
   // Initialize H/3 control stream.
   QuicStreamId id;
-  if (VersionUsesQpack(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     id = GetNthServerInitiatedUnidirectionalStreamId(
         connection_->transport_version(), 3);
     char type[] = {0x00};
diff --git a/quic/core/http/quic_spdy_client_stream_test.cc b/quic/core/http/quic_spdy_client_stream_test.cc
index ad85d02..84a207a 100644
--- a/quic/core/http/quic_spdy_client_stream_test.cc
+++ b/quic/core/http/quic_spdy_client_stream_test.cc
@@ -124,7 +124,7 @@
   QuicByteCount header_length =
       encoder_.SerializeDataFrameHeader(body_.length(), &buffer);
   std::string header = std::string(buffer.get(), header_length);
-  std::string data = VersionHasDataFrameHeader(connection_->transport_version())
+  std::string data = VersionUsesHttp3(connection_->transport_version())
                          ? header + body_
                          : body_;
   stream_->OnStreamFrame(
@@ -155,7 +155,7 @@
   QuicByteCount header_length =
       encoder_.SerializeDataFrameHeader(body_.length(), &buffer);
   std::string header = std::string(buffer.get(), header_length);
-  std::string data = VersionHasDataFrameHeader(connection_->transport_version())
+  std::string data = VersionUsesHttp3(connection_->transport_version())
                          ? header + body_
                          : body_;
   stream_->OnStreamFrame(
@@ -180,7 +180,7 @@
   QuicByteCount header_length =
       encoder_.SerializeDataFrameHeader(large_body.length(), &buffer);
   std::string header = std::string(buffer.get(), header_length);
-  std::string data = VersionHasDataFrameHeader(connection_->transport_version())
+  std::string data = VersionUsesHttp3(connection_->transport_version())
                          ? header + large_body
                          : large_body;
   EXPECT_CALL(*connection_, SendControlFrame(_));
@@ -198,7 +198,7 @@
 TEST_P(QuicSpdyClientStreamTest, ReceivingTrailers) {
   // There is no kFinalOffsetHeaderKey if trailers are sent on the
   // request/response stream.
-  if (VersionUsesQpack(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     return;
   }
 
@@ -224,7 +224,7 @@
   QuicByteCount header_length =
       encoder_.SerializeDataFrameHeader(body_.length(), &buffer);
   std::string header = std::string(buffer.get(), header_length);
-  std::string data = VersionHasDataFrameHeader(connection_->transport_version())
+  std::string data = VersionUsesHttp3(connection_->transport_version())
                          ? header + body_
                          : body_;
   stream_->OnStreamFrame(
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index d89584b..6f1f22e 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -96,12 +96,12 @@
 
   SpdyHeadersHandlerInterface* OnHeaderFrameStart(
       SpdyStreamId /* stream_id */) override {
-    DCHECK(!VersionUsesQpack(session_->transport_version()));
+    DCHECK(!VersionUsesHttp3(session_->transport_version()));
     return &header_list_;
   }
 
   void OnHeaderFrameEnd(SpdyStreamId /* stream_id */) override {
-    DCHECK(!VersionUsesQpack(session_->transport_version()));
+    DCHECK(!VersionUsesHttp3(session_->transport_version()));
 
     LogHeaderCompressionRatioHistogram(
         /* using_qpack = */ false,
@@ -117,7 +117,7 @@
   void OnStreamFrameData(SpdyStreamId /*stream_id*/,
                          const char* /*data*/,
                          size_t /*len*/) override {
-    DCHECK(!VersionUsesQpack(session_->transport_version()));
+    DCHECK(!VersionUsesHttp3(session_->transport_version()));
     CloseConnection("SPDY DATA frame received.",
                     QUIC_INVALID_HEADERS_STREAM_DATA);
   }
@@ -150,7 +150,7 @@
   void OnDataFrameHeader(SpdyStreamId /*stream_id*/,
                          size_t /*length*/,
                          bool /*fin*/) override {
-    DCHECK(!VersionUsesQpack(session_->transport_version()));
+    DCHECK(!VersionUsesHttp3(session_->transport_version()));
     CloseConnection("SPDY DATA frame received.",
                     QUIC_INVALID_HEADERS_STREAM_DATA);
   }
@@ -162,12 +162,12 @@
   }
 
   void OnSetting(SpdySettingsId id, uint32_t value) override {
-    DCHECK(!VersionUsesQpack(session_->transport_version()));
+    DCHECK(!VersionUsesHttp3(session_->transport_version()));
     session_->OnSetting(id, value);
   }
 
   void OnSettingsEnd() override {
-    DCHECK(!VersionUsesQpack(session_->transport_version()));
+    DCHECK(!VersionUsesHttp3(session_->transport_version()));
   }
 
   void OnPing(SpdyPingId /*unique_id*/, bool /*is_ack*/) override {
@@ -192,7 +192,7 @@
       return;
     }
 
-    if (VersionUsesQpack(session_->transport_version())) {
+    if (VersionUsesHttp3(session_->transport_version())) {
       CloseConnection("HEADERS frame not allowed on headers stream.",
                       QUIC_INVALID_HEADERS_STREAM_DATA);
       return;
@@ -226,7 +226,7 @@
   void OnPushPromise(SpdyStreamId stream_id,
                      SpdyStreamId promised_stream_id,
                      bool /*end*/) override {
-    DCHECK(!VersionUsesQpack(session_->transport_version()));
+    DCHECK(!VersionUsesHttp3(session_->transport_version()));
     if (!session_->supports_push_promise()) {
       CloseConnection("PUSH_PROMISE not supported.",
                       QUIC_INVALID_HEADERS_STREAM_DATA);
@@ -244,7 +244,7 @@
                   SpdyStreamId parent_id,
                   int weight,
                   bool exclusive) override {
-    DCHECK(!VersionUsesQpack(session_->transport_version()));
+    DCHECK(!VersionUsesHttp3(session_->transport_version()));
     if (session_->transport_version() <= QUIC_VERSION_39) {
       CloseConnection("SPDY PRIORITY frame received.",
                       QUIC_INVALID_HEADERS_STREAM_DATA);
@@ -328,7 +328,7 @@
                   config,
                   supported_versions,
                   /*num_expected_unidirectional_static_streams = */
-                  VersionUsesQpack(connection->transport_version()) ? 3 : 0),
+                  VersionUsesHttp3(connection->transport_version()) ? 3 : 0),
       send_control_stream_(nullptr),
       receive_control_stream_(nullptr),
       qpack_encoder_receive_stream_(nullptr),
@@ -381,7 +381,7 @@
 void QuicSpdySession::Initialize() {
   QuicSession::Initialize();
 
-  if (!VersionUsesQpack(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     if (perspective() == Perspective::IS_SERVER) {
       set_largest_peer_created_stream_id(
           QuicUtils::GetHeadersStreamId(transport_version()));
@@ -414,7 +414,7 @@
 }
 
 void QuicSpdySession::OnDecoderStreamError(QuicStringPiece error_message) {
-  DCHECK(VersionUsesQpack(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
 
   // TODO(b/124216424): Use HTTP_QPACK_DECODER_STREAM_ERROR.
   CloseConnectionWithDetails(
@@ -423,7 +423,7 @@
 }
 
 void QuicSpdySession::OnEncoderStreamError(QuicStringPiece error_message) {
-  DCHECK(VersionUsesQpack(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
 
   // TODO(b/124216424): Use HTTP_QPACK_ENCODER_STREAM_ERROR.
   CloseConnectionWithDetails(
@@ -506,7 +506,7 @@
     bool fin,
     const spdy::SpdyStreamPrecedence& precedence,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
-  DCHECK(!VersionUsesQpack(transport_version()));
+  DCHECK(!VersionUsesHttp3(transport_version()));
 
   return WriteHeadersOnHeadersStreamImpl(
       id, std::move(headers), fin,
@@ -519,7 +519,7 @@
                                       QuicStreamId parent_stream_id,
                                       int weight,
                                       bool exclusive) {
-  DCHECK(!VersionUsesQpack(transport_version()));
+  DCHECK(!VersionUsesHttp3(transport_version()));
   if (transport_version() <= QUIC_VERSION_39) {
     return 0;
   }
@@ -531,7 +531,7 @@
 }
 
 void QuicSpdySession::WriteH3Priority(const PriorityFrame& priority) {
-  DCHECK(VersionHasStreamType(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
   DCHECK(GetQuicFlag(FLAGS_quic_allow_http3_priority));
   DCHECK(perspective() == Perspective::IS_CLIENT)
       << "Server must not send priority";
@@ -556,7 +556,7 @@
     return;
   }
 
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     SpdyPushPromiseIR push_promise(original_stream_id, promised_stream_id,
                                    std::move(headers));
     // PUSH_PROMISE must not be the last frame sent out, at least followed by
@@ -580,7 +580,7 @@
 }
 
 void QuicSpdySession::SendMaxHeaderListSize(size_t value) {
-  if (VersionHasStreamType(transport_version())) {
+  if (VersionUsesHttp3(transport_version())) {
     QuicConnection::ScopedPacketFlusher flusher(connection());
     send_control_stream_->MaybeSendSettingsFrame();
     // TODO(renjietang): Remove this once stream id manager can take dynamically
@@ -603,13 +603,13 @@
 }
 
 QpackEncoder* QuicSpdySession::qpack_encoder() {
-  DCHECK(VersionUsesQpack(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
 
   return qpack_encoder_.get();
 }
 
 QpackDecoder* QuicSpdySession::qpack_decoder() {
-  DCHECK(VersionUsesQpack(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
 
   return qpack_decoder_.get();
 }
@@ -629,7 +629,7 @@
 
 void QuicSpdySession::OnCryptoHandshakeEvent(CryptoHandshakeEvent event) {
   QuicSession::OnCryptoHandshakeEvent(event);
-  if (VersionUsesQpack(transport_version()) ||
+  if (VersionUsesHttp3(transport_version()) ||
       (event == HANDSHAKE_CONFIRMED && config()->SupportMaxHeaderListSize())) {
     SendMaxHeaderListSize(max_inbound_header_list_size_);
   }
@@ -648,7 +648,7 @@
   // QuicSpdySession supports PendingStreams, therefore this method should
   // eventually just return true.  However, pending streams can only be used if
   // unidirectional stream type is supported.
-  return VersionHasStreamType(transport_version());
+  return VersionUsesHttp3(transport_version());
 }
 
 size_t QuicSpdySession::WriteHeadersOnHeadersStreamImpl(
@@ -659,7 +659,7 @@
     int weight,
     bool exclusive,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
-  DCHECK(!VersionUsesQpack(transport_version()));
+  DCHECK(!VersionUsesHttp3(transport_version()));
 
   const QuicByteCount uncompressed_size = headers.TotalBytesUsed();
   SpdyHeadersIR headers_frame(id, std::move(headers));
@@ -703,7 +703,7 @@
 }
 
 void QuicSpdySession::OnSetting(uint64_t id, uint64_t value) {
-  if (VersionHasStreamType(transport_version())) {
+  if (VersionUsesHttp3(transport_version())) {
     // SETTINGS frame received on the control stream.
     switch (id) {
       case SETTINGS_QPACK_MAX_TABLE_CAPACITY:
@@ -842,7 +842,7 @@
   QUIC_DVLOG(1) << "Received header list for stream " << stream_id_ << ": "
                 << header_list.DebugString();
   // This code path is only executed for push promise in IETF QUIC.
-  if (VersionUsesQpack(transport_version())) {
+  if (VersionUsesHttp3(transport_version())) {
     DCHECK(promised_stream_id_ !=
            QuicUtils::GetInvalidStreamId(transport_version()));
   }
@@ -903,7 +903,7 @@
 }
 
 bool QuicSpdySession::ProcessPendingStream(PendingStream* pending) {
-  DCHECK(VersionHasStreamType(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
   DCHECK(connection()->connected());
   struct iovec iov;
   if (!pending->sequencer()->GetReadableRegion(&iov)) {
@@ -989,7 +989,7 @@
 }
 
 void QuicSpdySession::MaybeInitializeHttp3UnidirectionalStreams() {
-  DCHECK(VersionHasStreamType(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
   if (!send_control_stream_ && CanOpenNextOutgoingUnidirectionalStream()) {
     auto send_control = std::make_unique<QuicSendControlStream>(
         GetNextOutgoingUnidirectionalStreamId(), this,
@@ -1021,7 +1021,7 @@
 }
 
 void QuicSpdySession::OnCanCreateNewOutgoingStream(bool unidirectional) {
-  if (unidirectional && VersionHasStreamType(transport_version())) {
+  if (unidirectional && VersionUsesHttp3(transport_version())) {
     MaybeInitializeHttp3UnidirectionalStreams();
   }
 }
@@ -1043,7 +1043,7 @@
 }
 
 void QuicSpdySession::SendMaxPushId(QuicStreamId max_allowed_push_id) {
-  DCHECK(VersionHasStreamType(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
   send_control_stream_->SendMaxPushIdFrame(max_allowed_push_id);
 }
 
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 0f73e62..85e79a7 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -328,7 +328,7 @@
         kInitialStreamFlowControlWindowForTest);
     session_.config()->SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
-    if (VersionUsesQpack(transport_version())) {
+    if (VersionUsesHttp3(transport_version())) {
       QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
           session_.config(),
           session_.num_expected_unidirectional_static_streams());
@@ -440,7 +440,7 @@
                          ::testing::PrintToStringParamName());
 
 TEST_P(QuicSpdySessionTestServer, UsesPendingStreams) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
   EXPECT_TRUE(session_.UsesPendingStreams());
@@ -457,7 +457,7 @@
 
 TEST_P(QuicSpdySessionTestServer, IsCryptoHandshakeConfirmed) {
   if (!GetQuicReloadableFlag(quic_do_not_send_settings) ||
-      VersionUsesQpack(transport_version())) {
+      VersionUsesHttp3(transport_version())) {
     MockPacketWriter* writer = static_cast<MockPacketWriter*>(
         QuicConnectionPeer::GetWriter(session_.connection()));
     EXPECT_CALL(*writer, WritePacket(_, _, _, _, _))
@@ -958,7 +958,7 @@
     EXPECT_CALL(*crypto_stream, OnCanWrite());
   }
 
-  if (!VersionUsesQpack(connection_->transport_version())) {
+  if (!VersionUsesHttp3(connection_->transport_version())) {
     TestHeadersStream* headers_stream;
     QuicSpdySessionPeer::SetHeadersStream(&session_, nullptr);
     headers_stream = new TestHeadersStream(&session_);
@@ -1050,7 +1050,7 @@
 
 TEST_P(QuicSpdySessionTestServer, IncreasedTimeoutAfterCryptoHandshake) {
   if (!GetQuicReloadableFlag(quic_do_not_send_settings) ||
-      VersionUsesQpack(transport_version())) {
+      VersionUsesHttp3(transport_version())) {
     MockPacketWriter* writer = static_cast<MockPacketWriter*>(
         QuicConnectionPeer::GetWriter(session_.connection()));
     EXPECT_CALL(*writer, WritePacket(_, _, _, _, _))
@@ -1108,7 +1108,7 @@
 TEST_P(QuicSpdySessionTestServer, OnStreamFrameFinStaticStreamId) {
   QuicStreamId id;
   // Initialize HTTP/3 control stream.
-  if (VersionUsesQpack(transport_version())) {
+  if (VersionUsesHttp3(transport_version())) {
     id = GetNthClientInitiatedUnidirectionalStreamId(transport_version(), 3);
     char type[] = {kControlStream};
 
@@ -1130,7 +1130,7 @@
 TEST_P(QuicSpdySessionTestServer, OnRstStreamStaticStreamId) {
   QuicStreamId id;
   // Initialize HTTP/3 control stream.
-  if (VersionUsesQpack(transport_version())) {
+  if (VersionUsesHttp3(transport_version())) {
     id = GetNthClientInitiatedUnidirectionalStreamId(transport_version(), 3);
     char type[] = {kControlStream};
 
@@ -1286,7 +1286,7 @@
 
   // This test depends on the headers stream, which does not exist when QPACK is
   // used.
-  if (VersionUsesQpack(transport_version())) {
+  if (VersionUsesHttp3(transport_version())) {
     return;
   }
 
@@ -1520,7 +1520,7 @@
 }
 
 TEST_P(QuicSpdySessionTestServer, TooLowUnidirectionalStreamLimitHttp3) {
-  if (!VersionUsesQpack(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
   QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(session_.config(),
@@ -1566,7 +1566,7 @@
 }
 
 TEST_P(QuicSpdySessionTestServer, WindowUpdateUnblocksHeadersStream) {
-  if (VersionUsesQpack(GetParam().transport_version)) {
+  if (VersionUsesHttp3(GetParam().transport_version)) {
     // The test relies on headers stream, which no longer exists in IETF QUIC.
     return;
   }
@@ -1714,7 +1714,7 @@
                          ::testing::PrintToStringParamName());
 
 TEST_P(QuicSpdySessionTestClient, UsesPendingStreams) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
   EXPECT_TRUE(session_.UsesPendingStreams());
@@ -1722,7 +1722,7 @@
 
 // Regression test for crbug.com/977581.
 TEST_P(QuicSpdySessionTestClient, BadStreamFramePendingStream) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
 
@@ -1762,7 +1762,7 @@
 TEST_P(QuicSpdySessionTestClient, TooLargeHeadersMustNotCauseWriteAfterReset) {
   // In IETF QUIC, HEADERS do not carry FIN flag, and OnStreamHeaderList() is
   // never called after an error, including too large headers.
-  if (VersionUsesQpack(transport_version())) {
+  if (VersionUsesHttp3(transport_version())) {
     return;
   }
 
@@ -1815,7 +1815,7 @@
 }
 
 TEST_P(QuicSpdySessionTestClient, WritePriority) {
-  if (VersionHasStreamType(transport_version())) {
+  if (VersionUsesHttp3(transport_version())) {
     // IETF QUIC currently doesn't support PRIORITY.
     return;
   }
@@ -1856,7 +1856,7 @@
 }
 
 TEST_P(QuicSpdySessionTestClient, Http3ServerPush) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
 
@@ -1888,7 +1888,7 @@
 }
 
 TEST_P(QuicSpdySessionTestClient, Http3ServerPushOutofOrderFrame) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
 
@@ -2092,7 +2092,7 @@
 }
 
 TEST_P(QuicSpdySessionTestServer, SimplePendingStreamType) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
 
@@ -2128,7 +2128,7 @@
 }
 
 TEST_P(QuicSpdySessionTestServer, SimplePendingStreamTypeOutOfOrderDelivery) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
 
@@ -2169,7 +2169,7 @@
 
 TEST_P(QuicSpdySessionTestServer,
        MultipleBytesPendingStreamTypeOutOfOrderDelivery) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
 
@@ -2213,7 +2213,7 @@
 }
 
 TEST_P(QuicSpdySessionTestServer, ReceiveControlStream) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
   MockHttp3DebugVisitor debug_visitor;
@@ -2255,7 +2255,7 @@
 }
 
 TEST_P(QuicSpdySessionTestServer, ReceiveControlStreamOutOfOrderDelivery) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
   // Use an arbitrary stream id.
@@ -2278,7 +2278,7 @@
 
 // Regression test for https://crbug.com/1009551.
 TEST_P(QuicSpdySessionTestServer, StreamClosedWhileHeaderDecodingBlocked) {
-  if (!VersionUsesQpack(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
 
@@ -2313,7 +2313,7 @@
 
 // Regression test for https://crbug.com/1011294.
 TEST_P(QuicSpdySessionTestServer, SessionDestroyedWhileHeaderDecodingBlocked) {
-  if (!VersionUsesQpack(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
 
@@ -2345,7 +2345,7 @@
 }
 
 TEST_P(QuicSpdySessionTestClient, ResetAfterInvalidIncomingStreamType) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
   ASSERT_TRUE(session_.UsesPendingStreams());
@@ -2397,7 +2397,7 @@
 }
 
 TEST_P(QuicSpdySessionTestClient, FinAfterInvalidIncomingStreamType) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
   ASSERT_TRUE(session_.UsesPendingStreams());
@@ -2436,7 +2436,7 @@
 }
 
 TEST_P(QuicSpdySessionTestClient, ResetInMiddleOfStreamType) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
   ASSERT_TRUE(session_.UsesPendingStreams());
@@ -2470,7 +2470,7 @@
 }
 
 TEST_P(QuicSpdySessionTestClient, FinInMiddleOfStreamType) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
   ASSERT_TRUE(session_.UsesPendingStreams());
@@ -2487,7 +2487,7 @@
 }
 
 TEST_P(QuicSpdySessionTestClient, DuplicateHttp3UnidirectionalStreams) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
 
@@ -2552,7 +2552,7 @@
 }
 
 TEST_P(QuicSpdySessionTestClient, EncoderStreamError) {
-  if (!VersionUsesQpack(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
 
@@ -2573,7 +2573,7 @@
 }
 
 TEST_P(QuicSpdySessionTestClient, DecoderStreamError) {
-  if (!VersionUsesQpack(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
 
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index cd32507..5dd9f3a 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -99,7 +99,7 @@
   bool OnDataFrameEnd() override { return stream_->OnDataFrameEnd(); }
 
   bool OnHeadersFrameStart(QuicByteCount header_length) override {
-    if (!VersionUsesQpack(stream_->transport_version())) {
+    if (!VersionUsesHttp3(stream_->transport_version())) {
       CloseConnectionOnWrongFrame("Headers");
       return false;
     }
@@ -108,7 +108,7 @@
 
   bool OnHeadersFramePayload(QuicStringPiece payload) override {
     DCHECK(!payload.empty());
-    if (!VersionUsesQpack(stream_->transport_version())) {
+    if (!VersionUsesHttp3(stream_->transport_version())) {
       CloseConnectionOnWrongFrame("Headers");
       return false;
     }
@@ -116,7 +116,7 @@
   }
 
   bool OnHeadersFrameEnd() override {
-    if (!VersionUsesQpack(stream_->transport_version())) {
+    if (!VersionUsesHttp3(stream_->transport_version())) {
       CloseConnectionOnWrongFrame("Headers");
       return false;
     }
@@ -124,7 +124,7 @@
   }
 
   bool OnPushPromiseFrameStart(QuicByteCount header_length) override {
-    if (!VersionUsesQpack(stream_->transport_version())) {
+    if (!VersionUsesHttp3(stream_->transport_version())) {
       CloseConnectionOnWrongFrame("Push Promise");
       return false;
     }
@@ -133,7 +133,7 @@
 
   bool OnPushPromiseFramePushId(PushId push_id,
                                 QuicByteCount push_id_length) override {
-    if (!VersionUsesQpack(stream_->transport_version())) {
+    if (!VersionUsesHttp3(stream_->transport_version())) {
       CloseConnectionOnWrongFrame("Push Promise");
       return false;
     }
@@ -142,7 +142,7 @@
 
   bool OnPushPromiseFramePayload(QuicStringPiece payload) override {
     DCHECK(!payload.empty());
-    if (!VersionUsesQpack(stream_->transport_version())) {
+    if (!VersionUsesHttp3(stream_->transport_version())) {
       CloseConnectionOnWrongFrame("Push Promise");
       return false;
     }
@@ -150,7 +150,7 @@
   }
 
   bool OnPushPromiseFrameEnd() override {
-    if (!VersionUsesQpack(stream_->transport_version())) {
+    if (!VersionUsesHttp3(stream_->transport_version())) {
       CloseConnectionOnWrongFrame("Push Promise");
       return false;
     }
@@ -209,11 +209,11 @@
   DCHECK_EQ(0u, sequencer()->NumBytesConsumed());
   // If headers are sent on the headers stream, then do not receive any
   // callbacks from the sequencer until headers are complete.
-  if (!VersionUsesQpack(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     sequencer()->SetBlockedUntilFlush();
   }
 
-  if (VersionHasDataFrameHeader(transport_version())) {
+  if (VersionUsesHttp3(transport_version())) {
     sequencer()->set_level_triggered(true);
   }
 }
@@ -242,11 +242,11 @@
   DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id()));
   // If headers are sent on the headers stream, then do not receive any
   // callbacks from the sequencer until headers are complete.
-  if (!VersionUsesQpack(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     sequencer()->SetBlockedUntilFlush();
   }
 
-  if (VersionHasDataFrameHeader(transport_version())) {
+  if (VersionUsesHttp3(transport_version())) {
     sequencer()->set_level_triggered(true);
   }
 }
@@ -259,8 +259,8 @@
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   QuicConnection::ScopedPacketFlusher flusher(spdy_session_->connection());
   // Send stream type for server push stream
-  if (VersionHasStreamType(transport_version()) &&
-      type() == WRITE_UNIDIRECTIONAL && send_buffer().stream_offset() == 0) {
+  if (VersionUsesHttp3(transport_version()) && type() == WRITE_UNIDIRECTIONAL &&
+      send_buffer().stream_offset() == 0) {
     char data[sizeof(kServerPushStream)];
     QuicDataWriter writer(QUIC_ARRAYSIZE(data), data);
     writer.WriteVarInt62(kServerPushStream);
@@ -276,7 +276,7 @@
   }
   size_t bytes_written =
       WriteHeadersImpl(std::move(header_block), fin, std::move(ack_listener));
-  if (!VersionUsesQpack(transport_version()) && fin) {
+  if (!VersionUsesHttp3(transport_version()) && fin) {
     // If HEADERS are sent on the headers stream, then |fin_sent_| needs to be
     // set and write side needs to be closed without actually sending a FIN on
     // this stream.
@@ -288,7 +288,7 @@
 }
 
 void QuicSpdyStream::WriteOrBufferBody(QuicStringPiece data, bool fin) {
-  if (!VersionHasDataFrameHeader(transport_version()) || data.length() == 0) {
+  if (!VersionUsesHttp3(transport_version()) || data.length() == 0) {
     WriteOrBufferData(data, fin, nullptr);
     return;
   }
@@ -322,7 +322,7 @@
     return 0;
   }
 
-  if (!VersionUsesQpack(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     // The header block must contain the final offset for this stream, as the
     // trailers may be processed out of order at the peer.
     const QuicStreamOffset final_offset =
@@ -341,7 +341,7 @@
 
   // If trailers are sent on the headers stream, then |fin_sent_| needs to be
   // set without actually sending a FIN on this stream.
-  if (!VersionUsesQpack(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     set_fin_sent(kFin);
 
     // Also, write side of this stream needs to be closed.  However, only do
@@ -355,7 +355,7 @@
 }
 
 void QuicSpdyStream::WritePushPromise(const PushPromiseFrame& frame) {
-  DCHECK(VersionUsesQpack(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
   std::unique_ptr<char[]> push_promise_frame_with_id;
   const size_t push_promise_frame_length =
       encoder_.SerializePushPromiseFrameWithOnlyPushId(
@@ -395,7 +395,7 @@
 
 QuicConsumedData QuicSpdyStream::WriteBodySlices(QuicMemSliceSpan slices,
                                                  bool fin) {
-  if (!VersionHasDataFrameHeader(transport_version()) || slices.empty()) {
+  if (!VersionUsesHttp3(transport_version()) || slices.empty()) {
     return WriteMemSlices(slices, fin);
   }
 
@@ -431,7 +431,7 @@
 
 size_t QuicSpdyStream::Readv(const struct iovec* iov, size_t iov_len) {
   DCHECK(FinishedReadingHeaders());
-  if (!VersionHasDataFrameHeader(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return sequencer()->Readv(iov, iov_len);
   }
   size_t bytes_read = 0;
@@ -442,7 +442,7 @@
 
 int QuicSpdyStream::GetReadableRegions(iovec* iov, size_t iov_len) const {
   DCHECK(FinishedReadingHeaders());
-  if (!VersionHasDataFrameHeader(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return sequencer()->GetReadableRegions(iov, iov_len);
   }
   return body_manager_.PeekBody(iov, iov_len);
@@ -450,7 +450,7 @@
 
 void QuicSpdyStream::MarkConsumed(size_t num_bytes) {
   DCHECK(FinishedReadingHeaders());
-  if (!VersionHasDataFrameHeader(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     sequencer()->MarkConsumed(num_bytes);
     return;
   }
@@ -466,7 +466,7 @@
 }
 
 bool QuicSpdyStream::HasBytesToRead() const {
-  if (!VersionHasDataFrameHeader(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return sequencer()->HasBytesToRead();
   }
   return body_manager_.HasBytesToRead();
@@ -477,7 +477,7 @@
 }
 
 uint64_t QuicSpdyStream::total_body_bytes_read() const {
-  if (VersionHasDataFrameHeader(transport_version())) {
+  if (VersionUsesHttp3(transport_version())) {
     return body_manager_.total_body_bytes_received();
   }
   return sequencer()->NumBytesConsumed();
@@ -490,7 +490,7 @@
     return;
   }
 
-  if (!VersionUsesQpack(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     sequencer()->SetUnblocked();
     return;
   }
@@ -555,7 +555,7 @@
 }
 
 void QuicSpdyStream::OnHeadersTooLarge() {
-  if (VersionUsesQpack(transport_version())) {
+  if (VersionUsesHttp3(transport_version())) {
     // TODO(124216424): Use HTTP_EXCESSIVE_LOAD error code.
     std::string error_message =
         QuicStrCat("Too large headers received on stream ", id());
@@ -574,7 +574,7 @@
   headers_decompressed_ = true;
   header_list_ = header_list;
 
-  if (VersionUsesQpack(transport_version())) {
+  if (VersionUsesHttp3(transport_version())) {
     if (fin) {
       OnStreamFrame(
           QuicStreamFrame(id(), /* fin = */ true,
@@ -610,7 +610,7 @@
     const QuicHeaderList& header_list) {
   // TODO(b/134706391): remove |fin| argument.
   DCHECK(!trailers_decompressed_);
-  if (!VersionUsesQpack(transport_version()) && fin_received()) {
+  if (!VersionUsesHttp3(transport_version()) && fin_received()) {
     QUIC_DLOG(INFO) << ENDPOINT
                     << "Received Trailers after FIN, on stream: " << id();
     session()->connection()->CloseConnection(
@@ -619,7 +619,7 @@
     return;
   }
 
-  if (!VersionUsesQpack(transport_version()) && !fin) {
+  if (!VersionUsesHttp3(transport_version()) && !fin) {
     QUIC_DLOG(INFO) << ENDPOINT
                     << "Trailers must have FIN set, on stream: " << id();
     session()->connection()->CloseConnection(
@@ -629,7 +629,7 @@
   }
 
   size_t final_byte_offset = 0;
-  const bool expect_final_byte_offset = !VersionUsesQpack(transport_version());
+  const bool expect_final_byte_offset = !VersionUsesHttp3(transport_version());
   if (!SpdyUtils::CopyAndValidateTrailers(header_list, expect_final_byte_offset,
                                           &final_byte_offset,
                                           &received_trailers_)) {
@@ -643,7 +643,7 @@
   trailers_decompressed_ = true;
   if (fin) {
     const QuicStreamOffset offset =
-        VersionUsesQpack(transport_version())
+        VersionUsesHttp3(transport_version())
             ? flow_controller()->highest_received_byte_offset()
             : final_byte_offset;
     OnStreamFrame(QuicStreamFrame(id(), fin, offset, QuicStringPiece()));
@@ -670,12 +670,12 @@
 }
 
 void QuicSpdyStream::OnDataAvailable() {
-  if (!VersionUsesQpack(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     // Sequencer must be blocked until headers are consumed.
     DCHECK(FinishedReadingHeaders());
   }
 
-  if (!VersionHasDataFrameHeader(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     OnBodyAvailable();
     return;
   }
@@ -789,7 +789,7 @@
 }
 
 bool QuicSpdyStream::OnDataFrameStart(QuicByteCount header_length) {
-  DCHECK(VersionHasDataFrameHeader(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
   if (!headers_decompressed_ || trailers_decompressed_) {
     // TODO(b/124216424): Change error code to HTTP_UNEXPECTED_FRAME.
     session()->connection()->CloseConnection(
@@ -804,7 +804,7 @@
 }
 
 bool QuicSpdyStream::OnDataFramePayload(QuicStringPiece payload) {
-  DCHECK(VersionHasDataFrameHeader(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
 
   body_manager_.OnBody(payload);
 
@@ -812,7 +812,7 @@
 }
 
 bool QuicSpdyStream::OnDataFrameEnd() {
-  DCHECK(VersionHasDataFrameHeader(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
   QUIC_DVLOG(1) << ENDPOINT
                 << "Reaches the end of a data frame. Total bytes received are "
                 << body_manager_.total_body_bytes_received();
@@ -867,7 +867,7 @@
 }
 
 bool QuicSpdyStream::OnHeadersFrameStart(QuicByteCount header_length) {
-  DCHECK(VersionUsesQpack(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
   DCHECK(!qpack_decoded_headers_accumulator_);
 
   if (trailers_decompressed_) {
@@ -890,7 +890,7 @@
 }
 
 bool QuicSpdyStream::OnHeadersFramePayload(QuicStringPiece payload) {
-  DCHECK(VersionUsesQpack(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
   DCHECK(qpack_decoded_headers_accumulator_);
 
   if (headers_decompressed_) {
@@ -915,7 +915,7 @@
 }
 
 bool QuicSpdyStream::OnHeadersFrameEnd() {
-  DCHECK(VersionUsesQpack(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
   DCHECK(qpack_decoded_headers_accumulator_);
 
   auto result = qpack_decoded_headers_accumulator_->EndHeaderBlock();
@@ -941,7 +941,7 @@
 }
 
 bool QuicSpdyStream::OnPushPromiseFrameStart(QuicByteCount header_length) {
-  DCHECK(VersionHasStreamType(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
   DCHECK(!qpack_decoded_headers_accumulator_);
 
   sequencer()->MarkConsumed(body_manager_.OnNonBody(header_length));
@@ -951,7 +951,7 @@
 
 bool QuicSpdyStream::OnPushPromiseFramePushId(PushId push_id,
                                               QuicByteCount push_id_length) {
-  DCHECK(VersionHasStreamType(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
   DCHECK(!qpack_decoded_headers_accumulator_);
 
   // TODO(renjietang): Check max push id and handle errors.
@@ -972,7 +972,7 @@
 }
 
 bool QuicSpdyStream::OnPushPromiseFrameEnd() {
-  DCHECK(VersionUsesQpack(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
 
   return OnHeadersFrameEnd();
 }
@@ -1021,7 +1021,7 @@
     spdy::SpdyHeaderBlock header_block,
     bool fin,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
-  if (!VersionUsesQpack(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return spdy_session_->WriteHeadersOnHeadersStream(
         id(), std::move(header_block), fin, precedence(),
         std::move(ack_listener));
diff --git a/quic/core/http/quic_spdy_stream.h b/quic/core/http/quic_spdy_stream.h
index a2ebc54..6da102b 100644
--- a/quic/core/http/quic_spdy_stream.h
+++ b/quic/core/http/quic_spdy_stream.h
@@ -110,7 +110,7 @@
   virtual void OnBodyAvailable() = 0;
 
   // Writes the headers contained in |header_block| on the dedicated headers
-  // stream or on this stream, depending on VersionUsesQpack().  Returns the
+  // stream or on this stream, depending on VersionUsesHttp3().  Returns the
   // number of bytes sent, including data sent on the encoder stream when using
   // QPACK.
   virtual size_t WriteHeaders(
@@ -122,7 +122,7 @@
   void WriteOrBufferBody(QuicStringPiece data, bool fin);
 
   // Writes the trailers contained in |trailer_block| on the dedicated headers
-  // stream or on this stream, depending on VersionUsesQpack().  Trailers will
+  // stream or on this stream, depending on VersionUsesHttp3().  Trailers will
   // always have the FIN flag set.  Returns the number of bytes sent, including
   // data sent on the encoder stream when using QPACK.
   virtual size_t WriteTrailers(
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index 5e88aba..a993126 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -84,7 +84,7 @@
                           /*ack_listener*/) override {
     saved_headers_ = std::move(header_block);
     WriteHeadersMock(fin);
-    if (VersionUsesQpack(transport_version())) {
+    if (VersionUsesHttp3(transport_version())) {
       // In this case, call QuicSpdyStream::WriteHeadersImpl() that does the
       // actual work of closing the stream.
       QuicSpdyStream::WriteHeadersImpl(saved_headers_.Clone(), fin, nullptr);
@@ -235,8 +235,8 @@
         connection_->transport_version(), n);
   }
 
-  bool HasFrameHeader() const {
-    return VersionHasDataFrameHeader(GetParam().transport_version);
+  bool UsesHttp3() const {
+    return VersionUsesHttp3(GetParam().transport_version);
   }
 
   // Construct HEADERS frame with QPACK-encoded |headers| without using the
@@ -327,7 +327,7 @@
       spdy::SpdyStreamPrecedence(kV3HighestPriority));
 
   const bool version_uses_qpack =
-      VersionUsesQpack(GetParam().transport_version);
+      VersionUsesHttp3(GetParam().transport_version);
 
   if (version_uses_qpack) {
     EXPECT_CALL(
@@ -435,7 +435,7 @@
 }
 
 TEST_P(QuicSpdyStreamTest, ProcessWrongFramesOnSpdyStream) {
-  if (!HasFrameHeader()) {
+  if (!UsesHttp3()) {
     return;
   }
 
@@ -478,7 +478,7 @@
   Initialize(kShouldProcessData);
 
   std::string body = "this is the body";
-  std::string data = HasFrameHeader() ? DataFrame(body) : body;
+  std::string data = UsesHttp3() ? DataFrame(body) : body;
 
   EXPECT_EQ("", stream_->data());
   QuicHeaderList headers = ProcessHeaders(false, headers_);
@@ -493,7 +493,7 @@
 
 TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyFragments) {
   std::string body = "this is the body";
-  std::string data = HasFrameHeader() ? DataFrame(body) : body;
+  std::string data = UsesHttp3() ? DataFrame(body) : body;
 
   for (size_t fragment_size = 1; fragment_size < data.size(); ++fragment_size) {
     Initialize(kShouldProcessData);
@@ -514,7 +514,7 @@
 
 TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyFragmentsSplit) {
   std::string body = "this is the body";
-  std::string data = HasFrameHeader() ? DataFrame(body) : body;
+  std::string data = UsesHttp3() ? DataFrame(body) : body;
 
   for (size_t split_point = 1; split_point < data.size() - 1; ++split_point) {
     Initialize(kShouldProcessData);
@@ -541,7 +541,7 @@
   Initialize(!kShouldProcessData);
 
   std::string body = "this is the body";
-  std::string data = HasFrameHeader() ? DataFrame(body) : body;
+  std::string data = UsesHttp3() ? DataFrame(body) : body;
 
   ProcessHeaders(false, headers_);
   QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
@@ -564,7 +564,7 @@
 TEST_P(QuicSpdyStreamTest, ProcessHeadersAndLargeBodySmallReadv) {
   Initialize(kShouldProcessData);
   std::string body(12 * 1024, 'a');
-  std::string data = HasFrameHeader() ? DataFrame(body) : body;
+  std::string data = UsesHttp3() ? DataFrame(body) : body;
 
   ProcessHeaders(false, headers_);
   QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
@@ -588,7 +588,7 @@
   Initialize(!kShouldProcessData);
 
   std::string body = "this is the body";
-  std::string data = HasFrameHeader() ? DataFrame(body) : body;
+  std::string data = UsesHttp3() ? DataFrame(body) : body;
 
   ProcessHeaders(false, headers_);
   QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
@@ -609,9 +609,9 @@
 TEST_P(QuicSpdyStreamTest, ProcessHeadersAndConsumeMultipleBody) {
   Initialize(!kShouldProcessData);
   std::string body1 = "this is body 1";
-  std::string data1 = HasFrameHeader() ? DataFrame(body1) : body1;
+  std::string data1 = UsesHttp3() ? DataFrame(body1) : body1;
   std::string body2 = "body 2";
-  std::string data2 = HasFrameHeader() ? DataFrame(body2) : body2;
+  std::string data2 = UsesHttp3() ? DataFrame(body2) : body2;
 
   ProcessHeaders(false, headers_);
   QuicStreamFrame frame1(GetNthClientInitiatedBidirectionalId(0), false, 0,
@@ -631,7 +631,7 @@
   Initialize(!kShouldProcessData);
 
   std::string body = "this is the body";
-  std::string data = HasFrameHeader() ? DataFrame(body) : body;
+  std::string data = UsesHttp3() ? DataFrame(body) : body;
 
   ProcessHeaders(false, headers_);
   QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
@@ -655,7 +655,7 @@
   Initialize(!kShouldProcessData);
 
   std::string body = "this is the body";
-  std::string data = HasFrameHeader() ? DataFrame(body) : body;
+  std::string data = UsesHttp3() ? DataFrame(body) : body;
 
   ProcessHeaders(false, headers_);
   QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
@@ -696,8 +696,8 @@
   const uint64_t kOverflow = 15;
   std::string body(kWindow + kOverflow, 'a');
 
-  const uint64_t kHeaderLength = HasFrameHeader() ? 2 : 0;
-  if (HasFrameHeader()) {
+  const uint64_t kHeaderLength = UsesHttp3() ? 2 : 0;
+  if (UsesHttp3()) {
     EXPECT_CALL(*session_, WritevData(_, _, kHeaderLength, _, NO_FIN));
   }
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _))
@@ -737,7 +737,7 @@
   QuicByteCount header_length = 0;
   std::string data;
 
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     std::unique_ptr<char[]> buffer;
     header_length = encoder_.SerializeDataFrameHeader(body.length(), &buffer);
     std::string header = std::string(buffer.get(), header_length);
@@ -786,7 +786,7 @@
   QuicByteCount header_length = 0;
   std::string data;
 
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     std::unique_ptr<char[]> buffer;
     header_length = encoder_.SerializeDataFrameHeader(body.length(), &buffer);
     std::string header = std::string(buffer.get(), header_length);
@@ -855,7 +855,7 @@
   std::string data2;
   std::string body2(1, 'a');
 
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     body = std::string(kWindow / 4 - 2, 'a');
     std::unique_ptr<char[]> buffer;
     header_length = encoder_.SerializeDataFrameHeader(body.length(), &buffer);
@@ -904,7 +904,7 @@
 
   // Receive data to overflow the window, violating flow control.
   std::string body(kWindow + 1, 'a');
-  std::string data = HasFrameHeader() ? DataFrame(body) : body;
+  std::string data = UsesHttp3() ? DataFrame(body) : body;
   QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
                         QuicStringPiece(data));
   EXPECT_CALL(*connection_,
@@ -942,7 +942,7 @@
 
   // Send enough data to overflow the connection level flow control window.
   std::string body(kConnectionWindow + 1, 'a');
-  std::string data = HasFrameHeader() ? DataFrame(body) : body;
+  std::string data = UsesHttp3() ? DataFrame(body) : body;
 
   EXPECT_LT(data.size(), kStreamWindow);
   QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), false, 0,
@@ -999,7 +999,7 @@
   trailers_block["key2"] = "value2";
   trailers_block["key3"] = "value3";
   SpdyHeaderBlock trailers_block_with_final_offset = trailers_block.Clone();
-  if (!VersionUsesQpack(GetParam().transport_version)) {
+  if (!VersionUsesHttp3(GetParam().transport_version)) {
     // :final-offset pseudo-header is only added if trailers are sent
     // on the headers stream.
     trailers_block_with_final_offset[kFinalOffsetHeaderKey] = "0";
@@ -1027,7 +1027,7 @@
 TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithOffset) {
   // kFinalOffsetHeaderKey is not used when HEADERS are sent on the
   // request/response stream.
-  if (VersionUsesQpack(GetParam().transport_version)) {
+  if (VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -1038,7 +1038,7 @@
   stream_->ConsumeHeaderList();
 
   const std::string body = "this is the body";
-  std::string data = HasFrameHeader() ? DataFrame(body) : body;
+  std::string data = UsesHttp3() ? DataFrame(body) : body;
 
   // Receive trailing headers.
   SpdyHeaderBlock trailers_block;
@@ -1074,7 +1074,7 @@
 TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithoutOffset) {
   // kFinalOffsetHeaderKey is not used when HEADERS are sent on the
   // request/response stream.
-  if (VersionUsesQpack(GetParam().transport_version)) {
+  if (VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -1106,7 +1106,7 @@
 TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithoutFin) {
   // In IETF QUIC, there is no such thing as FIN flag on HTTP/3 frames like the
   // HEADERS frame.
-  if (VersionUsesQpack(GetParam().transport_version)) {
+  if (VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -1137,7 +1137,7 @@
   // If HEADERS frames are sent on the request/response stream, then the
   // sequencer will signal an error if any stream data arrives after a FIN,
   // so QuicSpdyStream does not need to.
-  if (VersionUsesQpack(GetParam().transport_version)) {
+  if (VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -1159,7 +1159,7 @@
   // If HEADERS frames are sent on the request/response stream,
   // then the sequencer will block them from reaching QuicSpdyStream
   // after the stream is closed.
-  if (VersionUsesQpack(GetParam().transport_version)) {
+  if (VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -1195,7 +1195,7 @@
 
   // Receive and consume body with FIN set, and no trailers.
   std::string body(1024, 'x');
-  std::string data = HasFrameHeader() ? DataFrame(body) : body;
+  std::string data = UsesHttp3() ? DataFrame(body) : body;
 
   QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), /*fin=*/true,
                         0, data);
@@ -1209,7 +1209,7 @@
 TEST_P(QuicSpdyStreamTest, WritingTrailersSendsAFin) {
   Initialize(kShouldProcessData);
 
-  if (VersionUsesQpack(GetParam().transport_version)) {
+  if (VersionUsesHttp3(GetParam().transport_version)) {
     // In this case, TestStream::WriteHeadersImpl() does not prevent writes.
     EXPECT_CALL(*session_, WritevData(stream_, stream_->id(), _, _, _))
         .Times(AtLeast(1));
@@ -1231,7 +1231,7 @@
   SetQuicFlag(FLAGS_quic_allow_http3_priority, true);
   InitializeWithPerspective(kShouldProcessData, Perspective::IS_CLIENT);
 
-  if (VersionUsesQpack(GetParam().transport_version)) {
+  if (VersionUsesHttp3(GetParam().transport_version)) {
     // In this case, TestStream::WriteHeadersImpl() does not prevent writes.
     // Six writes include priority for headers, headers frame header, headers
     // frame, priority of trailers, trailing headers frame header, and trailers.
@@ -1271,7 +1271,7 @@
 TEST_P(QuicSpdyStreamTest, WritingTrailersFinalOffset) {
   Initialize(kShouldProcessData);
 
-  if (VersionUsesQpack(GetParam().transport_version)) {
+  if (VersionUsesHttp3(GetParam().transport_version)) {
     // In this case, TestStream::WriteHeadersImpl() does not prevent writes.
     EXPECT_CALL(*session_, WritevData(stream_, stream_->id(), _, _, _))
         .Times(AtLeast(1));
@@ -1285,7 +1285,7 @@
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _)).Times(AtLeast(1));
   std::string body(1024, 'x');  // 1 kB
   QuicByteCount header_length = 0;
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     std::unique_ptr<char[]> buf;
     header_length = encoder_.SerializeDataFrameHeader(body.length(), &buf);
   }
@@ -1300,7 +1300,7 @@
   SpdyHeaderBlock expected_trailers(trailers.Clone());
   // :final-offset pseudo-header is only added if trailers are sent
   // on the headers stream.
-  if (!VersionUsesQpack(GetParam().transport_version)) {
+  if (!VersionUsesHttp3(GetParam().transport_version)) {
     expected_trailers[kFinalOffsetHeaderKey] =
         QuicTextUtils::Uint64ToString(body.length() + header_length);
   }
@@ -1342,7 +1342,7 @@
   // This test exercises sending trailers on the headers stream while data is
   // still queued on the response/request stream.  In IETF QUIC, data and
   // trailers are sent on the same stream, so this test does not apply.
-  if (VersionUsesQpack(GetParam().transport_version)) {
+  if (VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -1355,7 +1355,7 @@
 
   // Write non-zero body data, but only consume partially, ensuring queueing.
   const int kBodySize = 1 * 1024;  // 1 kB
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     EXPECT_CALL(*session_, WritevData(_, _, 3, _, NO_FIN));
   }
   EXPECT_CALL(*session_, WritevData(_, _, kBodySize, _, NO_FIN))
@@ -1401,7 +1401,7 @@
 
 TEST_P(QuicSpdyStreamTest, HeaderStreamNotiferCorrespondingSpdyStream) {
   // There is no headers stream if QPACK is used.
-  if (VersionUsesQpack(GetParam().transport_version)) {
+  if (VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -1430,12 +1430,12 @@
       QuicUtils::GetHeadersStreamId(connection_->transport_version()), false, 0,
       kHeader1);
 
-  std::string data1 = HasFrameHeader() ? DataFrame(kBody1) : kBody1;
+  std::string data1 = UsesHttp3() ? DataFrame(kBody1) : kBody1;
   QuicStreamFrame frame2(stream_->id(), true, 0, data1);
   QuicStreamFrame frame3(
       QuicUtils::GetHeadersStreamId(connection_->transport_version()), false, 7,
       kHeader2);
-  std::string data2 = HasFrameHeader() ? DataFrame(kBody2) : kBody2;
+  std::string data2 = UsesHttp3() ? DataFrame(kBody2) : kBody2;
   QuicStreamFrame frame4(stream2_->id(), false, 0, data2);
 
   EXPECT_CALL(*ack_listener1, OnPacketRetransmitted(7));
@@ -1478,7 +1478,7 @@
   testing::InSequence seq;
   Initialize(kShouldProcessData);
 
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     EXPECT_CALL(*session_, WritevData(_, _, 2, _, NO_FIN));
   }
   EXPECT_CALL(*session_, WritevData(_, _, 4, _, FIN));
@@ -1620,7 +1620,7 @@
 
 // HTTP/3 only.
 TEST_P(QuicSpdyStreamTest, HeadersAckNotReportedWriteOrBufferBody) {
-  if (!HasFrameHeader()) {
+  if (!UsesHttp3()) {
     return;
   }
 
@@ -1667,7 +1667,7 @@
 
 // HTTP/3 only.
 TEST_P(QuicSpdyStreamTest, HeadersAckNotReportedWriteBodySlices) {
-  if (!HasFrameHeader()) {
+  if (!UsesHttp3()) {
     return;
   }
 
@@ -1702,7 +1702,7 @@
 
 // HTTP/3 only.
 TEST_P(QuicSpdyStreamTest, HeaderBytesNotReportedOnRetransmission) {
-  if (!HasFrameHeader()) {
+  if (!UsesHttp3()) {
     return;
   }
 
@@ -1733,7 +1733,7 @@
 }
 
 TEST_P(QuicSpdyStreamTest, HeadersFrameOnRequestStream) {
-  if (!VersionUsesQpack(GetParam().transport_version)) {
+  if (!VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -1761,7 +1761,7 @@
 }
 
 TEST_P(QuicSpdyStreamTest, ProcessBodyAfterTrailers) {
-  if (!VersionUsesQpack(GetParam().transport_version)) {
+  if (!VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -1805,7 +1805,7 @@
 // normal body. Make sure the http decoder stops processing body after the
 // connection shuts down.
 TEST_P(QuicSpdyStreamTest, MalformedHeadersStopHttpDecoder) {
-  if (!VersionUsesQpack(GetParam().transport_version)) {
+  if (!VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -1847,7 +1847,7 @@
 }
 
 TEST_P(QuicSpdyStreamTest, ImmediateHeaderDecodingWithDynamicTableEntries) {
-  if (!VersionUsesQpack(GetParam().transport_version)) {
+  if (!VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -1904,7 +1904,7 @@
 }
 
 TEST_P(QuicSpdyStreamTest, BlockedHeaderDecoding) {
-  if (!VersionUsesQpack(GetParam().transport_version)) {
+  if (!VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -1963,7 +1963,7 @@
 }
 
 TEST_P(QuicSpdyStreamTest, AsyncErrorDecodingHeaders) {
-  if (!VersionUsesQpack(GetParam().transport_version)) {
+  if (!VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -1995,7 +1995,7 @@
 }
 
 TEST_P(QuicSpdyStreamTest, AsyncErrorDecodingTrailers) {
-  if (!VersionUsesQpack(GetParam().transport_version)) {
+  if (!VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -2107,7 +2107,7 @@
 // Test that stream bytes are consumed (by calling
 // sequencer()->MarkConsumed()) incrementally, as soon as possible.
 TEST_P(QuicSpdyStreamIncrementalConsumptionTest, OnlyKnownFrames) {
-  if (!VersionUsesQpack(GetParam().transport_version)) {
+  if (!VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -2166,7 +2166,7 @@
 }
 
 TEST_P(QuicSpdyStreamIncrementalConsumptionTest, UnknownFramesInterleaved) {
-  if (!VersionUsesQpack(GetParam().transport_version)) {
+  if (!VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -2249,7 +2249,7 @@
 
 TEST_P(QuicSpdyStreamTest, PushPromiseOnDataStream) {
   Initialize(kShouldProcessData);
-  if (!HasFrameHeader()) {
+  if (!UsesHttp3()) {
     return;
   }
 
@@ -2273,7 +2273,7 @@
 
 // Close connection if a DATA frame is received before a HEADERS frame.
 TEST_P(QuicSpdyStreamTest, DataBeforeHeaders) {
-  if (!VersionUsesQpack(GetParam().transport_version)) {
+  if (!VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -2295,7 +2295,7 @@
 
 // Close connection if a HEADERS frame is received after the trailing HEADERS.
 TEST_P(QuicSpdyStreamTest, TrailersAfterTrailers) {
-  if (!VersionUsesQpack(GetParam().transport_version)) {
+  if (!VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -2348,7 +2348,7 @@
 // Regression test for https://crbug.com/978733.
 // Close connection if a DATA frame is received after the trailing HEADERS.
 TEST_P(QuicSpdyStreamTest, DataAfterTrailers) {
-  if (!VersionUsesQpack(GetParam().transport_version)) {
+  if (!VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
@@ -2398,7 +2398,7 @@
 // SETTINGS frames are invalid on bidirectional streams.  If one is received,
 // the connection is closed.  No more data should be processed.
 TEST_P(QuicSpdyStreamTest, StopProcessingIfConnectionClosed) {
-  if (!VersionUsesQpack(GetParam().transport_version)) {
+  if (!VersionUsesHttp3(GetParam().transport_version)) {
     return;
   }
 
diff --git a/quic/core/qpack/qpack_receive_stream_test.cc b/quic/core/qpack/qpack_receive_stream_test.cc
index df081d1..af02f64 100644
--- a/quic/core/qpack/qpack_receive_stream_test.cc
+++ b/quic/core/qpack/qpack_receive_stream_test.cc
@@ -35,7 +35,7 @@
   std::vector<TestParams> params;
   ParsedQuicVersionVector all_supported_versions = AllSupportedVersions();
   for (const auto& version : AllSupportedVersions()) {
-    if (!VersionHasStreamType(version.transport_version)) {
+    if (!VersionUsesHttp3(version.transport_version)) {
       continue;
     }
     for (Perspective p : {Perspective::IS_SERVER, Perspective::IS_CLIENT}) {
diff --git a/quic/core/qpack/qpack_send_stream_test.cc b/quic/core/qpack/qpack_send_stream_test.cc
index 82db2a5..9529f51 100644
--- a/quic/core/qpack/qpack_send_stream_test.cc
+++ b/quic/core/qpack/qpack_send_stream_test.cc
@@ -44,7 +44,7 @@
   std::vector<TestParams> params;
   ParsedQuicVersionVector all_supported_versions = AllSupportedVersions();
   for (const auto& version : AllSupportedVersions()) {
-    if (!VersionHasStreamType(version.transport_version)) {
+    if (!VersionUsesHttp3(version.transport_version)) {
       continue;
     }
     for (Perspective p : {Perspective::IS_SERVER, Perspective::IS_CLIENT}) {
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 56fb396..b6e4b83 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -127,7 +127,7 @@
 }
 
 void QuicSession::PendingStreamOnStreamFrame(const QuicStreamFrame& frame) {
-  DCHECK(VersionHasStreamType(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
   QuicStreamId stream_id = frame.stream_id;
 
   PendingStream* pending = GetOrCreatePendingStream(stream_id);
@@ -295,7 +295,7 @@
 }
 
 void QuicSession::PendingStreamOnRstStream(const QuicRstStreamFrame& frame) {
-  DCHECK(VersionHasStreamType(transport_version()));
+  DCHECK(VersionUsesHttp3(transport_version()));
   QuicStreamId stream_id = frame.stream_id;
 
   PendingStream* pending = GetOrCreatePendingStream(stream_id);
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index a3069ec..9eb4fed 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -1429,7 +1429,7 @@
 }
 
 TEST_P(QuicSessionTestServer, OnStreamFrameFinStaticStreamId) {
-  if (VersionUsesQpack(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     // The test relies on headers stream, which no longer exists in IETF QUIC.
     return;
   }
@@ -1449,7 +1449,7 @@
 }
 
 TEST_P(QuicSessionTestServer, OnRstStreamStaticStreamId) {
-  if (VersionUsesQpack(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     // The test relies on headers stream, which no longer exists in IETF QUIC.
     return;
   }
@@ -1854,7 +1854,7 @@
 }
 
 TEST_P(QuicSessionTestServer, PendingStreams) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
   session_.set_uses_pending_streams(true);
@@ -1873,7 +1873,7 @@
 }
 
 TEST_P(QuicSessionTestServer, RstPendingStreams) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
   session_.set_uses_pending_streams(true);
@@ -1904,7 +1904,7 @@
 }
 
 TEST_P(QuicSessionTestServer, OnFinPendingStreams) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
   session_.set_uses_pending_streams(true);
@@ -1920,7 +1920,7 @@
 }
 
 TEST_P(QuicSessionTestServer, PendingStreamOnWindowUpdate) {
-  if (!VersionHasStreamType(transport_version())) {
+  if (!VersionUsesHttp3(transport_version())) {
     return;
   }
 
diff --git a/quic/core/quic_utils.cc b/quic/core/quic_utils.cc
index d0d93ff..33f7de1 100644
--- a/quic/core/quic_utils.cc
+++ b/quic/core/quic_utils.cc
@@ -374,7 +374,7 @@
 
 // static
 QuicStreamId QuicUtils::GetHeadersStreamId(QuicTransportVersion version) {
-  DCHECK(!VersionUsesQpack(version));
+  DCHECK(!VersionUsesHttp3(version));
   return GetFirstBidirectionalStreamId(version, Perspective::IS_CLIENT);
 }
 
diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index fe8c9ef..de5bbea 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -375,41 +375,20 @@
   return transport_version >= QUIC_VERSION_46;
 }
 
-// Returns true if QuicSpdyStream encodes body using HTTP/3 specification and
-// sends data frame header along with body.
-QUIC_EXPORT_PRIVATE inline bool VersionHasDataFrameHeader(
+// If true, HTTP/3 instead of gQUIC will be used at the HTTP layer.
+// Notable changes are:
+// * Headers stream no longer exists.
+// * PRIORITY, HEADERS are moved from headers stream to HTTP/3 control stream.
+// * PUSH_PROMISE is moved to request stream.
+// * Unidirectional streams will have their first byte as a stream type.
+// * HEADERS frames are compressed using QPACK.
+// * DATA frame has frame headers.
+// * GOAWAY is moved to HTTP layer.
+QUIC_EXPORT_PRIVATE inline bool VersionUsesHttp3(
     QuicTransportVersion transport_version) {
   return transport_version == QUIC_VERSION_99;
 }
 
-// Returns whether |transport_version| has HTTP/3 unidirectional stream type.
-QUIC_EXPORT_PRIVATE inline bool VersionHasStreamType(
-    QuicTransportVersion transport_version) {
-  return transport_version == QUIC_VERSION_99;
-}
-
-// If true:
-// * QuicSpdySession instantiates a QPACK encoder and decoder;
-// * HEADERS frames (containing headers or trailers) are sent on
-//   request/response streams, compressed with QPACK;
-// * trailers must not contain :final-offset key,
-// * PUSH_PROMISE and PRIORITY frames are sent on the request stream,
-// * there is no headers stream.
-// If false:
-// * HEADERS frames (containing headers or trailers) are sent on the headers
-//   stream, compressed with HPACK;
-// * trailers must contain :final-offset key,
-// * PUSH_PROMISE and PRIORITY frames are sent on the headers stream.
-QUIC_EXPORT_PRIVATE inline bool VersionUsesQpack(
-    QuicTransportVersion transport_version) {
-  const bool uses_qpack = (transport_version == QUIC_VERSION_99);
-  if (uses_qpack) {
-    DCHECK(VersionHasDataFrameHeader(transport_version));
-    DCHECK(VersionHasStreamType(transport_version));
-  }
-  return uses_qpack;
-}
-
 // Returns whether the transport_version supports the variable length integer
 // length field as defined by IETF QUIC draft-13 and later.
 QUIC_EXPORT_PRIVATE inline bool QuicVersionHasLongHeaderLengths(
diff --git a/quic/test_tools/quic_spdy_session_peer.cc b/quic/test_tools/quic_spdy_session_peer.cc
index 4af55f5..cad9599 100644
--- a/quic/test_tools/quic_spdy_session_peer.cc
+++ b/quic/test_tools/quic_spdy_session_peer.cc
@@ -14,13 +14,13 @@
 // static
 QuicHeadersStream* QuicSpdySessionPeer::GetHeadersStream(
     QuicSpdySession* session) {
-  DCHECK(!VersionUsesQpack(session->transport_version()));
+  DCHECK(!VersionUsesHttp3(session->transport_version()));
   return session->headers_stream();
 }
 
 void QuicSpdySessionPeer::SetHeadersStream(QuicSpdySession* session,
                                            QuicHeadersStream* headers_stream) {
-  DCHECK(!VersionUsesQpack(session->transport_version()));
+  DCHECK(!VersionUsesHttp3(session->transport_version()));
   for (auto& it : session->stream_map()) {
     if (it.first ==
         QuicUtils::GetHeadersStreamId(session->transport_version())) {
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index ddf42ef..ff02392 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -1194,7 +1194,7 @@
     QuicTransportVersion version,
     int n) {
   int num = n;
-  if (!VersionUsesQpack(version)) {
+  if (!VersionUsesHttp3(version)) {
     num++;
   }
   return QuicUtils::GetFirstBidirectionalStreamId(version,
diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc
index be2d0d6..08697d4 100644
--- a/quic/tools/quic_simple_server_session_test.cc
+++ b/quic/tools/quic_simple_server_session_test.cc
@@ -208,7 +208,7 @@
         kInitialStreamFlowControlWindowForTest);
     config_.SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
-    if (VersionUsesQpack(GetParam().transport_version)) {
+    if (VersionUsesHttp3(GetParam().transport_version)) {
       QuicConfigPeer::SetReceivedMaxIncomingUnidirectionalStreams(
           &config_, kMaxStreamsForTest + 3);
     } else {
@@ -481,7 +481,7 @@
   EXPECT_EQ(1u, session_->GetNumOpenIncomingStreams());
   EXPECT_EQ(0u, session_->GetNumOpenOutgoingStreams());
 
-  if (!VersionUsesQpack(connection_->transport_version())) {
+  if (!VersionUsesHttp3(connection_->transport_version())) {
     session_->UnregisterStreamPriority(
         QuicUtils::GetHeadersStreamId(connection_->transport_version()),
         /*is_static=*/true);
@@ -493,7 +493,7 @@
                                      session_.get(), &stream_helper_);
   crypto_stream->set_encryption_established(true);
   QuicSimpleServerSessionPeer::SetCryptoStream(session_.get(), crypto_stream);
-  if (!VersionUsesQpack(connection_->transport_version())) {
+  if (!VersionUsesHttp3(connection_->transport_version())) {
     session_->RegisterStreamPriority(
         QuicUtils::GetHeadersStreamId(connection_->transport_version()),
         /*is_static=*/true,
@@ -505,7 +505,7 @@
     QuicSpdyStream* created_stream =
         QuicSimpleServerSessionPeer::CreateOutgoingUnidirectionalStream(
             session_.get());
-    if (VersionHasStreamType(connection_->transport_version())) {
+    if (VersionUsesHttp3(connection_->transport_version())) {
       EXPECT_EQ(GetNthServerInitiatedUnidirectionalId(i + 3),
                 created_stream->id());
     } else {
@@ -602,7 +602,7 @@
 
     visitor_ = QuicConnectionPeer::GetVisitor(connection_);
 
-    if (!VersionUsesQpack(connection_->transport_version())) {
+    if (!VersionUsesHttp3(connection_->transport_version())) {
       session_->UnregisterStreamPriority(
           QuicUtils::GetHeadersStreamId(connection_->transport_version()),
           /*is_static=*/true);
@@ -615,7 +615,7 @@
 
     crypto_stream->set_encryption_established(true);
     QuicSimpleServerSessionPeer::SetCryptoStream(session_.get(), crypto_stream);
-    if (!VersionUsesQpack(connection_->transport_version())) {
+    if (!VersionUsesHttp3(connection_->transport_version())) {
       session_->RegisterStreamPriority(
           QuicUtils::GetHeadersStreamId(connection_->transport_version()),
           /*is_static=*/true,
@@ -644,7 +644,7 @@
     QuicByteCount data_frame_header_length = 0;
     for (unsigned int i = 1; i <= num_resources; ++i) {
       QuicStreamId stream_id;
-      if (VersionHasStreamType(connection_->transport_version())) {
+      if (VersionUsesHttp3(connection_->transport_version())) {
         stream_id = GetNthServerInitiatedUnidirectionalId(i + 2);
       } else {
         stream_id = GetNthServerInitiatedUnidirectionalId(i - 1);
@@ -656,7 +656,7 @@
       std::string body(body_size, 'a');
       std::string data;
       data_frame_header_length = 0;
-      if (VersionHasDataFrameHeader(connection_->transport_version())) {
+      if (VersionUsesHttp3(connection_->transport_version())) {
         HttpEncoder encoder;
         std::unique_ptr<char[]> buffer;
         data_frame_header_length =
@@ -680,13 +680,13 @@
         // Since flow control window is smaller than response body, not the
         // whole body will be sent.
         QuicStreamOffset offset = 0;
-        if (VersionHasStreamType(connection_->transport_version())) {
+        if (VersionUsesHttp3(connection_->transport_version())) {
           EXPECT_CALL(*connection_,
                       SendStreamData(stream_id, 1, offset, NO_FIN));
           offset++;
         }
 
-        if (VersionUsesQpack(connection_->transport_version())) {
+        if (VersionUsesHttp3(connection_->transport_version())) {
           EXPECT_CALL(*connection_,
                       SendStreamData(stream_id, kHeadersFrameHeaderLength,
                                      offset, NO_FIN));
@@ -696,7 +696,7 @@
                                      offset, NO_FIN));
           offset += kHeadersFramePayloadLength;
         }
-        if (VersionHasDataFrameHeader(connection_->transport_version())) {
+        if (VersionUsesHttp3(connection_->transport_version())) {
           EXPECT_CALL(*connection_,
                       SendStreamData(stream_id, data_frame_header_length,
                                      offset, NO_FIN));
@@ -716,7 +716,7 @@
   }
 
   void MaybeConsumeHeadersStreamData() {
-    if (!VersionUsesQpack(connection_->transport_version())) {
+    if (!VersionUsesHttp3(connection_->transport_version())) {
       QuicStreamId headers_stream_id =
           QuicUtils::GetHeadersStreamId(connection_->transport_version());
       EXPECT_CALL(*connection_, SendStreamData(headers_stream_id, _, _, _))
@@ -749,7 +749,7 @@
   size_t num_resources = kMaxStreamsForTest + 1;
   QuicByteCount data_frame_header_length = PromisePushResources(num_resources);
   QuicStreamId next_out_going_stream_id;
-  if (VersionHasStreamType(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     next_out_going_stream_id =
         GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest + 3);
   } else {
@@ -760,12 +760,12 @@
   // After an open stream is marked draining, a new stream is expected to be
   // created and a response sent on the stream.
   QuicStreamOffset offset = 0;
-  if (VersionHasStreamType(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(next_out_going_stream_id, 1, offset, NO_FIN));
     offset++;
   }
-  if (VersionUsesQpack(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(next_out_going_stream_id,
                                kHeadersFrameHeaderLength, offset, NO_FIN));
@@ -775,7 +775,7 @@
                                kHeadersFramePayloadLength, offset, NO_FIN));
     offset += kHeadersFramePayloadLength;
   }
-  if (VersionHasDataFrameHeader(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(next_out_going_stream_id,
                                data_frame_header_length, offset, NO_FIN));
@@ -799,7 +799,7 @@
         QuicMaxStreamsFrame(0, num_resources + 3, /*unidirectional=*/true));
   }
 
-  if (VersionHasStreamType(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     session_->StreamDraining(GetNthServerInitiatedUnidirectionalId(3));
   } else {
     session_->StreamDraining(GetNthServerInitiatedUnidirectionalId(0));
@@ -830,7 +830,7 @@
 
   // Reset the last stream in the queue. It should be marked cancelled.
   QuicStreamId stream_got_reset;
-  if (VersionHasStreamType(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     stream_got_reset =
         GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest + 4);
   } else {
@@ -850,7 +850,7 @@
   // be created. But since one of them was marked cancelled due to RST frame,
   // only one queued resource will be sent out.
   QuicStreamId stream_not_reset;
-  if (VersionHasStreamType(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     stream_not_reset =
         GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest + 3);
   } else {
@@ -859,12 +859,12 @@
   }
   InSequence s;
   QuicStreamOffset offset = 0;
-  if (VersionHasStreamType(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(stream_not_reset, 1, offset, NO_FIN));
     offset++;
   }
-  if (VersionUsesQpack(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(stream_not_reset, kHeadersFrameHeaderLength,
                                offset, NO_FIN));
@@ -874,7 +874,7 @@
                                offset, NO_FIN));
     offset += kHeadersFramePayloadLength;
   }
-  if (VersionHasDataFrameHeader(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(stream_not_reset, data_frame_header_length,
                                offset, NO_FIN));
@@ -914,7 +914,7 @@
   }
   QuicByteCount data_frame_header_length = PromisePushResources(num_resources);
   QuicStreamId stream_to_open;
-  if (VersionHasStreamType(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     stream_to_open =
         GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest + 3);
   } else {
@@ -932,12 +932,12 @@
                 OnStreamReset(stream_got_reset, QUIC_RST_ACKNOWLEDGEMENT));
   }
   QuicStreamOffset offset = 0;
-  if (VersionHasStreamType(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(stream_to_open, 1, offset, NO_FIN));
     offset++;
   }
-  if (VersionUsesQpack(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(stream_to_open, kHeadersFrameHeaderLength,
                                offset, NO_FIN));
@@ -947,7 +947,7 @@
                                offset, NO_FIN));
     offset += kHeadersFramePayloadLength;
   }
-  if (VersionHasDataFrameHeader(connection_->transport_version())) {
+  if (VersionUsesHttp3(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(stream_to_open, data_frame_header_length, offset,
                                NO_FIN));
diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc
index 72c3201..783dba0 100644
--- a/quic/tools/quic_simple_server_stream_test.cc
+++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -230,8 +230,8 @@
     return (*stream_->mutable_headers())[key].as_string();
   }
 
-  bool HasFrameHeader() const {
-    return VersionHasDataFrameHeader(connection_->transport_version());
+  bool UsesHttp3() const {
+    return VersionUsesHttp3(connection_->transport_version());
   }
 
   spdy::SpdyHeaderBlock response_headers_;
@@ -264,7 +264,7 @@
   QuicByteCount header_length =
       encoder_.SerializeDataFrameHeader(body_.length(), &buffer);
   std::string header = std::string(buffer.get(), header_length);
-  std::string data = HasFrameHeader() ? header + body_ : body_;
+  std::string data = UsesHttp3() ? header + body_ : body_;
   stream_->OnStreamFrame(
       QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, data));
   EXPECT_EQ("11", StreamHeadersValue("content-length"));
@@ -282,7 +282,7 @@
   QuicByteCount header_length =
       encoder_.SerializeDataFrameHeader(body_.length(), &buffer);
   std::string header = std::string(buffer.get(), header_length);
-  std::string data = HasFrameHeader() ? header + body_ : body_;
+  std::string data = UsesHttp3() ? header + body_ : body_;
   stream_->OnStreamFrame(
       QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, data));
   EXPECT_EQ("11", StreamHeadersValue("content-length"));
@@ -311,7 +311,7 @@
 
   // We'll automatically write out an error (headers + body)
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     EXPECT_CALL(session_, WritevData(_, _, kDataFrameHeaderLength, _, NO_FIN));
   }
   EXPECT_CALL(session_, WritevData(_, _, kErrorLength, _, FIN));
@@ -323,7 +323,7 @@
   QuicByteCount header_length =
       encoder_.SerializeDataFrameHeader(body_.length(), &buffer);
   std::string header = std::string(buffer.get(), header_length);
-  std::string data = HasFrameHeader() ? header + body_ : body_;
+  std::string data = UsesHttp3() ? header + body_ : body_;
 
   stream_->OnStreamFrame(
       QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, data));
@@ -332,7 +332,7 @@
   header_length =
       encoder_.SerializeDataFrameHeader(large_body.length(), &buffer);
   header = std::string(buffer.get(), header_length);
-  std::string data2 = HasFrameHeader() ? header + large_body : large_body;
+  std::string data2 = UsesHttp3() ? header + large_body : large_body;
   stream_->OnStreamFrame(
       QuicStreamFrame(stream_->id(), /*fin=*/true, data.size(), data2));
   EXPECT_EQ("11", StreamHeadersValue("content-length"));
@@ -364,7 +364,7 @@
 
   InSequence s;
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     EXPECT_CALL(session_, WritevData(_, _, header_length, _, NO_FIN));
   }
   EXPECT_CALL(session_, WritevData(_, _, kErrorLength, _, FIN));
@@ -399,7 +399,7 @@
 
   InSequence s;
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     EXPECT_CALL(session_, WritevData(_, _, header_length, _, NO_FIN));
   }
   EXPECT_CALL(session_, WritevData(_, _, kErrorLength, _, FIN));
@@ -463,7 +463,7 @@
 
   InSequence s;
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     EXPECT_CALL(session_, WritevData(_, _, header_length, _, NO_FIN));
   }
   EXPECT_CALL(session_, WritevData(_, _, body.length(), _, FIN));
@@ -506,7 +506,7 @@
                                 connection_->transport_version(), 0),
                             _, _));
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     EXPECT_CALL(session_, WritevData(_, _, header_length, _, NO_FIN));
   }
   EXPECT_CALL(session_, WritevData(_, _, body.length(), _, FIN));
@@ -564,7 +564,7 @@
   InSequence s;
   EXPECT_CALL(*server_initiated_stream, WriteHeadersMock(false));
 
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     EXPECT_CALL(session_, WritevData(_, kServerInitiatedStreamId, header_length,
                                      _, NO_FIN));
   }
@@ -582,7 +582,7 @@
 
   InSequence s;
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
-  if (HasFrameHeader()) {
+  if (UsesHttp3()) {
     EXPECT_CALL(session_, WritevData(_, _, kDataFrameHeaderLength, _, NO_FIN));
   }
   EXPECT_CALL(session_, WritevData(_, _, kErrorLength, _, FIN));