grpc 1.73.0 → 1.75.0

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

@@ -0,0 +1,121 @@
+//
+//
+// 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/http2_transport.h"
+
+#include <cstdint>
+#include <utility>
+
+#include "src/core/call/call_spine.h"
+#include "src/core/call/metadata_info.h"
+#include "src/core/ext/transport/chttp2/transport/frame.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.)
+
+void InitLocalSettings(Http2Settings& settings, const bool is_client) {
+  if (is_client) {
+    // gRPC has never supported PUSH_PROMISE and we have no plan to do so in the
+    // future.
+    settings.SetEnablePush(false);
+    // This is to make it double-sure that server cannot initite a stream.
+    settings.SetMaxConcurrentStreams(0);
+  }
+  settings.SetMaxHeaderListSize(DEFAULT_MAX_HEADER_LIST_SIZE);
+  settings.SetAllowTrueBinaryMetadata(true);
+}
+
+void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
+                                 Http2Settings& settings,
+                                 const bool is_client) {
+  if (channel_args.Contains(GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER)) {
+    settings.SetHeaderTableSize(
+        channel_args.GetInt(GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER)
+            .value_or(-1));
+  }
+
+  if (channel_args.Contains(GRPC_ARG_MAX_CONCURRENT_STREAMS)) {
+    if (!is_client) {
+      settings.SetMaxConcurrentStreams(
+          channel_args.GetInt(GRPC_ARG_MAX_CONCURRENT_STREAMS).value_or(-1));
+    } else {
+      // We do not allow the channel arg to alter our 0 setting for
+      // MAX_CONCURRENT_STREAMS for clients because we dont support PUSH_PROMISE
+      LOG(WARNING) << "ChannelArg GRPC_ARG_MAX_CONCURRENT_STREAMS is not "
+                      "available on clients";
+    }
+  }
+
+  if (channel_args.Contains(GRPC_ARG_HTTP2_STREAM_LOOKAHEAD_BYTES)) {
+    settings.SetInitialWindowSize(
+        channel_args.GetInt(GRPC_ARG_HTTP2_STREAM_LOOKAHEAD_BYTES)
+            .value_or(-1));
+    // TODO(tjagtap) [PH2][P2] : Also set this for flow control.
+    // Refer to read_channel_args() in chttp2_transport.cc for more details.
+  }
+
+  settings.SetMaxHeaderListSize(GetHardLimitFromChannelArgs(channel_args));
+
+  if (channel_args.Contains(GRPC_ARG_HTTP2_MAX_FRAME_SIZE)) {
+    settings.SetMaxFrameSize(
+        channel_args.GetInt(GRPC_ARG_HTTP2_MAX_FRAME_SIZE).value_or(-1));
+  }
+
+  if (channel_args
+          .GetBool(GRPC_ARG_EXPERIMENTAL_HTTP2_PREFERRED_CRYPTO_FRAME_SIZE)
+          .value_or(false)) {
+    settings.SetPreferredReceiveCryptoMessageSize(INT_MAX);
+  }
+
+  if (channel_args.Contains(GRPC_ARG_HTTP2_ENABLE_TRUE_BINARY)) {
+    settings.SetAllowTrueBinaryMetadata(
+        channel_args.GetInt(GRPC_ARG_HTTP2_ENABLE_TRUE_BINARY).value_or(-1) !=
+        0);
+  }
+
+  settings.SetAllowSecurityFrame(
+      channel_args.GetBool(GRPC_ARG_SECURITY_FRAME_ALLOWED).value_or(false));
+
+  GRPC_HTTP2_COMMON_DLOG
+      << "Http2Settings: {"
+      << "header_table_size: " << settings.header_table_size()
+      << ", max_concurrent_streams: " << settings.max_concurrent_streams()
+      << ", initial_window_size: " << settings.initial_window_size()
+      << ", max_frame_size: " << settings.max_frame_size()
+      << ", max_header_list_size: " << settings.max_header_list_size()
+      << ", preferred_receive_crypto_message_size: "
+      << settings.preferred_receive_crypto_message_size()
+      << ", enable_push: " << settings.enable_push()
+      << ", allow_true_binary_metadata: "
+      << settings.allow_true_binary_metadata()
+      << ", allow_security_frame: " << settings.allow_security_frame() << "}";
+}
+
+}  // namespace http2
+}  // namespace grpc_core

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

@@ -0,0 +1,76 @@
+//
+//
+// 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/ext/transport/chttp2/transport/frame.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings.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))
+
+// Timeout for getting an ack back on settings changes
+#define GRPC_ARG_SETTINGS_TIMEOUT "grpc.http2.settings_timeout"
+
+// TODO(akshitpatel) : [PH2][P2] : Choose appropriate size later.
+constexpr int kMpscSize = 10;
+constexpr uint32_t kStreamQueueSize = /*1 MB*/ 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& settings, const bool is_client);
+
+}  // 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

@@ -43,8 +43,6 @@ struct H2DataTrace {
   bool end_stream;
   uint32_t payload_length;
 
-  size_t MemoryUsage() const { return sizeof(*this); }
-
   void RenderJson(Json::Object& json) const {
     json["read"] = Json::FromBool(kRead);
     json["frame_type"] = Json::FromString("DATA");
@@ -62,8 +60,6 @@ struct H2HeaderTrace {
   bool continuation;
   uint32_t payload_length;
 
-  size_t MemoryUsage() const { return sizeof(*this); }
-
   void RenderJson(Json::Object& json) const {
     json["read"] = Json::FromBool(kRead);
     json["frame_type"] = continuation ? Json::FromString("CONTINUATION")
@@ -80,8 +76,6 @@ struct H2RstStreamTrace {
   uint32_t stream_id;
   uint32_t error_code;
 
-  size_t MemoryUsage() const { return sizeof(*this); }
-
   void RenderJson(Json::Object& json) const {
     json["read"] = Json::FromBool(kRead);
     json["frame_type"] = Json::FromString("RST_STREAM");
@@ -95,11 +89,6 @@ struct H2SettingsTrace {
   bool ack;
   std::vector<Http2SettingsFrame::Setting> settings;
 
-  size_t MemoryUsage() const {
-    return sizeof(*this) +
-           sizeof(Http2SettingsFrame::Setting) * settings.size();
-  }
-
   void RenderJson(Json::Object& json) const {
     json["read"] = Json::FromBool(kRead);
     json["frame_type"] = Json::FromString("SETTINGS");
@@ -120,8 +109,6 @@ struct H2PingTrace {
   bool ack;
   uint64_t opaque;
 
-  size_t MemoryUsage() const { return sizeof(*this); }
-
   void RenderJson(Json::Object& json) const {
     json["read"] = Json::FromBool(kRead);
     json["frame_type"] = Json::FromString("PING");
@@ -136,8 +123,6 @@ struct H2GoAwayTrace {
   uint32_t error_code;
   std::string debug_data;
 
-  size_t MemoryUsage() const { return sizeof(*this) + debug_data.size(); }
-
   void RenderJson(Json::Object& json) const {
     json["read"] = Json::FromBool(kRead);
     json["frame_type"] = Json::FromString("GOAWAY");
@@ -152,8 +137,6 @@ struct H2WindowUpdateTrace {
   uint32_t stream_id;
   uint32_t window_size_increment;
 
-  size_t MemoryUsage() const { return sizeof(*this); }
-
   void RenderJson(Json::Object& json) const {
     json["read"] = Json::FromBool(kRead);
     json["frame_type"] = Json::FromString("WINDOW_UPDATE");
@@ -166,8 +149,6 @@ template <bool kRead>
 struct H2SecurityTrace {
   uint32_t payload_length;
 
-  size_t MemoryUsage() const { return sizeof(*this); }
-
   void RenderJson(Json::Object& json) const {
     json["read"] = Json::FromBool(kRead);
     json["frame_type"] = Json::FromString("SECURITY");
@@ -181,8 +162,6 @@ struct H2UnknownFrameTrace {
   uint32_t stream_id;
   uint32_t payload_length;
 
-  size_t MemoryUsage() const { return sizeof(*this); }
-
   void RenderJson(Json::Object& json) const {
     json["frame_type"] = Json::FromString("UNKNOWN");
     json["type"] = Json::FromNumber(type);
@@ -197,8 +176,6 @@ struct H2FlowControlStall {
   int64_t stream_window;
   uint32_t stream_id;
 
-  size_t MemoryUsage() const { return sizeof(*this); }
-
   void RenderJson(Json::Object& json) const {
     json["metadata_type"] = Json::FromString("FLOW_CONTROL_STALL");
     json["transport_window"] = Json::FromNumber(transport_window);
@@ -210,8 +187,6 @@ struct H2FlowControlStall {
 struct H2BeginWriteCycle {
   uint32_t target_size;
 
-  size_t MemoryUsage() const { return sizeof(*this); }
-
   void RenderJson(Json::Object& json) const {
     json["metadata_type"] = Json::FromString("BEGIN_WRITE_CYCLE");
     json["target_size"] = Json::FromNumber(target_size);
@@ -221,8 +196,6 @@ struct H2BeginWriteCycle {
 struct H2BeginEndpointWrite {
   uint32_t write_size;
 
-  size_t MemoryUsage() const { return sizeof(*this); }
-
   void RenderJson(Json::Object& json) const {
     json["metadata_type"] = Json::FromString("BEGIN_ENDPOINT_WRITE");
     json["write_size"] = Json::FromNumber(write_size);
@@ -230,8 +203,6 @@ struct H2BeginEndpointWrite {
 };
 
 struct H2EndWriteCycle {
-  size_t MemoryUsage() const { return sizeof(*this); }
-
   void RenderJson(Json::Object& json) const {
     json["metadata_type"] = Json::FromString("END_WRITE_CYCLE");
   }

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

@@ -57,6 +57,7 @@
 #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"
@@ -76,6 +77,7 @@
 #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"
 #include "src/core/util/ref_counted.h"
@@ -236,10 +238,12 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
    public:
     explicit ChannelzDataSource(grpc_chttp2_transport* transport)
         : grpc_core::channelz::DataSource(transport->channelz_socket),
-          transport_(transport) {}
-    ~ChannelzDataSource() { ResetDataSource(); }
+          transport_(transport) {
+      SourceConstructed();
+    }
+    ~ChannelzDataSource() { SourceDestructing(); }
 
-    void AddData(grpc_core::channelz::DataSink& sink) override;
+    void AddData(grpc_core::channelz::DataSink sink) override;
     std::unique_ptr<grpc_core::channelz::ZTrace> GetZTrace(
         absl::string_view name) override;
 
@@ -283,6 +287,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.
 
@@ -581,7 +588,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   grpc_core::Timestamp last_window_update_time =
       grpc_core::Timestamp::InfPast();
 
-  grpc_core::Http2StatsCollector http2_stats;
+  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;
@@ -759,6 +766,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;
@@ -766,6 +778,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);
@@ -822,10 +836,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/keepalive.cc

@@ -0,0 +1,105 @@
+//
+//
+// 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/keepalive.h"
+
+#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/race.h"
+#include "src/core/lib/promise/sleep.h"
+#include "src/core/lib/promise/try_seq.h"
+
+namespace grpc_core {
+namespace http2 {
+KeepaliveManager::KeepaliveManager(
+    std::unique_ptr<KeepAliveInterface> keep_alive_interface,
+    Duration keepalive_timeout, const Duration keepalive_time)
+    : keep_alive_interface_(std::move(keep_alive_interface)),
+      keepalive_timeout_(keepalive_timeout),
+      keepalive_time_(keepalive_time) {}
+
+auto KeepaliveManager::WaitForKeepAliveTimeout() {
+  return AssertResultType<absl::Status>(
+      TrySeq(Sleep(keepalive_timeout_), [this] {
+        return If(
+            data_received_in_last_cycle_,
+            [] {
+              GRPC_HTTP2_KEEPALIVE_LOG
+                  << "Keepalive timeout triggered but "
+                  << "received data. Resolving with ok status";
+              return Immediate(absl::OkStatus());
+            },
+            [this] {
+              GRPC_HTTP2_KEEPALIVE_LOG
+                  << "Keepalive timeout triggered and no "
+                     "data received. Triggering keepalive timeout.";
+              // Once the keepalive timeout is triggered, ensure that
+              // WaitForData() is never resolved. This is needed as the
+              // keepalive loop should break once the timeout is triggered.
+              keep_alive_timeout_triggered_ = true;
+              return TrySeq(keep_alive_interface_->OnKeepAliveTimeout(), [] {
+                return absl::CancelledError("keepalive timeout");
+              });
+            });
+      }));
+}
+auto KeepaliveManager::TimeoutAndSendPing() {
+  DCHECK(!data_received_in_last_cycle_);
+  DCHECK(keepalive_timeout_ != Duration::Infinity());
+
+  return AllOk<absl::Status>(Race(WaitForData(), WaitForKeepAliveTimeout()),
+                             SendPingAndWaitForAck());
+}
+auto KeepaliveManager::MaybeSendKeepAlivePing() {
+  GRPC_HTTP2_KEEPALIVE_LOG << "KeepaliveManager::MaybeSendKeepAlivePing";
+  return AssertResultType<absl::Status>(
+      TrySeq(If(
+                 NeedToSendKeepAlivePing(),
+                 [this]() {
+                   return If(
+                       keepalive_timeout_ != Duration::Infinity(),
+                       [this] { return TimeoutAndSendPing(); },
+                       [this] { return SendPingAndWaitForAck(); });
+                 },
+                 []() { return Immediate(absl::OkStatus()); }),
+             [this] {
+               data_received_in_last_cycle_ = false;
+               return Immediate(absl::OkStatus());
+             }));
+}
+
+void KeepaliveManager::Spawn(Party* party) {
+  if (!IsKeepAliveNeeded()) {
+    GRPC_HTTP2_KEEPALIVE_LOG << "Not spawning keepalive loop.";
+    return;
+  }
+  keep_alive_spawned_ = true;
+
+  party->Spawn("KeepAliveLoop", Loop([this]() {
+                 return TrySeq(
+                     Sleep(keepalive_time_),
+                     [this]() { return MaybeSendKeepAlivePing(); },
+                     []() -> LoopCtl<absl::Status> { return Continue(); });
+               }),
+               [](auto status) {
+                 GRPC_HTTP2_KEEPALIVE_LOG << "KeepAlive end with status: "
+                                          << status;
+               });
+}
+}  // namespace http2
+}  // namespace grpc_core

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

@@ -0,0 +1,138 @@
+//
+//
+// 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_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"
+
+namespace grpc_core {
+namespace http2 {
+
+#define GRPC_HTTP2_KEEPALIVE_LOG VLOG(2)
+
+class KeepAliveInterface {
+ public:
+  // Returns a promise that sends a ping frame and resolves when the ack is
+  // received.
+  virtual Promise<absl::Status> SendPingAndWaitForAck() = 0;
+
+  // Returns a promise that processes the keepalive timeout.
+  virtual Promise<absl::Status> OnKeepAliveTimeout() = 0;
+
+  // Returns true if a keepalive ping needs to be sent.
+  virtual bool NeedToSendKeepAlivePing() = 0;
+  virtual ~KeepAliveInterface() = default;
+};
+
+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);
+
+  // Needs to be called when any data is read from the endpoint.
+  void GotData() {
+    if (keep_alive_timeout_triggered_) {
+      GRPC_HTTP2_KEEPALIVE_LOG
+          << "KeepAlive timeout triggered. Not setting data_received_ to true";
+      return;
+    }
+    GRPC_HTTP2_KEEPALIVE_LOG << "Data received. Setting data_received_ to true";
+    data_received_in_last_cycle_ = true;
+    auto waker = std::move(waker_);
+    // This will only trigger a wakeup if WaitForData() is pending on this
+    // waker. Otherwise this would be noop.
+    waker.Wakeup();
+  }
+  void SetKeepAliveTimeout(Duration keepalive_timeout) {
+    keepalive_timeout_ = keepalive_timeout;
+  }
+
+ private:
+  // Returns a promise that sleeps for the keepalive_timeout_ and triggers the
+  // keepalive timeout unless data is read within the keepalive timeout.
+  auto WaitForKeepAliveTimeout();
+
+  // Returns a promise that sends a keepalive ping and spawns the keepalive
+  // timeout promise. The promise resolves in the following scenarios:
+  // 1. Ping ack is received within the keepalive timeout (when the ping ack is
+  //     received, a call to GotData() is expected).
+  // 2. Ping ack is received after keepalive timeout (but before the ping
+  //     timeout). In this case, if there is some data received while
+  //     waiting for ping ack, the keepalive timeout is not triggered and the
+  //     promise resolves when SendPingAndWaitForAck() resolves.
+  // 3. No data is received within the keepalive timeout and the keepalive
+  //    timeout is triggered.
+  auto TimeoutAndSendPing();
+
+  // Returns a promise that determines if a keepalive ping needs to be sent and
+  // sends a keepalive ping if needed. The promise resolves when either a ping
+  // ack is received or the keepalive timeout is triggered.
+  auto MaybeSendKeepAlivePing();
+
+  auto WaitForData() {
+    return [this]() -> Poll<absl::Status> {
+      if (data_received_in_last_cycle_) {
+        GRPC_HTTP2_KEEPALIVE_LOG << "WaitForData: Data received. Poll resolved";
+        return absl::OkStatus();
+      } else {
+        GRPC_HTTP2_KEEPALIVE_LOG
+            << "WaitForData: Data not received. Poll pending";
+        waker_ = GetContext<Activity>()->MakeNonOwningWaker();
+        return Pending{};
+      }
+    };
+  }
+  auto SendPingAndWaitForAck() {
+    DCHECK_EQ(data_received_in_last_cycle_, false);
+    return keep_alive_interface_->SendPingAndWaitForAck();
+  }
+
+  // If no data is received in the last keepalive_time, we should send a
+  // keepalive ping. This also means that there can be scenarios where we would
+  // send one keepalive ping in ~(2*keepalive_time).
+  bool NeedToSendKeepAlivePing() {
+    return (!data_received_in_last_cycle_) &&
+           (keep_alive_interface_->NeedToSendKeepAlivePing());
+  }
+
+  bool IsKeepAliveNeeded() {
+    return (keepalive_time_ != Duration::Infinity() && !keep_alive_spawned_);
+  }
+
+  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 keepalive_timeout_;
+  const Duration keepalive_time_;
+  bool data_received_in_last_cycle_ = false;
+  bool keep_alive_timeout_triggered_ = false;
+  bool keep_alive_spawned_ = false;
+  Waker waker_;
+};
+
+}  // namespace http2
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_KEEPALIVE_H