grpc 1.70.1 → 1.76.0

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

@@ -0,0 +1,83 @@
+//
+//
+// 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_HTTP2_TRANSPORT_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_TRANSPORT_H
+
+#include <cstdint>
+#include <utility>
+
+#include "src/core/call/call_spine.h"
+#include "src/core/call/metadata_info.h"
+#include "src/core/channelz/channelz.h"
+#include "src/core/ext/transport/chttp2/transport/flow_control.h"
+#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/lib/promise/mpsc.h"
+#include "src/core/lib/promise/party.h"
+#include "src/core/lib/transport/promise_endpoint.h"
+#include "src/core/lib/transport/transport.h"
+#include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/sync.h"
+
+namespace grpc_core {
+namespace http2 {
+
+// Experimental : This is just the initial skeleton of class
+// and it is functions. The code will be written iteratively.
+// Do not use or edit any of these functions unless you are
+// familiar with the PH2 project (Moving chttp2 to promises.)
+// TODO(tjagtap) : [PH2][P3] : Update the experimental status of the code before
+// http2 rollout begins.
+
+#define GRPC_HTTP2_CLIENT_DLOG \
+  DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
+
+#define GRPC_HTTP2_COMMON_DLOG \
+  DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
+
+// TODO(akshitpatel) : [PH2][P4] : Choose appropriate size later.
+constexpr uint32_t kStreamQueueSize = /*1 MB*/ 1024u * 1024u;
+constexpr uint32_t kMaxWriteSize = /*10 MB*/ 10u * 1024u * 1024u;
+
+enum class HttpStreamState : uint8_t {
+  // https://www.rfc-editor.org/rfc/rfc9113.html#name-stream-states
+  kIdle,
+  kOpen,
+  kHalfClosedLocal,
+  kHalfClosedRemote,
+  kClosed,
+};
+
+void InitLocalSettings(Http2Settings& settings, const bool is_client);
+
+void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
+                                 Http2Settings& local_settings,
+                                 chttp2::TransportFlowControl& flow_control,
+                                 const bool is_client);
+
+RefCountedPtr<channelz::SocketNode> CreateChannelzSocketNode(
+    std::shared_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+        event_engine_endpoint,
+    const ChannelArgs& args);
+
+}  // namespace http2
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_TRANSPORT_H

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

@@ -0,0 +1,267 @@
+// Copyright 2025 The 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_HTTP2_ZTRACE_COLLECTOR_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_ZTRACE_COLLECTOR_H
+
+#include <cstdint>
+#include <map>
+#include <string>
+
+#include "src/core/channelz/property_list.h"
+#include "src/core/channelz/ztrace_collector.h"
+#include "src/core/ext/transport/chttp2/transport/frame.h"
+
+namespace grpc_core {
+namespace http2_ztrace_collector_detail {
+
+class Config {
+ public:
+  explicit Config(const channelz::ZTrace::Args&) {}
+
+  template <typename T>
+  bool Finishes(const T&) {
+    return false;
+  }
+};
+
+}  // namespace http2_ztrace_collector_detail
+
+template <bool kRead>
+struct H2DataTrace {
+  uint32_t stream_id;
+  bool end_stream;
+  uint32_t payload_length;
+
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "DATA")
+        .Set("stream_id", stream_id)
+        .Set("end_stream", end_stream)
+        .Set("payload_length", payload_length);
+  }
+};
+
+template <bool kRead>
+struct H2HeaderTrace {
+  uint32_t stream_id;
+  bool end_headers;
+  bool end_stream;
+  bool continuation;
+  uint32_t payload_length;
+
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", continuation ? "CONTINUATION" : "HEADERS")
+        .Set("stream_id", stream_id)
+        .Set("end_headers", end_headers)
+        .Set("end_stream", end_stream)
+        .Set("payload_length", payload_length);
+  }
+};
+
+template <bool kRead>
+struct H2RstStreamTrace {
+  uint32_t stream_id;
+  uint32_t error_code;
+
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "RST_STREAM")
+        .Set("stream_id", stream_id)
+        .Set("error_code", error_code);
+  }
+};
+
+template <bool kRead>
+struct H2SettingsTrace {
+  bool ack;
+  std::vector<Http2SettingsFrame::Setting> settings;
+
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "SETTINGS")
+        .Set("ack", ack)
+        .Set("settings", [this]() {
+          channelz::PropertyTable table;
+          for (const auto& setting : settings) {
+            table.AppendRow(channelz::PropertyList()
+                                .Set("id", setting.id)
+                                .Set("value", setting.value));
+          }
+          return table;
+        }());
+  }
+};
+
+template <bool kRead>
+struct H2PingTrace {
+  bool ack;
+  uint64_t opaque;
+
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "PING")
+        .Set("ack", ack)
+        .Set("opaque", opaque);
+  }
+};
+
+template <bool kRead>
+struct H2GoAwayTrace {
+  uint32_t last_stream_id;
+  uint32_t error_code;
+  std::string debug_data;
+
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "GOAWAY")
+        .Set("last_stream_id", last_stream_id)
+        .Set("error_code", error_code)
+        .Set("debug_data", debug_data);
+  }
+};
+
+template <bool kRead>
+struct H2WindowUpdateTrace {
+  uint32_t stream_id;
+  uint32_t window_size_increment;
+
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "WINDOW_UPDATE")
+        .Set("stream_id", stream_id)
+        .Set("window_size_increment", window_size_increment);
+  }
+};
+
+template <bool kRead>
+struct H2SecurityTrace {
+  uint32_t payload_length;
+
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("read", kRead)
+        .Set("frame_type", "SECURITY")
+        .Set("payload_length", payload_length);
+  }
+};
+
+struct H2UnknownFrameTrace {
+  uint8_t type;
+  uint8_t flags;
+  uint32_t stream_id;
+  uint32_t payload_length;
+
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("frame_type", "UNKNOWN")
+        .Set("type", type)
+        .Set("flags", flags)
+        .Set("stream_id", stream_id)
+        .Set("payload_length", payload_length);
+  }
+};
+
+struct H2FlowControlStall {
+  int64_t transport_window;
+  int64_t stream_window;
+  uint32_t stream_id;
+
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("frame_type", "FLOW_CONTROL_STALL")
+        .Set("transport_window", transport_window)
+        .Set("stream_window", stream_window)
+        .Set("stream_id", stream_id);
+  }
+};
+
+struct H2BeginWriteCycle {
+  uint32_t target_size;
+
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("frame_type", "BEGIN_WRITE_CYCLE")
+        .Set("target_size", target_size);
+  }
+};
+
+struct H2BeginEndpointWrite {
+  uint32_t write_size;
+
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set("frame_type", "BEGIN_ENDPOINT_WRITE")
+        .Set("write_size", write_size);
+  }
+};
+
+struct H2EndWriteCycle {
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList().Set("frame_type", "END_WRITE_CYCLE");
+  }
+};
+
+using Http2ZTraceCollector = channelz::ZTraceCollector<
+    http2_ztrace_collector_detail::Config, H2DataTrace<false>,
+    H2HeaderTrace<false>, H2RstStreamTrace<false>, H2SettingsTrace<false>,
+    H2PingTrace<false>, H2GoAwayTrace<false>, H2WindowUpdateTrace<false>,
+    H2SecurityTrace<false>, H2DataTrace<true>, H2HeaderTrace<true>,
+    H2RstStreamTrace<true>, H2SettingsTrace<true>, H2PingTrace<true>,
+    H2GoAwayTrace<true>, H2WindowUpdateTrace<true>, H2SecurityTrace<true>,
+    H2UnknownFrameTrace, H2FlowControlStall, H2BeginWriteCycle, H2EndWriteCycle,
+    H2BeginEndpointWrite>;
+
+struct PromiseEndpointReadTrace {
+  uint64_t bytes;
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList().Set("read_bytes", bytes);
+  }
+};
+
+struct PromiseEndpointWriteTrace {
+  uint64_t bytes;
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList().Set("written_bytes", bytes);
+  }
+};
+
+namespace promise_http2_ztrace_collector_detail {
+class Config {
+ public:
+  explicit Config(const channelz::ZTrace::Args&) {}
+
+  template <typename T>
+  bool Finishes(const T&) {
+    return false;
+  }
+};
+}  // namespace promise_http2_ztrace_collector_detail
+
+using PromiseHttp2ZTraceCollector =
+    channelz::ZTraceCollector<promise_http2_ztrace_collector_detail::Config,
+                              PromiseEndpointReadTrace,
+                              PromiseEndpointWriteTrace>;
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_ZTRACE_COLLECTOR_H

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

@@ -30,17 +30,17 @@
 
 #include <atomic>
 #include <memory>
+#include <optional>
 #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 "absl/types/optional.h"
-#include "absl/types/variant.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"
-#include "src/core/ext/transport/chttp2/transport/context_list_entry.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/frame_goaway.h"
 #include "src/core/ext/transport/chttp2/transport/frame_ping.h"
@@ -51,10 +51,13 @@
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h"
+#include "src/core/ext/transport/chttp2/transport/internal_channel_arg_names.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/ext/transport/chttp2/transport/ping_abuse_policy.h"
 #include "src/core/ext/transport/chttp2/transport/ping_callbacks.h"
 #include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
+#include "src/core/ext/transport/chttp2/transport/transport_common.h"
 #include "src/core/ext/transport/chttp2/transport/write_size_policy.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
@@ -69,10 +72,11 @@
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/surface/init_internally.h"
 #include "src/core/lib/transport/connectivity_state.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/lib/transport/transport_framing_endpoint_extension.h"
 #include "src/core/telemetry/call_tracer.h"
+#include "src/core/telemetry/context_list_entry.h"
+#include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/tcp_tracer.h"
 #include "src/core/util/bitset.h"
 #include "src/core/util/debug_location.h"
@@ -111,6 +115,7 @@ typedef enum {
   GRPC_CHTTP2_WRITE_STATE_WRITING_WITH_MORE,
 } grpc_chttp2_write_state;
 
+// Not getting used anywhere AFAIK
 typedef enum {
   GRPC_CHTTP2_OPTIMIZE_FOR_LATENCY,
   GRPC_CHTTP2_OPTIMIZE_FOR_THROUGHPUT,
@@ -230,6 +235,23 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
                         bool is_client);
   ~grpc_chttp2_transport() override;
 
+  class ChannelzDataSource final : public grpc_core::channelz::DataSource {
+   public:
+    explicit ChannelzDataSource(grpc_chttp2_transport* transport)
+        : grpc_core::channelz::DataSource(transport->channelz_socket),
+          transport_(transport->Ref()) {  // Take a ref
+      SourceConstructed();
+    }
+    ~ChannelzDataSource() { SourceDestructing(); }
+
+    void AddData(grpc_core::channelz::DataSink sink) override;
+    std::unique_ptr<grpc_core::channelz::ZTrace> GetZTrace(
+        absl::string_view name) override;
+
+   private:
+    grpc_core::RefCountedPtr<grpc_chttp2_transport> transport_;
+  };
+
   void Orphan() override;
 
   grpc_core::RefCountedPtr<grpc_chttp2_transport> Ref() {
@@ -251,6 +273,10 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   grpc_core::ServerTransport* server_transport() override { return nullptr; }
 
   absl::string_view GetTransportName() const override;
+  grpc_core::RefCountedPtr<grpc_core::channelz::SocketNode> GetSocketNode()
+      const override {
+    return channelz_socket;
+  }
   void InitStream(grpc_stream* gs, grpc_stream_refcount* refcount,
                   const void* server_data, grpc_core::Arena* arena) override;
   void SetPollset(grpc_stream* stream, grpc_pollset* pollset) override;
@@ -262,6 +288,9 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   void WriteSecurityFrame(grpc_core::SliceBuffer* data);
   void WriteSecurityFrameLocked(grpc_core::SliceBuffer* data);
 
+  // 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.
   grpc_core::OrphanablePtr<grpc_endpoint> ep;
   grpc_core::Mutex ep_destroy_mu;  // Guards endpoint destruction only.
 
@@ -273,10 +302,11 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   grpc_core::MemoryOwner memory_owner;
   const grpc_core::MemoryAllocator::Reservation self_reservation;
   grpc_core::ReclamationSweep active_reclamation;
+  grpc_core::InstrumentStorageRefPtr<grpc_core::ResourceQuotaDomain>
+      resource_quota_telemetry_storage;
 
   std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine;
   grpc_core::Combiner* combiner;
-  absl::BitGen bitgen;
 
   // On the client side, when the transport is first created, the
   // endpoint will already have been added to this pollset_set, and it
@@ -472,9 +502,11 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   grpc_event_engine::experimental::EventEngine::TaskHandle
       keepalive_ping_timer_handle =
           grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid;
-  ;
   /// time duration in between pings
   grpc_core::Duration keepalive_time;
+  /// Tracks any adjustments to the absolute timestamp of the next keepalive
+  /// timer callback execution.
+  grpc_core::Timestamp next_adjusted_keepalive_timestamp;
   /// grace period to wait for data after sending a ping before keepalives
   /// timeout
   grpc_core::Duration keepalive_timeout;
@@ -486,6 +518,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   uint32_t max_header_list_size_soft_limit = 0;
   grpc_core::ContextList* context_list = nullptr;
   grpc_core::RefCountedPtr<grpc_core::channelz::SocketNode> channelz_socket;
+  std::unique_ptr<ChannelzDataSource> channelz_data_source;
   uint32_t num_messages_in_next_write = 0;
   /// The number of pending induced frames (SETTINGS_ACK, PINGS_ACK and
   /// RST_STREAM) in the outgoing buffer (t->qbuf). If this number goes beyond
@@ -558,6 +591,9 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   grpc_core::Timestamp last_window_update_time =
       grpc_core::Timestamp::InfPast();
 
+  std::shared_ptr<grpc_core::Http2StatsCollector> http2_stats;
+  grpc_core::Http2ZTraceCollector http2_ztrace_collector;
+
   GPR_NO_UNIQUE_ADDRESS grpc_core::latent_see::Flow write_flow;
 };
 
@@ -606,7 +642,7 @@ struct grpc_chttp2_stream {
   grpc_metadata_batch* recv_initial_metadata;
   grpc_closure* recv_initial_metadata_ready = nullptr;
   bool* trailing_metadata_available = nullptr;
-  absl::optional<grpc_core::SliceBuffer>* recv_message = nullptr;
+  std::optional<grpc_core::SliceBuffer>* recv_message = nullptr;
   uint32_t* recv_message_flags = nullptr;
   bool* call_failed_before_recv_message = nullptr;
   grpc_closure* recv_message_ready = nullptr;
@@ -668,14 +704,22 @@ struct grpc_chttp2_stream {
   int64_t write_counter = 0;
 
   grpc_core::Chttp2CallTracerWrapper call_tracer_wrapper;
-
-  /// Only set when enabled.
-  // TODO(roth): Remove this when the call_tracer_in_transport
-  // experiment finishes rolling out.
-  grpc_core::CallTracerAnnotationInterface* call_tracer = nullptr;
-
-  /// Only set when enabled.
-  std::shared_ptr<grpc_core::TcpTracerInterface> tcp_tracer;
+  // null by default, set by the transport data source upon first query
+  grpc_core::RefCountedPtr<grpc_core::channelz::CallNode> channelz_call_node;
+
+  // TODO(yashykt): Remove call_tracer field after transition to call v3. (See
+  // https://github.com/grpc/grpc/pull/38729 for more information.)
+  // In the transport, we use tracers for two things, recording byte stats and
+  // recording annotations. Recording byte stats is safe as long as call_tracer
+  // is non null. Recording annotations on the other hand is only safe after
+  // send_initial_metadata. On the client, this is not an issue since that is
+  // the first operation. On the server, we would ideally be able to record
+  // annotations as soon as we have parsed initial metadata, but in our legacy
+  // stack, we create the stream before parsing headers. In the new v3 stack,
+  // that won't be an issue.
+  grpc_core::CallTracer* call_tracer = nullptr;
+  // TODO(yashykt): Remove this once call_tracer_transport_fix is rolled out
+  grpc_core::CallTracerAnnotationInterface* parent_call_tracer = nullptr;
 
   // time this stream was created
   gpr_timespec creation_time = gpr_now(GPR_CLOCK_MONOTONIC);
@@ -699,19 +743,6 @@ struct grpc_chttp2_stream {
       grpc_core::Timestamp::InfPast();
 };
 
-#define GRPC_ARG_PING_TIMEOUT_MS "grpc.http2.ping_timeout_ms"
-
-// EXPERIMENTAL: provide protection against overloading a server with too many
-// requests: wait for streams to be deallocated before they stop counting
-// against MAX_CONCURRENT_STREAMS
-#define GRPC_ARG_MAX_CONCURRENT_STREAMS_OVERLOAD_PROTECTION \
-  "grpc.http.overload_protection"
-
-// EXPERIMENTAL: Fail requests at the client if the client is over max
-// concurrent streams, so they may be retried elsewhere.
-#define GRPC_ARG_MAX_CONCURRENT_STREAMS_REJECT_ON_CLIENT \
-  "grpc.http.max_concurrent_streams_reject_on_client"
-
 /// Transport writing call flow:
 /// grpc_chttp2_initiate_write() is called anywhere that we know bytes need to
 /// go out on the wire.
@@ -727,6 +758,11 @@ struct grpc_chttp2_stream {
 void grpc_chttp2_initiate_write(grpc_chttp2_transport* t,
                                 grpc_chttp2_initiate_write_reason reason);
 
+struct TcpCallTracerWithOffset {
+  std::shared_ptr<grpc_core::TcpCallTracer> tcp_call_tracer;
+  size_t byte_offset;
+};
+
 struct grpc_chttp2_begin_write_result {
   /// are we writing?
   bool writing;
@@ -734,6 +770,8 @@ struct grpc_chttp2_begin_write_result {
   bool partial;
   /// did we queue any completions as part of beginning the write
   bool early_results_scheduled;
+  /// Tcp Call Tracers if any
+  std::vector<TcpCallTracerWithOffset> tcp_call_tracers;
 };
 grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
     grpc_chttp2_transport* t);
@@ -744,7 +782,7 @@ void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error_handle error);
 ///  - a count of parsed bytes in the event of a partial read: the caller should
 ///    offload responsibilities to another thread to continue parsing.
 ///  - or a status in the case of a completed read
-absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
+std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
     grpc_chttp2_transport* t, const grpc_slice& slice,
     size_t& requests_started);
 
@@ -790,10 +828,6 @@ void grpc_chttp2_settings_timeout(
 #define GRPC_HEADER_SIZE_IN_BYTES 5
 #define MAX_SIZE_T (~(size_t)0)
 
-#define GRPC_CHTTP2_CLIENT_CONNECT_STRING "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
-#define GRPC_CHTTP2_CLIENT_CONNECT_STRLEN \
-  (sizeof(GRPC_CHTTP2_CLIENT_CONNECT_STRING) - 1)
-
 #define GRPC_CHTTP2_IF_TRACING(severity) \
   LOG_IF(severity, GRPC_TRACE_FLAG_ENABLED(http))
 

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

@@ -0,0 +1,24 @@
+//
+//
+// 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_INTERNAL_CHANNEL_ARG_NAMES_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_CHANNEL_ARG_NAMES_H
+
+#define GRPC_ARG_PING_TIMEOUT_MS "grpc.http2.ping_timeout_ms"
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_CHANNEL_ARG_NAMES_H