grpc 1.76.0 → 1.78.0.pre1

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

@@ -0,0 +1,128 @@
+//
+//
+// Copyright 2025 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_INCOMING_METADATA_TRACKER_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INCOMING_METADATA_TRACKER_H
+
+#include <cstdint>
+#include <string>
+
+#include "src/core/call/metadata_info.h"
+#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/strings/str_cat.h"
+
+namespace grpc_core {
+namespace http2 {
+
+class IncomingMetadataTracker {
+  // Manages transport-wide state for incoming HEADERS and CONTINUATION frames.
+  // RFC 9113 (Section 6.10) requires that if a HEADERS frame does not have
+  // END_HEADERS set, it must be followed by a contiguous sequence of
+  // CONTINUATION frames for the same stream, ending with END_HEADERS. No other
+  // frame types or frames for other streams may be interleaved during this
+  // sequence. This constraint makes tracking header sequence state a
+  // transport-level concern, as only one stream can be receiving headers at
+  // a time. This class is distinct from HeaderAssembler, which buffers header
+  // payloads on a per-stream basis.
+ public:
+  IncomingMetadataTracker() = default;
+  ~IncomingMetadataTracker() = default;
+
+  IncomingMetadataTracker(IncomingMetadataTracker&& rvalue) = delete;
+  IncomingMetadataTracker& operator=(IncomingMetadataTracker&& rvalue) = delete;
+  IncomingMetadataTracker(const IncomingMetadataTracker&) = delete;
+  IncomingMetadataTracker& operator=(const IncomingMetadataTracker&) = delete;
+
+  void set_soft_limit(uint32_t limit) {
+    max_header_list_size_soft_limit_ = limit;
+  }
+  uint32_t soft_limit() const { return max_header_list_size_soft_limit_; }
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Writing Header and Continuation State
+
+  // Called when a HEADER frame is received.
+  void OnHeaderReceived(const Http2HeaderFrame& frame) {
+    GRPC_CHECK(!incoming_header_in_progress_);
+    incoming_header_in_progress_ = !frame.end_headers;
+    incoming_header_stream_id_ = frame.stream_id;
+    incoming_header_end_stream_ = frame.end_stream;
+  }
+
+  // Called when a CONTINUATION frame is received.
+  void OnContinuationReceived(const Http2ContinuationFrame& frame) {
+    GRPC_CHECK(incoming_header_in_progress_);
+    GRPC_CHECK_EQ(frame.stream_id, incoming_header_stream_id_);
+    incoming_header_in_progress_ = !frame.end_headers;
+  }
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Reading Header and Continuation State
+
+  // Returns true if we are in the middle of receiving a header block
+  // (i.e., HEADERS without END_HEADERS was received, and we are waiting for
+  // CONTINUATION frames).
+  bool IsWaitingForContinuationFrame() const {
+    return incoming_header_in_progress_;
+  }
+
+  // Returns true if end_stream was set in the received header.
+  bool HeaderHasEndStream() const { return incoming_header_end_stream_; }
+
+  // Returns stream id of stream for which headers are being received.
+  uint32_t GetStreamId() const { return incoming_header_stream_id_; }
+
+  bool ClientReceivedDuplicateMetadata(
+      const bool did_receive_initial_metadata,
+      const bool did_receive_trailing_metadata) const {
+    const bool is_duplicate_initial_metadata =
+        !incoming_header_end_stream_ && did_receive_initial_metadata;
+    const bool is_duplicate_trailing_metadata =
+        incoming_header_end_stream_ && did_receive_trailing_metadata;
+    return is_duplicate_initial_metadata || is_duplicate_trailing_metadata;
+  }
+
+  bool ServerReceivedDuplicateMetadata(
+      const bool did_receive_initial_metadata) const {
+    // TODO(tjagtap) : [PH2][P2] : Verify this when implementing Server.
+    // Also write a small unit test for it.
+    return !incoming_header_end_stream_ && did_receive_initial_metadata;
+  }
+
+  std::string DebugString() const {
+    return absl::StrCat(
+        "{ incoming_header_in_progress : ",
+        incoming_header_in_progress_ ? "true" : "false",
+        ", incoming_header_end_stream : ",
+        incoming_header_end_stream_ ? "true" : "false",
+        ", incoming_header_stream_id : ", incoming_header_stream_id_, "}");
+  }
+
+ private:
+  bool incoming_header_in_progress_ = false;
+  bool incoming_header_end_stream_ = false;
+  uint32_t incoming_header_stream_id_ = 0;
+  uint32_t max_header_list_size_soft_limit_ =
+      DEFAULT_MAX_HEADER_LIST_SIZE_SOFT_LIMIT;
+};
+
+}  // namespace http2
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INCOMING_METADATA_TRACKER_H

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

@@ -34,10 +34,6 @@
 #include <utility>
 #include <variant>
 
-#include "absl/container/flat_hash_map.h"
-#include "absl/random/random.h"
-#include "absl/status/status.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
@@ -68,6 +64,7 @@
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/resource_quota/arena.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.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/surface/init_internally.h"
@@ -83,6 +80,10 @@
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/time.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/random/random.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
 
 // Flag that this closure barrier may be covering a write in a pollset, and so
 //   we should not complete this closure until we can prove that the write got
@@ -288,6 +289,19 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   void WriteSecurityFrame(grpc_core::SliceBuffer* data);
   void WriteSecurityFrameLocked(grpc_core::SliceBuffer* data);
 
+  void StartWatch(grpc_core::RefCountedPtr<StateWatcher> watcher) override;
+  void StopWatch(grpc_core::RefCountedPtr<StateWatcher> watcher) override;
+
+  void NotifyStateWatcherOnDisconnectLocked(
+      absl::Status status, StateWatcher::DisconnectInfo disconnect_info);
+
+  void OnPeerMaxConcurrentStreamsUpdateComplete();
+  void MaybeNotifyStateWatcherOfPeerMaxConcurrentStreamsLocked();
+  void NotifyStateWatcherOnPeerMaxConcurrentStreamsUpdateLocked();
+
+  void MaybeNotifyOnReceiveSettingsLocked(
+      absl::StatusOr<uint32_t> max_concurrent_streams);
+
   // We depend on the ep being available for the life of the transport in
   // at least one place - event callback in WriteEventSink. Hence, this should
   // only be orphaned in the destructor.
@@ -316,7 +330,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   // starts a connectivity watch.
   grpc_pollset_set* interested_parties_until_recv_settings = nullptr;
 
-  grpc_closure* notify_on_receive_settings = nullptr;
+  absl::AnyInvocable<void(absl::StatusOr<uint32_t>)> notify_on_receive_settings;
   grpc_closure* notify_on_close = nullptr;
 
   /// has the upper layer closed the transport?
@@ -375,7 +389,12 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
       void* user_data, grpc_core::ServerMetadata* metadata) = nullptr;
   void* accept_stream_cb_user_data;
 
+  // There should be only a single watcher in use at any given time.
+  grpc_core::RefCountedPtr<StateWatcher> watcher;
+  uint32_t last_reported_max_concurrent_streams;
+  bool max_concurrent_streams_notification_in_flight;
   /// connectivity tracking
+  // TODO(roth): Get rid of this in favor of the new state watcher.
   grpc_core::ConnectivityStateTracker state_tracker;
 
   /// data to write now
@@ -593,6 +612,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
 
   std::shared_ptr<grpc_core::Http2StatsCollector> http2_stats;
   grpc_core::Http2ZTraceCollector http2_ztrace_collector;
+  grpc_core::Timestamp last_ztrace_time = grpc_core::Timestamp::InfPast();
 
   GPR_NO_UNIQUE_ADDRESS grpc_core::latent_see::Flow write_flow;
 };

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

@@ -17,21 +17,28 @@
 //
 #include "src/core/ext/transport/chttp2/transport/keepalive.h"
 
+#include <utility>
+
 #include "src/core/lib/promise/all_ok.h"
 #include "src/core/lib/promise/if.h"
 #include "src/core/lib/promise/loop.h"
+#include "src/core/lib/promise/party.h"
 #include "src/core/lib/promise/race.h"
 #include "src/core/lib/promise/sleep.h"
 #include "src/core/lib/promise/try_seq.h"
+#include "src/core/util/grpc_check.h"
+#include "src/core/util/time.h"
 
 namespace grpc_core {
 namespace http2 {
 KeepaliveManager::KeepaliveManager(
     std::unique_ptr<KeepAliveInterface> keep_alive_interface,
-    Duration keepalive_timeout, const Duration keepalive_time)
+    Duration keepalive_timeout, const Duration keepalive_time, Party* party)
     : keep_alive_interface_(std::move(keep_alive_interface)),
       keepalive_timeout_(keepalive_timeout),
-      keepalive_time_(keepalive_time) {}
+      keepalive_time_(keepalive_time) {
+  MaybeSpawnKeepaliveLoop(party);
+}
 
 auto KeepaliveManager::WaitForKeepAliveTimeout() {
   return AssertResultType<absl::Status>(
@@ -59,8 +66,8 @@ auto KeepaliveManager::WaitForKeepAliveTimeout() {
       }));
 }
 auto KeepaliveManager::TimeoutAndSendPing() {
-  DCHECK(!data_received_in_last_cycle_);
-  DCHECK(keepalive_timeout_ != Duration::Infinity());
+  GRPC_DCHECK(!data_received_in_last_cycle_);
+  GRPC_DCHECK(keepalive_timeout_ != Duration::Infinity());
 
   return AllOk<absl::Status>(Race(WaitForData(), WaitForKeepAliveTimeout()),
                              SendPingAndWaitForAck());
@@ -83,7 +90,7 @@ auto KeepaliveManager::MaybeSendKeepAlivePing() {
              }));
 }
 
-void KeepaliveManager::Spawn(Party* party) {
+void KeepaliveManager::MaybeSpawnKeepaliveLoop(Party* party) {
   if (!IsKeepAliveNeeded()) {
     GRPC_HTTP2_KEEPALIVE_LOG << "Not spawning keepalive loop.";
     return;

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

@@ -18,9 +18,10 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_KEEPALIVE_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_KEEPALIVE_H
 
-#include "absl/status/status.h"
 #include "src/core/lib/promise/party.h"
 #include "src/core/lib/promise/promise.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/status/status.h"
 
 namespace grpc_core {
 namespace http2 {
@@ -44,11 +45,8 @@ class KeepAliveInterface {
 class KeepaliveManager {
  public:
   KeepaliveManager(std::unique_ptr<KeepAliveInterface> keep_alive_interface,
-                   Duration keepalive_timeout, Duration keepalive_time);
-
-  // Spawns the keepalive loop on the given party. This MUST be called at most
-  // once during the lifetime of the keepalive manager.
-  void Spawn(Party* party);
+                   Duration keepalive_timeout, Duration keepalive_time,
+                   Party* party);
 
   // Needs to be called when any data is read from the endpoint.
   void GotData() {
@@ -69,6 +67,10 @@ class KeepaliveManager {
   }
 
  private:
+  // Spawns the keepalive loop on the given party. This MUST be called at most
+  // once during the lifetime of the keepalive manager.
+  void MaybeSpawnKeepaliveLoop(Party* party);
+
   // Returns a promise that sleeps for the keepalive_timeout_ and triggers the
   // keepalive timeout unless data is read within the keepalive timeout.
   auto WaitForKeepAliveTimeout();
@@ -104,7 +106,7 @@ class KeepaliveManager {
     };
   }
   auto SendPingAndWaitForAck() {
-    DCHECK_EQ(data_received_in_last_cycle_, false);
+    GRPC_DCHECK_EQ(data_received_in_last_cycle_, false);
     return keep_alive_interface_->SendPingAndWaitForAck();
   }
 
@@ -121,10 +123,12 @@ class KeepaliveManager {
   }
 
   std::unique_ptr<KeepAliveInterface> keep_alive_interface_;
-  // If the keepalive_timeout_ is set to infinity, then the timeout is dictated
-  // by the ping timeout. Otherwise, this field can be used to set a specific
-  // timeout for keepalive pings.
+  // Duration to wait before triggering a keepalive timeout. If the
+  // keepalive_timeout_ is set to infinity, then the timeout is dictated by the
+  // ping timeout. Otherwise, this field can be used to set a specific timeout
+  // for keepalive pings.
   Duration keepalive_timeout_;
+  // Duration between two consecutive keepalive pings.
   const Duration keepalive_time_;
   bool data_received_in_last_cycle_ = false;
   bool keep_alive_timeout_triggered_ = false;

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

@@ -19,6 +19,8 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_MESSAGE_ASSEMBLER_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_MESSAGE_ASSEMBLER_H
 
+#include <grpc/support/port_platform.h>
+
 #include <cstdint>
 #include <utility>
 
@@ -30,10 +32,13 @@
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/log/log.h"
 
 namespace grpc_core {
 namespace http2 {
 
+#define GRPC_MESSAGE_ASSEMBLER_DEBUG VLOG(2)
+
 // TODO(tjagtap) TODO(akshitpatel): [PH2][P3] : Write micro benchmarks for
 // assembler and disassembler code
 
@@ -79,15 +84,21 @@ class GrpcMessageAssembler {
       // TODO(tjagtap) : [PH2][P3] : Write a test for this.
       return ReturnNullOrError();
     }
-    GrpcMessageHeader header = ExtractGrpcHeader(message_buffer_);
+    ValueOrHttp2Status<GrpcMessageHeader> header =
+        ExtractGrpcHeader(message_buffer_);
+    if (!header.IsOk()) {
+      return header.TakeStatus(std::move(header));
+    }
+    const uint32_t header_length = header.value().length;
+
     if constexpr (sizeof(size_t) == 4) {
-      if (GPR_UNLIKELY(header.length > kOneGb)) {
+      if (GPR_UNLIKELY(header_length > kOneGb)) {
         return Http2Status::Http2StreamError(
             Http2ErrorCode::kInternalError,
             "Stream Error: SliceBuffer overflow for 32 bit platforms.");
       }
     }
-    if (GPR_LIKELY(current_len - kGrpcHeaderSizeInBytes >= header.length)) {
+    if (GPR_LIKELY(current_len - kGrpcHeaderSizeInBytes >= header_length)) {
       SliceBuffer discard;
       message_buffer_.MoveFirstNBytesIntoSliceBuffer(kGrpcHeaderSizeInBytes,
                                                      discard);
@@ -98,9 +109,8 @@ class GrpcMessageAssembler {
       // bounds.
       MessageHandle grpc_message = Arena::MakePooled<Message>();
       message_buffer_.MoveFirstNBytesIntoSliceBuffer(
-          header.length, *(grpc_message->payload()));
-      uint32_t& flag = grpc_message->mutable_flags();
-      flag = header.flags;
+          header_length, *(grpc_message->payload()));
+      grpc_message->mutable_flags() = header.value().flags;
       return std::move(grpc_message);
     }
     return ReturnNullOrError();
@@ -112,21 +122,18 @@ class GrpcMessageAssembler {
       return Http2Status::Http2StreamError(Http2ErrorCode::kInternalError,
                                            "Incomplete gRPC frame received");
     }
-    VLOG(2) << "Incomplete gRPC message received. Return nullptr";
+    GRPC_MESSAGE_ASSEMBLER_DEBUG
+        << "Incomplete gRPC message received. Return nullptr";
     return ValueOrHttp2Status<MessageHandle>(nullptr);
   }
+
   bool is_end_stream_ = false;
   SliceBuffer message_buffer_;
 };
 
-constexpr uint32_t kMaxMessageBatchSize = (16 * 1024u);
-
 // This class is meant to convert gRPC Messages into Http2DataFrame ensuring
 // that the payload size of the data frame is configurable.
-// This class is not responsible for queueing or backpressure. That will be done
-// by other classes.
-// TODO(tjagtap) : [PH2][P2] Edit comment once this
-// class is integrated and exercised.
+// This class is not responsible for queueing or backpressure.
 class GrpcMessageDisassembler {
  public:
   // One GrpcMessageDisassembler instance MUST be associated with one stream
@@ -141,9 +148,11 @@ class GrpcMessageDisassembler {
 
   // GrpcMessageDisassembler object will take ownership of the message.
   void PrepareBatchedMessageForSending(MessageHandle message) {
+    // The size of the message is controlled by the application (and by using
+    // GRPC_ARG_MAX_SEND_MESSAGE_LENGTH). PH2 ensures that if the the message
+    // size is larger than the default stream queue size kStreamQueueSize, at
+    // max one message will be buffered in the disassembler.
     PrepareMessageForSending(std::move(message));
-    GRPC_DCHECK_LE(GetBufferedLength(), kMaxMessageBatchSize)
-        << "Avoid batches larger than " << kMaxMessageBatchSize << "bytes";
   }
 
   size_t GetBufferedLength() const { return message_.Length(); }

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

@@ -31,14 +31,6 @@
 #include <utility>
 #include <variant>
 
-#include "absl/base/attributes.h"
-#include "absl/container/flat_hash_map.h"
-#include "absl/log/log.h"
-#include "absl/random/bit_gen_ref.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
@@ -77,6 +69,14 @@
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/status_helper.h"
+#include "absl/base/attributes.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/log/log.h"
+#include "absl/random/bit_gen_ref.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
 
 using grpc_core::HPackParser;
 using grpc_core::http2::Http2ErrorCode;

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

@@ -18,9 +18,9 @@
 
 #include <utility>
 
+#include "src/core/util/grpc_check.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/distributions.h"
-#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 

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

@@ -24,13 +24,13 @@
 #include <optional>
 #include <vector>
 
+#include "src/core/channelz/property_list.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/util/time.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/hash/hash.h"
 #include "absl/random/bit_gen_ref.h"
-#include "src/core/channelz/property_list.h"
-#include "src/core/lib/debug/trace.h"
-#include "src/core/util/time.h"
 
 namespace grpc_core {
 

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

@@ -17,12 +17,17 @@
 //
 #include "src/core/ext/transport/chttp2/transport/ping_promise.h"
 
+#include <memory>
+#include <utility>
+
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/promise/latch.h"
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/party.h"
 #include "src/core/lib/promise/race.h"
 #include "src/core/lib/promise/sleep.h"
 #include "src/core/lib/promise/try_seq.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/match.h"
 #include "src/core/util/time.h"
 
@@ -54,13 +59,14 @@ Promise<absl::Status> PingManager::PingPromiseCallbacks::WaitForPingAck() {
 }
 
 // Ping System implementation
-PingManager::PingManager(const ChannelArgs& channel_args,
+PingManager::PingManager(const ChannelArgs& channel_args, Duration ping_timeout,
                          std::unique_ptr<PingInterface> ping_interface,
                          std::shared_ptr<EventEngine> event_engine)
     : ping_callbacks_(event_engine),
       ping_abuse_policy_(channel_args),
       ping_rate_policy_(channel_args, /*is_client=*/true),
-      ping_interface_(std::move(ping_interface)) {}
+      ping_interface_(std::move(ping_interface)),
+      ping_timeout_(ping_timeout) {}
 
 void PingManager::TriggerDelayedPing(const Duration wait) {
   // Spawn at most once.
@@ -146,7 +152,7 @@ void PingManager::MaybeGetSerializedPingFrames(
                       << pending_ping_acks_.size()
                       << " next_allowed_ping_interval: "
                       << next_allowed_ping_interval;
-  DCHECK(!opaque_data_.has_value());
+  GRPC_DCHECK(!opaque_data_.has_value());
   std::vector<Http2Frame> frames;
   frames.reserve(pending_ping_acks_.size() + 1);  // +1 for the ping frame.
 
@@ -170,9 +176,9 @@ void PingManager::MaybeGetSerializedPingFrames(
   }
 }
 
-void PingManager::NotifyPingSent(const Duration ping_timeout) {
+void PingManager::NotifyPingSent() {
   if (opaque_data_.has_value()) {
-    SpawnTimeout(ping_timeout, opaque_data_.value());
+    SpawnTimeout(ping_timeout_, opaque_data_.value());
     SentPing();
     opaque_data_.reset();
   }

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

@@ -29,6 +29,7 @@
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/time.h"
 
@@ -71,7 +72,7 @@ class PingInterface {
 // returned by this class on the same transport party.
 class PingManager {
  public:
-  PingManager(const ChannelArgs& channel_args,
+  PingManager(const ChannelArgs& channel_args, Duration ping_timeout,
               std::unique_ptr<PingInterface> ping_interface,
               std::shared_ptr<grpc_event_engine::experimental::EventEngine>
                   event_engine);
@@ -83,7 +84,7 @@ class PingManager {
 
   // Notify the ping system that a ping has been sent. This will spawn a ping
   // timeout promise.
-  void NotifyPingSent(Duration ping_timeout);
+  void NotifyPingSent();
 
   // Ping Rate policy wrapper
   void ReceivedDataFrame() { ping_rate_policy_.ReceivedDataFrame(); }
@@ -132,7 +133,7 @@ class PingManager {
 
   std::optional<uint64_t> TestOnlyMaybeGetSerializedPingFrames(
       SliceBuffer& output_buffer, Duration next_allowed_ping_interval) {
-    DCHECK(!opaque_data_.has_value());
+    GRPC_DCHECK(!opaque_data_.has_value());
     if (NeedToPing(next_allowed_ping_interval)) {
       uint64_t opaque_data = ping_callbacks_.StartPing();
       Http2Frame frame = GetHttp2PingFrame(/*ack*/ false, opaque_data);
@@ -153,6 +154,7 @@ class PingManager {
         std::shared_ptr<grpc_event_engine::experimental::EventEngine>
             event_engine)
         : event_engine_(event_engine) {}
+    ~PingPromiseCallbacks() { CancelCallbacks(); }
     Promise<absl::Status> RequestPing(absl::AnyInvocable<void()> on_initiate,
                                       bool important);
     Promise<absl::Status> WaitForPingAck();
@@ -220,6 +222,8 @@ class PingManager {
   std::optional<uint64_t> opaque_data_;
   std::unique_ptr<PingInterface> ping_interface_;
   std::vector<uint64_t> pending_ping_acks_;
+  // Duration to wait before triggering a ping timeout.
+  Duration ping_timeout_;
 
   void TriggerDelayedPing(Duration wait);
   bool NeedToPing(Duration next_allowed_ping_interval);

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

@@ -21,9 +21,9 @@
 #include <optional>
 #include <ostream>
 
-#include "absl/strings/str_cat.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/util/match.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 

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

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 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/security_frame.h"
+
+#include <cstddef>
+#include <cstdint>
+
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/lib/transport/transport_framing_endpoint_extension.h"
+#include "absl/status/status.h"
+
+namespace grpc_core {
+
+// TODO(tjagtap) [PH2][P1] Implement
+
+}  // namespace grpc_core

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

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 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_SECURITY_FRAME_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_SECURITY_FRAME_H
+
+#include <grpc/slice.h>
+#include <stdint.h>
+
+#include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/lib/transport/transport_framing_endpoint_extension.h"
+
+namespace grpc_core {
+
+// TODO(tjagtap) [PH2][P1] Implement
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_SECURITY_FRAME_H