grpc 1.55.0 → 1.56.0

data/src/core/lib/json/json.h

@@ -19,175 +19,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <map>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "absl/types/variant.h"
+#include <grpc/support/json.h>
 
 namespace grpc_core {
 
-// A JSON value, which can be any one of object, array, string,
-// number, true, false, or null.
-class Json {
- public:
-  // TODO(roth): Currently, numbers are stored internally as strings,
-  // which makes the API a bit cumbersome to use. When we have time,
-  // consider whether there's a better alternative (e.g., maybe storing
-  // each numeric type as the native C++ type and automatically converting
-  // to string as needed).
-  enum class Type { kNull, kTrue, kFalse, kNumber, kString, kObject, kArray };
-
-  using Object = std::map<std::string, Json>;
-  using Array = std::vector<Json>;
-
-  Json() = default;
-
-  // Copyable.
-  Json(const Json& other) = default;
-  Json& operator=(const Json& other) = default;
-
-  // Moveable.
-  Json(Json&& other) noexcept : value_(std::move(other.value_)) {
-    other.value_ = absl::monostate();
-  }
-  Json& operator=(Json&& other) noexcept {
-    value_ = std::move(other.value_);
-    other.value_ = absl::monostate();
-    return *this;
-  }
-
-  // Construct from copying a string.
-  // If is_number is true, the type will be kNumber instead of kString.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(const std::string& string, bool is_number = false)
-      : value_(is_number ? Value(NumberValue{string}) : Value(string)) {}
-  Json& operator=(const std::string& string) {
-    value_ = string;
-    return *this;
-  }
-
-  // Same thing for C-style strings, both const and mutable.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(const char* string, bool is_number = false)
-      : Json(std::string(string), is_number) {}
-  Json& operator=(const char* string) {
-    *this = std::string(string);
-    return *this;
-  }
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(char* string, bool is_number = false)
-      : Json(std::string(string), is_number) {}
-  Json& operator=(char* string) {
-    *this = std::string(string);
-    return *this;
-  }
-
-  // Construct by moving a string.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(std::string&& string) : value_(Value(std::move(string))) {}
-  Json& operator=(std::string&& string) {
-    value_ = Value(std::move(string));
-    return *this;
-  }
-
-  // Construct from bool.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(bool b) : value_(b) {}
-  Json& operator=(bool b) {
-    value_ = b;
-    return *this;
-  }
-
-  // Construct from any numeric type.
-  template <typename NumericType>
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(NumericType number) : value_(NumberValue{std::to_string(number)}) {}
-  template <typename NumericType>
-  Json& operator=(NumericType number) {
-    value_ = NumberValue{std::to_string(number)};
-    return *this;
-  }
-
-  // Construct by copying object.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(const Object& object) : value_(object) {}
-  Json& operator=(const Object& object) {
-    value_ = object;
-    return *this;
-  }
-
-  // Construct by moving object.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(Object&& object) : value_(std::move(object)) {}
-  Json& operator=(Object&& object) {
-    value_ = std::move(object);
-    return *this;
-  }
-
-  // Construct by copying array.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(const Array& array) : value_(array) {}
-  Json& operator=(const Array& array) {
-    value_ = array;
-    return *this;
-  }
-
-  // Construct by moving array.
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  Json(Array&& array) : value_(std::move(array)) {}
-  Json& operator=(Array&& array) {
-    value_ = std::move(array);
-    return *this;
-  }
-
-  // Returns the JSON type.
-  Type type() const {
-    struct ValueFunctor {
-      Json::Type operator()(const absl::monostate&) { return Type::kNull; }
-      Json::Type operator()(bool value) {
-        return value ? Type::kTrue : Type::kFalse;
-      }
-      Json::Type operator()(const NumberValue&) { return Type::kNumber; }
-      Json::Type operator()(const std::string&) { return Type::kString; }
-      Json::Type operator()(const Object&) { return Type::kObject; }
-      Json::Type operator()(const Array&) { return Type::kArray; }
-    };
-    return absl::visit(ValueFunctor(), value_);
-  }
-
-  // Accessor methods.
-  const std::string& string() const {
-    const NumberValue* num = absl::get_if<NumberValue>(&value_);
-    if (num != nullptr) return num->value;
-    return absl::get<std::string>(value_);
-  }
-  const Object& object() const { return absl::get<Object>(value_); }
-  const Array& array() const { return absl::get<Array>(value_); }
-
-  bool operator==(const Json& other) const { return value_ == other.value_; }
-  bool operator!=(const Json& other) const { return !(*this == other); }
-
- private:
-  struct NumberValue {
-    std::string value;
-
-    bool operator==(const NumberValue& other) const {
-      return value == other.value;
-    }
-  };
-  using Value = absl::variant<absl::monostate,  // kNull
-                              bool,             // kTrue or kFalse
-                              NumberValue,      // kNumber
-                              std::string,      // kString
-                              Object,           // kObject
-                              Array>;           // kArray
-
-  explicit Json(Value value) : value_(std::move(value)) {}
-
-  Value value_;
-};
+using Json = experimental::Json;
 
 }  // namespace grpc_core
 

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

@@ -22,6 +22,8 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/strip.h"
 
+#include <grpc/support/json.h>
+
 namespace grpc_core {
 namespace json_detail {
 
@@ -91,13 +93,11 @@ bool LoadNumber::IsNumber() const { return true; }
 
 void LoadBool::LoadInto(const Json& json, const JsonArgs&, void* dst,
                         ValidationErrors* errors) const {
-  if (json.type() == Json::Type::kTrue) {
-    *static_cast<bool*>(dst) = true;
-  } else if (json.type() == Json::Type::kFalse) {
-    *static_cast<bool*>(dst) = false;
-  } else {
+  if (json.type() != Json::Type::kBoolean) {
     errors->AddError("is not a boolean");
+    return;
   }
+  *static_cast<bool*>(dst) = json.boolean();
 }
 
 void LoadUnprocessedJsonObject::LoadInto(const Json& json, const JsonArgs&,
@@ -168,9 +168,8 @@ void LoadMap::LoadInto(const Json& json, const JsonArgs& args, void* dst,
   }
 }
 
-void LoadOptional::LoadInto(const Json& json, const JsonArgs& args, void* dst,
-                            ValidationErrors* errors) const {
-  if (json.type() == Json::Type::kNull) return;
+void LoadWrapped::LoadInto(const Json& json, const JsonArgs& args, void* dst,
+                           ValidationErrors* errors) const {
   void* element = Emplace(dst);
   size_t starting_error_size = errors->size();
   ElementLoader()->LoadInto(json, args, element, errors);
@@ -191,7 +190,7 @@ bool LoadObject(const Json& json, const JsonArgs& args, const Element* elements,
     ValidationErrors::ScopedField field(errors,
                                         absl::StrCat(".", element.name));
     const auto& it = json.object().find(element.name);
-    if (it == json.object().end()) {
+    if (it == json.object().end() || it->second.type() == Json::Type::kNull) {
       if (element.optional) continue;
       errors->AddError("field not present");
       continue;

data/src/core/lib/json/json_object_loader.h

@@ -253,14 +253,14 @@ class LoadMap : public LoaderInterface {
   virtual const LoaderInterface* ElementLoader() const = 0;
 };
 
-// Load an optional of some type.
-class LoadOptional : public LoaderInterface {
+// Load a wrapped value of some type.
+class LoadWrapped : public LoaderInterface {
  public:
   void LoadInto(const Json& json, const JsonArgs& args, void* dst,
                 ValidationErrors* errors) const override;
 
  protected:
-  ~LoadOptional() = default;
+  ~LoadWrapped() = default;
 
  private:
   virtual void* Emplace(void* dst) const = 0;
@@ -392,7 +392,7 @@ class AutoLoader<std::map<std::string, T>> final : public LoadMap {
 
 // Specializations of AutoLoader for absl::optional<>.
 template <typename T>
-class AutoLoader<absl::optional<T>> final : public LoadOptional {
+class AutoLoader<absl::optional<T>> final : public LoadWrapped {
  public:
   void* Emplace(void* dst) const final {
     return &static_cast<absl::optional<T>*>(dst)->emplace();
@@ -410,7 +410,7 @@ class AutoLoader<absl::optional<T>> final : public LoadOptional {
 
 // Specializations of AutoLoader for std::unique_ptr<>.
 template <typename T>
-class AutoLoader<std::unique_ptr<T>> final : public LoadOptional {
+class AutoLoader<std::unique_ptr<T>> final : public LoadWrapped {
  public:
   void* Emplace(void* dst) const final {
     auto& p = *static_cast<std::unique_ptr<T>*>(dst);
@@ -428,6 +428,26 @@ class AutoLoader<std::unique_ptr<T>> final : public LoadOptional {
   ~AutoLoader() = default;
 };
 
+// Specializations of AutoLoader for RefCountedPtr<>.
+template <typename T>
+class AutoLoader<RefCountedPtr<T>> final : public LoadWrapped {
+ public:
+  void* Emplace(void* dst) const final {
+    auto& p = *static_cast<RefCountedPtr<T>*>(dst);
+    p = MakeRefCounted<T>();
+    return p.get();
+  }
+  void Reset(void* dst) const final {
+    static_cast<RefCountedPtr<T>*>(dst)->reset();
+  }
+  const LoaderInterface* ElementLoader() const final {
+    return LoaderForType<T>();
+  }
+
+ private:
+  ~AutoLoader() = default;
+};
+
 // Implementation of aforementioned LoaderForType.
 // Simply keeps a static AutoLoader<T> and returns a pointer to that.
 template <typename T>
@@ -596,19 +616,6 @@ absl::StatusOr<T> LoadFromJson(
   return std::move(result);
 }
 
-template <typename T>
-absl::StatusOr<RefCountedPtr<T>> LoadRefCountedFromJson(
-    const Json& json, const JsonArgs& args = JsonArgs(),
-    absl::string_view error_prefix = "errors validating JSON") {
-  ValidationErrors errors;
-  auto result = MakeRefCounted<T>();
-  json_detail::LoaderForType<T>()->LoadInto(json, args, result.get(), &errors);
-  if (!errors.ok()) {
-    return errors.status(absl::StatusCode::kInvalidArgument, error_prefix);
-  }
-  return std::move(result);
-}
-
 template <typename T>
 T LoadFromJson(const Json& json, const JsonArgs& args,
                ValidationErrors* errors) {

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

@@ -35,6 +35,7 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/variant.h"
 
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/match.h"
@@ -107,8 +108,13 @@ class JsonReader {
 
     Json TakeAsJson() {
       return MatchMutable(
-          &data, [&](Json::Object* object) { return Json(std::move(*object)); },
-          [&](Json::Array* array) { return Json(std::move(*array)); });
+          &data,
+          [&](Json::Object* object) {
+            return Json::FromObject(std::move(*object));
+          },
+          [&](Json::Array* array) {
+            return Json::FromArray(std::move(*array));
+          });
     }
   };
 
@@ -307,26 +313,26 @@ void JsonReader::SetKey() {
 
 void JsonReader::SetString() {
   Json* value = CreateAndLinkValue();
-  *value = std::move(string_);
+  *value = Json::FromString(std::move(string_));
   string_.clear();
 }
 
 bool JsonReader::SetNumber() {
   Json* value = CreateAndLinkValue();
-  *value = Json(string_, /*is_number=*/true);
+  *value = Json::FromNumber(std::move(string_));
   string_.clear();
   return true;
 }
 
 void JsonReader::SetTrue() {
   Json* value = CreateAndLinkValue();
-  *value = true;
+  *value = Json::FromBool(true);
   string_.clear();
 }
 
 void JsonReader::SetFalse() {
   Json* value = CreateAndLinkValue();
-  *value = false;
+  *value = Json::FromBool(false);
   string_.clear();
 }
 
@@ -470,6 +476,7 @@ JsonReader::Status JsonReader::Run() {
                 return Status::GRPC_JSON_PARSE_ERROR;
               }
               state_ = State::GRPC_JSON_STATE_VALUE_END;
+              container_just_begun_ = false;
               EndContainer();
               if (stack_.empty()) {
                 state_ = State::GRPC_JSON_STATE_END;

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

@@ -37,18 +37,13 @@ bool ParseDurationFromJson(const Json& field, Duration* duration) {
 
 bool ExtractJsonBool(const Json& json, absl::string_view field_name,
                      bool* output, std::vector<grpc_error_handle>* error_list) {
-  switch (json.type()) {
-    case Json::Type::kTrue:
-      *output = true;
-      return true;
-    case Json::Type::kFalse:
-      *output = false;
-      return true;
-    default:
-      error_list->push_back(GRPC_ERROR_CREATE(
-          absl::StrCat("field:", field_name, " error:type should be BOOLEAN")));
-      return false;
+  if (json.type() != Json::Type::kBoolean) {
+    error_list->push_back(GRPC_ERROR_CREATE(
+        absl::StrCat("field:", field_name, " error:type should be BOOLEAN")));
+    return false;
   }
+  *output = json.boolean();
+  return true;
 }
 
 bool ExtractJsonArray(const Json& json, absl::string_view field_name,

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) {
@@ -311,11 +309,12 @@ void JsonWriter::DumpValue(const Json& value) {
     case Json::Type::kNumber:
       ValueRaw(value.string());
       break;
-    case Json::Type::kTrue:
-      ValueRaw(std::string("true", 4));
-      break;
-    case Json::Type::kFalse:
-      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::kNull:
       ValueRaw(std::string("null", 4));

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

@@ -366,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.

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;

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

@@ -26,6 +26,7 @@
 #include "absl/strings/str_join.h"
 
 #include "src/core/lib/gprpp/atomic_utils.h"
+#include "src/core/lib/gprpp/crash.h"
 
 namespace grpc_core {
 
@@ -83,6 +84,10 @@ class FreestandingActivity::Handle final : public Wakeable {
     Unref();
   }
 
+  void WakeupAsync(WakeupMask) override ABSL_LOCKS_EXCLUDED(mu_) {
+    Crash("not implemented");
+  }
+
   void Drop(WakeupMask) override { Unref(); }
 
   std::string ActivityDebugTag(WakeupMask) const override {

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

@@ -32,6 +32,7 @@
 #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"
@@ -56,6 +57,9 @@ class Wakeable {
   // 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(WakeupMask wakeup_mask) = 0;
 
@@ -69,6 +73,7 @@ class Wakeable {
 namespace promise_detail {
 struct Unwakeable final : public Wakeable {
   void Wakeup(WakeupMask) override {}
+  void WakeupAsync(WakeupMask) override {}
   void Drop(WakeupMask) override {}
   std::string ActivityDebugTag(WakeupMask) const override;
 };
@@ -96,6 +101,8 @@ 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),
@@ -125,6 +132,7 @@ class Waker {
     WakeupMask wakeup_mask;
 
     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>"
@@ -512,6 +520,8 @@ class PromiseActivity final
     }
   }
 
+  void WakeupAsync(WakeupMask) final { Crash("not implemented"); }
+
   // Drop a wakeup
   void Drop(WakeupMask) final { this->WakeupComplete(); }
 

data/src/core/lib/promise/detail/promise_factory.h

@@ -169,7 +169,7 @@ absl::enable_if_t<IsVoidCallable<ResultOf<F()>>::value,
                   PromiseLike<decltype(std::declval<F>()())>>
 PromiseFactoryImpl(F&& f) {
   return f();
-};
+}
 
 template <typename A, typename F>
 class OncePromiseFactory {

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

@@ -26,12 +26,11 @@
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/trace.h"
 
-// #define GRPC_PARTY_MAXIMIZE_THREADS
-
-#ifdef GRPC_PARTY_MAXIMIZE_THREADS
+#ifdef GRPC_MAXIMIZE_THREADYNESS
 #include "src/core/lib/gprpp/thd.h"       // IWYU pragma: keep
 #include "src/core/lib/iomgr/exec_ctx.h"  // IWYU pragma: keep
 #endif
@@ -100,9 +99,9 @@ class Party::Handle final : public Wakeable {
     Unref();
   }
 
-  // Activity needs to wake up (if it still exists!) - wake it up, and drop the
-  // ref that was kept for this handle.
-  void Wakeup(WakeupMask wakeup_mask) override ABSL_LOCKS_EXCLUDED(mu_) {
+  void WakeupGeneric(WakeupMask wakeup_mask,
+                     void (Party::*wakeup_method)(WakeupMask))
+      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
@@ -112,7 +111,7 @@ class Party::Handle final : public Wakeable {
       mu_.Unlock();
       // Activity still exists and we have a reference: wake it up, which will
       // drop the ref.
-      party->Wakeup(wakeup_mask);
+      (party->*wakeup_method)(wakeup_mask);
     } else {
       // Could not get the activity - it's either gone or going. No need to wake
       // it up!
@@ -122,6 +121,16 @@ class Party::Handle final : public Wakeable {
     Unref();
   }
 
+  // Activity needs to wake up (if it still exists!) - wake it up, and drop the
+  // ref that was kept for this handle.
+  void Wakeup(WakeupMask wakeup_mask) override ABSL_LOCKS_EXCLUDED(mu_) {
+    WakeupGeneric(wakeup_mask, &Party::Wakeup);
+  }
+
+  void WakeupAsync(WakeupMask wakeup_mask) override ABSL_LOCKS_EXCLUDED(mu_) {
+    WakeupGeneric(wakeup_mask, &Party::WakeupAsync);
+  }
+
   void Drop(WakeupMask) override { Unref(); }
 
   std::string ActivityDebugTag(WakeupMask) const override {
@@ -202,7 +211,7 @@ void Party::RunLocked() {
       PartyOver();
     }
   };
-#ifdef GRPC_PARTY_MAXIMIZE_THREADS
+#ifdef GRPC_MAXIMIZE_THREADYNESS
   Thread thd(
       "RunParty",
       [body]() {
@@ -267,15 +276,24 @@ void Party::AddParticipants(Participant** participants, size_t count) {
   Unref();
 }
 
-void Party::ScheduleWakeup(WakeupMask mask) {
-  if (sync_.ScheduleWakeup(mask)) RunLocked();
-}
-
 void Party::Wakeup(WakeupMask wakeup_mask) {
-  ScheduleWakeup(wakeup_mask);
+  if (sync_.ScheduleWakeup(wakeup_mask)) RunLocked();
   Unref();
 }
 
+void Party::WakeupAsync(WakeupMask wakeup_mask) {
+  if (sync_.ScheduleWakeup(wakeup_mask)) {
+    event_engine()->Run([this]() {
+      ApplicationCallbackExecCtx app_exec_ctx;
+      ExecCtx exec_ctx;
+      RunLocked();
+      Unref();
+    });
+  } else {
+    Unref();
+  }
+}
+
 void Party::Drop(WakeupMask) { Unref(); }
 
 void Party::PartyIsOver() {