diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index c72622c..59159a5 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -11,6 +11,21 @@
 #include <utility>
 #include <vector>
 
+<<<<<<<
+|||||||
+#include "net/third_party/quic/core/crypto/null_encrypter.h"
+#include "net/third_party/quic/core/http/quic_spdy_client_stream.h"
+#include "net/third_party/quic/core/quic_epoll_connection_helper.h"
+#include "net/third_party/quic/core/quic_error_codes.h"
+#include "net/third_party/quic/core/quic_framer.h"
+=======
+#include "net/third_party/quic/core/crypto/null_encrypter.h"
+#include "net/third_party/quic/core/http/quic_spdy_client_stream.h"
+#include "net/third_party/quic/core/qpack/qpack_encoder_test_utils.h"
+#include "net/third_party/quic/core/quic_epoll_connection_helper.h"
+#include "net/third_party/quic/core/quic_error_codes.h"
+#include "net/third_party/quic/core/quic_framer.h"
+>>>>>>>
 #include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
 #include "net/third_party/quiche/src/quic/core/http/quic_spdy_client_stream.h"
 #include "net/third_party/quiche/src/quic/core/quic_epoll_connection_helper.h"
@@ -1368,8 +1383,17 @@
   headers["key3"] = std::string(15 * 1024, 'a');
 
   client_->SendCustomSynchronousRequest(headers, body);
-  EXPECT_EQ(QUIC_HEADERS_TOO_LARGE, client_->stream_error());
-  EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
+
+  if (VersionUsesQpack(client_->client()
+                           ->client_session()
+                           ->connection()
+                           ->transport_version())) {
+    EXPECT_EQ(QUIC_HEADERS_STREAM_DATA_DECOMPRESS_FAILURE,
+              client_->connection_error());
+  } else {
+    EXPECT_EQ(QUIC_HEADERS_TOO_LARGE, client_->stream_error());
+    EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
+  }
 }
 
 TEST_P(EndToEndTest, EarlyResponseWithQuicStreamNoError) {
@@ -2007,10 +2031,9 @@
       client_->client()->client_session());
   // In v47 and later, the crypto handshake (sent in CRYPTO frames) is not
   // subject to flow control.
-  if (!QuicVersionUsesCryptoFrames(client_->client()
-                                       ->client_session()
-                                       ->connection()
-                                       ->transport_version())) {
+  const QuicTransportVersion transport_version =
+      client_->client()->client_session()->connection()->transport_version();
+  if (!QuicVersionUsesCryptoFrames(transport_version)) {
     EXPECT_LT(QuicFlowControllerPeer::SendWindowSize(
                   crypto_stream->flow_controller()),
               kStreamIFCW);
@@ -2023,6 +2046,11 @@
   // has not been affected.
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
 
+  // No headers stream in IETF QUIC.
+  if (VersionUsesQpack(transport_version)) {
+    return;
+  }
+
   QuicHeadersStream* headers_stream = QuicSpdySessionPeer::GetHeadersStream(
       client_->client()->client_session());
   EXPECT_LT(
@@ -2187,6 +2215,29 @@
 
   client_->SendMessage(headers, "", /*fin=*/false);
 
+  // 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()
+                           ->client_session()
+                           ->connection()
+                           ->transport_version())) {
+    // Determine size of compressed headers.
+    NoopDecoderStreamErrorDelegate decoder_stream_error_delegate;
+    NoopEncoderStreamSenderDelegate encoder_stream_sender_delegate;
+    QpackEncoder qpack_encoder(&decoder_stream_error_delegate,
+                               &encoder_stream_sender_delegate);
+    auto progressive_encoder =
+        qpack_encoder.EncodeHeaderList(/* stream_id = */ 0, &headers);
+    std::string encoded_headers;
+    while (progressive_encoder->HasNext()) {
+      progressive_encoder->Next(
+          /* max_encoded_bytes = */ std::numeric_limits<size_t>::max(),
+          &encoded_headers);
+    }
+    header_size = encoded_headers.size();
+  }
+
   // Test the AckNotifier's ability to track multiple packets by making the
   // request body exceed the size of a single packet.
   std::string request_string = "a request body bigger than one packet" +
@@ -2194,7 +2245,7 @@
 
   // The TestAckListener will cause a failure if not notified.
   QuicReferenceCountedPointer<TestAckListener> ack_listener(
-      new TestAckListener(request_string.length()));
+      new TestAckListener(header_size + request_string.length()));
 
   // Send the request, and register the delegate for ACKs.
   client_->SendData(request_string, true, ack_listener);
diff --git a/quic/core/http/quic_headers_stream_test.cc b/quic/core/http/quic_headers_stream_test.cc
index 2f669df..a41235f 100644
--- a/quic/core/http/quic_headers_stream_test.cc
+++ b/quic/core/http/quic_headers_stream_test.cc
@@ -370,6 +370,10 @@
 }
 
 TEST_P(QuicHeadersStreamTest, WriteHeaders) {
+  if (VersionUsesQpack(transport_version())) {
+    return;
+  }
+
   for (QuicStreamId stream_id = client_id_1_; stream_id < client_id_3_;
        stream_id += next_stream_id_) {
     for (bool fin : {false, true}) {
@@ -421,6 +425,10 @@
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessRawData) {
+  if (VersionUsesQpack(transport_version())) {
+    return;
+  }
+
   for (QuicStreamId stream_id = client_id_1_; stream_id < client_id_3_;
        stream_id += next_stream_id_) {
     for (bool fin : {false, true}) {
@@ -536,6 +544,10 @@
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessLargeRawData) {
+  if (VersionUsesQpack(transport_version())) {
+    return;
+  }
+
   QuicSpdySessionPeer::SetMaxUncompressedHeaderBytes(&session_, 256 * 1024);
   // We want to create a frame that is more than the SPDY Framer's max control
   // frame size, which is 16K, but less than the HPACK decoders max decode
@@ -710,6 +722,10 @@
 }
 
 TEST_P(QuicHeadersStreamTest, HpackDecoderDebugVisitor) {
+  if (VersionUsesQpack(transport_version())) {
+    return;
+  }
+
   auto hpack_decoder_visitor =
       QuicMakeUnique<StrictMock<MockQuicHpackDebugVisitor>>();
   {
@@ -762,6 +778,10 @@
 }
 
 TEST_P(QuicHeadersStreamTest, HpackEncoderDebugVisitor) {
+  if (VersionUsesQpack(transport_version())) {
+    return;
+  }
+
   auto hpack_encoder_visitor =
       QuicMakeUnique<StrictMock<MockQuicHpackDebugVisitor>>();
   if (perspective() == Perspective::IS_SERVER) {
diff --git a/quic/core/http/quic_spdy_client_stream_test.cc b/quic/core/http/quic_spdy_client_stream_test.cc
index 007bba0..5f5d5c1 100644
--- a/quic/core/http/quic_spdy_client_stream_test.cc
+++ b/quic/core/http/quic_spdy_client_stream_test.cc
@@ -193,9 +193,14 @@
   EXPECT_NE(QUIC_STREAM_NO_ERROR, stream_->stream_error());
 }
 
+// Test that receiving trailing headers (on the headers stream), containing a
+// final offset, results in the stream being closed at that byte offset.
 TEST_P(QuicSpdyClientStreamTest, ReceivingTrailers) {
-  // Test that receiving trailing headers, containing a final offset, results in
-  // the stream being closed at that byte offset.
+  // There is no kFinalOffsetHeaderKey if trailers are sent on the
+  // request/response stream.
+  if (VersionUsesQpack(connection_->transport_version())) {
+    return;
+  }
 
   // Send headers as usual.
   auto headers = AsHeaderList(headers_);
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index bdaa433..93d10e1 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -204,6 +204,12 @@
       return;
     }
 
+    if (VersionUsesQpack(session_->connection()->transport_version())) {
+      CloseConnection("HEADERS frame not allowed on headers stream.",
+                      QUIC_INVALID_HEADERS_STREAM_DATA);
+      return;
+    }
+
     // TODO(mpw): avoid down-conversion and plumb SpdyStreamPrecedence through
     // QuicHeadersStream.
     SpdyPriority priority =
@@ -399,7 +405,6 @@
   DCHECK(VersionUsesQpack(connection()->transport_version()));
 
   // TODO(112770235): Send decoder stream data on decoder stream.
-  QUIC_NOTREACHED();
 }
 
 void QuicSpdySession::OnStreamHeadersPriority(QuicStreamId stream_id,
@@ -472,6 +477,8 @@
     bool fin,
     SpdyPriority priority,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
+  DCHECK(!VersionUsesQpack(connection()->transport_version()));
+
   return WriteHeadersOnHeadersStreamImpl(
       id, std::move(headers), fin,
       /* parent_stream_id = */ 0, Spdy3PriorityToHttp2Weight(priority),
@@ -568,6 +575,8 @@
     int weight,
     bool exclusive,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
+  DCHECK(!VersionUsesQpack(connection()->transport_version()));
+
   SpdyHeadersIR headers_frame(id, std::move(headers));
   headers_frame.set_fin(fin);
   if (perspective() == Perspective::IS_CLIENT) {
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 0e2fcf8..1a33fd1 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -1221,6 +1221,13 @@
   if (QuicVersionUsesCryptoFrames(connection_->transport_version())) {
     return;
   }
+
+  // This test depends on the headers stream, which does not exist when QPACK is
+  // used.
+  if (VersionUsesQpack(transport_version())) {
+    return;
+  }
+
   // Test that if the header stream is flow control blocked, then if the SHLO
   // contains a larger send window offset, the stream becomes unblocked.
   session_.set_writev_consumes_all_data(true);
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index d04efc5..2f161ae 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -4,11 +4,22 @@
 
 #include "net/third_party/quiche/src/quic/core/http/quic_spdy_stream.h"
 
+#include <limits>
 #include <string>
 #include <utility>
 
 #include "net/third_party/quiche/src/quic/core/http/quic_spdy_session.h"
 #include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
+#include "net/third_party/quiche/src/quic/core/qpack/qpack_decoded_headers_accumulator.h"
+#include "net/third_party/quiche/src/quic/core/qpack/qpack_decoder.h"
+#include "net/third_party/quiche/src/quic/core/qpack/qpack_encoder.h"
+#include "net/third_party/quiche/src/quic/core/quic_utils.h"
+#include "net/third_party/quiche/src/quic/core/quic_versions.h"
+#include "net/third_party/quiche/src/quic/core/quic_write_blocked_list.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_flag_utils.h"
+#include "net/third_party/quiche/src/quic/core/http/quic_spdy_session.h"
+#include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
 #include "net/third_party/quiche/src/quic/core/quic_write_blocked_list.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
@@ -139,8 +150,11 @@
                                StreamType type)
     : QuicStream(id, spdy_session, /*is_static=*/false, type),
       spdy_session_(spdy_session),
+      on_body_available_called_because_sequencer_is_closed_(false),
       visitor_(nullptr),
       headers_decompressed_(false),
+      headers_length_(0, 0),
+      trailers_length_(0, 0),
       trailers_decompressed_(false),
       trailers_consumed_(false),
       http_decoder_visitor_(new HttpDecoderVisitor(this)),
@@ -148,9 +162,11 @@
       ack_listener_(nullptr) {
   DCHECK(!QuicUtils::IsCryptoStreamId(
       spdy_session->connection()->transport_version(), id));
-  // Don't receive any callbacks from the sequencer until headers
-  // are complete.
-  sequencer()->SetBlockedUntilFlush();
+  // If headers are sent on the headers stream, then do not receive any
+  // callbacks from the sequencer until headers are complete.
+  if (!VersionUsesQpack(spdy_session_->connection()->transport_version())) {
+    sequencer()->SetBlockedUntilFlush();
+  }
 
   if (VersionHasDataFrameHeader(
           spdy_session_->connection()->transport_version())) {
@@ -164,8 +180,11 @@
                                StreamType type)
     : QuicStream(std::move(pending), type, /*is_static=*/false),
       spdy_session_(spdy_session),
+      on_body_available_called_because_sequencer_is_closed_(false),
       visitor_(nullptr),
       headers_decompressed_(false),
+      headers_length_(0, 0),
+      trailers_length_(0, 0),
       trailers_decompressed_(false),
       trailers_consumed_(false),
       http_decoder_visitor_(new HttpDecoderVisitor(this)),
@@ -173,9 +192,11 @@
       ack_listener_(nullptr) {
   DCHECK(!QuicUtils::IsCryptoStreamId(
       spdy_session->connection()->transport_version(), id()));
-  // Don't receive any callbacks from the sequencer until headers
-  // are complete.
-  sequencer()->SetBlockedUntilFlush();
+  // If headers are sent on the headers stream, then do not receive any
+  // callbacks from the sequencer until headers are complete.
+  if (!VersionUsesQpack(spdy_session_->connection()->transport_version())) {
+    sequencer()->SetBlockedUntilFlush();
+  }
 
   if (VersionHasDataFrameHeader(
           spdy_session_->connection()->transport_version())) {
@@ -192,7 +213,11 @@
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   size_t bytes_written =
       WriteHeadersImpl(std::move(header_block), fin, std::move(ack_listener));
-  if (fin) {
+  if (!VersionUsesQpack(spdy_session_->connection()->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.
     // TODO(rch): Add test to ensure fin_sent_ is set whenever a fin is sent.
     set_fin_sent(true);
     CloseWriteSide();
@@ -217,13 +242,15 @@
   unacked_frame_headers_offsets_.Add(
       send_buffer().stream_offset(),
       send_buffer().stream_offset() + header_length);
-  QUIC_DLOG(INFO) << "Stream " << id() << " is writing header of length "
+  QUIC_DLOG(INFO) << "Stream " << id()
+                  << " is writing DATA frame header of length "
                   << header_length;
   WriteOrBufferData(QuicStringPiece(buffer.get(), header_length), false,
                     nullptr);
 
   // Write body.
-  QUIC_DLOG(INFO) << "Stream " << id() << " is writing body of length "
+  QUIC_DLOG(INFO) << "Stream " << id()
+                  << " is writing DATA frame payload of length "
                   << data.length();
   WriteOrBufferData(data, fin, nullptr);
 }
@@ -236,26 +263,33 @@
     return 0;
   }
 
-  // The header block must contain the final offset for this stream, as the
-  // trailers may be processed out of order at the peer.
-  QUIC_DLOG(INFO) << "Inserting trailer: (" << kFinalOffsetHeaderKey << ", "
-                  << stream_bytes_written() + BufferedDataBytes() << ")";
-  trailer_block.insert(
-      std::make_pair(kFinalOffsetHeaderKey,
-                     QuicTextUtils::Uint64ToString(stream_bytes_written() +
-                                                   BufferedDataBytes())));
+  if (!VersionUsesQpack(spdy_session_->connection()->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 =
+        stream_bytes_written() + BufferedDataBytes();
+    QUIC_DLOG(INFO) << "Inserting trailer: (" << kFinalOffsetHeaderKey << ", "
+                    << final_offset << ")";
+    trailer_block.insert(std::make_pair(
+        kFinalOffsetHeaderKey, QuicTextUtils::Uint64ToString(final_offset)));
+  }
 
   // Write the trailing headers with a FIN, and close stream for writing:
   // trailers are the last thing to be sent on a stream.
   const bool kFin = true;
   size_t bytes_written =
       WriteHeadersImpl(std::move(trailer_block), kFin, std::move(ack_listener));
-  set_fin_sent(kFin);
 
-  // Trailers are the last thing to be sent on a stream, but if there is still
-  // queued data then CloseWriteSide() will cause it never to be sent.
-  if (BufferedDataBytes() == 0) {
-    CloseWriteSide();
+  // 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(spdy_session_->connection()->transport_version())) {
+    set_fin_sent(kFin);
+
+    // Also, write side of this stream needs to be closed.  However, only do
+    // this if there is no more buffered data, otherwise it will never be sent.
+    if (BufferedDataBytes() == 0) {
+      CloseWriteSide();
+    }
   }
 
   return bytes_written;
@@ -298,12 +332,14 @@
   unacked_frame_headers_offsets_.Add(
       send_buffer().stream_offset(),
       send_buffer().stream_offset() + header_length);
-  QUIC_DLOG(INFO) << "Stream " << id() << " is writing header of length "
+  QUIC_DLOG(INFO) << "Stream " << id()
+                  << " is writing DATA frame header of length "
                   << header_length;
   WriteMemSlices(storage.ToSpan(), false);
 
   // Write body.
-  QUIC_DLOG(INFO) << "Stream " << id() << " is writing body of length "
+  QUIC_DLOG(INFO) << "Stream " << id()
+                  << " is writing DATA frame payload of length "
                   << slices.total_length();
   return WriteMemSlices(slices, fin);
 }
@@ -352,6 +388,15 @@
 }
 
 void QuicSpdyStream::MarkTrailersConsumed() {
+  /*if (VersionUsesQpack(spdy_session_->connection()->transport_version()) &&
+      !reading_stopped()) {
+    const QuicByteCount trailers_total_length =
+        trailers_length_.header_length + trailers_length_.payload_length;
+    if (trailers_total_length > 0) {
+      sequencer()->MarkConsumed(trailers_total_length);
+    }
+  }*/
+
   trailers_consumed_ = true;
 }
 
@@ -365,8 +410,35 @@
 
 void QuicSpdyStream::ConsumeHeaderList() {
   header_list_.Clear();
-  if (FinishedReadingHeaders()) {
-    sequencer()->SetUnblocked();
+
+  if (!VersionUsesQpack(spdy_session_->connection()->transport_version())) {
+    if (FinishedReadingHeaders()) {
+      sequencer()->SetUnblocked();
+    }
+    return;
+  }
+
+  /*if (!reading_stopped()) {
+    const QuicByteCount headers_total_length =
+        headers_length_.header_length + headers_length_.payload_length;
+    if (headers_total_length > 0) {
+      sequencer()->MarkConsumed(headers_total_length);
+    }
+  }*/
+
+  if (!FinishedReadingHeaders()) {
+    return;
+  }
+
+  if (body_buffer_.HasBytesToRead()) {
+    OnBodyAvailable();
+    return;
+  }
+
+  if (sequencer()->IsClosed() &&
+      !on_body_available_called_because_sequencer_is_closed_) {
+    on_body_available_called_because_sequencer_is_closed_ = true;
+    OnBodyAvailable();
   }
 }
 
@@ -398,7 +470,15 @@
 }
 
 void QuicSpdyStream::OnHeadersTooLarge() {
-  Reset(QUIC_HEADERS_TOO_LARGE);
+  if (VersionUsesQpack(spdy_session_->connection()->transport_version())) {
+    // TODO(124216424): Use HTTP_EXCESSIVE_LOAD error code.
+    std::string error_message =
+        QuicStrCat("Too large headers received on stream ", id());
+    CloseConnectionWithDetails(QUIC_HEADERS_STREAM_DATA_DECOMPRESS_FAILURE,
+                               error_message);
+  } else {
+    Reset(QUIC_HEADERS_TOO_LARGE);
+  }
 }
 
 void QuicSpdyStream::OnInitialHeadersComplete(
@@ -407,8 +487,20 @@
     const QuicHeaderList& header_list) {
   headers_decompressed_ = true;
   header_list_ = header_list;
+
+  if (VersionUsesQpack(spdy_session_->connection()->transport_version())) {
+    if (fin) {
+      OnStreamFrame(
+          QuicStreamFrame(id(), /* fin = */ true,
+                          flow_controller()->highest_received_byte_offset(),
+                          QuicStringPiece()));
+    }
+    return;
+  }
+
   if (fin) {
-    OnStreamFrame(QuicStreamFrame(id(), fin, 0, QuicStringPiece()));
+    OnStreamFrame(
+        QuicStreamFrame(id(), fin, /* offset = */ 0, QuicStringPiece()));
   }
   if (FinishedReadingHeaders()) {
     sequencer()->SetUnblocked();
@@ -431,15 +523,18 @@
     size_t /*frame_len*/,
     const QuicHeaderList& header_list) {
   DCHECK(!trailers_decompressed_);
-  if (fin_received()) {
-    QUIC_DLOG(ERROR) << "Received Trailers after FIN, on stream: " << id();
+  if (!VersionUsesQpack(spdy_session_->connection()->transport_version()) &&
+      fin_received()) {
+    QUIC_DLOG(INFO) << "Received Trailers after FIN, on stream: " << id();
     session()->connection()->CloseConnection(
         QUIC_INVALID_HEADERS_STREAM_DATA, "Trailers after fin",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     return;
   }
-  if (!fin) {
-    QUIC_DLOG(ERROR) << "Trailers must have FIN set, on stream: " << id();
+
+  if (!VersionUsesQpack(spdy_session_->connection()->transport_version()) &&
+      !fin) {
+    QUIC_DLOG(INFO) << "Trailers must have FIN set, on stream: " << id();
     session()->connection()->CloseConnection(
         QUIC_INVALID_HEADERS_STREAM_DATA, "Fin missing from trailers",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
@@ -447,8 +542,9 @@
   }
 
   size_t final_byte_offset = 0;
-  if (!SpdyUtils::CopyAndValidateTrailers(header_list,
-                                          /* expect_final_byte_offset = */ true,
+  const bool expect_final_byte_offset =
+      !VersionUsesQpack(spdy_session_->connection()->transport_version());
+  if (!SpdyUtils::CopyAndValidateTrailers(header_list, expect_final_byte_offset,
                                           &final_byte_offset,
                                           &received_trailers_)) {
     QUIC_DLOG(ERROR) << "Trailers for stream " << id() << " are malformed.";
@@ -458,16 +554,12 @@
     return;
   }
   trailers_decompressed_ = true;
+  const QuicStreamOffset offset =
+      VersionUsesQpack(spdy_session_->connection()->transport_version())
+          ? flow_controller()->highest_received_byte_offset()
+          : final_byte_offset;
   OnStreamFrame(
-      QuicStreamFrame(id(), fin, final_byte_offset, QuicStringPiece()));
-}
-
-size_t QuicSpdyStream::WriteHeadersImpl(
-    spdy::SpdyHeaderBlock header_block,
-    bool fin,
-    QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
-  return spdy_session_->WriteHeadersOnHeadersStream(
-      id(), std::move(header_block), fin, priority(), std::move(ack_listener));
+      QuicStreamFrame(id(), /* fin = */ true, offset, QuicStringPiece()));
 }
 
 void QuicSpdyStream::OnPriorityFrame(SpdyPriority priority) {
@@ -488,7 +580,10 @@
 }
 
 void QuicSpdyStream::OnDataAvailable() {
-  DCHECK(FinishedReadingHeaders());
+  if (!VersionUsesQpack(spdy_session_->connection()->transport_version())) {
+    // Sequencer must be blocked until headers are consumed.
+    DCHECK(FinishedReadingHeaders());
+  }
 
   if (!VersionHasDataFrameHeader(
           session()->connection()->transport_version())) {
@@ -502,14 +597,20 @@
                           iov.iov_len);
   }
 
+  // Do not call OnBodyAvailable() until headers are consumed.
+  if (!FinishedReadingHeaders()) {
+    return;
+  }
+
   if (body_buffer_.HasBytesToRead()) {
     OnBodyAvailable();
     return;
   }
 
-  if (sequencer()->IsClosed()) {
+  if (sequencer()->IsClosed() &&
+      !on_body_available_called_because_sequencer_is_closed_) {
+    on_body_available_called_because_sequencer_is_closed_ = true;
     OnBodyAvailable();
-    return;
   }
 }
 
@@ -645,14 +746,98 @@
 
 void QuicSpdyStream::OnHeadersFrameStart(Http3FrameLengths frame_length) {
   DCHECK(VersionUsesQpack(spdy_session_->connection()->transport_version()));
+  DCHECK(!qpack_decoded_headers_accumulator_);
+
+  if (headers_decompressed_) {
+    trailers_length_ = frame_length;
+  } else {
+    headers_length_ = frame_length;
+  }
+
+  qpack_decoded_headers_accumulator_ =
+      QuicMakeUnique<QpackDecodedHeadersAccumulator>(
+          id(), spdy_session_->qpack_decoder(),
+          spdy_session_->max_inbound_header_list_size());
+  sequencer()->MarkConsumed(frame_length.header_length);
 }
 
 void QuicSpdyStream::OnHeadersFramePayload(QuicStringPiece payload) {
   DCHECK(VersionUsesQpack(spdy_session_->connection()->transport_version()));
+
+  if (!qpack_decoded_headers_accumulator_->Decode(payload)) {
+    // TODO(124216424): Use HTTP_QPACK_DECOMPRESSION_FAILED error code.
+    std::string error_message =
+        QuicStrCat("Error decompressing header block on stream ", id(), ": ",
+                   qpack_decoded_headers_accumulator_->error_message());
+    CloseConnectionWithDetails(QUIC_DECOMPRESSION_FAILURE, error_message);
+    return;
+  }
+  sequencer()->MarkConsumed(payload.size());
 }
 
 void QuicSpdyStream::OnHeadersFrameEnd() {
   DCHECK(VersionUsesQpack(spdy_session_->connection()->transport_version()));
+
+  if (!qpack_decoded_headers_accumulator_->EndHeaderBlock()) {
+    // TODO(124216424): Use HTTP_QPACK_DECOMPRESSION_FAILED error code.
+    std::string error_message =
+        QuicStrCat("Error decompressing header block on stream ", id(), ": ",
+                   qpack_decoded_headers_accumulator_->error_message());
+    CloseConnectionWithDetails(QUIC_DECOMPRESSION_FAILURE, error_message);
+    return;
+  }
+
+  const QuicByteCount frame_length = headers_decompressed_
+                                         ? trailers_length_.payload_length
+                                         : headers_length_.payload_length;
+  OnStreamHeaderList(/* fin = */ false, frame_length,
+                     qpack_decoded_headers_accumulator_->quic_header_list());
+
+  qpack_decoded_headers_accumulator_.reset();
+}
+
+size_t QuicSpdyStream::WriteHeadersImpl(
+    spdy::SpdyHeaderBlock header_block,
+    bool fin,
+    QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
+  if (!VersionUsesQpack(spdy_session_->connection()->transport_version())) {
+    return spdy_session_->WriteHeadersOnHeadersStream(
+        id(), std::move(header_block), fin, priority(),
+        std::move(ack_listener));
+  }
+
+  // Encode header list.
+  auto progressive_encoder = spdy_session_->qpack_encoder()->EncodeHeaderList(
+      /* stream_id = */ id(), &header_block);
+  std::string encoded_headers;
+  while (progressive_encoder->HasNext()) {
+    progressive_encoder->Next(
+        /* max_encoded_bytes = */ std::numeric_limits<size_t>::max(),
+        &encoded_headers);
+  }
+
+  // Write HEADERS frame.
+  std::unique_ptr<char[]> headers_frame_header;
+  const size_t headers_frame_header_length =
+      encoder_.SerializeHeadersFrameHeader(encoded_headers.size(),
+                                           &headers_frame_header);
+  unacked_frame_headers_offsets_.Add(
+      send_buffer().stream_offset(),
+      send_buffer().stream_offset() + headers_frame_header_length);
+
+  QUIC_DLOG(INFO) << "Stream " << id()
+                  << " is writing HEADERS frame header of length "
+                  << headers_frame_header_length;
+  WriteOrBufferData(
+      QuicStringPiece(headers_frame_header.get(), headers_frame_header_length),
+      /* fin = */ false, /* ack_listener = */ nullptr);
+
+  QUIC_DLOG(INFO) << "Stream " << id()
+                  << " is writing HEADERS frame payload of length "
+                  << encoded_headers.length();
+  WriteOrBufferData(encoded_headers, fin, nullptr);
+
+  return encoded_headers.size();
 }
 
 #undef ENDPOINT  // undef for jumbo builds
diff --git a/quic/core/http/quic_spdy_stream.h b/quic/core/http/quic_spdy_stream.h
index f81a421..3c5a166 100644
--- a/quic/core/http/quic_spdy_stream.h
+++ b/quic/core/http/quic_spdy_stream.h
@@ -34,6 +34,7 @@
 class QuicStreamPeer;
 }  // namespace test
 
+class QpackDecodedHeadersAccumulator;
 class QuicSpdySession;
 
 // A QUIC stream that can send and receive HTTP2 (SPDY) headers.
@@ -105,8 +106,8 @@
   // Called in OnDataAvailable() after it finishes the decoding job.
   virtual void OnBodyAvailable() = 0;
 
-  // Writes the headers contained in |header_block| to the dedicated
-  // headers stream.
+  // Writes the headers contained in |header_block| on the dedicated headers
+  // stream or on this stream, depending on VersionUsesQpack().
   virtual size_t WriteHeaders(
       spdy::SpdyHeaderBlock header_block,
       bool fin,
@@ -115,8 +116,9 @@
   // Sends |data| to the peer, or buffers if it can't be sent immediately.
   void WriteOrBufferBody(QuicStringPiece data, bool fin);
 
-  // Writes the trailers contained in |trailer_block| to the dedicated
-  // headers stream. Trailers will always have the FIN set.
+  // Writes the trailers contained in |trailer_block| on the dedicated headers
+  // stream or on this stream, depending on VersionUsesQpack().  Trailers will
+  // always have the FIN flag set.
   virtual size_t WriteTrailers(
       spdy::SpdyHeaderBlock trailer_block,
       QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
@@ -247,12 +249,18 @@
 
   QuicSpdySession* spdy_session_;
 
+  bool on_body_available_called_because_sequencer_is_closed_;
+
   Visitor* visitor_;
   // True if the headers have been completely decompressed.
   bool headers_decompressed_;
   // Contains a copy of the decompressed header (name, value) pairs until they
   // are consumed via Readv.
   QuicHeaderList header_list_;
+  // Length of HEADERS frame, including frame header and payload.
+  Http3FrameLengths headers_length_;
+  // Length of TRAILERS frame, including frame header and payload.
+  Http3FrameLengths trailers_length_;
 
   // True if the trailers have been completely decompressed.
   bool trailers_decompressed_;
@@ -265,6 +273,9 @@
   HttpEncoder encoder_;
   // Http decoder for processing raw incoming stream frames.
   HttpDecoder decoder_;
+  // Headers accumulator for decoding HEADERS frame payload.
+  std::unique_ptr<QpackDecodedHeadersAccumulator>
+      qpack_decoded_headers_accumulator_;
   // Visitor of the HttpDecoder.
   std::unique_ptr<HttpDecoderVisitor> http_decoder_visitor_;
   // Buffer that contains decoded data of the stream.
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index c45a899..eb9a0b3 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -78,6 +78,11 @@
                               ack_listener) override {
     saved_headers_ = std::move(header_block);
     WriteHeadersMock(fin);
+    if (VersionUsesQpack(transport_version())) {
+      // In this case, call QuicSpdyStream::WriteHeadersImpl() that does the
+      // actual work of closing the stream.
+      QuicSpdyStream::WriteHeadersImpl(saved_headers_.Clone(), fin, nullptr);
+    }
     return 0;
   }
 
@@ -212,10 +217,23 @@
   QuicHeaderList headers;
   stream_->OnStreamHeadersPriority(kV3HighestPriority);
 
-  EXPECT_CALL(*session_,
-              SendRstStream(stream_->id(), QUIC_HEADERS_TOO_LARGE, 0));
+  const bool version_uses_qpack =
+      VersionUsesQpack(connection_->transport_version());
+
+  if (version_uses_qpack) {
+    EXPECT_CALL(*connection_,
+                CloseConnection(QUIC_HEADERS_STREAM_DATA_DECOMPRESS_FAILURE,
+                                "Too large headers received on stream 4", _));
+  } else {
+    EXPECT_CALL(*session_,
+                SendRstStream(stream_->id(), QUIC_HEADERS_TOO_LARGE, 0));
+  }
+
   stream_->OnStreamHeaderList(false, 1 << 20, headers);
-  EXPECT_EQ(QUIC_HEADERS_TOO_LARGE, stream_->stream_error());
+
+  if (!version_uses_qpack) {
+    EXPECT_EQ(QUIC_HEADERS_TOO_LARGE, stream_->stream_error());
+  }
 }
 
 TEST_P(QuicSpdyStreamTest, ProcessHeaderListWithFin) {
@@ -919,7 +937,11 @@
   trailers_block["key2"] = "value2";
   trailers_block["key3"] = "value3";
   SpdyHeaderBlock trailers_block_with_final_offset = trailers_block.Clone();
-  trailers_block_with_final_offset[kFinalOffsetHeaderKey] = "0";
+  if (!VersionUsesQpack(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";
+  }
   total_bytes = 0;
   QuicHeaderList trailers;
   for (const auto& p : trailers_block_with_final_offset) {
@@ -943,6 +965,12 @@
   // body, stream is closed at the right offset.
   Initialize(kShouldProcessData);
 
+  // kFinalOffsetHeaderKey is not used when HEADERS are sent on the
+  // request/response stream.
+  if (VersionUsesQpack(GetParam().transport_version)) {
+    return;
+  }
+
   // Receive initial headers.
   QuicHeaderList headers = ProcessHeaders(false, headers_);
   stream_->ConsumeHeaderList();
@@ -988,6 +1016,12 @@
   // Test that receiving trailers without a final offset field is an error.
   Initialize(kShouldProcessData);
 
+  // kFinalOffsetHeaderKey is not used when HEADERS are sent on the
+  // request/response stream.
+  if (VersionUsesQpack(GetParam().transport_version)) {
+    return;
+  }
+
   // Receive initial headers.
   ProcessHeaders(false, headers_);
   stream_->ConsumeHeaderList();
@@ -1010,10 +1044,60 @@
                               trailers.uncompressed_header_bytes(), trailers);
 }
 
+TEST_P(QuicSpdyStreamTest, ReceivingTrailersOnRequestStream) {
+  Initialize(kShouldProcessData);
+
+  if (!VersionUsesQpack(GetParam().transport_version)) {
+    return;
+  }
+
+  // Receive initial headers.
+  QuicHeaderList headers = ProcessHeaders(false, headers_);
+  stream_->ConsumeHeaderList();
+
+  const std::string body = "this is the body";
+  std::unique_ptr<char[]> buf;
+  QuicByteCount header_length =
+      encoder_.SerializeDataFrameHeader(body.length(), &buf);
+  std::string header = std::string(buf.get(), header_length);
+  std::string data = HasFrameHeader() ? header + body : body;
+
+  // Receive trailing headers.
+  SpdyHeaderBlock trailers_block;
+  trailers_block["key1"] = "value1";
+  trailers_block["key2"] = "value2";
+  trailers_block["key3"] = "value3";
+
+  QuicHeaderList trailers = ProcessHeaders(true, trailers_block);
+
+  // The trailers should be decompressed, and readable from the stream.
+  EXPECT_TRUE(stream_->trailers_decompressed());
+
+  EXPECT_EQ(trailers_block, stream_->received_trailers());
+
+  // Consuming the trailers erases them from the stream.
+  stream_->MarkTrailersConsumed();
+  EXPECT_TRUE(stream_->FinishedReadingTrailers());
+  EXPECT_TRUE(stream_->IsDoneReading());
+
+  // Receive and consume body.
+  QuicStreamFrame frame(GetNthClientInitiatedBidirectionalId(0), /*fin=*/false,
+                        0, data);
+  stream_->OnStreamFrame(frame);
+  EXPECT_EQ(body, stream_->data());
+  EXPECT_TRUE(stream_->IsDoneReading());
+}
+
 TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithoutFin) {
   // Test that received Trailers must always have the FIN set.
   Initialize(kShouldProcessData);
 
+  // In IETF QUIC, there is no such thing as FIN flag on HTTP/3 frames like the
+  // HEADERS frame.
+  if (VersionUsesQpack(GetParam().transport_version)) {
+    return;
+  }
+
   // Receive initial headers.
   auto headers = AsHeaderList(headers_);
   stream_->OnStreamHeaderList(/*fin=*/false,
@@ -1053,6 +1137,13 @@
   // If body data are received with a FIN, no trailers should then arrive.
   Initialize(kShouldProcessData);
 
+  // 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)) {
+    return;
+  }
+
   // Receive initial headers without FIN set.
   ProcessHeaders(false, headers_);
   stream_->ConsumeHeaderList();
@@ -1101,6 +1192,12 @@
   // to be sent on a stream.
   Initialize(kShouldProcessData);
 
+  if (VersionUsesQpack(GetParam().transport_version)) {
+    // In this case, TestStream::WriteHeadersImpl() does not prevent writes.
+    EXPECT_CALL(*session_, WritevData(stream_, stream_->id(), _, _, _))
+        .Times(AtLeast(1));
+  }
+
   // Write the initial headers, without a FIN.
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
   stream_->WriteHeaders(SpdyHeaderBlock(), /*fin=*/false, nullptr);
@@ -1118,6 +1215,12 @@
   // peer contain the final offset field indicating last byte of data.
   Initialize(kShouldProcessData);
 
+  if (VersionUsesQpack(GetParam().transport_version)) {
+    // In this case, TestStream::WriteHeadersImpl() does not prevent writes.
+    EXPECT_CALL(*session_, WritevData(stream_, stream_->id(), _, _, _))
+        .Times(AtLeast(1));
+  }
+
   // Write the initial headers.
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
   stream_->WriteHeaders(SpdyHeaderBlock(), /*fin=*/false, nullptr);
@@ -1137,12 +1240,18 @@
   // number of body bytes written (including queued bytes).
   SpdyHeaderBlock trailers;
   trailers["trailer key"] = "trailer value";
-  SpdyHeaderBlock trailers_with_offset(trailers.Clone());
-  trailers_with_offset[kFinalOffsetHeaderKey] =
-      QuicTextUtils::Uint64ToString(body.length() + header_length);
+
+  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)) {
+    expected_trailers[kFinalOffsetHeaderKey] =
+        QuicTextUtils::Uint64ToString(body.length() + header_length);
+  }
+
   EXPECT_CALL(*stream_, WriteHeadersMock(true));
   stream_->WriteTrailers(std::move(trailers), nullptr);
-  EXPECT_EQ(trailers_with_offset, stream_->saved_headers());
+  EXPECT_EQ(expected_trailers, stream_->saved_headers());
 }
 
 TEST_P(QuicSpdyStreamTest, WritingTrailersClosesWriteSide) {
@@ -1150,12 +1259,16 @@
   // (headers and body), that this closes the stream for writing.
   Initialize(kShouldProcessData);
 
+  // Expect data being written on the stream.  In addition to that, headers are
+  // also written on the stream in case of IETF QUIC.
+  EXPECT_CALL(*session_, WritevData(stream_, stream_->id(), _, _, _))
+      .Times(AtLeast(1));
+
   // Write the initial headers.
   EXPECT_CALL(*stream_, WriteHeadersMock(false));
   stream_->WriteHeaders(SpdyHeaderBlock(), /*fin=*/false, nullptr);
 
   // Write non-zero body data.
-  EXPECT_CALL(*session_, WritevData(_, _, _, _, _)).Times(AtLeast(1));
   const int kBodySize = 1 * 1024;  // 1 kB
   stream_->WriteOrBufferBody(std::string(kBodySize, 'x'), false);
   EXPECT_EQ(0u, stream_->BufferedDataBytes());
@@ -1168,6 +1281,13 @@
 }
 
 TEST_P(QuicSpdyStreamTest, WritingTrailersWithQueuedBytes) {
+  // 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)) {
+    return;
+  }
+
   // Test that the stream is not closed for writing when trailers are sent
   // while there are still body bytes queued.
   testing::InSequence seq;
@@ -1202,7 +1322,10 @@
 
 TEST_P(QuicSpdyStreamTest, WritingTrailersAfterFIN) {
   // EXPECT_QUIC_BUG tests are expensive so only run one instance of them.
-  if (GetParam() != AllSupportedVersions()[0]) {
+  // In IETF QUIC, there is no such thing as FIN flag on HTTP/3 frames like the
+  // HEADERS frame.  That is version 99, which is element 0 of the array, so
+  // pick another element.
+  if (GetParam() != AllSupportedVersions()[1]) {
     return;
   }
 
@@ -1554,6 +1677,65 @@
       QuicSpdyStreamPeer::unacked_frame_headers_offsets(stream_).Empty());
 }
 
+TEST_P(QuicSpdyStreamTest, HeadersFrameOnRequestStream) {
+  if (!VersionUsesQpack(GetParam().transport_version)) {
+    return;
+  }
+
+  Initialize(kShouldProcessData);
+
+  // QPACK encoded header block with single header field "foo: bar".
+  std::string headers_frame_payload =
+      QuicTextUtils::HexDecode("00002a94e703626172");
+  std::unique_ptr<char[]> headers_buffer;
+  QuicByteCount headers_frame_header_length =
+      encoder_.SerializeHeadersFrameHeader(headers_frame_payload.length(),
+                                           &headers_buffer);
+  QuicStringPiece headers_frame_header(headers_buffer.get(),
+                                       headers_frame_header_length);
+
+  std::string data_frame_payload = "some data";
+  std::unique_ptr<char[]> data_buffer;
+  QuicByteCount data_frame_header_length = encoder_.SerializeDataFrameHeader(
+      data_frame_payload.length(), &data_buffer);
+  QuicStringPiece data_frame_header(data_buffer.get(),
+                                    data_frame_header_length);
+
+  // QPACK encoded header block with single header field
+  // "custom-key: custom-value".
+  std::string trailers_frame_payload =
+      QuicTextUtils::HexDecode("00002f0125a849e95ba97d7f8925a849e95bb8e8b4bf");
+  std::unique_ptr<char[]> trailers_buffer;
+  QuicByteCount trailers_frame_header_length =
+      encoder_.SerializeHeadersFrameHeader(trailers_frame_payload.length(),
+                                           &trailers_buffer);
+  QuicStringPiece trailers_frame_header(trailers_buffer.get(),
+                                        trailers_frame_header_length);
+
+  std::string stream_frame_payload = QuicStrCat(
+      headers_frame_header, headers_frame_payload, data_frame_header,
+      data_frame_payload, trailers_frame_header, trailers_frame_payload);
+  QuicStreamFrame frame(stream_->id(), false, 0, stream_frame_payload);
+  stream_->OnStreamFrame(frame);
+
+  auto it = stream_->header_list().begin();
+  ASSERT_TRUE(it != stream_->header_list().end());
+  EXPECT_EQ("foo", it->first);
+  EXPECT_EQ("bar", it->second);
+  ++it;
+  EXPECT_TRUE(it == stream_->header_list().end());
+
+  // QuicSpdyStream only calls OnBodyAvailable()
+  // after the header list has been consumed.
+  EXPECT_EQ("", stream_->data());
+  stream_->ConsumeHeaderList();
+  EXPECT_EQ("some data", stream_->data());
+
+  const spdy::SpdyHeaderBlock& trailers = stream_->received_trailers();
+  EXPECT_THAT(trailers, testing::ElementsAre(
+                            testing::Pair("custom-key", "custom-value")));
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace quic
diff --git a/quic/core/quic_versions.h b/quic/core/quic_versions.h
index 1f6a431..02a0681 100644
--- a/quic/core/quic_versions.h
+++ b/quic/core/quic_versions.h
@@ -343,13 +343,23 @@
   return transport_version == QUIC_VERSION_99;
 }
 
-// Returns true if QuicSpdySession instantiates a QPACK encoder and decoder.
+// 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.
+// If false:
+// * HEADERS frames (containing headers or trailers) are sent on the headers
+//   stream, compressed with HPACK;
+// * trailers must contain :final-offset key.
+//
 // TODO(123528590): Implement the following features and gate them on this
-// function as well, optionally renaming this function as appropriate.
-// Send HEADERS on the request/response stream instead of the headers stream.
-// Send PUSH_PROMISE on the request/response stream instead of headers stream.
-// Send PRIORITY on the request/response stream instead of the headers stream.
-// Do not instantiate the headers stream object.
+// function as well, optionally renaming this function as appropriate:
+// * send PUSH_PROMISE frames on the request/response stream instead of the
+//   headers stream;
+// * send PRIORITY frames on the request/response stream instead of the headers
+//   stream;
+// * do not instantiate the headers stream object.
 QUIC_EXPORT_PRIVATE inline bool VersionUsesQpack(
     QuicTransportVersion transport_version) {
   const bool uses_qpack = (transport_version == QUIC_VERSION_99);
diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc
index aa9104a..e08af9a 100644
--- a/quic/tools/quic_simple_server_session_test.cc
+++ b/quic/tools/quic_simple_server_session_test.cc
@@ -46,7 +46,12 @@
 namespace quic {
 namespace test {
 namespace {
+
 typedef QuicSimpleServerSession::PromisedStreamInfo PromisedStreamInfo;
+
+const QuicByteCount kHeadersFrameHeaderLength = 2;
+const QuicByteCount kHeadersFramePayloadLength = 9;
+
 }  // namespace
 
 class QuicSimpleServerSessionPeer {
@@ -643,6 +648,16 @@
         // Since flow control window is smaller than response body, not the
         // whole body will be sent.
         QuicStreamOffset offset = 0;
+        if (VersionUsesQpack(connection_->transport_version())) {
+          EXPECT_CALL(*connection_,
+                      SendStreamData(stream_id, kHeadersFrameHeaderLength,
+                                     offset, NO_FIN));
+          offset += kHeadersFrameHeaderLength;
+          EXPECT_CALL(*connection_,
+                      SendStreamData(stream_id, kHeadersFramePayloadLength,
+                                     offset, NO_FIN));
+          offset += kHeadersFramePayloadLength;
+        }
         if (VersionHasDataFrameHeader(connection_->transport_version())) {
           EXPECT_CALL(*connection_,
                       SendStreamData(stream_id, data_frame_header_length,
@@ -661,11 +676,13 @@
     return data_frame_header_length;
   }
 
-  void ConsumeHeadersStreamData() {
-    QuicStreamId headers_stream_id =
-        QuicUtils::GetHeadersStreamId(connection_->transport_version());
-    EXPECT_CALL(*connection_, SendStreamData(headers_stream_id, _, _, _))
-        .Times(AtLeast(1));
+  void MaybeConsumeHeadersStreamData() {
+    if (!VersionUsesQpack(connection_->transport_version())) {
+      QuicStreamId headers_stream_id =
+          QuicUtils::GetHeadersStreamId(connection_->transport_version());
+      EXPECT_CALL(*connection_, SendStreamData(headers_stream_id, _, _, _))
+          .Times(AtLeast(1));
+    }
   }
 };
 
@@ -677,7 +694,7 @@
 // PUSH_PROMISE's will be sent out and only kMaxStreamsForTest streams will be
 // opened and send push response.
 TEST_P(QuicSimpleServerSessionServerPushTest, TestPromisePushResources) {
-  ConsumeHeadersStreamData();
+  MaybeConsumeHeadersStreamData();
   size_t num_resources = kMaxStreamsForTest + 5;
   PromisePushResources(num_resources);
   EXPECT_EQ(kMaxStreamsForTest, session_->GetNumOpenOutgoingStreams());
@@ -687,7 +704,7 @@
 // draining, a queued promised stream will become open and send push response.
 TEST_P(QuicSimpleServerSessionServerPushTest,
        HandlePromisedPushRequestsAfterStreamDraining) {
-  ConsumeHeadersStreamData();
+  MaybeConsumeHeadersStreamData();
   size_t num_resources = kMaxStreamsForTest + 1;
   QuicByteCount data_frame_header_length = PromisePushResources(num_resources);
   QuicStreamId next_out_going_stream_id =
@@ -696,6 +713,16 @@
   // 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 (VersionUsesQpack(connection_->transport_version())) {
+    EXPECT_CALL(*connection_,
+                SendStreamData(next_out_going_stream_id,
+                               kHeadersFrameHeaderLength, offset, NO_FIN));
+    offset += kHeadersFrameHeaderLength;
+    EXPECT_CALL(*connection_,
+                SendStreamData(next_out_going_stream_id,
+                               kHeadersFramePayloadLength, offset, NO_FIN));
+    offset += kHeadersFramePayloadLength;
+  }
   if (VersionHasDataFrameHeader(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(next_out_going_stream_id,
@@ -728,7 +755,7 @@
 // prevent a promised resource to be send out.
 TEST_P(QuicSimpleServerSessionServerPushTest,
        ResetPromisedStreamToCancelServerPush) {
-  ConsumeHeadersStreamData();
+  MaybeConsumeHeadersStreamData();
 
   // 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.
@@ -763,6 +790,16 @@
       GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest);
   InSequence s;
   QuicStreamOffset offset = 0;
+  if (VersionUsesQpack(connection_->transport_version())) {
+    EXPECT_CALL(*connection_,
+                SendStreamData(stream_not_reset, kHeadersFrameHeaderLength,
+                               offset, NO_FIN));
+    offset += kHeadersFrameHeaderLength;
+    EXPECT_CALL(*connection_,
+                SendStreamData(stream_not_reset, kHeadersFramePayloadLength,
+                               offset, NO_FIN));
+    offset += kHeadersFramePayloadLength;
+  }
   if (VersionHasDataFrameHeader(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(stream_not_reset, data_frame_header_length,
@@ -791,7 +828,7 @@
 // the queue to be send out.
 TEST_P(QuicSimpleServerSessionServerPushTest,
        CloseStreamToHandleMorePromisedStream) {
-  ConsumeHeadersStreamData();
+  MaybeConsumeHeadersStreamData();
   size_t num_resources = kMaxStreamsForTest + 1;
   if (IsVersion99()) {
     // V99 will send out a stream-id-blocked frame when the we desired to exceed
@@ -816,6 +853,16 @@
                 OnStreamReset(stream_got_reset, QUIC_RST_ACKNOWLEDGEMENT));
   }
   QuicStreamOffset offset = 0;
+  if (VersionUsesQpack(connection_->transport_version())) {
+    EXPECT_CALL(*connection_,
+                SendStreamData(stream_to_open, kHeadersFrameHeaderLength,
+                               offset, NO_FIN));
+    offset += kHeadersFrameHeaderLength;
+    EXPECT_CALL(*connection_,
+                SendStreamData(stream_to_open, kHeadersFramePayloadLength,
+                               offset, NO_FIN));
+    offset += kHeadersFramePayloadLength;
+  }
   if (VersionHasDataFrameHeader(connection_->transport_version())) {
     EXPECT_CALL(*connection_,
                 SendStreamData(stream_to_open, data_frame_header_length, offset,