Support blocked decoding in QuicSpdyStream.

Modify QpackDecodedHeadersAccumulator interface and QuicSpdyStream
implementation to support blocked decoding of QPACK headers.

gfe-relnote: n/a, QUIC v99-only change.
PiperOrigin-RevId: 256201744
Change-Id: I17a4b6c0c6d4f30d8526c8b645c55da3ce01a076

quic/core/http/quic_spdy_stream.cc

diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index e3d9357..9966f81 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -11,7 +11,6 @@
 #include "net/third_party/quiche/src/quic/core/http/http_decoder.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/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"
@@ -163,12 +162,14 @@
       spdy_session_(spdy_session),
       on_body_available_called_because_sequencer_is_closed_(false),
       visitor_(nullptr),
+      blocked_on_decoding_headers_(false),
       headers_decompressed_(false),
       headers_length_(0, 0),
       trailers_length_(0, 0),
       trailers_decompressed_(false),
       trailers_consumed_(false),
       headers_bytes_to_be_marked_consumed_(0),
+      pretend_blocked_decoding_for_tests_(false),
       http_decoder_visitor_(new HttpDecoderVisitor(this)),
       body_buffer_(sequencer()),
       sequencer_offset_(0),
@@ -197,12 +198,14 @@
       spdy_session_(spdy_session),
       on_body_available_called_because_sequencer_is_closed_(false),
       visitor_(nullptr),
+      blocked_on_decoding_headers_(false),
       headers_decompressed_(false),
       headers_length_(0, 0),
       trailers_length_(0, 0),
       trailers_decompressed_(false),
       trailers_consumed_(false),
       headers_bytes_to_be_marked_consumed_(0),
+      pretend_blocked_decoding_for_tests_(false),
       http_decoder_visitor_(new HttpDecoderVisitor(this)),
       body_buffer_(sequencer()),
       sequencer_offset_(sequencer()->NumBytesConsumed()),
@@ -497,6 +500,24 @@
   }
 }
 
+void QuicSpdyStream::OnHeadersDecoded(QuicHeaderList headers) {
+  blocked_on_decoding_headers_ = false;
+  ProcessDecodedHeaders(headers);
+  // Continue decoding HTTP/3 frames.
+  OnDataAvailable();
+}
+
+void QuicSpdyStream::OnHeaderDecodingError() {
+  // TODO(b/124216424): Use HTTP_EXCESSIVE_LOAD or
+  // HTTP_QPACK_DECOMPRESSION_FAILED error code as indicated by
+  // |qpack_decoded_headers_accumulator_|.
+  std::string error_message = QuicStrCat(
+      "Error during async decoding of ",
+      headers_decompressed_ ? "trailers" : "headers", " on stream ", id(), ": ",
+      qpack_decoded_headers_accumulator_->error_message());
+  CloseConnectionWithDetails(QUIC_DECOMPRESSION_FAILURE, error_message);
+}
+
 void QuicSpdyStream::OnHeadersTooLarge() {
   if (VersionUsesQpack(spdy_session_->connection()->transport_version())) {
     // TODO(124216424): Use HTTP_EXCESSIVE_LOAD error code.
@@ -632,6 +653,10 @@
     return;
   }
 
+  if (blocked_on_decoding_headers_) {
+    return;
+  }
+
   iovec iov;
   while (!reading_stopped() && decoder_.error() == QUIC_NO_ERROR) {
     DCHECK_GE(sequencer_offset_, sequencer()->NumBytesConsumed());
@@ -645,6 +670,9 @@
         reinterpret_cast<const char*>(iov.iov_base), iov.iov_len);
     is_decoder_processing_input_ = false;
     sequencer_offset_ += processed_bytes;
+    if (blocked_on_decoding_headers_) {
+      return;
+    }
   }
 
   // Do not call OnBodyAvailable() until headers are consumed.
@@ -819,8 +847,9 @@
 
   qpack_decoded_headers_accumulator_ =
       QuicMakeUnique<QpackDecodedHeadersAccumulator>(
-          id(), spdy_session_->qpack_decoder(),
-          spdy_session_->max_inbound_header_list_size());
+          id(), spdy_session_->qpack_decoder(), this,
+          spdy_session_->max_inbound_header_list_size(),
+          pretend_blocked_decoding_for_tests_);
 
   // Do not call MaybeMarkHeadersBytesConsumed() yet, because
   // HEADERS frame header bytes might not have been parsed completely.
@@ -851,7 +880,9 @@
 bool QuicSpdyStream::OnHeadersFrameEnd() {
   DCHECK(VersionUsesQpack(spdy_session_->connection()->transport_version()));
 
-  if (!qpack_decoded_headers_accumulator_->EndHeaderBlock()) {
+  auto result = qpack_decoded_headers_accumulator_->EndHeaderBlock();
+
+  if (result == QpackDecodedHeadersAccumulator::Status::kError) {
     // TODO(124216424): Use HTTP_QPACK_DECOMPRESSION_FAILED error code.
     std::string error_message =
         QuicStrCat("Error decompressing header block on stream ", id(), ": ",
@@ -860,13 +891,23 @@
     return false;
   }
 
+  if (result == QpackDecodedHeadersAccumulator::Status::kBlocked) {
+    blocked_on_decoding_headers_ = true;
+    return false;
+  }
+
+  DCHECK(result == QpackDecodedHeadersAccumulator::Status::kSuccess);
+
+  ProcessDecodedHeaders(qpack_decoded_headers_accumulator_->quic_header_list());
+  return !sequencer()->IsClosed() && !reading_stopped();
+}
+
+void QuicSpdyStream::ProcessDecodedHeaders(const QuicHeaderList& headers) {
   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());
+  OnStreamHeaderList(/* fin = */ false, frame_length, headers);
   qpack_decoded_headers_accumulator_.reset();
-  return !sequencer()->IsClosed() && !reading_stopped();
 }
 
 size_t QuicSpdyStream::WriteHeadersImpl(

quic/core/http/quic_spdy_stream.h

diff --git a/quic/core/http/quic_spdy_stream.h b/quic/core/http/quic_spdy_stream.h
index 1a5c1b6..9a59ddc 100644
--- a/quic/core/http/quic_spdy_stream.h
+++ b/quic/core/http/quic_spdy_stream.h
@@ -19,6 +19,7 @@
 #include "net/third_party/quiche/src/quic/core/http/http_encoder.h"
 #include "net/third_party/quiche/src/quic/core/http/quic_header_list.h"
 #include "net/third_party/quiche/src/quic/core/http/quic_spdy_stream_body_buffer.h"
+#include "net/third_party/quiche/src/quic/core/qpack/qpack_decoded_headers_accumulator.h"
 #include "net/third_party/quiche/src/quic/core/quic_packets.h"
 #include "net/third_party/quiche/src/quic/core/quic_stream.h"
 #include "net/third_party/quiche/src/quic/core/quic_stream_sequencer.h"
@@ -34,11 +35,12 @@
 class QuicStreamPeer;
 }  // namespace test
 
-class QpackDecodedHeadersAccumulator;
 class QuicSpdySession;
 
 // A QUIC stream that can send and receive HTTP2 (SPDY) headers.
-class QUIC_EXPORT_PRIVATE QuicSpdyStream : public QuicStream {
+class QUIC_EXPORT_PRIVATE QuicSpdyStream
+    : public QuicStream,
+      public QpackDecodedHeadersAccumulator::Visitor {
  public:
   // Visitor receives callbacks from the stream.
   class QUIC_EXPORT_PRIVATE Visitor {
@@ -206,6 +208,10 @@
 
   using QuicStream::CloseWriteSide;
 
+  // QpackDecodedHeadersAccumulator::Visitor implementation.
+  void OnHeadersDecoded(QuicHeaderList headers) override;
+  void OnHeaderDecodingError() override;
+
  protected:
   // Called when the received headers are too large. By default this will
   // reset the stream.
@@ -246,6 +252,9 @@
   bool OnHeadersFramePayload(QuicStringPiece payload);
   bool OnHeadersFrameEnd();
 
+  // Called internally when headers are decoded.
+  void ProcessDecodedHeaders(const QuicHeaderList& headers);
+
   // Call QuicStreamSequencer::MarkConsumed() with
   // |headers_bytes_to_be_marked_consumed_| if appropriate.
   void MaybeMarkHeadersBytesConsumed();
@@ -260,6 +269,10 @@
   bool on_body_available_called_because_sequencer_is_closed_;
 
   Visitor* visitor_;
+
+  // True if read side processing is blocked while waiting for callback from
+  // QPACK decoder.
+  bool blocked_on_decoding_headers_;
   // True if the headers have been completely decompressed.
   bool headers_decompressed_;
   // Contains a copy of the decompressed header (name, value) pairs until they
@@ -284,6 +297,9 @@
   HttpEncoder encoder_;
   // Http decoder for processing raw incoming stream frames.
   HttpDecoder decoder_;
+  // TODO(b/112770235): Remove once blocked decoding is implemented
+  // and can be tested with delayed encoder stream data.
+  bool pretend_blocked_decoding_for_tests_;
   // Headers accumulator for decoding HEADERS frame payload.
   std::unique_ptr<QpackDecodedHeadersAccumulator>
       qpack_decoded_headers_accumulator_;

quic/core/http/quic_spdy_stream_test.cc

diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index bab9228..b50c3bb 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -1810,6 +1810,146 @@
   stream_->OnStreamFrame(frame);
 }
 
+TEST_P(QuicSpdyStreamTest, BlockedHeaderDecoding) {
+  if (!VersionUsesQpack(GetParam().transport_version)) {
+    return;
+  }
+
+  Initialize(kShouldProcessData);
+  QuicSpdyStreamPeer::pretend_blocked_decoding(stream_);
+
+  // HEADERS frame with QPACK encoded single header field "foo: bar".
+  std::string headers =
+      HeadersFrame(QuicTextUtils::HexDecode("00002a94e703626172"));
+  stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), false, 0, headers));
+
+  // Even though entire header block is received, it cannot be decoded.
+  EXPECT_FALSE(stream_->headers_decompressed());
+
+  // Signal to QpackDecodedHeadersAccumulator that the header block has been
+  // decoded.  (OnDecodingCompleted() has already been called by the QPACK
+  // decoder, so technically quic_header_list_.OnHeaderBlockEnd() is called
+  // twice, which is a no-op.)
+  QuicSpdyStreamPeer::qpack_decoded_headers_accumulator(stream_)
+      ->OnDecodingCompleted();
+
+  EXPECT_TRUE(stream_->headers_decompressed());
+
+  EXPECT_THAT(stream_->header_list(), ElementsAre(Pair("foo", "bar")));
+  stream_->ConsumeHeaderList();
+
+  std::string data = DataFrame(kDataFramePayload);
+  stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), false, /* offset = */
+                                         headers.length(), data));
+  EXPECT_EQ(kDataFramePayload, stream_->data());
+
+  // Trailing HEADERS frame with QPACK encoded
+  // single header field "custom-key: custom-value".
+  std::string trailers = HeadersFrame(
+      QuicTextUtils::HexDecode("00002f0125a849e95ba97d7f8925a849e95bb8e8b4bf"));
+  stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), true, /* offset = */
+                                         headers.length() + data.length(),
+                                         trailers));
+
+  // Even though entire header block is received, it cannot be decoded.
+  EXPECT_FALSE(stream_->trailers_decompressed());
+
+  // Signal to QpackDecodedHeadersAccumulator that the header block has been
+  // decoded.
+  QuicSpdyStreamPeer::qpack_decoded_headers_accumulator(stream_)
+      ->OnDecodingCompleted();
+  EXPECT_TRUE(stream_->trailers_decompressed());
+
+  // Verify trailers.
+  EXPECT_THAT(stream_->received_trailers(),
+              ElementsAre(Pair("custom-key", "custom-value")));
+  stream_->MarkTrailersConsumed();
+}
+
+TEST_P(QuicSpdyStreamTest, AsyncErrorDecodingHeaders) {
+  if (!VersionUsesQpack(GetParam().transport_version)) {
+    return;
+  }
+
+  Initialize(kShouldProcessData);
+  QuicSpdyStreamPeer::pretend_blocked_decoding(stream_);
+
+  // HEADERS frame with QPACK encoded single header field "foo: bar".
+  std::string headers =
+      HeadersFrame(QuicTextUtils::HexDecode("00002a94e703626172"));
+  stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), false, 0, headers));
+
+  // Even though entire header block is received, it cannot be decoded.
+  EXPECT_FALSE(stream_->headers_decompressed());
+
+  // Signal a decoding error to QpackDecodedHeadersAccumulator.
+  std::string expected_error_message =
+      QuicStrCat("Error during async decoding of headers on stream ",
+                 stream_->id(), ": unexpected error");
+  EXPECT_CALL(
+      *connection_,
+      CloseConnection(QUIC_DECOMPRESSION_FAILURE, expected_error_message,
+                      ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET));
+  QuicSpdyStreamPeer::qpack_decoded_headers_accumulator(stream_)
+      ->OnDecodingErrorDetected("unexpected error");
+}
+
+TEST_P(QuicSpdyStreamTest, AsyncErrorDecodingTrailers) {
+  if (!VersionUsesQpack(GetParam().transport_version)) {
+    return;
+  }
+
+  Initialize(kShouldProcessData);
+  QuicSpdyStreamPeer::pretend_blocked_decoding(stream_);
+
+  // HEADERS frame with QPACK encoded single header field "foo: bar".
+  std::string headers =
+      HeadersFrame(QuicTextUtils::HexDecode("00002a94e703626172"));
+  stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), false, 0, headers));
+
+  // Even though entire header block is received, it cannot be decoded.
+  EXPECT_FALSE(stream_->headers_decompressed());
+
+  // Signal to QpackDecodedHeadersAccumulator that the header block has been
+  // decoded.  (OnDecodingCompleted() has already been called by the QPACK
+  // decoder, so technically quic_header_list_.OnHeaderBlockEnd() is called
+  // twice, which is a no-op.)
+  QuicSpdyStreamPeer::qpack_decoded_headers_accumulator(stream_)
+      ->OnDecodingCompleted();
+
+  EXPECT_TRUE(stream_->headers_decompressed());
+
+  EXPECT_THAT(stream_->header_list(), ElementsAre(Pair("foo", "bar")));
+  stream_->ConsumeHeaderList();
+
+  std::string data = DataFrame(kDataFramePayload);
+  stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), false, /* offset = */
+                                         headers.length(), data));
+  EXPECT_EQ(kDataFramePayload, stream_->data());
+
+  // Trailing HEADERS frame with QPACK encoded
+  // single header field "custom-key: custom-value".
+  std::string trailers = HeadersFrame(
+      QuicTextUtils::HexDecode("00002f0125a849e95ba97d7f8925a849e95bb8e8b4bf"));
+  stream_->OnStreamFrame(QuicStreamFrame(stream_->id(), true, /* offset = */
+                                         headers.length() + data.length(),
+                                         trailers));
+
+  // Even though entire header block is received, it cannot be decoded.
+  EXPECT_FALSE(stream_->trailers_decompressed());
+
+  // Signal a decoding error to QpackDecodedHeadersAccumulator.
+  std::string expected_error_message =
+      QuicStrCat("Error during async decoding of trailers on stream ",
+                 stream_->id(), ": unexpected error");
+  EXPECT_CALL(
+      *connection_,
+      CloseConnection(QUIC_DECOMPRESSION_FAILURE, expected_error_message,
+                      ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET));
+  QuicSpdyStreamPeer::qpack_decoded_headers_accumulator(stream_)
+      ->OnDecodingErrorDetected("unexpected error");
+}
+
 class QuicSpdyStreamIncrementalConsumptionTest : public QuicSpdyStreamTest {
  protected:
   QuicSpdyStreamIncrementalConsumptionTest() : offset_(0), consumed_bytes_(0) {}

quic/core/qpack/qpack_decoded_headers_accumulator.cc

diff --git a/quic/core/qpack/qpack_decoded_headers_accumulator.cc b/quic/core/qpack/qpack_decoded_headers_accumulator.cc
index 7a3b157..8ca28c9 100644
--- a/quic/core/qpack/qpack_decoded_headers_accumulator.cc
+++ b/quic/core/qpack/qpack_decoded_headers_accumulator.cc
@@ -11,10 +11,15 @@
 QpackDecodedHeadersAccumulator::QpackDecodedHeadersAccumulator(
     QuicStreamId id,
     QpackDecoder* qpack_decoder,
-    size_t max_header_list_size)
+    Visitor* visitor,
+    size_t max_header_list_size,
+    bool pretend_blocked_decoding_for_tests)
     : decoder_(qpack_decoder->CreateProgressiveDecoder(id, this)),
+      visitor_(visitor),
       uncompressed_header_bytes_(0),
       compressed_header_bytes_(0),
+      blocked_(false),
+      pretend_blocked_decoding_for_tests_(pretend_blocked_decoding_for_tests),
       error_detected_(false) {
   quic_header_list_.set_max_header_list_size(max_header_list_size);
   quic_header_list_.OnHeaderBlockStart();
@@ -28,7 +33,14 @@
   quic_header_list_.OnHeader(name, value);
 }
 
-void QpackDecodedHeadersAccumulator::OnDecodingCompleted() {}
+void QpackDecodedHeadersAccumulator::OnDecodingCompleted() {
+  quic_header_list_.OnHeaderBlockEnd(uncompressed_header_bytes_,
+                                     compressed_header_bytes_);
+
+  if (blocked_) {
+    visitor_->OnHeadersDecoded(quic_header_list_);
+  }
+}
 
 void QpackDecodedHeadersAccumulator::OnDecodingErrorDetected(
     QuicStringPiece error_message) {
@@ -37,6 +49,10 @@
   error_detected_ = true;
   // Copy error message to ensure it remains valid for the lifetime of |this|.
   error_message_.assign(error_message.data(), error_message.size());
+
+  if (blocked_) {
+    visitor_->OnHeaderDecodingError();
+  }
 }
 
 bool QpackDecodedHeadersAccumulator::Decode(QuicStringPiece data) {
@@ -48,15 +64,18 @@
   return !error_detected_;
 }
 
-bool QpackDecodedHeadersAccumulator::EndHeaderBlock() {
+QpackDecodedHeadersAccumulator::Status
+QpackDecodedHeadersAccumulator::EndHeaderBlock() {
   DCHECK(!error_detected_);
 
   decoder_->EndHeaderBlock();
 
-  quic_header_list_.OnHeaderBlockEnd(uncompressed_header_bytes_,
-                                     compressed_header_bytes_);
+  if (pretend_blocked_decoding_for_tests_) {
+    blocked_ = true;
+    return Status::kBlocked;
+  }
 
-  return !error_detected_;
+  return error_detected_ ? Status::kError : Status::kSuccess;
 }
 
 const QuicHeaderList& QpackDecodedHeadersAccumulator::quic_header_list() const {

quic/core/qpack/qpack_decoded_headers_accumulator.h

diff --git a/quic/core/qpack/qpack_decoded_headers_accumulator.h b/quic/core/qpack/qpack_decoded_headers_accumulator.h
index 5db88d7..59480db 100644
--- a/quic/core/qpack/qpack_decoded_headers_accumulator.h
+++ b/quic/core/qpack/qpack_decoded_headers_accumulator.h
@@ -24,9 +24,35 @@
 class QUIC_EXPORT_PRIVATE QpackDecodedHeadersAccumulator
     : public QpackProgressiveDecoder::HeadersHandlerInterface {
  public:
+  // Return value for EndHeaderBlock().
+  enum class Status {
+    // Headers have been successfully decoded.
+    kSuccess,
+    // An error has occurred.
+    kError,
+    // Decoding is blocked.
+    kBlocked
+  };
+
+  // Visitor interface used for blocked decoding.  Exactly one visitor method
+  // will be called if EndHeaderBlock() returned kBlocked.  No visitor method
+  // will be called if EndHeaderBlock() returned any other value.
+  class Visitor {
+   public:
+    virtual ~Visitor() = default;
+
+    // Called when headers are successfully decoded.
+    virtual void OnHeadersDecoded(QuicHeaderList headers) = 0;
+
+    // Called when an error has occurred.
+    virtual void OnHeaderDecodingError() = 0;
+  };
+
   QpackDecodedHeadersAccumulator(QuicStreamId id,
                                  QpackDecoder* qpack_decoder,
-                                 size_t max_header_list_size);
+                                 Visitor* visitor,
+                                 size_t max_header_list_size,
+                                 bool pretend_blocked_decoding_for_tests);
   virtual ~QpackDecodedHeadersAccumulator() = default;
 
   // QpackProgressiveDecoder::HeadersHandlerInterface implementation.
@@ -40,23 +66,36 @@
   // Must not be called after EndHeaderBlock().
   bool Decode(QuicStringPiece data);
 
-  // Signal end of HEADERS frame.  Returns true on success, false on error.
+  // Signal end of HEADERS frame.
   // Must not be called if an error has been detected.
   // Must not be called more that once.
-  bool EndHeaderBlock();
+  // Returns kSuccess if headers can be readily decoded.
+  // Returns kError if an error occurred.
+  // Returns kBlocked if headers cannot be decoded at the moment, in which case
+  // exactly one Visitor method will be called as soon as sufficient data
+  // is received on the QPACK decoder stream.
+  Status EndHeaderBlock();
 
   // Returns accumulated header list.
   const QuicHeaderList& quic_header_list() const;
 
   // Returns error message.
   // Must not be called unless an error has been detected.
+  // TODO(b/124216424): Add accessor for error code, return HTTP_EXCESSIVE_LOAD
+  // or HTTP_QPACK_DECOMPRESSION_FAILED.
   QuicStringPiece error_message() const;
 
  private:
   std::unique_ptr<QpackProgressiveDecoder> decoder_;
+  Visitor* visitor_;
   QuicHeaderList quic_header_list_;
   size_t uncompressed_header_bytes_;
   size_t compressed_header_bytes_;
+  // Set to true when EndHeaderBlock() returns kBlocked.
+  bool blocked_;
+  // TODO(b/112770235): Remove once blocked decoding is implemented
+  // and can be tested with delayed encoder stream data.
+  bool pretend_blocked_decoding_for_tests_;
   bool error_detected_;
   std::string error_message_;
 };

quic/core/qpack/qpack_decoded_headers_accumulator_test.cc

diff --git a/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc b/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc
index 2ba9c4f..6f424e4 100644
--- a/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc
+++ b/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc
@@ -16,6 +16,7 @@
 using ::testing::Eq;
 using ::testing::Pair;
 using ::testing::StrictMock;
+using Status = quic::QpackDecodedHeadersAccumulator::Status;
 
 namespace quic {
 namespace test {
@@ -32,29 +33,41 @@
 
 }  // anonymous namespace
 
+class NoopVisitor : public QpackDecodedHeadersAccumulator::Visitor {
+ public:
+  ~NoopVisitor() override = default;
+  void OnHeadersDecoded(QuicHeaderList /* headers */) override {}
+  void OnHeaderDecodingError() override {}
+};
+
 class QpackDecodedHeadersAccumulatorTest : public QuicTest {
  protected:
   QpackDecodedHeadersAccumulatorTest()
       : qpack_decoder_(&encoder_stream_error_delegate_,
                        &decoder_stream_sender_delegate_),
-        accumulator_(kTestStreamId, &qpack_decoder_, kMaxHeaderListSize) {}
+        accumulator_(kTestStreamId,
+                     &qpack_decoder_,
+                     &visitor_,
+                     kMaxHeaderListSize,
+                     false) {}
 
   NoopEncoderStreamErrorDelegate encoder_stream_error_delegate_;
   StrictMock<MockQpackStreamSenderDelegate> decoder_stream_sender_delegate_;
   QpackDecoder qpack_decoder_;
+  NoopVisitor visitor_;
   QpackDecodedHeadersAccumulator accumulator_;
 };
 
 // HEADERS frame payload must have a complete Header Block Prefix.
 TEST_F(QpackDecodedHeadersAccumulatorTest, EmptyPayload) {
-  EXPECT_FALSE(accumulator_.EndHeaderBlock());
+  EXPECT_EQ(Status::kError, accumulator_.EndHeaderBlock());
   EXPECT_EQ("Incomplete header data prefix.", accumulator_.error_message());
 }
 
 // HEADERS frame payload must have a complete Header Block Prefix.
 TEST_F(QpackDecodedHeadersAccumulatorTest, TruncatedHeaderBlockPrefix) {
   EXPECT_TRUE(accumulator_.Decode(QuicTextUtils::HexDecode("00")));
-  EXPECT_FALSE(accumulator_.EndHeaderBlock());
+  EXPECT_EQ(Status::kError, accumulator_.EndHeaderBlock());
   EXPECT_EQ("Incomplete header data prefix.", accumulator_.error_message());
 }
 
@@ -63,7 +76,7 @@
               WriteStreamData(Eq(kHeaderAcknowledgement)));
 
   EXPECT_TRUE(accumulator_.Decode(QuicTextUtils::HexDecode("0000")));
-  EXPECT_TRUE(accumulator_.EndHeaderBlock());
+  EXPECT_EQ(Status::kSuccess, accumulator_.EndHeaderBlock());
 
   EXPECT_TRUE(accumulator_.quic_header_list().empty());
 }
@@ -72,7 +85,7 @@
 // before it can be completely decoded.
 TEST_F(QpackDecodedHeadersAccumulatorTest, TruncatedPayload) {
   EXPECT_TRUE(accumulator_.Decode(QuicTextUtils::HexDecode("00002366")));
-  EXPECT_FALSE(accumulator_.EndHeaderBlock());
+  EXPECT_EQ(Status::kError, accumulator_.EndHeaderBlock());
   EXPECT_EQ("Incomplete header block.", accumulator_.error_message());
 }
 
@@ -88,7 +101,7 @@
 
   std::string encoded_data(QuicTextUtils::HexDecode("000023666f6f03626172"));
   EXPECT_TRUE(accumulator_.Decode(encoded_data));
-  EXPECT_TRUE(accumulator_.EndHeaderBlock());
+  EXPECT_EQ(Status::kSuccess, accumulator_.EndHeaderBlock());
 
   const QuicHeaderList& header_list = accumulator_.quic_header_list();
   EXPECT_THAT(header_list, ElementsAre(Pair("foo", "bar")));
@@ -110,11 +123,25 @@
       "616161616161616161616161616161616161616161616161616161616161616161616161"
       "616161616161616161616161616161616161616161616161616161616161616161616161"
       "61616161616161616161616161616161616161616161616161616161616161616161")));
-  EXPECT_TRUE(accumulator_.EndHeaderBlock());
+  EXPECT_EQ(Status::kSuccess, accumulator_.EndHeaderBlock());
 
   // QuicHeaderList signals header list over limit by clearing it.
   EXPECT_TRUE(accumulator_.quic_header_list().empty());
 }
 
+// TODO(b/112770235): Remove once blocked decoding is implemented
+// and can be tested with delayed encoder stream data.
+TEST_F(QpackDecodedHeadersAccumulatorTest, PretendBlockedEncoding) {
+  QpackDecodedHeadersAccumulator accumulator(
+      kTestStreamId, &qpack_decoder_, &visitor_, kMaxHeaderListSize,
+      /* pretend_blocked_decoding_for_tests = */ true);
+
+  EXPECT_CALL(decoder_stream_sender_delegate_,
+              WriteStreamData(Eq(kHeaderAcknowledgement)));
+
+  EXPECT_TRUE(accumulator.Decode(QuicTextUtils::HexDecode("0000")));
+  EXPECT_EQ(Status::kBlocked, accumulator.EndHeaderBlock());
+}
+
 }  // namespace test
 }  // namespace quic

quic/test_tools/quic_spdy_stream_peer.cc

diff --git a/quic/test_tools/quic_spdy_stream_peer.cc b/quic/test_tools/quic_spdy_stream_peer.cc
index 4d23434..b02c145 100644
--- a/quic/test_tools/quic_spdy_stream_peer.cc
+++ b/quic/test_tools/quic_spdy_stream_peer.cc
@@ -5,6 +5,7 @@
 #include "net/third_party/quiche/src/quic/test_tools/quic_spdy_stream_peer.h"
 
 #include "net/third_party/quiche/src/quic/core/http/quic_spdy_stream.h"
+#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 
 namespace quic {
 namespace test {
@@ -22,5 +23,16 @@
   return stream->unacked_frame_headers_offsets_;
 }
 
+// static
+void QuicSpdyStreamPeer::pretend_blocked_decoding(QuicSpdyStream* stream) {
+  stream->pretend_blocked_decoding_for_tests_ = true;
+}
+
+// static
+QpackDecodedHeadersAccumulator*
+QuicSpdyStreamPeer::qpack_decoded_headers_accumulator(QuicSpdyStream* stream) {
+  return stream->qpack_decoded_headers_accumulator_.get();
+}
+
 }  // namespace test
 }  // namespace quic

quic/test_tools/quic_spdy_stream_peer.h

diff --git a/quic/test_tools/quic_spdy_stream_peer.h b/quic/test_tools/quic_spdy_stream_peer.h
index 7b3fe7c..bd93f37 100644
--- a/quic/test_tools/quic_spdy_stream_peer.h
+++ b/quic/test_tools/quic_spdy_stream_peer.h
@@ -8,9 +8,11 @@
 #include "net/third_party/quiche/src/quic/core/quic_ack_listener_interface.h"
 #include "net/third_party/quiche/src/quic/core/quic_interval_set.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
 
 namespace quic {
 
+class QpackDecodedHeadersAccumulator;
 class QuicSpdyStream;
 
 namespace test {
@@ -22,6 +24,12 @@
       QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
   static const QuicIntervalSet<QuicStreamOffset>& unacked_frame_headers_offsets(
       QuicSpdyStream* stream);
+
+  // TODO(b/112770235): Remove once blocked decoding is implemented
+  // and can be tested with delayed encoder stream data.
+  static void pretend_blocked_decoding(QuicSpdyStream* stream);
+  static QpackDecodedHeadersAccumulator* qpack_decoded_headers_accumulator(
+      QuicSpdyStream* stream);
 };
 
 }  // namespace test