grpc 1.84.0 → 1.85.0.pre1

data/src/core/ext/transport/chttp2/transport/http2_server_transport.h

@@ -29,7 +29,9 @@
 #include <optional>
 #include <type_traits>
 #include <utility>
+#include <vector>
 
+#include "src/core/call/call_arena_allocator.h"
 #include "src/core/call/call_destination.h"
 #include "src/core/call/call_spine.h"
 #include "src/core/call/metadata.h"
@@ -45,6 +47,7 @@
 #include "src/core/ext/transport/chttp2/transport/keepalive.h"
 #include "src/core/ext/transport/chttp2/transport/ping_promise.h"
 #include "src/core/ext/transport/chttp2/transport/read_context.h"
+#include "src/core/ext/transport/chttp2/transport/reclaimer.h"
 #include "src/core/ext/transport/chttp2/transport/security_frame.h"
 #include "src/core/ext/transport/chttp2/transport/stream.h"
 #include "src/core/ext/transport/chttp2/transport/stream_data_queue.h"
@@ -60,6 +63,7 @@
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/promise/race.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
+#include "src/core/lib/resource_quota/stream_quota.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/promise_endpoint.h"
@@ -174,14 +178,17 @@ class Http2ServerTransport final : public ServerTransport,
   int64_t TestOnlyTransportFlowControlWindow();
   int64_t TestOnlyGetStreamFlowControlWindow(uint32_t stream_id);
 
-  uint32_t TestOnlyLastIncomingStreamId() const {
-    return last_incoming_stream_id_;
-  }
+  uint32_t TestOnlyLastIncomingStreamId() const { return GetLastStreamId(); }
 
   Duration TestOnlyNextAllowedPingInterval() {
     return NextAllowedPingInterval();
   }
 
+  void TestOnlySetLocalMaxConcurrentStreams(
+      const uint32_t max_concurrent_streams) {
+    settings_->mutable_local().SetMaxConcurrentStreams(max_concurrent_streams);
+  }
+
  private:
   //////////////////////////////////////////////////////////////////////////////
   // Endpoint Helpers
@@ -262,7 +269,8 @@ class Http2ServerTransport final : public ServerTransport,
   }
 
   template <typename T>
-  Http2Status ProcessIncomingMetadata(T&& frame);
+  Http2Status ProcessIncomingMetadata(T&& frame,
+                                      const RefCountedPtr<Stream>& stream);
 
   auto ReadAndProcessOneFrame();
 
@@ -444,15 +452,7 @@ class Http2ServerTransport final : public ServerTransport,
   // tokens are calculated based on the initial window size.
   absl::Status UpdateAllStreamsWritability();
 
-  auto FlowControlPeriodicUpdateLoop();
-
-  // TODO(tjagtap) [PH2][P2][BDP] Remove this when the BDP code is done.
-  void AddPeriodicUpdatePromiseWaker() {
-    periodic_updates_waker_ = GetContext<Activity>()->MakeNonOwningWaker();
-  }
-
-  // TODO(tjagtap) [PH2][P2][BDP] Remove this when the BDP code is done.
-  void WakeupPeriodicUpdatePromise() { periodic_updates_waker_.Wakeup(); }
+  auto BdpLoop();
 
   //////////////////////////////////////////////////////////////////////////////
   // Stream List Operations
@@ -473,18 +473,28 @@ class Http2ServerTransport final : public ServerTransport,
     return stream_list_.size();
   }
 
+  // Returns the last stream id seen by the transport from the client.
+  // If no streams were seen, returns 0.
+  uint32_t GetLastStreamId() const { return last_incoming_stream_id_; }
+
   bool IsPingWithoutCallsAllowed() const {
     return keepalive_permit_without_calls_;
   }
 
   bool IsTransportIdle() {
-    MutexLock lock(&transport_mutex_);
+    MutexLock lock(transport_mutex_);
     return GetActiveStreamCountLocked() == 0;
   }
 
   void EnqueueResetStreamFromTransportParty(RefCountedPtr<Stream> stream,
                                             uint32_t reset_stream_error_code);
 
+  // Enqueues a RST_STREAM frame directly onto the transport write context when
+  // no Stream object exists yet (e.g. when an incoming stream is rejected
+  // before stream creation).
+  void EnqueueResetStreamFromTransportParty(
+      const uint32_t stream_id, const uint32_t reset_stream_error_code);
+
   //////////////////////////////////////////////////////////////////////////////
   // Stream Operations
 
@@ -494,9 +504,19 @@ class Http2ServerTransport final : public ServerTransport,
   std::optional<RefCountedPtr<Stream>> MakeStream(
       CallInitiator&& call_initiator, uint32_t stream_id);
 
+  // Validates the transport-level conditions for the incoming stream before
+  // creating the stream object.
+  Http2Status ValidateIncomingStream(uint32_t stream_id);
+
   Http2Status IncomingStream(ClientMetadataHandle&& metadata,
                              uint32_t stream_id);
 
+  // This MUST be called from the transport party only.
+  // Recomputes the MAX_CONCURRENT_STREAMS that we advertise to the peer, based
+  // on the process wide StreamQuota.
+  // Based on CHTTP2's use of GetConnectionMaxConcurrentRequests in parsing.cc
+  void UpdateMaxConcurrentStreamsFromStreamQuota();
+
   // Call this when a stream needs to be closed and we must notify the client by
   // sending a RST_STREAM frame (e.g., due to local stream error, cancellation).
   // This enqueues the RST_STREAM frame and immediately closes the stream for
@@ -735,6 +755,7 @@ class Http2ServerTransport final : public ServerTransport,
   bool is_goaway_received_;
 
   bool should_reset_ping_clock_;
+  bool max_concurrent_streams_overload_protection_ = false;
   ReadContext read_context_;
 
   // Transport wide write context. This is used to track the state of the
@@ -744,6 +765,9 @@ class Http2ServerTransport final : public ServerTransport,
   // Tracks last stream id received by the transport.
   uint32_t last_incoming_stream_id_;
 
+  // Tracks last stream id accepted for processing (for graceful GOAWAY).
+  uint32_t last_accepted_stream_id_;
+
   // Duration between two consecutive keepalive pings.
   Duration keepalive_time_;
   GRPC_UNUSED bool test_only_ack_pings_;
@@ -755,14 +779,13 @@ class Http2ServerTransport final : public ServerTransport,
   GoawayManager goaway_manager_;
 
   MemoryOwner memory_owner_;
+  const RefCountedPtr<CallArenaAllocator> call_arena_allocator_;
+  RefCountedPtr<StreamQuota> stream_quota_;
   chttp2::TransportFlowControl flow_control_;
   WritableStreams<RefCountedPtr<Stream>> writable_stream_list_;
 
   RefCountedPtr<SecurityFrameHandler> security_frame_handler_;
   std::shared_ptr<PromiseHttp2ZTraceCollector> ztrace_collector_;
-
-  // TODO(tjagtap) [PH2][P2][BDP] Remove this when the BDP code is done.
-  Waker periodic_updates_waker_;
   TarpitManager tarpit_manager_;
 };
 

data/src/core/ext/transport/chttp2/transport/http2_transport.cc

@@ -150,7 +150,9 @@ std::string TransportChannelArgs::DebugString() const {
       " max_header_list_size_soft_limit: ", max_header_list_size_soft_limit,
       " max_usable_hpack_table_size: ", max_usable_hpack_table_size,
       " initial_sequence_number: ", initial_sequence_number,
-      " test_only_ack_pings: ", test_only_ack_pings);
+      " test_only_ack_pings: ", test_only_ack_pings,
+      " max_concurrent_streams_overload_protection: ",
+      max_concurrent_streams_overload_protection);
 }
 
 void ReadChannelArgs(const ChannelArgs& channel_args,
@@ -186,6 +188,13 @@ void ReadChannelArgs(const ChannelArgs& channel_args,
       channel_args.GetBool(GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS)
           .value_or(kDefaultKeepalivePermitWithoutCalls);
 
+  args.max_concurrent_streams_overload_protection =
+      is_client
+          ? false
+          : channel_args
+                .GetBool(GRPC_ARG_MAX_CONCURRENT_STREAMS_OVERLOAD_PROTECTION)
+                .value_or(true);
+
   args.max_usable_hpack_table_size =
       channel_args.GetInt(GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_ENCODER).value_or(-1);
 
@@ -371,6 +380,8 @@ ProcessIncomingDataFrameFlowControl(const Http2FrameHeader& frame_header,
       chttp2::StreamFlowControl::IncomingUpdateContext stream_fc(
           &stream->GetStreamFlowControl());
       absl::Status fc_status = stream_fc.RecvData(frame_header.length);
+      // TODO(tjagtap) [PH2][P1][FlowControl] This is a HACK. Fix this.
+      stream_fc.HackIncrementPendingSize(frame_header.length);
       chttp2::FlowControlAction action = stream_fc.MakeAction();
       GRPC_HTTP2_COMMON_DLOG
           << "ProcessIncomingDataFrameFlowControl Stream RecvData status: "
@@ -383,8 +394,6 @@ ProcessIncomingDataFrameFlowControl(const Http2FrameHeader& frame_header,
             Http2ErrorCode::kFlowControlError,
             std::string(fc_status.message()));
       }
-      // TODO(tjagtap) [PH2][P1][FlowControl] This is a HACK. Fix this.
-      stream_fc.HackIncrementPendingSize(frame_header.length);
       return action;
     }
   }
@@ -489,8 +498,6 @@ std::string TarpitEntry::DebugString() const {
       std::get_if<OutgoingResetPayload>(&payload_);
   const OutgoingTrailingMetadataPayload* const trailers =
       std::get_if<OutgoingTrailingMetadataPayload>(&payload_);
-  const IncomingResetPayload* const incoming_reset =
-      std::get_if<IncomingResetPayload>(&payload_);
   if (reset != nullptr) {
     payload_str = absl::StrCat(
         "OutgoingReset(error_code=", reset->http2_error_code,
@@ -501,9 +508,6 @@ std::string TarpitEntry::DebugString() const {
                                    ? trailers->metadata->DebugString()
                                    : "null",
                                ")");
-  } else if (incoming_reset != nullptr) {
-    payload_str = absl::StrCat(
-        "IncomingReset(status=", incoming_reset->status.ToString(), ")");
   } else {
     payload_str = "unknown type";
   }
@@ -569,22 +573,6 @@ StatusFlag TarpitManager::StartTarpitTrailers(const uint32_t stream_id,
   return status;
 }
 
-StatusFlag TarpitManager::RequestTarpitIncomingReset(const uint32_t stream_id,
-                                                     absl::Status status) {
-  GRPC_DCHECK(allow_tarpit_);
-  GRPC_DCHECK_NE(stream_id, kInvalidStreamId);
-  GRPC_HTTP2_COMMON_DLOG
-      << "TarpitManager::RequestTarpitIncomingReset Stream id: " << stream_id
-      << " status: " << status;
-
-  const Timestamp expire_time = Timestamp::Now() + GetTarpitDuration();
-  TarpitEntry entry = TarpitEntry::CreateIncomingReset(
-      stream_id, std::move(status), expire_time);
-  const StatusFlag send_status =
-      sender_.UnbufferedImmediateSend(std::move(entry), 1);
-  return send_status;
-}
-
 StreamStateChange TarpitManager::OnTarpit(Stream& stream) {
   stream.SetTarpitActive();
   return stream.OnInitiateReset(absl::CancelledError("Stream tarpitted"));

data/src/core/ext/transport/chttp2/transport/http2_transport.h

@@ -153,6 +153,8 @@ struct TransportChannelArgs {
   bool keepalive_permit_without_calls;
   // This is used to test peer behaviour when we never send a ping ack.
   bool test_only_ack_pings;
+  // This is only applicable to servers.
+  bool max_concurrent_streams_overload_protection;
   uint32_t max_header_list_size_soft_limit;
   int max_usable_hpack_table_size;
   int initial_sequence_number;
@@ -272,8 +274,6 @@ class TransportShutdownTracker {
 // duration elapses:
 // - OutgoingResetPayload: sends a delayed RST_STREAM.
 // - OutgoingTrailingMetadataPayload: sends delayed server trailing metadata.
-// - IncomingResetPayload: Stream closure triggered by Client sending an
-//   RST_STREAM.
 // The functions in this class are not thread-safe.
 class TarpitEntry {
  public:
@@ -286,10 +286,6 @@ class TarpitEntry {
     ServerMetadataHandle metadata;
   };
 
-  struct IncomingResetPayload {
-    absl::Status status;
-  };
-
   TarpitEntry(TarpitEntry&&) = default;
   TarpitEntry& operator=(TarpitEntry&&) = default;
   TarpitEntry(const TarpitEntry&) = delete;
@@ -313,12 +309,6 @@ class TarpitEntry {
                        OutgoingTrailingMetadataPayload{std::move(metadata)},
                        expire_time);
   }
-  static TarpitEntry CreateIncomingReset(const uint32_t stream_id,
-                                         absl::Status status,
-                                         const Timestamp expire_time) {
-    return TarpitEntry(stream_id, IncomingResetPayload{std::move(status)},
-                       expire_time);
-  }
 
   Timestamp GetExpireTime() const { return expire_time_; }
   uint32_t GetStreamId() const { return stream_id_; }
@@ -329,9 +319,6 @@ class TarpitEntry {
   bool IsOutgoingTrailingMetadata() const {
     return std::holds_alternative<OutgoingTrailingMetadataPayload>(payload_);
   }
-  bool IsIncomingReset() const {
-    return std::holds_alternative<IncomingResetPayload>(payload_);
-  }
 
   // Consumes and extracts the payload when executing the post-tarpit action.
   // Returns std::nullopt if the payload type does not match.
@@ -352,14 +339,6 @@ class TarpitEntry {
     }
     return std::nullopt;
   }
-  std::optional<IncomingResetPayload> TakeIncomingResetPayload() {
-    IncomingResetPayload* const p =
-        std::get_if<IncomingResetPayload>(&payload_);
-    if (p != nullptr) {
-      return std::move(*p);
-    }
-    return std::nullopt;
-  }
 
   std::string DebugString() const;
 
@@ -369,8 +348,7 @@ class TarpitEntry {
 
  private:
   using Payload =
-      std::variant<OutgoingResetPayload, OutgoingTrailingMetadataPayload,
-                   IncomingResetPayload>;
+      std::variant<OutgoingResetPayload, OutgoingTrailingMetadataPayload>;
 
   TarpitEntry(const uint32_t stream_id, Payload payload,
               const Timestamp expire_time)
@@ -452,10 +430,6 @@ class TarpitManager {
   StatusFlag StartTarpitTrailers(uint32_t stream_id,
                                  ServerMetadataHandle metadata);
 
-  // Performs delayed stream closure following an incoming RST_STREAM.
-  StatusFlag RequestTarpitIncomingReset(uint32_t stream_id,
-                                        absl::Status status);
-
   //----------------------------------------------------------------------------
   // Transport-Party Confined Methods (Must be run on TransportParty)
   //----------------------------------------------------------------------------

data/src/core/ext/transport/chttp2/transport/internal.h

@@ -294,7 +294,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   void PerformOp(grpc_transport_op* op) override;
   // Callback for transport framing endpoint extension to send security frames
   // received directly from the endpoint on wire.
-  void WriteSecurityFrame(grpc_core::SliceBuffer* data);
+  void WriteSecurityFrame(grpc_core::SliceBuffer data);
   void WriteSecurityFrameLocked(grpc_core::SliceBuffer* data);
 
   void StartWatch(grpc_core::RefCountedPtr<StateWatcher> watcher) override;
@@ -631,7 +631,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
 
   std::optional<uint32_t> max_recv_message_length;
 
-  // Current mitigation engine, retrieved once per connection.
+  grpc_auth_context* auth_context = nullptr;
   grpc_core::RefCountedPtr<grpc_core::MitigationEngine> mitigation_engine;
 };
 

data/src/core/ext/transport/chttp2/transport/parsing.cc

@@ -544,7 +544,8 @@ static grpc_error_handle init_header_skip_frame_parser(
       t->settings.acked().max_header_list_size(),
       hpack_boundary_type(t, is_eoh), priority_type,
       hpack_parser_log_info(t, HPackParser::LogInfo::kDontKnow),
-      t->mitigation_engine.get(), t->peer_string.as_string_view());
+      t->mitigation_engine.get(), t->peer_string.as_string_view(),
+      t->auth_context);
   return absl::OkStatus();
 }
 
@@ -895,7 +896,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                              hpack_boundary_type(t, is_eoh), priority_type,
                              hpack_parser_log_info(t, frame_type),
                              t->mitigation_engine.get(),
-                             t->peer_string.as_string_view());
+                             t->peer_string.as_string_view(), t->auth_context);
   return absl::OkStatus();
 }
 

data/src/core/ext/transport/chttp2/transport/read_context.h

@@ -22,10 +22,12 @@
 #include <grpc/support/port_platform.h>
 
 #include <cstdint>
+#include <limits>
 #include <string>
 #include <utility>
 
 #include "src/core/call/metadata_info.h"
+#include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/header_assembler.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
@@ -143,6 +145,25 @@ class IncomingMetadataState {
   // Returns stream id of stream for which headers are being received.
   uint32_t GetStreamId() const { return stream_id_; }
 
+  void SetIsDiscardingIncomingStream(const bool is_discarding) {
+    is_discarding_incoming_stream_ = is_discarding;
+  }
+
+  // Set to true when:
+  // 1. A header frame or continuation frame causes a STREAM_ERROR.
+  // 2. The frame that caused the error did not have the END_HEADERS flag set.
+
+  // This ensures that subsequent CONTINUATION frames are safely parsed and
+  // discarded while keeping the HPACK table in sync. This function should be
+  // called each time a CONTINUATION frame is received.
+
+  // Returns true if the transport is actively discarding incoming
+  // CONTINUATION frames after a HEADERS frame was rejected, while continuing
+  // to decode their payload to keep the HPACK dynamic table in sync.
+  bool IsDiscardingIncomingStream() const {
+    return is_discarding_incoming_stream_;
+  }
+
   // A gRPC server is permitted to send both initial metadata and trailing
   // metadata where initial metadata is optional.
   // A gRPC C++ client is permitted to send only initial metadata.
@@ -163,12 +184,19 @@ class IncomingMetadataState {
         "{ incoming_header_in_progress : ",
         metadata_in_progress_ ? "true" : "false",
         ", incoming_header_end_stream : ", end_stream_ ? "true" : "false",
-        ", incoming_header_stream_id : ", stream_id_, "}");
+        ", incoming_header_stream_id : ", stream_id_,
+        ", is_discarding_incoming_stream_ : ",
+        is_discarding_incoming_stream_ ? "true" : "false", "}");
   }
 
  private:
   bool metadata_in_progress_ = false;
   bool end_stream_ = false;
+  // Indicates whether incoming CONTINUATION frames should have their payloads
+  // discarded after a HEADERS frame was rejected, while still feeding the
+  // payload through the HPACK decoder to maintain dynamic table
+  // synchronization.
+  bool is_discarding_incoming_stream_ = false;
   uint32_t stream_id_ = 0;
 };
 
@@ -298,8 +326,6 @@ class ReadContext {
 
   // Called when we are closing a stream.
   void OnResetFrameEnqueued(const uint32_t reset_stream_error_code) {
-    // TODO(tjagtap) [PH2][P1] Call this when we reject streams because of
-    // MAX_CONCURRENT_STREAMS limit.
     if (reset_stream_error_code != 0u) {
       IncrementInducedFrames();
     }
@@ -307,6 +333,61 @@ class ReadContext {
   void OnSettingsFrameReceived() { IncrementInducedFrames(); }
   void OnPingFrameReceived() { IncrementInducedFrames(); }
 
+  // This is applicable only to servers.
+  // Based on CHTTP2's num_incoming_streams_before_settings_ack in parsing.cc.
+  // Sets the number of streams the peer may open before it acknowledges our
+  // SETTINGS frame. Has no effect once the first SETTINGS ACK has been
+  // received.
+  void SetNumIncomingStreamsBeforeSettingsAck(const uint32_t limit) {
+    num_incoming_streams_before_settings_ack_ = limit;
+  }
+
+  // Returns true once the peer has acknowledged our first SETTINGS frame.
+  bool HasReceivedSettingsAck() const {
+    return has_received_first_settings_ack_;
+  }
+
+  // Called when the first SETTINGS ACK frame is received.
+  // Removes the incoming streams limit for the rest of the connection.
+  void OnSettingsAckReceived() {
+    has_received_first_settings_ack_ = true;
+    num_incoming_streams_before_settings_ack_ =
+        std::numeric_limits<uint32_t>::max();
+  }
+
+  // Rejects incoming streams with ENHANCE_YOUR_CALM if received before the
+  // first settings ACK when limit is exhausted.
+  // Based on CHTTP2's check in parsing.cc:790.
+  Http2Status ValidateIncomingStreamBeforeSettingsAck(
+      const uint32_t stream_id) const {
+    if (GPR_LIKELY(has_received_first_settings_ack_)) {
+      return Http2Status::Ok();
+    } else if (GPR_UNLIKELY(num_incoming_streams_before_settings_ack_ == 0u)) {
+      GRPC_HTTP2_COMMON_DLOG
+          << "ReadContext::ValidateIncomingStreamBeforeSettingsAck "
+          << "Rejecting stream before settings have been acknowledged, "
+             "refusing stream_id="
+          << stream_id;
+      return Http2Status::Http2StreamError(
+          Http2ErrorCode::kEnhanceYourCalm,
+          std::string(GrpcErrors::kRejectStreamBeforeSettingsAck));
+    }
+    return Http2Status::Ok();
+  }
+
+  // Consumes one unit of the pre-SETTINGS-ACK stream limit once all stream
+  // validation checks have passed and the stream is accepted.
+  // Based on CHTTP2's --t->num_incoming_streams_before_settings_ack in
+  // parsing.cc:811.
+  void ConsumeIncomingStreamBeforeSettingsAck() {
+    if (GPR_LIKELY(has_received_first_settings_ack_)) {
+      return;
+    }
+    if (GPR_LIKELY(num_incoming_streams_before_settings_ack_ > 0u)) {
+      --num_incoming_streams_before_settings_ack_;
+    }
+  }
+
   // Called when we read a RST_STREAM frame from the peer.
   // Returns true if a ping should be sent in response.
   ShouldSendPing OnResetFrameReceived() {
@@ -358,6 +439,14 @@ class ReadContext {
   // Returns stream id of stream for which headers are being received.
   uint32_t GetStreamId() const { return metadata_state_.GetStreamId(); }
 
+  bool IsDiscardingIncomingStream() const {
+    return metadata_state_.IsDiscardingIncomingStream();
+  }
+
+  void SetIsDiscardingIncomingStream(const bool is_discarding) {
+    metadata_state_.SetIsDiscardingIncomingStream(is_discarding);
+  }
+
   // A gRPC server is permitted to send both initial metadata and trailing
   // metadata where initial metadata is optional.
   // A gRPC C++ client is permitted to send only initial metadata.
@@ -513,6 +602,10 @@ class ReadContext {
   ReadLoopPauseRestart read_loop_manager_;
   HeaderAssembler header_assembler_;
   IncomingMetadataState metadata_state_;
+  // Number of streams the peer may still open before it acknowledges our
+  // SETTINGS frame. Unused once has_received_first_settings_ack_ is true.
+  uint32_t num_incoming_streams_before_settings_ack_ = 0u;
+  bool has_received_first_settings_ack_ = false;
 };
 
 }  // namespace http2

data/src/core/ext/transport/chttp2/transport/reclaimer.cc

@@ -0,0 +1,32 @@
+//
+//
+// Copyright 2026 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#include "src/core/ext/transport/chttp2/transport/reclaimer.h"
+
+#include <memory>
+#include <optional>
+#include <utility>
+
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/resource_quota/memory_quota.h"
+#include "src/core/util/grpc_check.h"
+#include "src/core/util/sync.h"
+
+namespace grpc_core {
+namespace http2 {}  // namespace http2
+}  // namespace grpc_core

data/src/core/ext/transport/chttp2/transport/reclaimer.h

@@ -0,0 +1,64 @@
+//
+//
+// Copyright 2026 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_RECLAIMER_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_RECLAIMER_H
+
+#include <memory>
+#include <optional>
+#include <utility>
+
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/loop.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/resource_quota/memory_quota.h"
+#include "src/core/util/grpc_check.h"
+#include "src/core/util/ref_counted.h"
+#include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/sync.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+
+namespace grpc_core {
+namespace http2 {
+
+#define GRPC_HTTP2_RECLAIMER_LOG VLOG(2)
+
+// PH2 Client and PH2 Server transports provide their own implementation of this
+// interface. Each method maps to the actions that a memory reclamation pass
+// performs on a PH2 transport.
+class ReclaimerInterface {
+ public:
+  virtual ~ReclaimerInterface() = default;
+
+  // Benign pass. Closes the transport if it has no active streams.
+  // Returns true if the transport close was initiated.
+  virtual bool CloseTransportIfIdle() = 0;
+
+  // Destructive pass. Cancels exactly one active stream, if any exists.
+  // Returns true if at least one stream is still active after the
+  // cancellation. Returns false otherwise.
+  virtual bool CancelOneActiveStream() = 0;
+};
+
+}  // namespace http2
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_RECLAIMER_H

data/src/core/ext/transport/chttp2/transport/security_frame.h

@@ -67,12 +67,12 @@ class SecurityFrameHandler final : public RefCounted<SecurityFrameHandler> {
   auto SendFrameCallbackFactory(
       std::shared_ptr<grpc_event_engine::experimental::EventEngine>
           event_engine) {
-    return [self = this->Ref(), event_engine](SliceBuffer* data) {
-      event_engine->Run([self, data = std::move(*data)]() mutable {
+    return [self = this->Ref(), event_engine](SliceBuffer data) {
+      event_engine->Run([self, data = std::move(data)]() mutable {
         GRPC_HTTP2_SECURITY_FRAME_DLOG << "SecurityFrameHandler::Callback";
         bool call_wakeup = false;
         {
-          MutexLock lock(&self->mutex_);
+          MutexLock lock(self->mutex_);
           // In the rare possibility that we receive 2 quick callbacks in
           // succession before the transport is able to read the payload_
           // then we will apply the latest key and discard the old key.
@@ -121,7 +121,7 @@ class SecurityFrameHandler final : public RefCounted<SecurityFrameHandler> {
     if (endpoint_extension_ != nullptr && payload.Length() > 0) {
       bool should_receive = false;
       {
-        MutexLock lock(&mutex_);
+        MutexLock lock(mutex_);
         should_receive = !transport_closed_;
       }
       // Since transport_closed_ is only changed from the transport party, we
@@ -154,7 +154,7 @@ class SecurityFrameHandler final : public RefCounted<SecurityFrameHandler> {
       if (self->sleep_state_ == SleepState::kTransportClosed) {
         return Empty{};
       } else if (self->sleep_state_ == SleepState::kWaitingForFrame) {
-        MutexLock lock(&self->mutex_);
+        MutexLock lock(self->mutex_);
         if (self->payload_.Length() > 0) {
           self->sleep_state_ = SleepState::kWriteOneFrame;
           return Empty{};
@@ -195,7 +195,7 @@ class SecurityFrameHandler final : public RefCounted<SecurityFrameHandler> {
         endpoint_extension_ != nullptr) {
       Http2Frame frame = Http2SecurityFrame();
       {
-        MutexLock lock(&mutex_);
+        MutexLock lock(mutex_);
         GRPC_DCHECK(payload_.Length() != 0);
         GRPC_DCHECK(payload_.Length() <= GrpcErrors::kMaxSecurityFrameSize);
         GRPC_HTTP2_SECURITY_FRAME_DLOG
@@ -216,7 +216,7 @@ class SecurityFrameHandler final : public RefCounted<SecurityFrameHandler> {
   // Only run on the Transport Party
   void OnTransportClosed() {
     GRPC_HTTP2_SECURITY_FRAME_DLOG << "SecurityFrameHandler::OnTransportClosed";
-    MutexLock lock(&mutex_);
+    MutexLock lock(mutex_);
     transport_closed_ = true;
     sleep_state_ = SleepState::kTransportClosed;
     payload_.Clear();
@@ -241,7 +241,7 @@ class SecurityFrameHandler final : public RefCounted<SecurityFrameHandler> {
         sleep_state_str = "kTransportClosed";
         break;
     }
-    MutexLock lock(&mutex_);
+    MutexLock lock(mutex_);
     // Do not ever LOG the payload. It has a security key.
     return absl::StrFormat(
         "SecurityFrameHandler{endpoint_extension_=%s, sleep_state_=%s, "