grpc 1.53.0 → 1.56.0

data/src/core/lib/json/json_writer.cc

@@ -145,9 +145,7 @@ void JsonWriter::EscapeString(const std::string& string) {
   OutputChar('"');
   for (size_t idx = 0; idx < string.size(); ++idx) {
     uint8_t c = static_cast<uint8_t>(string[idx]);
-    if (c == 0) {
-      break;
-    } else if (c >= 32 && c <= 126) {
+    if (c >= 32 && c <= 126) {
       if (c == '\\' || c == '"') OutputChar('\\');
       OutputChar(static_cast<char>(c));
     } else if (c < 32 || c == 127) {
@@ -243,7 +241,7 @@ void JsonWriter::EscapeString(const std::string& string) {
 void JsonWriter::ContainerBegins(Json::Type type) {
   if (!got_key_) ValueEnd();
   OutputIndent();
-  OutputChar(type == Json::Type::OBJECT ? '{' : '[');
+  OutputChar(type == Json::Type::kObject ? '{' : '[');
   container_empty_ = true;
   got_key_ = false;
   depth_++;
@@ -253,7 +251,7 @@ void JsonWriter::ContainerEnds(Json::Type type) {
   if (indent_ && !container_empty_) OutputChar('\n');
   depth_--;
   if (!container_empty_) OutputIndent();
-  OutputChar(type == Json::Type::OBJECT ? '}' : ']');
+  OutputChar(type == Json::Type::kObject ? '}' : ']');
   container_empty_ = false;
   got_key_ = false;
 }
@@ -281,43 +279,44 @@ void JsonWriter::ValueString(const std::string& string) {
 }
 
 void JsonWriter::DumpObject(const Json::Object& object) {
-  ContainerBegins(Json::Type::OBJECT);
+  ContainerBegins(Json::Type::kObject);
   for (const auto& p : object) {
     ObjectKey(p.first);
     DumpValue(p.second);
   }
-  ContainerEnds(Json::Type::OBJECT);
+  ContainerEnds(Json::Type::kObject);
 }
 
 void JsonWriter::DumpArray(const Json::Array& array) {
-  ContainerBegins(Json::Type::ARRAY);
+  ContainerBegins(Json::Type::kArray);
   for (const auto& v : array) {
     DumpValue(v);
   }
-  ContainerEnds(Json::Type::ARRAY);
+  ContainerEnds(Json::Type::kArray);
 }
 
 void JsonWriter::DumpValue(const Json& value) {
   switch (value.type()) {
-    case Json::Type::OBJECT:
-      DumpObject(value.object_value());
-      break;
-    case Json::Type::ARRAY:
-      DumpArray(value.array_value());
+    case Json::Type::kObject:
+      DumpObject(value.object());
       break;
-    case Json::Type::STRING:
-      ValueString(value.string_value());
+    case Json::Type::kArray:
+      DumpArray(value.array());
       break;
-    case Json::Type::NUMBER:
-      ValueRaw(value.string_value());
+    case Json::Type::kString:
+      ValueString(value.string());
       break;
-    case Json::Type::JSON_TRUE:
-      ValueRaw(std::string("true", 4));
+    case Json::Type::kNumber:
+      ValueRaw(value.string());
       break;
-    case Json::Type::JSON_FALSE:
-      ValueRaw(std::string("false", 5));
+    case Json::Type::kBoolean:
+      if (value.boolean()) {
+        ValueRaw(std::string("true", 4));
+      } else {
+        ValueRaw(std::string("false", 5));
+      }
       break;
-    case Json::Type::JSON_NULL:
+    case Json::Type::kNull:
       ValueRaw(std::string("null", 4));
       break;
     default:
@@ -333,8 +332,8 @@ std::string JsonWriter::Dump(const Json& value, int indent) {
 
 }  // namespace
 
-std::string Json::Dump(int indent) const {
-  return JsonWriter::Dump(*this, indent);
+std::string JsonDump(const Json& json, int indent) {
+  return JsonWriter::Dump(json, indent);
 }
 
 }  // namespace grpc_core

data/src/core/lib/{security/security_connector/ssl_utils_config.h → json/json_writer.h}

@@ -1,6 +1,5 @@
 //
-//
-// Copyright 2019 gRPC authors.
+// Copyright 2015 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -14,16 +13,21 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-//
 
-#ifndef GRPC_SRC_CORE_LIB_SECURITY_SECURITY_CONNECTOR_SSL_UTILS_CONFIG_H
-#define GRPC_SRC_CORE_LIB_SECURITY_SECURITY_CONNECTOR_SSL_UTILS_CONFIG_H
+#ifndef GRPC_SRC_CORE_LIB_JSON_JSON_WRITER_H
+#define GRPC_SRC_CORE_LIB_JSON_JSON_WRITER_H
+
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gprpp/global_config.h"
-#include "src/core/lib/gprpp/memory.h"
+#include <string>
+
+#include "src/core/lib/json/json.h"
+
+namespace grpc_core {
+
+// Dumps JSON from value to string form.
+std::string JsonDump(const Json& json, int indent = 0);
 
-GPR_GLOBAL_CONFIG_DECLARE_STRING(grpc_default_ssl_roots_file_path);
-GPR_GLOBAL_CONFIG_DECLARE_BOOL(grpc_not_use_system_ssl_roots);
+}  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_SECURITY_SECURITY_CONNECTOR_SSL_UTILS_CONFIG_H
+#endif  // GRPC_SRC_CORE_LIB_JSON_JSON_WRITER_H

data/src/core/lib/load_balancing/lb_policy.cc

@@ -69,19 +69,15 @@ LoadBalancingPolicy::SubchannelPicker::SubchannelPicker()
 LoadBalancingPolicy::PickResult LoadBalancingPolicy::QueuePicker::Pick(
     PickArgs /*args*/) {
   // We invoke the parent's ExitIdleLocked() via a closure instead
-  // of doing it directly here, for two reasons:
-  // 1. ExitIdleLocked() may cause the policy's state to change and
-  //    a new picker to be delivered to the channel.  If that new
-  //    picker is delivered before ExitIdleLocked() returns, then by
-  //    the time this function returns, the pick will already have
-  //    been processed, and we'll be trying to re-process the same
-  //    pick again, leading to a crash.
-  // 2. We are currently running in the data plane mutex, but we
-  //    need to bounce into the control plane work_serializer to call
-  //    ExitIdleLocked().
-  if (!exit_idle_called_ && parent_ != nullptr) {
-    exit_idle_called_ = true;
-    auto* parent = parent_->Ref().release();  // ref held by lambda.
+  // of doing it directly here because ExitIdleLocked() may cause the
+  // policy's state to change and a new picker to be delivered to the
+  // channel.  If that new picker is delivered before ExitIdleLocked()
+  // returns, then by the time this function returns, the pick will already
+  // have been processed, and we'll be trying to re-process the same pick
+  // again, leading to a crash.
+  MutexLock lock(&mu_);
+  if (parent_ != nullptr) {
+    auto* parent = parent_.release();  // ref held by lambda.
     ExecCtx::Run(DEBUG_LOCATION,
                  GRPC_CLOSURE_CREATE(
                      [](void* arg, grpc_error_handle /*error*/) {

data/src/core/lib/load_balancing/lb_policy.h

@@ -27,6 +27,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
@@ -44,6 +45,7 @@
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/load_balancing/subchannel_interface.h"
@@ -364,6 +366,19 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   /// whether the LB policy accepted the update; if non-OK, informs
   /// polling-based resolvers that they should go into backoff delay and
   /// eventually reattempt the resolution.
+  ///
+  /// The first time that UpdateLocked() is called, the LB policy will
+  /// generally not be able to determine the appropriate connectivity
+  /// state by the time UpdateLocked() returns (e.g., it will need to
+  /// wait for connectivity state notifications from each subchannel,
+  /// which will be delivered asynchronously).  In this case, the LB
+  /// policy should not call the helper's UpdateState() method until it
+  /// does have a clear picture of the connectivity state (e.g., it
+  /// should wait for all subchannels to report connectivity state
+  /// before calling the helper's UpdateState() method), although it is
+  /// expected to do so within some short period of time.  The parent of
+  /// the LB policy will assume that the policy's initial state is
+  /// CONNECTING and that picks should be queued.
   virtual absl::Status UpdateLocked(UpdateArgs) = 0;  // NOLINT
 
   /// Tries to enter a READY connectivity state.
@@ -392,8 +407,8 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     PickResult Pick(PickArgs args) override;
 
    private:
-    RefCountedPtr<LoadBalancingPolicy> parent_;
-    bool exit_idle_called_ = false;
+    Mutex mu_;
+    RefCountedPtr<LoadBalancingPolicy> parent_ ABSL_GUARDED_BY(&mu_);
   };
 
   // A picker that returns PickResult::Fail for all picks.

data/src/core/lib/load_balancing/lb_policy_registry.cc

@@ -31,6 +31,7 @@
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/load_balancing/lb_policy.h"
@@ -83,7 +84,7 @@ bool LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
   if (factory == nullptr) return false;
   // If requested, check if the load balancing policy allows an empty config.
   if (requires_config != nullptr) {
-    auto config = factory->ParseLoadBalancingConfig(Json());
+    auto config = factory->ParseLoadBalancingConfig(Json::FromObject({}));
     *requires_config = !config.ok();
   }
   return true;
@@ -94,23 +95,23 @@ bool LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
 absl::StatusOr<Json::Object::const_iterator>
 LoadBalancingPolicyRegistry::ParseLoadBalancingConfigHelper(
     const Json& lb_config_array) const {
-  if (lb_config_array.type() != Json::Type::ARRAY) {
+  if (lb_config_array.type() != Json::Type::kArray) {
     return absl::InvalidArgumentError("type should be array");
   }
   // Find the first LB policy that this client supports.
   std::vector<absl::string_view> policies_tried;
-  for (const Json& lb_config : lb_config_array.array_value()) {
-    if (lb_config.type() != Json::Type::OBJECT) {
+  for (const Json& lb_config : lb_config_array.array()) {
+    if (lb_config.type() != Json::Type::kObject) {
       return absl::InvalidArgumentError("child entry should be of type object");
     }
-    if (lb_config.object_value().empty()) {
+    if (lb_config.object().empty()) {
       return absl::InvalidArgumentError("no policy found in child entry");
     }
-    if (lb_config.object_value().size() > 1) {
+    if (lb_config.object().size() > 1) {
       return absl::InvalidArgumentError("oneOf violation");
     }
-    auto it = lb_config.object_value().begin();
-    if (it->second.type() != Json::Type::OBJECT) {
+    auto it = lb_config.object().begin();
+    if (it->second.type() != Json::Type::kObject) {
       return absl::InvalidArgumentError("child entry should be of type object");
     }
     // If we support this policy, then select it.

data/src/core/lib/matchers/matchers.cc

@@ -159,12 +159,11 @@ std::string StringMatcher::ToString() const {
 absl::StatusOr<HeaderMatcher> HeaderMatcher::Create(
     absl::string_view name, Type type, absl::string_view matcher,
     int64_t range_start, int64_t range_end, bool present_match,
-    bool invert_match) {
+    bool invert_match, bool case_sensitive) {
   if (static_cast<int>(type) < 5) {
     // Only for EXACT, PREFIX, SUFFIX, SAFE_REGEX and CONTAINS.
-    absl::StatusOr<StringMatcher> string_matcher =
-        StringMatcher::Create(static_cast<StringMatcher::Type>(type), matcher,
-                              /*case_sensitive=*/true);
+    absl::StatusOr<StringMatcher> string_matcher = StringMatcher::Create(
+        static_cast<StringMatcher::Type>(type), matcher, case_sensitive);
     if (!string_matcher.ok()) {
       return string_matcher.status();
     }

data/src/core/lib/matchers/matchers.h

@@ -113,7 +113,8 @@ class HeaderMatcher {
                                               int64_t range_start = 0,
                                               int64_t range_end = 0,
                                               bool present_match = false,
-                                              bool invert_match = false);
+                                              bool invert_match = false,
+                                              bool case_sensitive = true);
 
   HeaderMatcher() = default;
   HeaderMatcher(const HeaderMatcher& other);

data/src/core/lib/promise/activity.cc

@@ -19,10 +19,14 @@
 #include <stddef.h>
 
 #include <initializer_list>
+#include <vector>
 
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
 
 #include "src/core/lib/gprpp/atomic_utils.h"
+#include "src/core/lib/gprpp/crash.h"
 
 namespace grpc_core {
 
@@ -36,7 +40,9 @@ namespace promise_detail {
 ///////////////////////////////////////////////////////////////////////////////
 // HELPER TYPES
 
-std::string Unwakeable::ActivityDebugTag(void*) const { return "<unknown>"; }
+std::string Unwakeable::ActivityDebugTag(WakeupMask) const {
+  return "<unknown>";
+}
 
 // Weak handle to an Activity.
 // Handle can persist while Activity goes away.
@@ -58,7 +64,7 @@ class FreestandingActivity::Handle final : public Wakeable {
 
   // Activity needs to wake up (if it still exists!) - wake it up, and drop the
   // ref that was kept for this handle.
-  void Wakeup(void*) override ABSL_LOCKS_EXCLUDED(mu_) {
+  void Wakeup(WakeupMask) override ABSL_LOCKS_EXCLUDED(mu_) {
     mu_.Lock();
     // Note that activity refcount can drop to zero, but we could win the lock
     // against DropActivity, so we need to only increase activities refcount if
@@ -68,7 +74,7 @@ class FreestandingActivity::Handle final : public Wakeable {
       mu_.Unlock();
       // Activity still exists and we have a reference: wake it up, which will
       // drop the ref.
-      activity->Wakeup(nullptr);
+      activity->Wakeup(0);
     } else {
       // Could not get the activity - it's either gone or going. No need to wake
       // it up!
@@ -78,9 +84,13 @@ class FreestandingActivity::Handle final : public Wakeable {
     Unref();
   }
 
-  void Drop(void*) override { Unref(); }
+  void WakeupAsync(WakeupMask) override ABSL_LOCKS_EXCLUDED(mu_) {
+    Crash("not implemented");
+  }
+
+  void Drop(WakeupMask) override { Unref(); }
 
-  std::string ActivityDebugTag(void*) const override {
+  std::string ActivityDebugTag(WakeupMask) const override {
     MutexLock lock(&mu_);
     return activity_ == nullptr ? "<unknown>" : activity_->DebugTag();
   }
@@ -124,7 +134,7 @@ void FreestandingActivity::DropHandle() {
 
 Waker FreestandingActivity::MakeNonOwningWaker() {
   mu_.AssertHeld();
-  return Waker(RefHandle(), nullptr);
+  return Waker(RefHandle(), 0);
 }
 
 }  // namespace promise_detail
@@ -133,4 +143,15 @@ std::string Activity::DebugTag() const {
   return absl::StrFormat("ACTIVITY[%p]", this);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// INTRA ACTIVITY WAKER IMPLEMENTATION
+
+std::string IntraActivityWaiter::DebugString() const {
+  std::vector<int> bits;
+  for (size_t i = 0; i < 8 * sizeof(WakeupMask); i++) {
+    if (wakeups_ & (1 << i)) bits.push_back(i);
+  }
+  return absl::StrCat("{", absl::StrJoin(bits, ","), "}");
+}
+
 }  // namespace grpc_core

data/src/core/lib/promise/activity.h

@@ -32,30 +32,39 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/construct_destruct.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/no_destruct.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/detail/status.h"
+#include "src/core/lib/promise/poll.h"
 
 namespace grpc_core {
 
 class Activity;
 
+// WakeupMask is a bitfield representing which parts of an activity should be
+// woken up.
+using WakeupMask = uint16_t;
+
 // A Wakeable object is used by queues to wake activities.
 class Wakeable {
  public:
   // Wake up the underlying activity.
   // After calling, this Wakeable cannot be used again.
-  // arg comes from the Waker object and allows one Wakeable instance to be used
-  // for multiple disjoint subparts of an Activity.
-  virtual void Wakeup(void* arg) = 0;
+  // WakeupMask comes from the activity that created this Wakeable and specifies
+  // the set of promises that should be awoken.
+  virtual void Wakeup(WakeupMask wakeup_mask) = 0;
+  // Per Wakeup, but guarantee that the activity will be woken up out-of-line.
+  // Useful if there may be mutexes or the like held by the current thread.
+  virtual void WakeupAsync(WakeupMask wakeup_mask) = 0;
   // Drop this wakeable without waking up the underlying activity.
-  virtual void Drop(void* arg) = 0;
+  virtual void Drop(WakeupMask wakeup_mask) = 0;
 
   // Return the underlying activity debug tag, or "<unknown>" if not available.
-  virtual std::string ActivityDebugTag(void* arg) const = 0;
+  virtual std::string ActivityDebugTag(WakeupMask wakeup_mask) const = 0;
 
  protected:
   inline ~Wakeable() {}
@@ -63,9 +72,10 @@ class Wakeable {
 
 namespace promise_detail {
 struct Unwakeable final : public Wakeable {
-  void Wakeup(void*) override {}
-  void Drop(void*) override {}
-  std::string ActivityDebugTag(void*) const override;
+  void Wakeup(WakeupMask) override {}
+  void WakeupAsync(WakeupMask) override {}
+  void Drop(WakeupMask) override {}
+  std::string ActivityDebugTag(WakeupMask) const override;
 };
 static Unwakeable* unwakeable() {
   return NoDestructSingleton<Unwakeable>::Get();
@@ -76,8 +86,9 @@ static Unwakeable* unwakeable() {
 // This type is non-copyable but movable.
 class Waker {
  public:
-  Waker(Wakeable* wakeable, void* arg) : wakeable_and_arg_{wakeable, arg} {}
-  Waker() : Waker(promise_detail::unwakeable(), nullptr) {}
+  Waker(Wakeable* wakeable, WakeupMask wakeup_mask)
+      : wakeable_and_arg_{wakeable, wakeup_mask} {}
+  Waker() : Waker(promise_detail::unwakeable(), 0) {}
   ~Waker() { wakeable_and_arg_.Drop(); }
   Waker(const Waker&) = delete;
   Waker& operator=(const Waker&) = delete;
@@ -90,10 +101,12 @@ class Waker {
   // Wake the underlying activity.
   void Wakeup() { Take().Wakeup(); }
 
+  void WakeupAsync() { Take().WakeupAsync(); }
+
   template <typename H>
   friend H AbslHashValue(H h, const Waker& w) {
     return H::combine(H::combine(std::move(h), w.wakeable_and_arg_.wakeable),
-                      w.wakeable_and_arg_.arg);
+                      w.wakeable_and_arg_.wakeup_mask);
   }
 
   bool operator==(const Waker& other) const noexcept {
@@ -116,27 +129,43 @@ class Waker {
  private:
   struct WakeableAndArg {
     Wakeable* wakeable;
-    void* arg;
+    WakeupMask wakeup_mask;
 
-    void Wakeup() { wakeable->Wakeup(arg); }
-    void Drop() { wakeable->Drop(arg); }
+    void Wakeup() { wakeable->Wakeup(wakeup_mask); }
+    void WakeupAsync() { wakeable->WakeupAsync(wakeup_mask); }
+    void Drop() { wakeable->Drop(wakeup_mask); }
     std::string ActivityDebugTag() const {
       return wakeable == nullptr ? "<unknown>"
-                                 : wakeable->ActivityDebugTag(arg);
+                                 : wakeable->ActivityDebugTag(wakeup_mask);
     }
     bool operator==(const WakeableAndArg& other) const noexcept {
-      return wakeable == other.wakeable && arg == other.arg;
+      return wakeable == other.wakeable && wakeup_mask == other.wakeup_mask;
     }
   };
 
   WakeableAndArg Take() {
-    return std::exchange(wakeable_and_arg_,
-                         {promise_detail::unwakeable(), nullptr});
+    return std::exchange(wakeable_and_arg_, {promise_detail::unwakeable(), 0});
   }
 
   WakeableAndArg wakeable_and_arg_;
 };
 
+// Helper type to track wakeups between objects in the same activity.
+// Can be fairly fast as no ref counting or locking needs to occur.
+class IntraActivityWaiter {
+ public:
+  // Register for wakeup, return Pending(). If state is not ready to proceed,
+  // Promises should bottom out here.
+  Pending pending();
+  // Wake the activity
+  void Wake();
+
+  std::string DebugString() const;
+
+ private:
+  WakeupMask wakeups_ = 0;
+};
+
 // An Activity tracks execution of a single promise.
 // It executes the promise under a mutex.
 // When the promise stalls, it registers the containing activity to be woken up
@@ -156,7 +185,13 @@ class Activity : public Orphanable {
   void ForceWakeup() { MakeOwningWaker().Wakeup(); }
 
   // Force the current activity to immediately repoll if it doesn't complete.
-  virtual void ForceImmediateRepoll() = 0;
+  virtual void ForceImmediateRepoll(WakeupMask mask) = 0;
+  // Legacy version of ForceImmediateRepoll() that uses the current participant.
+  // Will go away once Party gets merged with Activity. New usage is banned.
+  void ForceImmediateRepoll() { ForceImmediateRepoll(CurrentParticipant()); }
+
+  // Return the current part of the activity as a bitmask
+  virtual WakeupMask CurrentParticipant() const { return 1; }
 
   // Return the current activity.
   // Additionally:
@@ -284,7 +319,7 @@ class FreestandingActivity : public Activity, private Wakeable {
  public:
   Waker MakeOwningWaker() final {
     Ref();
-    return Waker(this, nullptr);
+    return Waker(this, 0);
   }
   Waker MakeNonOwningWaker() final;
 
@@ -293,7 +328,7 @@ class FreestandingActivity : public Activity, private Wakeable {
     Unref();
   }
 
-  void ForceImmediateRepoll() final {
+  void ForceImmediateRepoll(WakeupMask) final {
     mu_.AssertHeld();
     SetActionDuringRun(ActionDuringRun::kWakeup);
   }
@@ -333,7 +368,7 @@ class FreestandingActivity : public Activity, private Wakeable {
 
   Mutex* mu() ABSL_LOCK_RETURNED(mu_) { return &mu_; }
 
-  std::string ActivityDebugTag(void*) const override { return DebugTag(); }
+  std::string ActivityDebugTag(WakeupMask) const override { return DebugTag(); }
 
  private:
   class Handle;
@@ -467,7 +502,7 @@ class PromiseActivity final
   // the activity to an external threadpool to run. If the activity is already
   // running on this thread, a note is taken of such and the activity is
   // repolled if it doesn't complete.
-  void Wakeup(void*) final {
+  void Wakeup(WakeupMask) final {
     // If there is an active activity, but hey it's us, flag that and we'll loop
     // in RunLoop (that's calling from above here!).
     if (Activity::is_current()) {
@@ -485,8 +520,10 @@ class PromiseActivity final
     }
   }
 
+  void WakeupAsync(WakeupMask) final { Crash("not implemented"); }
+
   // Drop a wakeup
-  void Drop(void*) final { this->WakeupComplete(); }
+  void Drop(WakeupMask) final { this->WakeupComplete(); }
 
   // Notification that we're no longer executing - it's ok to destruct the
   // promise.
@@ -593,6 +630,16 @@ ActivityPtr MakeActivity(Factory promise_factory,
           std::move(on_done), std::forward<Contexts>(contexts)...));
 }
 
+inline Pending IntraActivityWaiter::pending() {
+  wakeups_ |= Activity::current()->CurrentParticipant();
+  return Pending();
+}
+
+inline void IntraActivityWaiter::Wake() {
+  if (wakeups_ == 0) return;
+  Activity::current()->ForceImmediateRepoll(std::exchange(wakeups_, 0));
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_PROMISE_ACTIVITY_H

data/src/core/lib/promise/cancel_callback.h

@@ -0,0 +1,77 @@
+// Copyright 2022 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_LIB_PROMISE_CANCEL_CALLBACK_H
+#define GRPC_SRC_CORE_LIB_PROMISE_CANCEL_CALLBACK_H
+
+#include <grpc/support/port_platform.h>
+
+#include <utility>
+
+#include "src/core/lib/promise/detail/promise_like.h"
+
+namespace grpc_core {
+
+namespace cancel_callback_detail {
+
+template <typename Fn>
+class Handler {
+ public:
+  explicit Handler(Fn fn) : fn_(std::move(fn)) {}
+  Handler(const Handler&) = delete;
+  Handler& operator=(const Handler&) = delete;
+  ~Handler() {
+    if (!done_) {
+      fn_();
+    }
+  }
+  Handler(Handler&& other) noexcept
+      : fn_(std::move(other.fn_)), done_(other.done_) {
+    other.done_ = true;
+  }
+  Handler& operator=(Handler&& other) noexcept {
+    fn_ = std::move(other.fn_);
+    done_ = other.done_;
+    other.done_ = true;
+  }
+
+  void Done() { done_ = true; }
+
+ private:
+  Fn fn_;
+  bool done_ = false;
+};
+
+}  // namespace cancel_callback_detail
+
+// Wrap main_fn so that it calls cancel_fn if the promise is destroyed prior to
+// completion.
+// Returns a promise with the same result type as main_fn.
+template <typename MainFn, typename CancelFn>
+auto OnCancel(MainFn main_fn, CancelFn cancel_fn) {
+  return [on_cancel =
+              cancel_callback_detail::Handler<CancelFn>(std::move(cancel_fn)),
+          main_fn = promise_detail::PromiseLike<MainFn>(
+              std::move(main_fn))]() mutable {
+    auto r = main_fn();
+    if (r.ready()) {
+      on_cancel.Done();
+    }
+    return r;
+  };
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_CANCEL_CALLBACK_H