grpc 1.78.0 → 1.80.0.pre1

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

@@ -23,6 +23,7 @@
 #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/promise.h"
 #include "src/core/lib/promise/race.h"
 #include "src/core/lib/promise/sleep.h"
 #include "src/core/lib/promise/try_seq.h"
@@ -33,12 +34,10 @@ namespace grpc_core {
 namespace http2 {
 KeepaliveManager::KeepaliveManager(
     std::unique_ptr<KeepAliveInterface> keep_alive_interface,
-    Duration keepalive_timeout, const Duration keepalive_time, Party* party)
+    Duration keepalive_timeout, const Duration keepalive_time)
     : keep_alive_interface_(std::move(keep_alive_interface)),
       keepalive_timeout_(keepalive_timeout),
-      keepalive_time_(keepalive_time) {
-  MaybeSpawnKeepaliveLoop(party);
-}
+      keepalive_time_(keepalive_time) {}
 
 auto KeepaliveManager::WaitForKeepAliveTimeout() {
   return AssertResultType<absl::Status>(
@@ -90,23 +89,18 @@ auto KeepaliveManager::MaybeSendKeepAlivePing() {
              }));
 }
 
-void KeepaliveManager::MaybeSpawnKeepaliveLoop(Party* party) {
-  if (!IsKeepAliveNeeded()) {
-    GRPC_HTTP2_KEEPALIVE_LOG << "Not spawning keepalive loop.";
-    return;
-  }
-  keep_alive_spawned_ = true;
+bool KeepaliveManager::IsKeepAliveLoopNeeded() {
+  return IsKeepAliveNeeded() && !keep_alive_spawned_;
+}
 
-  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;
-               });
+Promise<absl::Status> KeepaliveManager::KeepaliveLoop() {
+  GRPC_HTTP2_KEEPALIVE_LOG << "KeepaliveManager::KeepaliveLoop Spawning.";
+  keep_alive_spawned_ = true;
+  return Loop([this]() {
+    return TrySeq(
+        Sleep(keepalive_time_), [this]() { return MaybeSendKeepAlivePing(); },
+        []() -> LoopCtl<absl::Status> { return Continue(); });
+  });
 }
 }  // namespace http2
 }  // namespace grpc_core

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

@@ -18,8 +18,10 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_KEEPALIVE_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_KEEPALIVE_H
 
+#include "src/core/lib/promise/loop.h"
 #include "src/core/lib/promise/party.h"
 #include "src/core/lib/promise/promise.h"
+#include "src/core/lib/promise/sleep.h"
 #include "src/core/util/grpc_check.h"
 #include "absl/status/status.h"
 
@@ -45,8 +47,7 @@ class KeepAliveInterface {
 class KeepaliveManager {
  public:
   KeepaliveManager(std::unique_ptr<KeepAliveInterface> keep_alive_interface,
-                   Duration keepalive_timeout, Duration keepalive_time,
-                   Party* party);
+                   Duration keepalive_timeout, Duration keepalive_time);
 
   // Needs to be called when any data is read from the endpoint.
   void GotData() {
@@ -66,11 +67,13 @@ class KeepaliveManager {
     keepalive_timeout_ = keepalive_timeout;
   }
 
- 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);
+  bool IsKeepAliveLoopNeeded();
+
+  // Returns a promise that processes keepalive pings. This MUST be called at
+  // most once during the lifetime of the keepalive manager.
+  Promise<absl::Status> KeepaliveLoop();
 
+ 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();

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

@@ -754,6 +754,17 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
       GRPC_CHTTP2_IF_TRACING(ERROR) << "grpc_chttp2_stream not accepted";
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
     }
+
+    uint32_t current_open_streams = t->stream_map.size() + t->extra_streams;
+    if (t->max_concurrent_streams_overload_protection) {
+      current_open_streams =
+          t->streams_allocated.load(std::memory_order_relaxed);
+    }
+
+    t->settings.mutable_local().UpdateMaxConcurrentStreams(
+        t->stream_quota->GetConnectionMaxConcurrentRequests(
+            current_open_streams));
+
     if (GRPC_TRACE_FLAG_ENABLED(http) ||
         GRPC_TRACE_FLAG_ENABLED(chttp2_new_stream)) {
       LOG(INFO) << "[t:" << t << " fd:" << grpc_endpoint_get_fd(t->ep.get())

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

@@ -17,31 +17,33 @@
 //
 #include "src/core/ext/transport/chttp2/transport/ping_promise.h"
 
+#include <cstdint>
 #include <memory>
+#include <optional>
 #include <utility>
+#include <vector>
 
+#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
+#include "src/core/ext/transport/chttp2/transport/write_cycle.h"
 #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/lib/promise/poll.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/match.h"
 #include "src/core/util/time.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+#include "absl/types/span.h"
 
 namespace grpc_core {
 namespace http2 {
 using Callback = absl::AnyInvocable<void()>;
 using grpc_event_engine::experimental::EventEngine;
 
-#define GRPC_HTTP2_PING_LOG                                \
-  LOG_IF(INFO, (GRPC_TRACE_FLAG_ENABLED(http) ||           \
-                GRPC_TRACE_FLAG_ENABLED(bdp_estimator) ||  \
-                GRPC_TRACE_FLAG_ENABLED(http_keepalive) || \
-                GRPC_TRACE_FLAG_ENABLED(http2_ping)))
-
 Promise<absl::Status> PingManager::PingPromiseCallbacks::RequestPing(
     Callback on_initiate, bool important) {
   important_ping_requested_ = (important_ping_requested_ || important);
@@ -68,28 +70,10 @@ PingManager::PingManager(const ChannelArgs& channel_args, Duration ping_timeout,
       ping_interface_(std::move(ping_interface)),
       ping_timeout_(ping_timeout) {}
 
-void PingManager::TriggerDelayedPing(const Duration wait) {
-  // Spawn at most once.
-  if (delayed_ping_spawned_) {
-    return;
-  }
-  delayed_ping_spawned_ = true;
-  GetContext<Party>()->Spawn(
-      "DelayedPing",
-      // TODO(akshitpatel) : [PH2][P2] : Verify if we need a RefCountedPtr for
-      // ping_manager.
-      [this, wait]() mutable {
-        GRPC_HTTP2_PING_LOG << "Scheduling delayed ping after wait=" << wait;
-        return AssertResultType<absl::Status>(TrySeq(
-            Sleep(wait),
-            [this]() mutable { return ping_interface_->TriggerWrite(); }));
-      },
-      [this](auto) { delayed_ping_spawned_ = false; });
-}
-
-bool PingManager::NeedToPing(const Duration next_allowed_ping_interval) {
+PingManager::TriggerPingArgs PingManager::NeedToPing(
+    const Duration next_allowed_ping_interval) {
   if (!ping_callbacks_.PingRequested()) {
-    return false;
+    return TriggerPingArgs(std::nullopt, /*need_to_ping=*/false);
   }
 
   return Match(
@@ -100,13 +84,13 @@ bool PingManager::NeedToPing(const Duration next_allowed_ping_interval) {
         GRPC_HTTP2_PING_LOG << "CLIENT" << "[" << "PH2"
                             << "]: Ping sent"
                             << ping_rate_policy_.GetDebugString();
-        return true;
+        return TriggerPingArgs(std::nullopt, /*need_to_ping=*/true);
       },
       [this](Chttp2PingRatePolicy::TooManyRecentPings) {
         GRPC_HTTP2_PING_LOG << "CLIENT" << "[" << "PH2"
                             << "]: Ping delayed too many recent pings: "
                             << ping_rate_policy_.GetDebugString();
-        return false;
+        return TriggerPingArgs(std::nullopt, /*need_to_ping=*/false);
       },
       [this](Chttp2PingRatePolicy::TooSoon too_soon) mutable {
         GRPC_HTTP2_PING_LOG
@@ -115,73 +99,49 @@ bool PingManager::NeedToPing(const Duration next_allowed_ping_interval) {
             << too_soon.last_ping
             << ", minimum wait:" << too_soon.next_allowed_ping_interval
             << ", need to wait:" << too_soon.wait;
-        TriggerDelayedPing(too_soon.wait);
-        return false;
+        std::optional<Duration> delayed_ping_wait;
+        if (!std::exchange(delayed_ping_spawned_, true)) {
+          delayed_ping_wait = too_soon.wait;
+        }
+        return TriggerPingArgs(delayed_ping_wait, /*need_to_ping=*/false);
       });
 }
 
-void PingManager::SpawnTimeout(const Duration ping_timeout,
-                               const uint64_t opaque_data) {
-  GetContext<Party>()->Spawn(
-      "PingTimeout",
-      // TODO(akshitpatel) : [PH2][P2] : Verify if we need a RefCountedPtr for
-      // ping_manager.
-      [this, ping_timeout, opaque_data]() {
-        return AssertResultType<absl::Status>(Race(
-            TrySeq(ping_callbacks_.PingTimeout(ping_timeout),
-                   [this, opaque_data](bool trigger_ping_timeout) mutable {
-                     return If(
-                         trigger_ping_timeout,
-                         [this, opaque_data]() {
-                           GRPC_HTTP2_PING_LOG
-                               << " Ping ack not received for id="
-                               << opaque_data << ". Ping timeout triggered.";
-                           return ping_interface_->PingTimeout();
-                         },
-                         []() { return absl::OkStatus(); });
-                   }),
-            ping_callbacks_.WaitForPingAck()));
-      },
-      [](auto) {});
-}
-
-void PingManager::MaybeGetSerializedPingFrames(
-    SliceBuffer& output_buffer, const Duration next_allowed_ping_interval) {
+std::optional<Duration> PingManager::MaybeGetSerializedPingFrames(
+    FrameSender& frame_sender, Duration next_allowed_ping_interval) {
   GRPC_HTTP2_PING_LOG << "PingManager MaybeGetSerializedPingFrames "
                          "pending_ping_acks_ size: "
                       << pending_ping_acks_.size()
                       << " next_allowed_ping_interval: "
                       << next_allowed_ping_interval;
   GRPC_DCHECK(!opaque_data_.has_value());
-  std::vector<Http2Frame> frames;
-  frames.reserve(pending_ping_acks_.size() + 1);  // +1 for the ping frame.
+  frame_sender.ReserveRegularFrames(pending_ping_acks_.size() + 1);
 
   // Get the serialized ping acks if needed.
   for (uint64_t opaque_data : pending_ping_acks_) {
-    frames.emplace_back(GetHttp2PingFrame(/*ack=*/true, opaque_data));
+    frame_sender.AddRegularFrame(GetHttp2PingFrame(/*ack=*/true, opaque_data));
   }
   pending_ping_acks_.clear();
 
   // Get the serialized ping frame if needed.
-  if (NeedToPing(next_allowed_ping_interval)) {
+  TriggerPingArgs trigger_ping_args = NeedToPing(next_allowed_ping_interval);
+  if (trigger_ping_args.need_to_ping) {
     const uint64_t opaque_data = ping_callbacks_.StartPing();
-    frames.emplace_back(GetHttp2PingFrame(/*ack=*/false, opaque_data));
+    frame_sender.AddRegularFrame(GetHttp2PingFrame(/*ack=*/false, opaque_data));
     opaque_data_ = opaque_data;
     GRPC_HTTP2_PING_LOG << "Created ping frame for id= " << opaque_data;
   }
 
-  // Serialize the frames if any.
-  if (!frames.empty()) {
-    Serialize(absl::Span<Http2Frame>(frames), output_buffer);
-  }
+  return trigger_ping_args.delayed_ping_wait;
 }
 
-void PingManager::NotifyPingSent() {
+std::optional<uint64_t> PingManager::NotifyPingSent() {
   if (opaque_data_.has_value()) {
-    SpawnTimeout(ping_timeout_, opaque_data_.value());
     SentPing();
-    opaque_data_.reset();
+    return std::exchange(opaque_data_, std::nullopt);
   }
+
+  return std::nullopt;
 }
 
 void PingManager::AddPendingPingAck(const uint64_t opaque_data) {

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

@@ -18,24 +18,44 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_PROMISE_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_PROMISE_H
 
+#include <cstddef>
+#include <cstdint>
 #include <memory>
+#include <optional>
+#include <utility>
+#include <vector>
 
 #include "src/core/ext/transport/chttp2/transport/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/write_cycle.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/promise/if.h"
 #include "src/core/lib/promise/inter_activity_latch.h"
 #include "src/core/lib/promise/map.h"
+#include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/promise.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/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"
+#include "absl/functional/any_invocable.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
 
 namespace grpc_core {
 namespace http2 {
 
+#define GRPC_HTTP2_PING_LOG                                \
+  LOG_IF(INFO, (GRPC_TRACE_FLAG_ENABLED(http) ||           \
+                GRPC_TRACE_FLAG_ENABLED(bdp_estimator) ||  \
+                GRPC_TRACE_FLAG_ENABLED(http_keepalive) || \
+                GRPC_TRACE_FLAG_ENABLED(http2_ping)))
+
 // Ping Promise Spawns Overview
 
 // | Promise Spawn   | Max Duration | Promise      | Max Spawns              |
@@ -60,7 +80,7 @@ namespace http2 {
 class PingInterface {
  public:
   // Returns a promise that triggers a write cycle on the transport.
-  virtual Promise<absl::Status> TriggerWrite() = 0;
+  virtual absl::Status TriggerWrite() = 0;
 
   // Returns a promise that handles the ping timeout.
   virtual Promise<absl::Status> PingTimeout() = 0;
@@ -71,83 +91,17 @@ class PingInterface {
 // single thread. This guarantee is achieved by spawning all the promises
 // returned by this class on the same transport party.
 class PingManager {
- public:
-  PingManager(const ChannelArgs& channel_args, Duration ping_timeout,
-              std::unique_ptr<PingInterface> ping_interface,
-              std::shared_ptr<grpc_event_engine::experimental::EventEngine>
-                  event_engine);
-
-  // If there are any pending ping requests or ping acks, populates the output
-  // buffer with the serialized ping frames.
-  void MaybeGetSerializedPingFrames(SliceBuffer& output_buf,
-                                    Duration next_allowed_ping_interval);
-
-  // Notify the ping system that a ping has been sent. This will spawn a ping
-  // timeout promise.
-  void NotifyPingSent();
-
-  // Ping Rate policy wrapper
-  void ReceivedDataFrame() { ping_rate_policy_.ReceivedDataFrame(); }
-
-  // Ping abuse policy wrapper
-  bool NotifyPingAbusePolicy(const bool transport_idle) {
-    return ping_abuse_policy_.ReceivedOnePing(transport_idle);
-  }
-
-  void ResetPingClock(bool is_client) {
-    if (!is_client) {
-      ping_abuse_policy_.ResetPingStrikes();
-    }
-    ping_rate_policy_.ResetPingsBeforeDataRequired();
-  }
-
-  // Ping callbacks wrapper
-
-  // Returns a promise that resolves once a new ping is initiated and ack is
-  // received for the same. The on_initiate callback is executed when the
-  // ping is initiated.
-  auto RequestPing(absl::AnyInvocable<void()> on_initiate, bool important) {
-    return ping_callbacks_.RequestPing(std::move(on_initiate), important);
-  }
-
-  // Returns a promise that resolves once the next valid ping ack is received.
-  auto WaitForPingAck() { return ping_callbacks_.WaitForPingAck(); }
-
-  // Cancels all the callbacks for the inflight pings. This function does not
-  // cancel the promises that are waiting on the ping ack.
-  // This should be called as part of closing the transport to free up any
-  // memory in use by the ping callbacks.
-  void CancelCallbacks() { ping_callbacks_.CancelCallbacks(); }
-
-  uint64_t StartPing() { return ping_callbacks_.StartPing(); }
-  bool PingRequested() { return ping_callbacks_.PingRequested(); }
-  bool ImportantPingRequested() const {
-    return ping_callbacks_.ImportantPingRequested();
-  }
-  bool AckPing(uint64_t id) { return ping_callbacks_.AckPing(id); }
-  size_t CountPingInflight() { return ping_callbacks_.CountPingInflight(); }
-
-  Http2Frame GetHttp2PingFrame(uint64_t opaque_data) {
-    return Http2PingFrame{/*ack=*/false, opaque_data};
-  }
-
-  std::optional<uint64_t> TestOnlyMaybeGetSerializedPingFrames(
-      SliceBuffer& output_buffer, Duration next_allowed_ping_interval) {
-    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);
-      Serialize(absl::Span<Http2Frame>(&frame, 1), output_buffer);
-      opaque_data_ = opaque_data;
-      return opaque_data;
+ private:
+  struct TriggerPingArgs {
+    TriggerPingArgs(std::optional<Duration> delayed_ping_wait,
+                    bool need_to_ping)
+        : delayed_ping_wait(delayed_ping_wait), need_to_ping(need_to_ping) {
+      GRPC_DCHECK(!(delayed_ping_wait.has_value() && need_to_ping));
     }
 
-    return std::nullopt;
-  }
-
-  void AddPendingPingAck(uint64_t opaque_data);
-
- private:
+    std::optional<Duration> delayed_ping_wait;
+    bool need_to_ping;
+  };
   class PingPromiseCallbacks {
    public:
     explicit PingPromiseCallbacks(
@@ -225,11 +179,101 @@ class PingManager {
   // Duration to wait before triggering a ping timeout.
   Duration ping_timeout_;
 
-  void TriggerDelayedPing(Duration wait);
-  bool NeedToPing(Duration next_allowed_ping_interval);
-  void SpawnTimeout(Duration ping_timeout, uint64_t opaque_data);
+  TriggerPingArgs NeedToPing(Duration next_allowed_ping_interval);
 
   void SentPing() { ping_rate_policy_.SentPing(); }
+
+ public:
+  PingManager(const ChannelArgs& channel_args, Duration ping_timeout,
+              std::unique_ptr<PingInterface> ping_interface,
+              std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+                  event_engine);
+
+  // If there are any pending ping requests or ping acks, populates the output
+  // buffer with the serialized ping frames. Returns the arguments for
+  // scheduling the delayed ping.
+  std::optional<Duration> MaybeGetSerializedPingFrames(
+      FrameSender& frame_sender, Duration next_allowed_ping_interval);
+
+  // Notify the ping system that a ping has been sent. Returns the opaque data
+  // of the ping frame if a new ping was sent. The caller is expected to
+  // spawn a ping timeout promise using TimeoutPromise() for this returned
+  // value.
+  std::optional<uint64_t> NotifyPingSent();
+
+  // Ping Rate policy wrapper
+  void ReceivedDataFrame() { ping_rate_policy_.ReceivedDataFrame(); }
+
+  // Ping abuse policy wrapper
+  bool NotifyPingAbusePolicy(const bool transport_idle) {
+    return ping_abuse_policy_.ReceivedOnePing(transport_idle);
+  }
+
+  void ResetPingClock(bool is_client) {
+    if (!is_client) {
+      ping_abuse_policy_.ResetPingStrikes();
+    }
+    ping_rate_policy_.ResetPingsBeforeDataRequired();
+  }
+
+  // Ping callbacks wrapper
+
+  // Returns a promise that resolves once a new ping is initiated and ack is
+  // received for the same. The on_initiate callback is executed when the
+  // ping is initiated.
+  auto RequestPing(absl::AnyInvocable<void()> on_initiate, bool important) {
+    return ping_callbacks_.RequestPing(std::move(on_initiate), important);
+  }
+
+  // Returns a promise that resolves once the next valid ping ack is received.
+  auto WaitForPingAck() { return ping_callbacks_.WaitForPingAck(); }
+
+  // Cancels all the callbacks for the inflight pings. This function does not
+  // cancel the promises that are waiting on the ping ack.
+  // This should be called as part of closing the transport to free up any
+  // memory in use by the ping callbacks.
+  void CancelCallbacks() { ping_callbacks_.CancelCallbacks(); }
+
+  uint64_t StartPing() { return ping_callbacks_.StartPing(); }
+  bool PingRequested() { return ping_callbacks_.PingRequested(); }
+  bool ImportantPingRequested() const {
+    return ping_callbacks_.ImportantPingRequested();
+  }
+  bool AckPing(uint64_t id) { return ping_callbacks_.AckPing(id); }
+  size_t CountPingInflight() { return ping_callbacks_.CountPingInflight(); }
+
+  Http2Frame GetHttp2PingFrame(uint64_t opaque_data) {
+    return Http2PingFrame{/*ack=*/false, opaque_data};
+  }
+
+  void AddPendingPingAck(uint64_t opaque_data);
+
+  auto TimeoutPromise(const uint64_t opaque_data) {
+    return AssertResultType<absl::Status>(Race(
+        TrySeq(ping_callbacks_.PingTimeout(ping_timeout_),
+               [this, opaque_data](bool trigger_ping_timeout) mutable {
+                 return If(
+                     trigger_ping_timeout,
+                     [this, opaque_data]() {
+                       GRPC_HTTP2_PING_LOG
+                           << " Ping ack not received for id=" << opaque_data
+                           << ". Ping timeout triggered.";
+                       return ping_interface_->PingTimeout();
+                     },
+                     []() { return absl::OkStatus(); });
+               }),
+        ping_callbacks_.WaitForPingAck()));
+  };
+
+  auto DelayedPingPromise(const Duration wait) {
+    return TrySeq(
+        Sleep(wait),
+        [this]() mutable { return ping_interface_->TriggerWrite(); },
+        [this]() {
+          delayed_ping_spawned_ = false;
+          return absl::OkStatus();
+        });
+  }
 };
 }  // namespace http2
 }  // namespace grpc_core