diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 4d7d1df..b3ea094 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -15,6 +15,7 @@
 #include "net/third_party/quiche/src/quic/core/http/http_constants.h"
 #include "net/third_party/quiche/src/quic/core/http/quic_spdy_client_stream.h"
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_encoder_test_utils.h"
+#include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
 #include "net/third_party/quiche/src/quic/core/quic_epoll_connection_helper.h"
 #include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
 #include "net/third_party/quiche/src/quic/core/quic_framer.h"
@@ -1670,8 +1671,8 @@
 
 TEST_P(EndToEndTest, SetIndependentMaxIncomingDynamicStreamsLimits) {
   // Each endpoint can set max incoming dynamic streams independently.
-  const uint32_t kClientMaxIncomingDynamicStreams = 2;
-  const uint32_t kServerMaxIncomingDynamicStreams = 1;
+  const uint32_t kClientMaxIncomingDynamicStreams = 4;
+  const uint32_t kServerMaxIncomingDynamicStreams = 3;
   client_config_.SetMaxIncomingBidirectionalStreamsToSend(
       kClientMaxIncomingDynamicStreams);
   server_config_.SetMaxIncomingBidirectionalStreamsToSend(
@@ -1739,6 +1740,7 @@
             server_max_open_outgoing_bidirectional_streams);
   EXPECT_EQ(kClientMaxIncomingDynamicStreams,
             server_max_open_outgoing_unidirectional_streams);
+
   server_thread_->Resume();
 }
 
@@ -2280,7 +2282,10 @@
     // below, the settings frame might not be received.
     HttpEncoder encoder;
     SettingsFrame settings;
-    settings.values[6] = kDefaultMaxUncompressedHeaderSize;
+    settings.values[SETTINGS_MAX_HEADER_LIST_SIZE] =
+        kDefaultMaxUncompressedHeaderSize;
+    settings.values[SETTINGS_QPACK_MAX_TABLE_CAPACITY] =
+        kDefaultQpackMaxDynamicTableCapacity;
     std::unique_ptr<char[]> buffer;
     auto header_length = encoder.SerializeSettingsFrame(settings, &buffer);
     QuicByteCount win_difference1 = QuicFlowControllerPeer::ReceiveWindowSize(
@@ -2294,11 +2299,15 @@
     EXPECT_TRUE(win_difference1 == 0 ||
                 win_difference1 ==
                     header_length +
-                        QuicDataWriter::GetVarInt62Len(kControlStream));
+                        QuicDataWriter::GetVarInt62Len(kControlStream) +
+                        QuicDataWriter::GetVarInt62Len(kQpackEncoderStream) +
+                        QuicDataWriter::GetVarInt62Len(kQpackDecoderStream));
     EXPECT_TRUE(win_difference2 == 0 ||
                 win_difference2 ==
                     header_length +
-                        QuicDataWriter::GetVarInt62Len(kControlStream));
+                        QuicDataWriter::GetVarInt62Len(kControlStream) +
+                        QuicDataWriter::GetVarInt62Len(kQpackEncoderStream) +
+                        QuicDataWriter::GetVarInt62Len(kQpackDecoderStream));
     // The test returns early because in this version, headers stream no longer
     // sends settings.
     return;
diff --git a/quic/core/http/quic_send_control_stream.cc b/quic/core/http/quic_send_control_stream.cc
index e033b61..ab02ae9 100644
--- a/quic/core/http/quic_send_control_stream.cc
+++ b/quic/core/http/quic_send_control_stream.cc
@@ -42,6 +42,8 @@
   SettingsFrame settings;
   settings.values[SETTINGS_MAX_HEADER_LIST_SIZE] =
       max_inbound_header_list_size_;
+  settings.values[SETTINGS_QPACK_MAX_TABLE_CAPACITY] =
+      kDefaultQpackMaxDynamicTableCapacity;
   std::unique_ptr<char[]> buffer;
   QuicByteCount frame_length =
       encoder_.SerializeSettingsFrame(settings, &buffer);
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index 1da419e..7fbccad 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -309,6 +309,10 @@
     : QuicSession(connection, visitor, config, supported_versions),
       send_control_stream_(nullptr),
       receive_control_stream_(nullptr),
+      qpack_encoder_receive_stream_(nullptr),
+      qpack_decoder_receive_stream_(nullptr),
+      qpack_encoder_send_stream_(nullptr),
+      qpack_decoder_send_stream_(nullptr),
       max_inbound_header_list_size_(kDefaultMaxUncompressedHeaderSize),
       max_outbound_header_list_size_(kDefaultMaxUncompressedHeaderSize),
       server_push_enabled_(true),
@@ -364,13 +368,10 @@
                          /*stream_already_counted = */ false);
   } else {
     qpack_encoder_ = QuicMakeUnique<QpackEncoder>(this);
-    qpack_encoder_->set_qpack_stream_sender_delegate(
-        &encoder_stream_sender_delegate_);
     qpack_decoder_ =
         QuicMakeUnique<QpackDecoder>(kDefaultQpackMaxDynamicTableCapacity,
                                      /* maximum_blocked_streams = */ 0, this);
-    qpack_decoder_->set_qpack_stream_sender_delegate(
-        &decoder_stream_sender_delegate_);
+    MaybeInitializeHttp3UnidirectionalStreams();
     // TODO(b/112770235): Set sensible limit on maximum number of blocked
     // streams.
     // TODO(b/112770235): Send SETTINGS_QPACK_MAX_TABLE_CAPACITY with value
@@ -378,10 +379,6 @@
     // with limit on maximum number of blocked streams.
   }
 
-  if (VersionHasStreamType(connection()->transport_version())) {
-    MaybeInitializeHttp3UnidirectionalStreams();
-  }
-
   spdy_framer_visitor_->set_max_header_list_size(max_inbound_header_list_size_);
 
   // Limit HPACK buffering to 2x header list size limit.
@@ -548,6 +545,10 @@
 void QuicSpdySession::SendMaxHeaderListSize(size_t value) {
   if (VersionHasStreamType(connection()->transport_version())) {
     send_control_stream_->SendSettingsFrame();
+    // TODO(renjietang): Remove this once stream id manager can take dynamically
+    // created HTTP/3 unidirectional streams.
+    qpack_encoder_send_stream_->SendStreamType();
+    qpack_decoder_send_stream_->SendStreamType();
     return;
   }
   SpdySettingsIR settings_frame;
@@ -893,6 +894,7 @@
       RegisterStaticStream(std::move(receive_stream),
                            /*stream_already_counted = */ true);
       receive_control_stream_->SetUnblocked();
+      QUIC_DVLOG(1) << "Receive Control stream is created";
       return true;
     }
     case kServerPushStream: {  // Push Stream.
@@ -900,12 +902,26 @@
       stream->SetUnblocked();
       return true;
     }
-    case kQpackEncoderStream:  // QPACK encoder stream.
-      // TODO(bnc): Create QPACK encoder stream.
-      break;
-    case kQpackDecoderStream:  // QPACK decoder stream.
-      // TODO(bnc): Create QPACK decoder stream.
-      break;
+    case kQpackEncoderStream: {  // QPACK encoder stream.
+      auto encoder_receive = QuicMakeUnique<QpackReceiveStream>(
+          pending, qpack_decoder_->encoder_stream_receiver());
+      qpack_encoder_receive_stream_ = encoder_receive.get();
+      RegisterStaticStream(std::move(encoder_receive),
+                           /*stream_already_counted = */ true);
+      qpack_encoder_receive_stream_->SetUnblocked();
+      QUIC_DVLOG(1) << "Receive QPACK Encoder stream is created";
+      return true;
+    }
+    case kQpackDecoderStream: {  // QPACK decoder stream.
+      auto decoder_receive = QuicMakeUnique<QpackReceiveStream>(
+          pending, qpack_encoder_->decoder_stream_receiver());
+      qpack_decoder_receive_stream_ = decoder_receive.get();
+      RegisterStaticStream(std::move(decoder_receive),
+                           /*stream_already_counted = */ true);
+      qpack_decoder_receive_stream_->SetUnblocked();
+      QUIC_DVLOG(1) << "Receive Qpack Decoder stream is created";
+      return true;
+    }
     default:
       SendStopSending(kHttpUnknownStreamType, pending->id());
       pending->StopReading();
@@ -923,6 +939,28 @@
     RegisterStaticStream(std::move(send_control),
                          /*stream_already_counted = */ false);
   }
+
+  if (!qpack_decoder_send_stream_ &&
+      CanOpenNextOutgoingUnidirectionalStream()) {
+    auto decoder_send = QuicMakeUnique<QpackSendStream>(
+        GetNextOutgoingUnidirectionalStreamId(), this, kQpackDecoderStream);
+    qpack_decoder_send_stream_ = decoder_send.get();
+    RegisterStaticStream(std::move(decoder_send),
+                         /*stream_already_counted = */ false);
+    qpack_decoder_->set_qpack_stream_sender_delegate(
+        qpack_decoder_send_stream_);
+  }
+
+  if (!qpack_encoder_send_stream_ &&
+      CanOpenNextOutgoingUnidirectionalStream()) {
+    auto encoder_send = QuicMakeUnique<QpackSendStream>(
+        GetNextOutgoingUnidirectionalStreamId(), this, kQpackEncoderStream);
+    qpack_encoder_send_stream_ = encoder_send.get();
+    RegisterStaticStream(std::move(encoder_send),
+                         /*stream_already_counted = */ false);
+    qpack_encoder_->set_qpack_stream_sender_delegate(
+        qpack_encoder_send_stream_);
+  }
 }
 
 void QuicSpdySession::OnCanCreateNewOutgoingStream(bool unidirectional) {
diff --git a/quic/core/http/quic_spdy_session.h b/quic/core/http/quic_spdy_session.h
index ce8fff0..bab74d3 100644
--- a/quic/core/http/quic_spdy_session.h
+++ b/quic/core/http/quic_spdy_session.h
@@ -18,6 +18,8 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_decoder_stream_sender.h"
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_encoder.h"
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_encoder_stream_sender.h"
+#include "net/third_party/quiche/src/quic/core/qpack/qpack_receive_stream.h"
+#include "net/third_party/quiche/src/quic/core/qpack/qpack_send_stream.h"
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_utils.h"
 #include "net/third_party/quiche/src/quic/core/quic_session.h"
 #include "net/third_party/quiche/src/quic/core/quic_versions.h"
@@ -284,11 +286,17 @@
   // Pointer to the header stream in stream_map_.
   QuicHeadersStream* headers_stream_;
 
-  // HTTP/3 control streams. They are owned by QuicSession inside dynamic
+  // HTTP/3 control streams. They are owned by QuicSession inside
   // stream map, and can be accessed by those unowned pointers below.
   QuicSendControlStream* send_control_stream_;
   QuicReceiveControlStream* receive_control_stream_;
 
+  // Pointers to HTTP/3 QPACK streams in stream map.
+  QpackReceiveStream* qpack_encoder_receive_stream_;
+  QpackReceiveStream* qpack_decoder_receive_stream_;
+  QpackSendStream* qpack_encoder_send_stream_;
+  QpackSendStream* qpack_decoder_send_stream_;
+
   // The maximum size of a header block that will be accepted from the peer,
   // defined per spec as key + value + overhead per field (uncompressed).
   size_t max_inbound_header_list_size_;
@@ -313,10 +321,6 @@
   spdy::SpdyFramer spdy_framer_;
   http2::Http2DecoderAdapter h2_deframer_;
   std::unique_ptr<SpdyFramerVisitor> spdy_framer_visitor_;
-
-  // TODO(renjietang): Replace these two members with actual QPACK send streams.
-  NoopQpackStreamSenderDelegate encoder_stream_sender_delegate_;
-  NoopQpackStreamSenderDelegate decoder_stream_sender_delegate_;
   QuicStreamId 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 e58a651..9ee89bf 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -17,6 +17,7 @@
 #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_utils.h"
+#include "net/third_party/quiche/src/quic/core/quic_versions.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
@@ -693,13 +694,16 @@
         .WillRepeatedly(Invoke(
             this, &QuicSpdySessionTestServer::ClearMaxStreamsControlFrame));
   }
+
   // Encryption needs to be established before data can be sent.
   CryptoHandshakeMessage msg;
   MockPacketWriter* writer = static_cast<MockPacketWriter*>(
       QuicConnectionPeer::GetWriter(session_.connection()));
   EXPECT_CALL(*writer, WritePacket(_, _, _, _, _))
-      .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
+      .Times(testing::AnyNumber())
+      .WillRepeatedly(Return(WriteResult(WRITE_STATUS_OK, 0)));
   session_.GetMutableCryptoStream()->OnHandshakeMessage(msg);
+  testing::Mock::VerifyAndClearExpectations(writer);
 
   // Drive congestion control manually.
   MockSendAlgorithm* send_algorithm = new StrictMock<MockSendAlgorithm>;
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index ef9d6ff..f247df4 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -1905,8 +1905,23 @@
     return;
   }
 
+  if (GetParam().handshake_protocol == PROTOCOL_TLS1_3) {
+    // TODO(nharper, b/112643533): Figure out why this test fails when TLS is
+    // enabled and fix it.
+    return;
+  }
+
+  testing::InSequence s;
   Initialize(kShouldProcessData);
 
+  auto decoder_send_stream =
+      QuicSpdySessionPeer::GetQpackDecoderSendStream(session_.get());
+
+  // The stream byte will be written in the first byte.
+  EXPECT_CALL(*session_, WritevData(decoder_send_stream,
+                                    decoder_send_stream->id(), 1, 0, _));
+  EXPECT_CALL(*session_, WritevData(decoder_send_stream,
+                                    decoder_send_stream->id(), _, _, _));
   // Deliver dynamic table entry to decoder.
   session_->qpack_decoder()->OnInsertWithoutNameReference("foo", "bar");
 
@@ -1927,6 +1942,8 @@
                                          headers.length(), data));
   EXPECT_EQ(kDataFramePayload, stream_->data());
 
+  EXPECT_CALL(*session_, WritevData(decoder_send_stream,
+                                    decoder_send_stream->id(), _, _, _));
   // Deliver second dynamic table entry to decoder.
   session_->qpack_decoder()->OnInsertWithoutNameReference("trailing", "foobar");
 
@@ -1950,6 +1967,13 @@
     return;
   }
 
+  if (GetParam().handshake_protocol == PROTOCOL_TLS1_3) {
+    // TODO(nharper, b/112643533): Figure out why this test fails when TLS is
+    // enabled and fix it.
+    return;
+  }
+
+  testing::InSequence s;
   Initialize(kShouldProcessData);
 
   // HEADERS frame referencing first dynamic table entry.
@@ -1959,6 +1983,14 @@
   // Decoding is blocked because dynamic table entry has not been received yet.
   EXPECT_FALSE(stream_->headers_decompressed());
 
+  auto decoder_send_stream =
+      QuicSpdySessionPeer::GetQpackDecoderSendStream(session_.get());
+
+  // The stream byte will be written in the first byte.
+  EXPECT_CALL(*session_, WritevData(decoder_send_stream,
+                                    decoder_send_stream->id(), 1, 0, _));
+  EXPECT_CALL(*session_, WritevData(decoder_send_stream,
+                                    decoder_send_stream->id(), _, _, _));
   // Deliver dynamic table entry to decoder.
   session_->qpack_decoder()->OnInsertWithoutNameReference("foo", "bar");
   EXPECT_TRUE(stream_->headers_decompressed());
@@ -1982,6 +2014,8 @@
   // Decoding is blocked because dynamic table entry has not been received yet.
   EXPECT_FALSE(stream_->trailers_decompressed());
 
+  EXPECT_CALL(*session_, WritevData(decoder_send_stream,
+                                    decoder_send_stream->id(), _, _, _));
   // Deliver second dynamic table entry to decoder.
   session_->qpack_decoder()->OnInsertWithoutNameReference("trailing", "foobar");
   EXPECT_TRUE(stream_->trailers_decompressed());
@@ -2028,6 +2062,13 @@
     return;
   }
 
+  if (GetParam().handshake_protocol == PROTOCOL_TLS1_3) {
+    // TODO(nharper, b/112643533): Figure out why this test fails when TLS is
+    // enabled and fix it.
+    return;
+  }
+
+  testing::InSequence s;
   Initialize(kShouldProcessData);
 
   // HEADERS frame referencing first dynamic table entry.
@@ -2037,6 +2078,14 @@
   // Decoding is blocked because dynamic table entry has not been received yet.
   EXPECT_FALSE(stream_->headers_decompressed());
 
+  auto decoder_send_stream =
+      QuicSpdySessionPeer::GetQpackDecoderSendStream(session_.get());
+
+  // The stream byte will be written in the first byte.
+  EXPECT_CALL(*session_, WritevData(decoder_send_stream,
+                                    decoder_send_stream->id(), 1, 0, _));
+  EXPECT_CALL(*session_, WritevData(decoder_send_stream,
+                                    decoder_send_stream->id(), _, _, _));
   // Deliver dynamic table entry to decoder.
   session_->qpack_decoder()->OnInsertWithoutNameReference("foo", "bar");
   EXPECT_TRUE(stream_->headers_decompressed());
diff --git a/quic/core/qpack/qpack_receive_stream.cc b/quic/core/qpack/qpack_receive_stream.cc
index d5f35fb..5920398 100644
--- a/quic/core/qpack/qpack_receive_stream.cc
+++ b/quic/core/qpack/qpack_receive_stream.cc
@@ -7,8 +7,10 @@
 #include "net/third_party/quiche/src/quic/core/quic_session.h"
 
 namespace quic {
-QpackReceiveStream::QpackReceiveStream(PendingStream* pending)
-    : QuicStream(pending, READ_UNIDIRECTIONAL, /*is_static=*/true) {}
+QpackReceiveStream::QpackReceiveStream(PendingStream* pending,
+                                       QpackStreamReceiver* receiver)
+    : QuicStream(pending, READ_UNIDIRECTIONAL, /*is_static=*/true),
+      receiver_(receiver) {}
 
 void QpackReceiveStream::OnStreamReset(const QuicRstStreamFrame& /*frame*/) {
   // TODO(renjietang) Change the error code to H/3 specific
@@ -18,4 +20,15 @@
       ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
 }
 
+void QpackReceiveStream::OnDataAvailable() {
+  iovec iov;
+  while (!reading_stopped() && sequencer()->GetReadableRegion(&iov)) {
+    DCHECK(!sequencer()->IsClosed());
+
+    receiver_->Decode(QuicStringPiece(
+        reinterpret_cast<const char*>(iov.iov_base), iov.iov_len));
+    sequencer()->MarkConsumed(iov.iov_len);
+  }
+}
+
 }  // namespace quic
diff --git a/quic/core/qpack/qpack_receive_stream.h b/quic/core/qpack/qpack_receive_stream.h
index db18f7c..0613871 100644
--- a/quic/core/qpack/qpack_receive_stream.h
+++ b/quic/core/qpack/qpack_receive_stream.h
@@ -5,6 +5,7 @@
 #ifndef QUICHE_QUIC_CORE_QPACK_QPACK_RECEIVE_STREAM_H_
 #define QUICHE_QUIC_CORE_QPACK_QPACK_RECEIVE_STREAM_H_
 
+#include "net/third_party/quiche/src/quic/core/qpack/qpack_stream_receiver.h"
 #include "net/third_party/quiche/src/quic/core/quic_stream.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
 
@@ -18,7 +19,7 @@
  public:
   // Construct receive stream from pending stream, the |pending| object needs
   // to be deleted after the construction.
-  explicit QpackReceiveStream(PendingStream* pending);
+  QpackReceiveStream(PendingStream* pending, QpackStreamReceiver* receiver);
   QpackReceiveStream(const QpackReceiveStream&) = delete;
   QpackReceiveStream& operator=(const QpackReceiveStream&) = delete;
   ~QpackReceiveStream() override = default;
@@ -27,9 +28,13 @@
   // closed before connection.
   void OnStreamReset(const QuicRstStreamFrame& frame) override;
 
-  // Implementation of QuicStream. Unimplemented yet.
-  // TODO(bnc): Feed data to QPACK.
-  void OnDataAvailable() override {}
+  // Implementation of QuicStream.
+  void OnDataAvailable() override;
+
+  void SetUnblocked() { sequencer()->SetUnblocked(); }
+
+ private:
+  QpackStreamReceiver* receiver_;
 };
 
 }  // namespace quic
diff --git a/quic/core/qpack/qpack_receive_stream_test.cc b/quic/core/qpack/qpack_receive_stream_test.cc
index 63c8baf..8bcfb27 100644
--- a/quic/core/qpack/qpack_receive_stream_test.cc
+++ b/quic/core/qpack/qpack_receive_stream_test.cc
@@ -62,7 +62,7 @@
                               GetParam().version.transport_version,
                               QuicUtils::InvertPerspective(perspective())),
                           &session_);
-    auto qpack_receive = QuicMakeUnique<QpackReceiveStream>(pending);
+    auto qpack_receive = QuicMakeUnique<QpackReceiveStream>(pending, nullptr);
     qpack_receive_stream_ = qpack_receive.get();
     session_.RegisterStaticStream(std::move(qpack_receive), false);
     delete pending;
diff --git a/quic/core/qpack/qpack_send_stream.cc b/quic/core/qpack/qpack_send_stream.cc
index 34bba65..fe25f26 100644
--- a/quic/core/qpack/qpack_send_stream.cc
+++ b/quic/core/qpack/qpack_send_stream.cc
@@ -36,4 +36,13 @@
   WriteOrBufferData(data, false, nullptr);
 }
 
+void QpackSendStream::SendStreamType() {
+  char type[sizeof(http3_stream_type_)];
+  QuicDataWriter writer(QUIC_ARRAYSIZE(type), type);
+  writer.WriteVarInt62(http3_stream_type_);
+  WriteOrBufferData(QuicStringPiece(writer.data(), writer.length()), false,
+                    nullptr);
+  stream_type_sent_ = true;
+}
+
 }  // namespace quic
diff --git a/quic/core/qpack/qpack_send_stream.h b/quic/core/qpack/qpack_send_stream.h
index 136a7cc..e7e4be3 100644
--- a/quic/core/qpack/qpack_send_stream.h
+++ b/quic/core/qpack/qpack_send_stream.h
@@ -42,6 +42,10 @@
   // before the first instruction so that the peer can open an qpack stream.
   void WriteStreamData(QuicStringPiece data) override;
 
+  // TODO(b/112770235): Remove this method once QuicStreamIdManager supports
+  // creating HTTP/3 unidirectional streams dynamically.
+  void SendStreamType();
+
  private:
   const uint64_t http3_stream_type_;
   bool stream_type_sent_;
diff --git a/quic/test_tools/quic_spdy_session_peer.cc b/quic/test_tools/quic_spdy_session_peer.cc
index 1f6e767..85237c4 100644
--- a/quic/test_tools/quic_spdy_session_peer.cc
+++ b/quic/test_tools/quic_spdy_session_peer.cc
@@ -5,6 +5,7 @@
 #include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h"
 
 #include "net/third_party/quiche/src/quic/core/http/quic_spdy_session.h"
+#include "net/third_party/quiche/src/quic/core/qpack/qpack_receive_stream.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
 
 namespace quic {
@@ -84,5 +85,29 @@
   return session->send_control_stream_;
 }
 
+// static
+QpackSendStream* QuicSpdySessionPeer::GetQpackDecoderSendStream(
+    QuicSpdySession* session) {
+  return session->qpack_decoder_send_stream_;
+}
+
+// static
+QpackSendStream* QuicSpdySessionPeer::GetQpackEncoderSendStream(
+    QuicSpdySession* session) {
+  return session->qpack_encoder_send_stream_;
+}
+
+// static
+QpackReceiveStream* QuicSpdySessionPeer::GetQpackDecoderReceiveStream(
+    QuicSpdySession* session) {
+  return session->qpack_decoder_receive_stream_;
+}
+
+// static
+QpackReceiveStream* QuicSpdySessionPeer::GetQpackEncoderReceiveStream(
+    QuicSpdySession* session) {
+  return session->qpack_encoder_receive_stream_;
+}
+
 }  // namespace test
 }  // namespace quic
diff --git a/quic/test_tools/quic_spdy_session_peer.h b/quic/test_tools/quic_spdy_session_peer.h
index 7d6cea7..1cfd45f 100644
--- a/quic/test_tools/quic_spdy_session_peer.h
+++ b/quic/test_tools/quic_spdy_session_peer.h
@@ -7,6 +7,8 @@
 
 #include "net/third_party/quiche/src/quic/core/http/quic_receive_control_stream.h"
 #include "net/third_party/quiche/src/quic/core/http/quic_send_control_stream.h"
+#include "net/third_party/quiche/src/quic/core/qpack/qpack_receive_stream.h"
+#include "net/third_party/quiche/src/quic/core/qpack/qpack_send_stream.h"
 #include "net/third_party/quiche/src/quic/core/quic_packets.h"
 #include "net/third_party/quiche/src/quic/core/quic_write_blocked_list.h"
 #include "net/third_party/quiche/src/spdy/core/spdy_framer.h"
@@ -49,6 +51,12 @@
   static QuicReceiveControlStream* GetReceiveControlStream(
       QuicSpdySession* session);
   static QuicSendControlStream* GetSendControlStream(QuicSpdySession* session);
+  static QpackSendStream* GetQpackDecoderSendStream(QuicSpdySession* session);
+  static QpackSendStream* GetQpackEncoderSendStream(QuicSpdySession* session);
+  static QpackReceiveStream* GetQpackDecoderReceiveStream(
+      QuicSpdySession* session);
+  static QpackReceiveStream* GetQpackEncoderReceiveStream(
+      QuicSpdySession* session);
 };
 
 }  // namespace test
diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc
index 10661ba..899db9c 100644
--- a/quic/tools/quic_simple_server_session_test.cc
+++ b/quic/tools/quic_simple_server_session_test.cc
@@ -496,7 +496,7 @@
         QuicSimpleServerSessionPeer::CreateOutgoingUnidirectionalStream(
             session_.get());
     if (VersionHasStreamType(connection_->transport_version())) {
-      EXPECT_EQ(GetNthServerInitiatedUnidirectionalId(i + 1),
+      EXPECT_EQ(GetNthServerInitiatedUnidirectionalId(i + 3),
                 created_stream->id());
     } else {
       EXPECT_EQ(GetNthServerInitiatedUnidirectionalId(i), created_stream->id());
@@ -533,7 +533,7 @@
                                             "Data for nonexistent stream", _));
   EXPECT_EQ(nullptr,
             QuicSessionPeer::GetOrCreateStream(
-                session_.get(), GetNthServerInitiatedUnidirectionalId(1)));
+                session_.get(), GetNthServerInitiatedUnidirectionalId(3)));
 }
 
 // In order to test the case where server push stream creation goes beyond
@@ -622,7 +622,7 @@
     for (unsigned int i = 1; i <= num_resources; ++i) {
       QuicStreamId stream_id;
       if (VersionHasStreamType(connection_->transport_version())) {
-        stream_id = GetNthServerInitiatedUnidirectionalId(i);
+        stream_id = GetNthServerInitiatedUnidirectionalId(i + 2);
       } else {
         stream_id = GetNthServerInitiatedUnidirectionalId(i - 1);
       }
@@ -728,7 +728,7 @@
   QuicStreamId next_out_going_stream_id;
   if (VersionHasStreamType(connection_->transport_version())) {
     next_out_going_stream_id =
-        GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest + 1);
+        GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest + 3);
   } else {
     next_out_going_stream_id =
         GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest);
@@ -773,11 +773,11 @@
     // Version 99 also has unidirectional static streams, so we need to send
     // MaxStreamFrame of the number of resources + number of static streams.
     session_->OnMaxStreamsFrame(
-        QuicMaxStreamsFrame(0, num_resources + 1, /*unidirectional=*/true));
+        QuicMaxStreamsFrame(0, num_resources + 3, /*unidirectional=*/true));
   }
 
   if (VersionHasStreamType(connection_->transport_version())) {
-    session_->StreamDraining(GetNthServerInitiatedUnidirectionalId(1));
+    session_->StreamDraining(GetNthServerInitiatedUnidirectionalId(3));
   } else {
     session_->StreamDraining(GetNthServerInitiatedUnidirectionalId(0));
   }
@@ -809,7 +809,7 @@
   QuicStreamId stream_got_reset;
   if (VersionHasStreamType(connection_->transport_version())) {
     stream_got_reset =
-        GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest + 2);
+        GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest + 4);
   } else {
     stream_got_reset =
         GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest + 1);
@@ -829,7 +829,7 @@
   QuicStreamId stream_not_reset;
   if (VersionHasStreamType(connection_->transport_version())) {
     stream_not_reset =
-        GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest + 1);
+        GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest + 3);
   } else {
     stream_not_reset =
         GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest);
@@ -869,10 +869,10 @@
     // For pre-v-99, the node monitors its own stream usage and makes streams
     // available as it closes/etc them.
     session_->OnMaxStreamsFrame(
-        QuicMaxStreamsFrame(0, num_resources + 1, /*unidirectional=*/true));
+        QuicMaxStreamsFrame(0, num_resources + 3, /*unidirectional=*/true));
   }
-  session_->StreamDraining(GetNthServerInitiatedUnidirectionalId(1));
-  session_->StreamDraining(GetNthServerInitiatedUnidirectionalId(2));
+  session_->StreamDraining(GetNthServerInitiatedUnidirectionalId(3));
+  session_->StreamDraining(GetNthServerInitiatedUnidirectionalId(4));
 }
 
 // Tests that closing a open outgoing stream can trigger a promised resource in
@@ -893,14 +893,14 @@
   QuicStreamId stream_to_open;
   if (VersionHasStreamType(connection_->transport_version())) {
     stream_to_open =
-        GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest + 1);
+        GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest + 3);
   } else {
     stream_to_open = GetNthServerInitiatedUnidirectionalId(kMaxStreamsForTest);
   }
 
   // Resetting an open stream will close the stream and give space for extra
   // stream to be opened.
-  QuicStreamId stream_got_reset = GetNthServerInitiatedUnidirectionalId(1);
+  QuicStreamId stream_got_reset = GetNthServerInitiatedUnidirectionalId(3);
   EXPECT_CALL(owner_, OnRstStreamReceived(_)).Times(1);
   EXPECT_CALL(*connection_, SendControlFrame(_));
   if (!VersionHasIetfQuicFrames(transport_version())) {
@@ -944,7 +944,7 @@
     // For pre-v-99, the node monitors its own stream usage and makes streams
     // available as it closes/etc them.
     session_->OnMaxStreamsFrame(
-        QuicMaxStreamsFrame(0, num_resources + 1, /*unidirectional=*/true));
+        QuicMaxStreamsFrame(0, num_resources + 3, /*unidirectional=*/true));
   }
   visitor_->OnRstStream(rst);
   // Create and inject a STOP_SENDING frame. In GOOGLE QUIC, receiving a
diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc
index bf435b9..55ea842 100644
--- a/quic/tools/quic_simple_server_stream_test.cc
+++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -417,7 +417,7 @@
   // Create a new promised stream with even id().
   auto promised_stream = new StrictMock<TestStream>(
       GetNthServerInitiatedUnidirectionalStreamId(
-          connection_->transport_version(), 1),
+          connection_->transport_version(), 3),
       &session_, WRITE_UNIDIRECTIONAL, &memory_cache_backend_);
   session_.ActivateStream(QuicWrapUnique(promised_stream));
 
@@ -553,7 +553,7 @@
   // Create a stream with even stream id and test against this stream.
   const QuicStreamId kServerInitiatedStreamId =
       GetNthServerInitiatedUnidirectionalStreamId(
-          connection_->transport_version(), 1);
+          connection_->transport_version(), 3);
   // Create a server initiated stream and pass it to session_.
   auto server_initiated_stream =
       new StrictMock<TestStream>(kServerInitiatedStreamId, &session_,