diff --git a/build/source_list.bzl b/build/source_list.bzl
index 89f45e2..ebaee62 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl
@@ -1189,7 +1189,6 @@
     "quic/core/http/http_decoder_test.cc",
     "quic/core/http/http_encoder_test.cc",
     "quic/core/http/http_frames_test.cc",
-    "quic/core/http/quic_client_promised_info_test.cc",
     "quic/core/http/quic_client_push_promise_index_test.cc",
     "quic/core/http/quic_header_list_test.cc",
     "quic/core/http/quic_headers_stream_test.cc",
diff --git a/build/source_list.gni b/build/source_list.gni
index da834ac..2866a7a 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni
@@ -1190,7 +1190,6 @@
     "src/quiche/quic/core/http/http_decoder_test.cc",
     "src/quiche/quic/core/http/http_encoder_test.cc",
     "src/quiche/quic/core/http/http_frames_test.cc",
-    "src/quiche/quic/core/http/quic_client_promised_info_test.cc",
     "src/quiche/quic/core/http/quic_client_push_promise_index_test.cc",
     "src/quiche/quic/core/http/quic_header_list_test.cc",
     "src/quiche/quic/core/http/quic_headers_stream_test.cc",
diff --git a/build/source_list.json b/build/source_list.json
index fdff71e..6f6595a 100644
--- a/build/source_list.json
+++ b/build/source_list.json
@@ -1189,7 +1189,6 @@
     "quiche/quic/core/http/http_decoder_test.cc",
     "quiche/quic/core/http/http_encoder_test.cc",
     "quiche/quic/core/http/http_frames_test.cc",
-    "quiche/quic/core/http/quic_client_promised_info_test.cc",
     "quiche/quic/core/http/quic_client_push_promise_index_test.cc",
     "quiche/quic/core/http/quic_header_list_test.cc",
     "quiche/quic/core/http/quic_headers_stream_test.cc",
diff --git a/quiche/quic/core/http/quic_client_promised_info_test.cc b/quiche/quic/core/http/quic_client_promised_info_test.cc
deleted file mode 100644
index 469c0c2..0000000
--- a/quiche/quic/core/http/quic_client_promised_info_test.cc
+++ /dev/null
@@ -1,350 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "quiche/quic/core/http/quic_client_promised_info.h"
-
-#include <memory>
-#include <string>
-#include <utility>
-
-#include "quiche/quic/core/crypto/null_encrypter.h"
-#include "quiche/quic/core/http/quic_spdy_client_session.h"
-#include "quiche/quic/core/http/spdy_server_push_utils.h"
-#include "quiche/quic/core/quic_utils.h"
-#include "quiche/quic/platform/api/quic_logging.h"
-#include "quiche/quic/platform/api/quic_socket_address.h"
-#include "quiche/quic/platform/api/quic_test.h"
-#include "quiche/quic/test_tools/crypto_test_utils.h"
-#include "quiche/quic/test_tools/quic_client_promised_info_peer.h"
-#include "quiche/quic/test_tools/quic_spdy_session_peer.h"
-#include "quiche/quic/test_tools/quic_test_utils.h"
-
-using spdy::Http2HeaderBlock;
-using testing::_;
-using testing::StrictMock;
-
-namespace quic {
-namespace test {
-namespace {
-
-class MockQuicSpdyClientSession : public QuicSpdyClientSession {
- public:
-  explicit MockQuicSpdyClientSession(
-      const ParsedQuicVersionVector& supported_versions,
-      QuicConnection* connection,
-      QuicClientPushPromiseIndex* push_promise_index)
-      : QuicSpdyClientSession(DefaultQuicConfig(), supported_versions,
-                              connection,
-                              QuicServerId("example.com", 443, false),
-                              &crypto_config_, push_promise_index),
-        crypto_config_(crypto_test_utils::ProofVerifierForTesting()),
-        authorized_(true) {}
-  MockQuicSpdyClientSession(const MockQuicSpdyClientSession&) = delete;
-  MockQuicSpdyClientSession& operator=(const MockQuicSpdyClientSession&) =
-      delete;
-  ~MockQuicSpdyClientSession() override {}
-
-  bool IsAuthorized(const std::string& /*authority*/) override {
-    return authorized_;
-  }
-
-  void set_authorized(bool authorized) { authorized_ = authorized; }
-
-  MOCK_METHOD(bool, WriteControlFrame,
-              (const QuicFrame& frame, TransmissionType type), (override));
-
- private:
-  QuicCryptoClientConfig crypto_config_;
-
-  bool authorized_;
-};
-
-class QuicClientPromisedInfoTest : public QuicTest {
- public:
-  class StreamVisitor;
-
-  QuicClientPromisedInfoTest()
-      : connection_(new StrictMock<MockQuicConnection>(
-            &helper_, &alarm_factory_, Perspective::IS_CLIENT)),
-        session_(connection_->supported_versions(), connection_,
-                 &push_promise_index_),
-        body_("hello world"),
-        promise_id_(
-            QuicUtils::GetInvalidStreamId(connection_->transport_version())) {
-    connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
-    connection_->SetEncrypter(
-        ENCRYPTION_FORWARD_SECURE,
-        std::make_unique<NullEncrypter>(connection_->perspective()));
-    session_.Initialize();
-
-    headers_[":status"] = "200";
-    headers_["content-length"] = "11";
-
-    stream_ = std::make_unique<QuicSpdyClientStream>(
-        GetNthClientInitiatedBidirectionalStreamId(
-            connection_->transport_version(), 0),
-        &session_, BIDIRECTIONAL);
-    stream_visitor_ = std::make_unique<StreamVisitor>();
-    stream_->set_visitor(stream_visitor_.get());
-
-    push_promise_[":path"] = "/bar";
-    push_promise_[":authority"] = "www.google.com";
-    push_promise_[":method"] = "GET";
-    push_promise_[":scheme"] = "https";
-
-    promise_url_ =
-        SpdyServerPushUtils::GetPromisedUrlFromHeaders(push_promise_);
-
-    client_request_ = push_promise_.Clone();
-    promise_id_ = GetNthServerInitiatedUnidirectionalStreamId(
-        connection_->transport_version(), 0);
-  }
-
-  class StreamVisitor : public QuicSpdyClientStream::Visitor {
-    void OnClose(QuicSpdyStream* stream) override {
-      QUIC_DVLOG(1) << "stream " << stream->id();
-    }
-  };
-
-  void ReceivePromise(QuicStreamId id) {
-    auto headers = AsHeaderList(push_promise_);
-    stream_->OnPromiseHeaderList(id, headers.uncompressed_header_bytes(),
-                                 headers);
-  }
-
-  MockQuicConnectionHelper helper_;
-  MockAlarmFactory alarm_factory_;
-  StrictMock<MockQuicConnection>* connection_;
-  QuicClientPushPromiseIndex push_promise_index_;
-
-  MockQuicSpdyClientSession session_;
-  std::unique_ptr<QuicSpdyClientStream> stream_;
-  std::unique_ptr<StreamVisitor> stream_visitor_;
-  std::unique_ptr<QuicSpdyClientStream> promised_stream_;
-  Http2HeaderBlock headers_;
-  std::string body_;
-  Http2HeaderBlock push_promise_;
-  QuicStreamId promise_id_;
-  std::string promise_url_;
-  Http2HeaderBlock client_request_;
-};
-
-TEST_F(QuicClientPromisedInfoTest, PushPromise) {
-  ReceivePromise(promise_id_);
-
-  // Verify that the promise is in the unclaimed streams map.
-  EXPECT_NE(session_.GetPromisedById(promise_id_), nullptr);
-}
-
-TEST_F(QuicClientPromisedInfoTest, PushPromiseCleanupAlarm) {
-  ReceivePromise(promise_id_);
-
-  // Verify that the promise is in the unclaimed streams map.
-  QuicClientPromisedInfo* promised = session_.GetPromisedById(promise_id_);
-  ASSERT_NE(promised, nullptr);
-
-  // Fire the alarm that will cancel the promised stream.
-  EXPECT_CALL(session_, WriteControlFrame(_, _));
-  EXPECT_CALL(*connection_,
-              OnStreamReset(promise_id_, QUIC_PUSH_STREAM_TIMED_OUT));
-  alarm_factory_.FireAlarm(QuicClientPromisedInfoPeer::GetAlarm(promised));
-
-  // Verify that the promise is gone after the alarm fires.
-  EXPECT_EQ(session_.GetPromisedById(promise_id_), nullptr);
-  EXPECT_EQ(session_.GetPromisedByUrl(promise_url_), nullptr);
-}
-
-TEST_F(QuicClientPromisedInfoTest, PushPromiseInvalidMethod) {
-  // Promise with an unsafe method
-  push_promise_[":method"] = "PUT";
-
-  EXPECT_CALL(session_, WriteControlFrame(_, _));
-  EXPECT_CALL(*connection_,
-              OnStreamReset(promise_id_, QUIC_INVALID_PROMISE_METHOD));
-  ReceivePromise(promise_id_);
-
-  // Verify that the promise headers were ignored
-  EXPECT_EQ(session_.GetPromisedById(promise_id_), nullptr);
-  EXPECT_EQ(session_.GetPromisedByUrl(promise_url_), nullptr);
-}
-
-TEST_F(QuicClientPromisedInfoTest, PushPromiseMissingMethod) {
-  // Promise with a missing method
-  push_promise_.erase(":method");
-
-  EXPECT_CALL(session_, WriteControlFrame(_, _));
-  EXPECT_CALL(*connection_,
-              OnStreamReset(promise_id_, QUIC_INVALID_PROMISE_METHOD));
-  ReceivePromise(promise_id_);
-
-  // Verify that the promise headers were ignored
-  EXPECT_EQ(session_.GetPromisedById(promise_id_), nullptr);
-  EXPECT_EQ(session_.GetPromisedByUrl(promise_url_), nullptr);
-}
-
-TEST_F(QuicClientPromisedInfoTest, PushPromiseInvalidUrl) {
-  // Remove required header field to make URL invalid
-  push_promise_.erase(":authority");
-
-  EXPECT_CALL(session_, WriteControlFrame(_, _));
-  EXPECT_CALL(*connection_,
-              OnStreamReset(promise_id_, QUIC_INVALID_PROMISE_URL));
-  ReceivePromise(promise_id_);
-
-  // Verify that the promise headers were ignored
-  EXPECT_EQ(session_.GetPromisedById(promise_id_), nullptr);
-  EXPECT_EQ(session_.GetPromisedByUrl(promise_url_), nullptr);
-}
-
-TEST_F(QuicClientPromisedInfoTest, PushPromiseUnauthorizedUrl) {
-  session_.set_authorized(false);
-
-  EXPECT_CALL(session_, WriteControlFrame(_, _));
-  EXPECT_CALL(*connection_,
-              OnStreamReset(promise_id_, QUIC_UNAUTHORIZED_PROMISE_URL));
-
-  ReceivePromise(promise_id_);
-
-  QuicClientPromisedInfo* promised = session_.GetPromisedById(promise_id_);
-  ASSERT_EQ(promised, nullptr);
-}
-
-TEST_F(QuicClientPromisedInfoTest, PushPromiseMismatch) {
-  ReceivePromise(promise_id_);
-
-  QuicClientPromisedInfo* promised = session_.GetPromisedById(promise_id_);
-  ASSERT_NE(promised, nullptr);
-
-  // Need to send the promised response headers and initiate the
-  // rendezvous for secondary validation to proceed.
-  QuicSpdyClientStream* promise_stream = static_cast<QuicSpdyClientStream*>(
-      session_.GetOrCreateStream(promise_id_));
-  auto headers = AsHeaderList(headers_);
-  promise_stream->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
-                                     headers);
-
-  TestPushPromiseDelegate delegate(/*match=*/false);
-  EXPECT_CALL(session_, WriteControlFrame(_, _));
-  EXPECT_CALL(*connection_,
-              OnStreamReset(promise_id_, QUIC_PROMISE_VARY_MISMATCH));
-
-  promised->HandleClientRequest(client_request_, &delegate);
-}
-
-TEST_F(QuicClientPromisedInfoTest, PushPromiseVaryWaits) {
-  ReceivePromise(promise_id_);
-
-  QuicClientPromisedInfo* promised = session_.GetPromisedById(promise_id_);
-  EXPECT_FALSE(promised->is_validating());
-  ASSERT_NE(promised, nullptr);
-
-  // Now initiate rendezvous.
-  TestPushPromiseDelegate delegate(/*match=*/true);
-  promised->HandleClientRequest(client_request_, &delegate);
-  EXPECT_TRUE(promised->is_validating());
-
-  // Promise is still there, waiting for response.
-  EXPECT_NE(session_.GetPromisedById(promise_id_), nullptr);
-
-  // Send Response, should trigger promise validation and complete rendezvous
-  QuicSpdyClientStream* promise_stream = static_cast<QuicSpdyClientStream*>(
-      session_.GetOrCreateStream(promise_id_));
-  ASSERT_NE(promise_stream, nullptr);
-  auto headers = AsHeaderList(headers_);
-  promise_stream->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
-                                     headers);
-
-  // Promise is gone
-  EXPECT_EQ(session_.GetPromisedById(promise_id_), nullptr);
-}
-
-TEST_F(QuicClientPromisedInfoTest, PushPromiseVaryNoWait) {
-  ReceivePromise(promise_id_);
-
-  QuicClientPromisedInfo* promised = session_.GetPromisedById(promise_id_);
-  ASSERT_NE(promised, nullptr);
-
-  QuicSpdyClientStream* promise_stream = static_cast<QuicSpdyClientStream*>(
-      session_.GetOrCreateStream(promise_id_));
-  ASSERT_NE(promise_stream, nullptr);
-
-  // Send Response, should trigger promise validation and complete rendezvous
-  auto headers = AsHeaderList(headers_);
-  promise_stream->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
-                                     headers);
-
-  // Now initiate rendezvous.
-  TestPushPromiseDelegate delegate(/*match=*/true);
-  promised->HandleClientRequest(client_request_, &delegate);
-
-  // Promise is gone
-  EXPECT_EQ(session_.GetPromisedById(promise_id_), nullptr);
-  // Have a push stream
-  EXPECT_TRUE(delegate.rendezvous_fired());
-
-  EXPECT_NE(delegate.rendezvous_stream(), nullptr);
-}
-
-TEST_F(QuicClientPromisedInfoTest, PushPromiseWaitCancels) {
-  ReceivePromise(promise_id_);
-
-  QuicClientPromisedInfo* promised = session_.GetPromisedById(promise_id_);
-  ASSERT_NE(promised, nullptr);
-
-  // Now initiate rendezvous.
-  TestPushPromiseDelegate delegate(/*match=*/true);
-  promised->HandleClientRequest(client_request_, &delegate);
-
-  // Promise is still there, waiting for response.
-  EXPECT_NE(session_.GetPromisedById(promise_id_), nullptr);
-
-  // Create response stream, but no data yet.
-  session_.GetOrCreateStream(promise_id_);
-
-  // Cancel the promised stream.
-  EXPECT_CALL(session_, WriteControlFrame(_, _));
-  EXPECT_CALL(*connection_, OnStreamReset(promise_id_, QUIC_STREAM_CANCELLED));
-  promised->Cancel();
-
-  // Promise is gone
-  EXPECT_EQ(session_.GetPromisedById(promise_id_), nullptr);
-}
-
-TEST_F(QuicClientPromisedInfoTest, PushPromiseDataClosed) {
-  ReceivePromise(promise_id_);
-
-  QuicClientPromisedInfo* promised = session_.GetPromisedById(promise_id_);
-  ASSERT_NE(promised, nullptr);
-
-  QuicSpdyClientStream* promise_stream = static_cast<QuicSpdyClientStream*>(
-      session_.GetOrCreateStream(promise_id_));
-  ASSERT_NE(promise_stream, nullptr);
-
-  // Send response, rendezvous will be able to finish synchronously.
-  auto headers = AsHeaderList(headers_);
-  promise_stream->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
-                                     headers);
-
-  EXPECT_CALL(session_, WriteControlFrame(_, _));
-  EXPECT_CALL(*connection_,
-              OnStreamReset(promise_id_, QUIC_STREAM_PEER_GOING_AWAY));
-  session_.ResetStream(promise_id_, QUIC_STREAM_PEER_GOING_AWAY);
-
-  // Now initiate rendezvous.
-  TestPushPromiseDelegate delegate(/*match=*/true);
-  EXPECT_EQ(promised->HandleClientRequest(client_request_, &delegate),
-            QUIC_FAILURE);
-
-  // Got an indication of the stream failure, client should retry
-  // request.
-  EXPECT_FALSE(delegate.rendezvous_fired());
-  EXPECT_EQ(delegate.rendezvous_stream(), nullptr);
-
-  // Promise is gone
-  EXPECT_EQ(session_.GetPromisedById(promise_id_), nullptr);
-}
-
-}  // namespace
-}  // namespace test
-}  // namespace quic
diff --git a/quiche/quic/core/http/quic_spdy_client_session_base.cc b/quiche/quic/core/http/quic_spdy_client_session_base.cc
index adc3348..4684ba9 100644
--- a/quiche/quic/core/http/quic_spdy_client_session_base.cc
+++ b/quiche/quic/core/http/quic_spdy_client_session_base.cc
@@ -21,9 +21,7 @@
     QuicClientPushPromiseIndex* push_promise_index, const QuicConfig& config,
     const ParsedQuicVersionVector& supported_versions)
     : QuicSpdySession(connection, visitor, config, supported_versions),
-      push_promise_index_(push_promise_index),
-      largest_promised_stream_id_(
-          QuicUtils::GetInvalidStreamId(connection->transport_version())) {}
+      push_promise_index_(push_promise_index) {}
 
 QuicSpdyClientSessionBase::~QuicSpdyClientSessionBase() {
   //  all promised streams for this session
@@ -51,56 +49,6 @@
   promised->OnResponseHeaders(response_headers);
 }
 
-void QuicSpdyClientSessionBase::OnPromiseHeaderList(
-    QuicStreamId stream_id, QuicStreamId promised_stream_id, size_t frame_len,
-    const QuicHeaderList& header_list) {
-  if (IsStaticStream(stream_id)) {
-    connection()->CloseConnection(
-        QUIC_INVALID_HEADERS_STREAM_DATA, "stream is static",
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-    return;
-  }
-  // In HTTP3, push promises are received on individual streams, so they could
-  // be arrive out of order.
-  if (!VersionUsesHttp3(transport_version()) &&
-      promised_stream_id !=
-          QuicUtils::GetInvalidStreamId(transport_version()) &&
-      largest_promised_stream_id_ !=
-          QuicUtils::GetInvalidStreamId(transport_version()) &&
-      promised_stream_id <= largest_promised_stream_id_) {
-    connection()->CloseConnection(
-        QUIC_INVALID_STREAM_ID,
-        "Received push stream id lesser or equal to the"
-        " last accepted before",
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-    return;
-  }
-  if (!IsIncomingStream(promised_stream_id)) {
-    connection()->CloseConnection(
-        QUIC_INVALID_STREAM_ID, "Received push stream id for outgoing stream.",
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-    return;
-  }
-
-  if (VersionUsesHttp3(transport_version())) {
-    // Received push stream id is higher than MAX_PUSH_ID
-    // because no MAX_PUSH_ID frame is ever sent.
-    connection()->CloseConnection(
-        QUIC_INVALID_STREAM_ID,
-        "Received push stream id higher than MAX_PUSH_ID.",
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-    return;
-  }
-  largest_promised_stream_id_ = promised_stream_id;
-
-  QuicSpdyStream* stream = GetOrCreateSpdyDataStream(stream_id);
-  if (!stream) {
-    // It's quite possible to receive headers after a stream has been reset.
-    return;
-  }
-  stream->OnPromiseHeaderList(promised_stream_id, frame_len, header_list);
-}
-
 bool QuicSpdyClientSessionBase::HandlePromised(
     QuicStreamId /* associated_id */, QuicStreamId promised_id,
     const Http2HeaderBlock& headers) {
diff --git a/quiche/quic/core/http/quic_spdy_client_session_base.h b/quiche/quic/core/http/quic_spdy_client_session_base.h
index eae401e..0aaf7a7 100644
--- a/quiche/quic/core/http/quic_spdy_client_session_base.h
+++ b/quiche/quic/core/http/quic_spdy_client_session_base.h
@@ -52,12 +52,6 @@
 
   void OnConfigNegotiated() override;
 
-  // Called by |headers_stream_| when push promise headers have been
-  // completely received.
-  void OnPromiseHeaderList(QuicStreamId stream_id,
-                           QuicStreamId promised_stream_id, size_t frame_len,
-                           const QuicHeaderList& header_list) override;
-
   // Called by |QuicSpdyClientStream| on receipt of response headers,
   // needed to detect promised server push streams, as part of
   // client-request to push-stream rendezvous.
@@ -138,7 +132,6 @@
   // arrive.
   QuicClientPushPromiseIndex* push_promise_index_;
   QuicPromisedByIdMap promised_by_id_;
-  QuicStreamId largest_promised_stream_id_;
 };
 
 }  // namespace quic
diff --git a/quiche/quic/core/http/quic_spdy_client_session_test.cc b/quiche/quic/core/http/quic_spdy_client_session_test.cc
index a209d8c..ba16205 100644
--- a/quiche/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quiche/quic/core/http/quic_spdy_client_session_test.cc
@@ -455,34 +455,6 @@
                                /*fin=*/false, 0, trailers);
 }
 
-TEST_P(QuicSpdyClientSessionTest, OnPromiseHeaderListWithStaticStream) {
-  // Test situation where OnPromiseHeaderList is called by stream with static
-  // id.
-  CompleteCryptoHandshake();
-
-  QuicHeaderList trailers;
-  trailers.OnHeaderBlockStart();
-  trailers.OnHeader(kFinalOffsetHeaderKey, "0");
-  trailers.OnHeaderBlockEnd(0, 0);
-
-  // Initialize H/3 control stream.
-  QuicStreamId id;
-  if (VersionUsesHttp3(connection_->transport_version())) {
-    id = GetNthServerInitiatedUnidirectionalStreamId(
-        connection_->transport_version(), 3);
-    char type[] = {0x00};
-
-    QuicStreamFrame data1(id, false, 0, absl::string_view(type, 1));
-    session_->OnStreamFrame(data1);
-  } else {
-    id = QuicUtils::GetHeadersStreamId(connection_->transport_version());
-  }
-  EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
-                                            "stream is static", _))
-      .Times(1);
-  session_->OnPromiseHeaderList(id, promised_stream_id_, 0, trailers);
-}
-
 TEST_P(QuicSpdyClientSessionTest, GoAwayReceived) {
   if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     return;
@@ -585,109 +557,6 @@
   session_->ProcessUdpPacket(client_address, server_address, *received);
 }
 
-TEST_P(QuicSpdyClientSessionTest, PushPromiseOnPromiseHeaders) {
-  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
-    return;
-  }
-
-  // Initialize crypto before the client session will create a stream.
-  CompleteCryptoHandshake();
-
-  MockQuicSpdyClientStream* stream = static_cast<MockQuicSpdyClientStream*>(
-      session_->CreateOutgoingBidirectionalStream());
-
-  EXPECT_CALL(*stream, OnPromiseHeaderList(_, _, _));
-  session_->OnPromiseHeaderList(associated_stream_id_, promised_stream_id_, 0,
-                                QuicHeaderList());
-}
-
-TEST_P(QuicSpdyClientSessionTest, PushPromiseStreamIdTooHigh) {
-  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
-    return;
-  }
-
-  // Initialize crypto before the client session will create a stream.
-  CompleteCryptoHandshake();
-  QuicStreamId stream_id =
-      QuicSessionPeer::GetNextOutgoingBidirectionalStreamId(session_.get());
-  QuicSessionPeer::ActivateStream(
-      session_.get(), std::make_unique<QuicSpdyClientStream>(
-                          stream_id, session_.get(), BIDIRECTIONAL));
-
-  QuicHeaderList headers;
-  headers.OnHeaderBlockStart();
-  headers.OnHeader(":path", "/bar");
-  headers.OnHeader(":authority", "www.google.com");
-  headers.OnHeader(":method", "GET");
-  headers.OnHeader(":scheme", "https");
-  headers.OnHeaderBlockEnd(0, 0);
-
-  const QuicStreamId promise_id = GetNthServerInitiatedUnidirectionalStreamId(
-      connection_->transport_version(), 11);
-  session_->OnPromiseHeaderList(stream_id, promise_id, 0, headers);
-}
-
-TEST_P(QuicSpdyClientSessionTest, PushPromiseOnPromiseHeadersAlreadyClosed) {
-  // Initialize crypto before the client session will create a stream.
-  CompleteCryptoHandshake();
-
-  session_->CreateOutgoingBidirectionalStream();
-
-  EXPECT_CALL(*connection_, SendControlFrame(_));
-  EXPECT_CALL(*connection_,
-              OnStreamReset(promised_stream_id_, QUIC_REFUSED_STREAM));
-  session_->ResetPromised(promised_stream_id_, QUIC_REFUSED_STREAM);
-
-  session_->OnPromiseHeaderList(associated_stream_id_, promised_stream_id_, 0,
-                                QuicHeaderList());
-}
-
-TEST_P(QuicSpdyClientSessionTest, PushPromiseOutOfOrder) {
-  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
-    return;
-  }
-
-  // Initialize crypto before the client session will create a stream.
-  CompleteCryptoHandshake();
-
-  MockQuicSpdyClientStream* stream = static_cast<MockQuicSpdyClientStream*>(
-      session_->CreateOutgoingBidirectionalStream());
-
-  EXPECT_CALL(*stream, OnPromiseHeaderList(promised_stream_id_, _, _));
-  session_->OnPromiseHeaderList(associated_stream_id_, promised_stream_id_, 0,
-                                QuicHeaderList());
-  associated_stream_id_ +=
-      QuicUtils::StreamIdDelta(connection_->transport_version());
-  if (!VersionUsesHttp3(session_->transport_version())) {
-    EXPECT_CALL(*connection_,
-                CloseConnection(QUIC_INVALID_STREAM_ID,
-                                "Received push stream id lesser or equal to the"
-                                " last accepted before",
-                                _));
-  }
-  session_->OnPromiseHeaderList(associated_stream_id_, promised_stream_id_, 0,
-                                QuicHeaderList());
-}
-
-TEST_P(QuicSpdyClientSessionTest, PushPromiseOutgoingStreamId) {
-  // Initialize crypto before the client session will create a stream.
-  CompleteCryptoHandshake();
-
-  MockQuicSpdyClientStream* stream = static_cast<MockQuicSpdyClientStream*>(
-      session_->CreateOutgoingBidirectionalStream());
-
-  // Promise an illegal (outgoing) stream id.
-  promised_stream_id_ = GetNthClientInitiatedBidirectionalStreamId(
-      connection_->transport_version(), 0);
-  EXPECT_CALL(
-      *connection_,
-      CloseConnection(QUIC_INVALID_STREAM_ID,
-                      "Received push stream id for outgoing stream.", _));
-
-  session_->OnPromiseHeaderList(stream->id(), promised_stream_id_, 0,
-                                QuicHeaderList());
-}
-
 TEST_P(QuicSpdyClientSessionTest, PushPromiseHandlePromise) {
   // Initialize crypto before the client session will create a stream.
   CompleteCryptoHandshake();
@@ -911,36 +780,6 @@
       connection_->transport_version(), 0));
 }
 
-TEST_P(QuicSpdyClientSessionTest, TooManyPushPromises) {
-  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
-    return;
-  }
-
-  // Initialize crypto before the client session will create a stream.
-  CompleteCryptoHandshake();
-  QuicStreamId stream_id =
-      QuicSessionPeer::GetNextOutgoingBidirectionalStreamId(session_.get());
-  QuicSessionPeer::ActivateStream(
-      session_.get(), std::make_unique<QuicSpdyClientStream>(
-                          stream_id, session_.get(), BIDIRECTIONAL));
-
-  EXPECT_CALL(*connection_, OnStreamReset(_, QUIC_REFUSED_STREAM));
-
-  for (size_t promise_count = 0; promise_count <= session_->get_max_promises();
-       promise_count++) {
-    auto promise_id = GetNthServerInitiatedUnidirectionalStreamId(
-        connection_->transport_version(), promise_count);
-    auto headers = QuicHeaderList();
-    headers.OnHeaderBlockStart();
-    headers.OnHeader(":path", absl::StrCat("/", promise_count));
-    headers.OnHeader(":authority", "www.google.com");
-    headers.OnHeader(":method", "GET");
-    headers.OnHeader(":scheme", "https");
-    headers.OnHeaderBlockEnd(0, 0);
-    session_->OnPromiseHeaderList(stream_id, promise_id, 0, headers);
-  }
-}
-
 // Test that upon receiving HTTP/3 SETTINGS, the settings are serialized and
 // stored into client session cache.
 TEST_P(QuicSpdyClientSessionTest, OnSettingsFrame) {
diff --git a/quiche/quic/core/http/quic_spdy_client_stream.cc b/quiche/quic/core/http/quic_spdy_client_stream.cc
index e5da71c..a962669 100644
--- a/quiche/quic/core/http/quic_spdy_client_stream.cc
+++ b/quiche/quic/core/http/quic_spdy_client_stream.cc
@@ -130,26 +130,6 @@
   MarkTrailersConsumed();
 }
 
-void QuicSpdyClientStream::OnPromiseHeaderList(
-    QuicStreamId promised_id, size_t frame_len,
-    const QuicHeaderList& header_list) {
-  header_bytes_read_ += frame_len;
-  int64_t content_length = -1;
-  Http2HeaderBlock promise_headers;
-  if (!SpdyUtils::CopyAndValidateHeaders(header_list, &content_length,
-                                         &promise_headers)) {
-    QUIC_DLOG(ERROR) << "Failed to parse promise headers: "
-                     << header_list.DebugString();
-    Reset(QUIC_BAD_APPLICATION_PAYLOAD);
-    return;
-  }
-
-  session_->HandlePromised(id(), promised_id, promise_headers);
-  if (visitor() != nullptr) {
-    visitor()->OnPromiseHeadersComplete(promised_id, frame_len);
-  }
-}
-
 void QuicSpdyClientStream::OnBodyAvailable() {
   // For push streams, visitor will not be set until the rendezvous
   // between server promise and client request is complete.
diff --git a/quiche/quic/core/http/quic_spdy_client_stream.h b/quiche/quic/core/http/quic_spdy_client_stream.h
index a5b5886..03c7409 100644
--- a/quiche/quic/core/http/quic_spdy_client_stream.h
+++ b/quiche/quic/core/http/quic_spdy_client_stream.h
@@ -39,10 +39,6 @@
   void OnTrailingHeadersComplete(bool fin, size_t frame_len,
                                  const QuicHeaderList& header_list) override;
 
-  // Override the base class to handle creation of the push stream.
-  void OnPromiseHeaderList(QuicStreamId promised_id, size_t frame_len,
-                           const QuicHeaderList& header_list) override;
-
   // QuicStream implementation called by the session when there's data for us.
   void OnBodyAvailable() override;
 
diff --git a/quiche/quic/core/http/quic_spdy_session.cc b/quiche/quic/core/http/quic_spdy_session.cc
index d76f6f3..4a4bcd9 100644
--- a/quiche/quic/core/http/quic_spdy_session.cc
+++ b/quiche/quic/core/http/quic_spdy_session.cc
@@ -996,16 +996,6 @@
   return frame.size();
 }
 
-void QuicSpdySession::OnPromiseHeaderList(
-    QuicStreamId /*stream_id*/, QuicStreamId /*promised_stream_id*/,
-    size_t /*frame_len*/, const QuicHeaderList& /*header_list*/) {
-  std::string error =
-      "OnPromiseHeaderList should be overridden in client code.";
-  QUIC_BUG(quic_bug_10360_6) << error;
-  connection()->CloseConnection(QUIC_INTERNAL_ERROR, error,
-                                ConnectionCloseBehavior::SILENT_CLOSE);
-}
-
 bool QuicSpdySession::ResumeApplicationState(ApplicationState* cached_state) {
   QUICHE_DCHECK_EQ(perspective(), Perspective::IS_CLIENT);
   QUICHE_DCHECK(VersionUsesHttp3(transport_version()));
diff --git a/quiche/quic/core/http/quic_spdy_session.h b/quiche/quic/core/http/quic_spdy_session.h
index 07b9644..ed70ed2 100644
--- a/quiche/quic/core/http/quic_spdy_session.h
+++ b/quiche/quic/core/http/quic_spdy_session.h
@@ -187,14 +187,6 @@
                                   size_t frame_len,
                                   const QuicHeaderList& header_list);
 
-  // Called by |headers_stream_| when push promise headers have been
-  // completely received.  |fin| will be true if the fin flag was set
-  // in the headers.
-  virtual void OnPromiseHeaderList(QuicStreamId stream_id,
-                                   QuicStreamId promised_stream_id,
-                                   size_t frame_len,
-                                   const QuicHeaderList& header_list);
-
   // Called by |headers_stream_| when a PRIORITY frame has been received for a
   // stream. This method will only be called for server streams.
   virtual void OnPriorityFrame(QuicStreamId stream_id,
diff --git a/quiche/quic/core/http/quic_spdy_stream.cc b/quiche/quic/core/http/quic_spdy_stream.cc
index 1b2c09f..1edcd4a 100644
--- a/quiche/quic/core/http/quic_spdy_stream.cc
+++ b/quiche/quic/core/http/quic_spdy_stream.cc
@@ -652,15 +652,6 @@
   }
 }
 
-void QuicSpdyStream::OnPromiseHeaderList(
-    QuicStreamId /* promised_id */, size_t /* frame_len */,
-    const QuicHeaderList& /*header_list */) {
-  // To be overridden in QuicSpdyClientStream.  Not supported on
-  // server side.
-  stream_delegate()->OnStreamError(QUIC_INVALID_HEADERS_STREAM_DATA,
-                                   "Promise headers received by server");
-}
-
 bool QuicSpdyStream::CopyAndValidateTrailers(const QuicHeaderList& header_list,
                                              bool expect_final_byte_offset,
                                              size_t* final_byte_offset,
diff --git a/quiche/quic/core/http/quic_spdy_stream.h b/quiche/quic/core/http/quic_spdy_stream.h
index 9c0086c..418c8cf 100644
--- a/quiche/quic/core/http/quic_spdy_stream.h
+++ b/quiche/quic/core/http/quic_spdy_stream.h
@@ -67,10 +67,6 @@
     // Called when the stream is closed.
     virtual void OnClose(QuicSpdyStream* stream) = 0;
 
-    // Allows subclasses to override and do work.
-    virtual void OnPromiseHeadersComplete(QuicStreamId /*promised_id*/,
-                                          size_t /*frame_len*/) {}
-
    protected:
     virtual ~Visitor() {}
   };
@@ -99,11 +95,6 @@
   virtual void OnStreamHeaderList(bool fin, size_t frame_len,
                                   const QuicHeaderList& header_list);
 
-  // Called by the session when decompressed push promise headers have
-  // been completely delivered to this stream.
-  virtual void OnPromiseHeaderList(QuicStreamId promised_id, size_t frame_len,
-                                   const QuicHeaderList& header_list);
-
   // Called by the session when a PRIORITY frame has been been received for this
   // stream. This method will only be called for server streams.
   void OnPriorityFrame(const spdy::SpdyStreamPrecedence& precedence);
diff --git a/quiche/quic/test_tools/mock_quic_spdy_client_stream.h b/quiche/quic/test_tools/mock_quic_spdy_client_stream.h
index 10c9c6d..671c22c 100644
--- a/quiche/quic/test_tools/mock_quic_spdy_client_stream.h
+++ b/quiche/quic/test_tools/mock_quic_spdy_client_stream.h
@@ -20,10 +20,6 @@
   ~MockQuicSpdyClientStream() override;
 
   MOCK_METHOD(void, OnStreamFrame, (const QuicStreamFrame& frame), (override));
-  MOCK_METHOD(void, OnPromiseHeaderList,
-              (QuicStreamId promised_stream_id, size_t frame_len,
-               const QuicHeaderList& list),
-              (override));
   MOCK_METHOD(void, OnDataAvailable, (), (override));
 };
 
diff --git a/quiche/quic/test_tools/quic_test_utils.h b/quiche/quic/test_tools/quic_test_utils.h
index 074705a..883bdda 100644
--- a/quiche/quic/test_tools/quic_test_utils.h
+++ b/quiche/quic/test_tools/quic_test_utils.h
@@ -960,10 +960,6 @@
               (QuicStreamId stream_id, bool fin, size_t frame_len,
                const QuicHeaderList& header_list),
               (override));
-  MOCK_METHOD(void, OnPromiseHeaderList,
-              (QuicStreamId stream_id, QuicStreamId promised_stream_id,
-               size_t frame_len, const QuicHeaderList& header_list),
-              (override));
   MOCK_METHOD(void, OnPriorityFrame,
               (QuicStreamId id, const spdy::SpdyStreamPrecedence& precedence),
               (override));