grpc 1.48.0 → 1.50.0

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

@@ -20,6 +20,7 @@
 #include <utility>
 
 #include "src/core/lib/promise/detail/basic_seq.h"
+#include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/poll.h"
 
 namespace grpc_core {
@@ -50,6 +51,26 @@ struct SeqTraits {
 template <typename... Fs>
 using Seq = BasicSeq<SeqTraits, Fs...>;
 
+template <typename I, typename F, typename Arg>
+struct SeqIterTraits {
+  using Iter = I;
+  using Factory = F;
+  using Argument = Arg;
+  using IterValue = decltype(*std::declval<Iter>());
+  using StateCreated = decltype(std::declval<F>()(std::declval<IterValue>(),
+                                                  std::declval<Arg>()));
+  using State = PromiseLike<StateCreated>;
+  using Wrapped = typename State::Result;
+
+  using Traits = SeqTraits<Wrapped>;
+};
+
+template <typename Iter, typename Factory, typename Argument>
+struct SeqIterResultTraits {
+  using IterTraits = SeqIterTraits<Iter, Factory, Argument>;
+  using Result = BasicSeqIter<IterTraits>;
+};
+
 }  // namespace promise_detail
 
 // Sequencing combinator.
@@ -75,11 +96,11 @@ F Seq(F functor) {
 //   }
 //   return argument;
 template <typename Iter, typename Factory, typename Argument>
-promise_detail::BasicSeqIter<promise_detail::SeqTraits, Factory, Argument, Iter>
+typename promise_detail::SeqIterResultTraits<Iter, Factory, Argument>::Result
 SeqIter(Iter begin, Iter end, Argument argument, Factory factory) {
-  return promise_detail::BasicSeqIter<promise_detail::SeqTraits, Factory,
-                                      Argument, Iter>(
-      begin, end, std::move(factory), std::move(argument));
+  using Result = typename promise_detail::SeqIterResultTraits<Iter, Factory,
+                                                              Argument>::Result;
+  return Result(begin, end, std::move(factory), std::move(argument));
 }
 
 }  // namespace grpc_core

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

@@ -16,10 +16,15 @@
 
 #include "src/core/lib/promise/sleep.h"
 
+#include <utility>
+
 #include <grpc/event_engine/event_engine.h>
 
-#include "src/core/lib/event_engine/event_engine_factory.h"
+#include "src/core/lib/event_engine/default_event_engine.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/poll.h"
 
 namespace grpc_core {
 
@@ -28,54 +33,57 @@ using ::grpc_event_engine::experimental::GetDefaultEventEngine;
 Sleep::Sleep(Timestamp deadline) : deadline_(deadline) {}
 
 Sleep::~Sleep() {
-  if (deadline_ == Timestamp::InfPast()) return;
-  ReleasableMutexLock lock(&mu_);
-  switch (stage_) {
-    case Stage::kInitial:
-      break;
-    case Stage::kStarted:
-      if (GetDefaultEventEngine()->Cancel(timer_handle_)) {
-        lock.Release();
-        OnTimer();
-      }
-      break;
-    case Stage::kDone:
-      break;
+  if (closure_ != nullptr) closure_->Cancel();
+}
+
+Poll<absl::Status> Sleep::operator()() {
+  // Invalidate now so that we see a fresh version of the time.
+  // TODO(ctiller): the following can be safely removed when we remove ExecCtx.
+  ExecCtx::Get()->InvalidateNow();
+  // If the deadline is earlier than now we can just return.
+  if (deadline_ <= Timestamp::Now()) return absl::OkStatus();
+  if (closure_ == nullptr) {
+    // TODO(ctiller): it's likely we'll want a pool of closures - probably per
+    // cpu? - to avoid allocating/deallocating on fast paths.
+    closure_ = new ActiveClosure(deadline_);
   }
+  if (closure_->HasRun()) return absl::OkStatus();
+  return Pending{};
 }
 
-void Sleep::OnTimer() {
-  Waker tmp_waker;
-  {
-    MutexLock lock(&mu_);
-    stage_ = Stage::kDone;
-    tmp_waker = std::move(waker_);
+Sleep::ActiveClosure::ActiveClosure(Timestamp deadline)
+    : waker_(Activity::current()->MakeOwningWaker()),
+      timer_handle_(GetDefaultEventEngine()->RunAfter(
+          deadline - Timestamp::Now(), this)) {}
+
+void Sleep::ActiveClosure::Run() {
+  ApplicationCallbackExecCtx callback_exec_ctx;
+  ExecCtx exec_ctx;
+  auto waker = std::move(waker_);
+  if (Unref()) {
+    delete this;
+  } else {
+    waker.Wakeup();
   }
-  tmp_waker.Wakeup();
 }
 
-Poll<absl::Status> Sleep::operator()() {
-  MutexLock lock(&mu_);
-  switch (stage_) {
-    case Stage::kInitial:
-      if (deadline_ <= ExecCtx::Get()->Now()) {
-        return absl::OkStatus();
-      }
-      stage_ = Stage::kStarted;
-      timer_handle_ = GetDefaultEventEngine()->RunAfter(
-          deadline_ - ExecCtx::Get()->Now(), [this] {
-            ApplicationCallbackExecCtx callback_exec_ctx;
-            ExecCtx exec_ctx;
-            OnTimer();
-          });
-      break;
-    case Stage::kStarted:
-      break;
-    case Stage::kDone:
-      return absl::OkStatus();
+void Sleep::ActiveClosure::Cancel() {
+  // If we cancel correctly then we must own both refs still and can simply
+  // delete without unreffing twice, otherwise try unreffing since this may be
+  // the last owned ref.
+  if (GetDefaultEventEngine()->Cancel(timer_handle_) || Unref()) {
+    delete this;
   }
-  waker_ = Activity::current()->MakeNonOwningWaker();
-  return Pending{};
+}
+
+bool Sleep::ActiveClosure::Unref() {
+  return (refs_.fetch_sub(1, std::memory_order_acq_rel) == 1);
+}
+
+bool Sleep::ActiveClosure::HasRun() const {
+  // If the closure has run (ie woken up the activity) then it will have
+  // decremented this ref count once.
+  return refs_.load(std::memory_order_acquire) == 1;
 }
 
 }  // namespace grpc_core

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

@@ -17,14 +17,13 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <utility>
+#include <atomic>
 
-#include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/log.h>
 
-#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/poll.h"
@@ -32,43 +31,53 @@
 namespace grpc_core {
 
 // Promise that sleeps until a deadline and then finishes.
-class Sleep {
+class Sleep final {
  public:
   explicit Sleep(Timestamp deadline);
   ~Sleep();
 
   Sleep(const Sleep&) = delete;
   Sleep& operator=(const Sleep&) = delete;
-  Sleep(Sleep&& other) noexcept
-      : deadline_(other.deadline_), timer_handle_(other.timer_handle_) {
-    MutexLock lock2(&other.mu_);
-    stage_ = other.stage_;
-    waker_ = std::move(other.waker_);
-    other.deadline_ = Timestamp::InfPast();
+  Sleep(Sleep&& other) noexcept : deadline_(other.deadline_) {
+    // Promises can be moved only until they're polled, and since we only create
+    // the closure when first polled we can assume it's nullptr here.
+    GPR_DEBUG_ASSERT(other.closure_ == nullptr);
   };
   Sleep& operator=(Sleep&& other) noexcept {
-    if (&other == this) return *this;
-    MutexLock lock1(&mu_);
-    MutexLock lock2(&other.mu_);
+    // Promises can be moved only until they're polled, and since we only create
+    // the closure when first polled we can assume it's nullptr here.
+    GPR_DEBUG_ASSERT(closure_ == nullptr);
+    GPR_DEBUG_ASSERT(other.closure_ == nullptr);
     deadline_ = other.deadline_;
-    timer_handle_ = other.timer_handle_;
-    stage_ = other.stage_;
-    waker_ = std::move(other.waker_);
-    other.deadline_ = Timestamp::InfPast();
     return *this;
   };
 
   Poll<absl::Status> operator()();
 
  private:
-  enum class Stage { kInitial, kStarted, kDone };
-  void OnTimer();
+  class ActiveClosure final
+      : public grpc_event_engine::experimental::EventEngine::Closure {
+   public:
+    explicit ActiveClosure(Timestamp deadline);
+
+    void Run() override;
+    // After calling Cancel, it's no longer safe to access this object.
+    void Cancel();
+
+    bool HasRun() const;
+
+   private:
+    bool Unref();
+
+    Waker waker_;
+    // One ref dropped by Run(), the other by Cancel().
+    std::atomic<int> refs_{2};
+    const grpc_event_engine::experimental::EventEngine::TaskHandle
+        timer_handle_;
+  };
 
   Timestamp deadline_;
-  grpc_event_engine::experimental::EventEngine::TaskHandle timer_handle_;
-  Mutex mu_;
-  Stage stage_ ABSL_GUARDED_BY(mu_) = Stage::kInitial;
-  Waker waker_ ABSL_GUARDED_BY(mu_);
+  ActiveClosure* closure_{nullptr};
 };
 
 }  // namespace grpc_core

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

@@ -17,7 +17,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <type_traits>
 #include <utility>
 
 #include "absl/meta/type_traits.h"
@@ -25,6 +24,7 @@
 #include "absl/status/statusor.h"
 
 #include "src/core/lib/promise/detail/basic_seq.h"
+#include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/detail/status.h"
 #include "src/core/lib/promise/poll.h"
 
@@ -116,6 +116,26 @@ using TrySeqTraits = TrySeqTraitsWithSfinae<T>;
 template <typename... Fs>
 using TrySeq = BasicSeq<TrySeqTraits, Fs...>;
 
+template <typename I, typename F, typename Arg>
+struct TrySeqIterTraits {
+  using Iter = I;
+  using Factory = F;
+  using Argument = Arg;
+  using IterValue = decltype(*std::declval<Iter>());
+  using StateCreated = decltype(std::declval<F>()(std::declval<IterValue>(),
+                                                  std::declval<Arg>()));
+  using State = PromiseLike<StateCreated>;
+  using Wrapped = typename State::Result;
+
+  using Traits = TrySeqTraits<Wrapped>;
+};
+
+template <typename Iter, typename Factory, typename Argument>
+struct TrySeqIterResultTraits {
+  using IterTraits = TrySeqIterTraits<Iter, Factory, Argument>;
+  using Result = BasicSeqIter<IterTraits>;
+};
+
 }  // namespace promise_detail
 
 // Try a sequence of operations.
@@ -144,12 +164,12 @@ promise_detail::TrySeq<Functors...> TrySeq(Functors... functors) {
 //   }
 //   return argument;
 template <typename Iter, typename Factory, typename Argument>
-promise_detail::BasicSeqIter<promise_detail::TrySeqTraits, Factory, Argument,
-                             Iter>
+typename promise_detail::TrySeqIterResultTraits<Iter, Factory, Argument>::Result
 TrySeqIter(Iter begin, Iter end, Argument argument, Factory factory) {
-  return promise_detail::BasicSeqIter<promise_detail::TrySeqTraits, Factory,
-                                      Argument, Iter>(
-      begin, end, std::move(factory), std::move(argument));
+  using Result =
+      typename promise_detail::TrySeqIterResultTraits<Iter, Factory,
+                                                      Argument>::Result;
+  return Result(begin, end, std::move(factory), std::move(argument));
 }
 
 }  // namespace grpc_core

data/src/core/lib/resolver/resolver.cc

@@ -20,11 +20,6 @@
 
 #include "src/core/lib/resolver/resolver.h"
 
-#include <algorithm>
-#include <utility>
-
-#include "src/core/lib/channel/channel_args.h"
-
 grpc_core::DebugOnlyTraceFlag grpc_trace_resolver_refcount(false,
                                                            "resolver_refcount");
 
@@ -39,46 +34,4 @@ Resolver::Resolver()
                                ? "Resolver"
                                : nullptr) {}
 
-//
-// Resolver::Result
-//
-
-Resolver::Result::~Result() { grpc_channel_args_destroy(args); }
-
-Resolver::Result::Result(const Result& other)
-    : addresses(other.addresses),
-      service_config(other.service_config),
-      resolution_note(other.resolution_note),
-      args(grpc_channel_args_copy(other.args)) {}
-
-Resolver::Result::Result(Result&& other) noexcept
-    : addresses(std::move(other.addresses)),
-      service_config(std::move(other.service_config)),
-      resolution_note(std::move(other.resolution_note)),
-      // TODO(roth): Use std::move() once channel args is converted to C++.
-      args(other.args) {
-  other.args = nullptr;
-}
-
-Resolver::Result& Resolver::Result::operator=(const Result& other) {
-  if (&other == this) return *this;
-  addresses = other.addresses;
-  service_config = other.service_config;
-  resolution_note = other.resolution_note;
-  grpc_channel_args_destroy(args);
-  args = grpc_channel_args_copy(other.args);
-  return *this;
-}
-
-Resolver::Result& Resolver::Result::operator=(Result&& other) noexcept {
-  addresses = std::move(other.addresses);
-  service_config = std::move(other.service_config);
-  resolution_note = std::move(other.resolution_note);
-  // TODO(roth): Use std::move() once channel args is converted to C++.
-  grpc_channel_args_destroy(args);
-  args = other.args;
-  other.args = nullptr;
-  return *this;
-}
-
 }  // namespace grpc_core

data/src/core/lib/resolver/resolver.h

@@ -19,12 +19,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <functional>
 #include <string>
 
+#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -67,16 +68,18 @@ class Resolver : public InternallyRefCounted<Resolver> {
     std::string resolution_note;
     // TODO(roth): Before making this a public API, figure out a way to
     // avoid exposing channel args this way.
-    const grpc_channel_args* args = nullptr;
-
-    // TODO(roth): Remove everything below once grpc_channel_args is
-    // converted to a copyable and movable C++ object.
-    Result() = default;
-    ~Result();
-    Result(const Result& other);
-    Result(Result&& other) noexcept;
-    Result& operator=(const Result& other);
-    Result& operator=(Result&& other) noexcept;
+    ChannelArgs args;
+    // If non-null, this callback will be invoked when the LB policy has
+    // processed the result.  The status value passed to the callback
+    // indicates whether the LB policy accepted the update.  For polling
+    // resolvers, if the reported status is non-OK, then the resolver
+    // should put itself into backoff to retry the resolution later.
+    // The resolver impl must not call ResultHandler::ReportResult()
+    // again until after this callback has been invoked.
+    // The callback will be invoked within the channel's WorkSerializer.
+    // It may or may not be invoked before ResultHandler::ReportResult()
+    // returns, which is why it's a separate callback.
+    std::function<void(absl::Status)> result_health_callback;
   };
 
   /// A proxy object used by the resolver to return results to the
@@ -86,9 +89,6 @@ class Resolver : public InternallyRefCounted<Resolver> {
     virtual ~ResultHandler() {}
 
     /// Reports a result to the channel.
-    // TODO(roth): Add a mechanism for the resolver to get back a signal
-    // indicating if the result was accepted by the LB policy, so that it
-    // knows whether to go into backoff to retry to resolution.
     virtual void ReportResult(Result result) = 0;  // NOLINT
   };
 

data/src/core/lib/resolver/resolver_factory.h

@@ -25,8 +25,7 @@
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/resolver/resolver.h"
@@ -42,7 +41,7 @@ struct ResolverArgs {
   /// The parsed URI to resolve.
   URI uri;
   /// Channel args to be included in resolver results.
-  const grpc_channel_args* args = nullptr;
+  ChannelArgs args;
   /// Used to drive I/O in the name resolution process.
   grpc_pollset_set* pollset_set = nullptr;
   /// The work_serializer under which all resolver calls will be run.

data/src/core/lib/resolver/resolver_registry.cc

@@ -71,7 +71,7 @@ bool ResolverRegistry::IsValidTarget(absl::string_view target) const {
 }
 
 OrphanablePtr<Resolver> ResolverRegistry::CreateResolver(
-    absl::string_view target, const grpc_channel_args* args,
+    absl::string_view target, const ChannelArgs& args,
     grpc_pollset_set* pollset_set,
     std::shared_ptr<WorkSerializer> work_serializer,
     std::unique_ptr<Resolver::ResultHandler> result_handler) const {

data/src/core/lib/resolver/resolver_registry.h

@@ -26,8 +26,7 @@
 
 #include "absl/strings/string_view.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/resolver/resolver.h"
@@ -93,7 +92,7 @@ class ResolverRegistry {
   /// which all resolver calls will be run. \a result_handler is used to return
   /// results from the resolver.
   OrphanablePtr<Resolver> CreateResolver(
-      absl::string_view target, const grpc_channel_args* args,
+      absl::string_view target, const ChannelArgs& args,
       grpc_pollset_set* pollset_set,
       std::shared_ptr<WorkSerializer> work_serializer,
       std::unique_ptr<Resolver::ResultHandler> result_handler) const;

data/src/core/lib/resolver/server_address.cc

@@ -35,6 +35,7 @@
 #include "absl/strings/str_join.h"
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/channel/channel_args.h"
 
 // IWYU pragma: no_include <sys/socket.h>
 
@@ -51,12 +52,12 @@ const char* ServerAddressWeightAttribute::kServerAddressWeightAttributeKey =
 //
 
 ServerAddress::ServerAddress(
-    const grpc_resolved_address& address, grpc_channel_args* args,
+    const grpc_resolved_address& address, const ChannelArgs& args,
     std::map<const char*, std::unique_ptr<AttributeInterface>> attributes)
     : address_(address), args_(args), attributes_(std::move(attributes)) {}
 
 ServerAddress::ServerAddress(
-    const void* address, size_t address_len, grpc_channel_args* args,
+    const void* address, size_t address_len, const ChannelArgs& args,
     std::map<const char*, std::unique_ptr<AttributeInterface>> attributes)
     : args_(args), attributes_(std::move(attributes)) {
   memcpy(address_.addr, address, address_len);
@@ -64,7 +65,7 @@ ServerAddress::ServerAddress(
 }
 
 ServerAddress::ServerAddress(const ServerAddress& other)
-    : address_(other.address_), args_(grpc_channel_args_copy(other.args_)) {
+    : address_(other.address_), args_(other.args_) {
   for (const auto& p : other.attributes_) {
     attributes_[p.first] = p.second->Copy();
   }
@@ -74,8 +75,7 @@ ServerAddress& ServerAddress::operator=(const ServerAddress& other) {
     return *this;
   }
   address_ = other.address_;
-  grpc_channel_args_destroy(args_);
-  args_ = grpc_channel_args_copy(other.args_);
+  args_ = other.args_;
   attributes_.clear();
   for (const auto& p : other.attributes_) {
     attributes_[p.first] = p.second->Copy();
@@ -85,16 +85,12 @@ ServerAddress& ServerAddress::operator=(const ServerAddress& other) {
 
 ServerAddress::ServerAddress(ServerAddress&& other) noexcept
     : address_(other.address_),
-      args_(other.args_),
-      attributes_(std::move(other.attributes_)) {
-  other.args_ = nullptr;
-}
+      args_(std::move(other.args_)),
+      attributes_(std::move(other.attributes_)) {}
 
 ServerAddress& ServerAddress::operator=(ServerAddress&& other) noexcept {
   address_ = other.address_;
-  grpc_channel_args_destroy(args_);
-  args_ = other.args_;
-  other.args_ = nullptr;
+  args_ = std::move(other.args_);
   attributes_ = std::move(other.attributes_);
   return *this;
 }
@@ -133,7 +129,7 @@ int ServerAddress::Cmp(const ServerAddress& other) const {
   if (address_.len < other.address_.len) return -1;
   int retval = memcmp(address_.addr, other.address_.addr, address_.len);
   if (retval != 0) return retval;
-  retval = grpc_channel_args_compare(args_, other.args_);
+  retval = QsortCompare(args_, other.args_);
   if (retval != 0) return retval;
   return CompareAttributes(attributes_, other.attributes_);
 }
@@ -163,8 +159,8 @@ std::string ServerAddress::ToString() const {
   std::vector<std::string> parts = {
       addr_str.ok() ? addr_str.value() : addr_str.status().ToString(),
   };
-  if (args_ != nullptr) {
-    parts.emplace_back(absl::StrCat("args=", grpc_channel_args_string(args_)));
+  if (args_ != ChannelArgs()) {
+    parts.emplace_back(absl::StrCat("args=", args_.ToString()));
   }
   if (!attributes_.empty()) {
     std::vector<std::string> attrs;

data/src/core/lib/resolver/server_address.h

@@ -31,8 +31,6 @@
 
 #include "absl/memory/memory.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/resolved_address.h"
@@ -70,16 +68,14 @@ class ServerAddress {
   };
 
   // Takes ownership of args.
-  ServerAddress(const grpc_resolved_address& address, grpc_channel_args* args,
+  ServerAddress(const grpc_resolved_address& address, const ChannelArgs& args,
                 std::map<const char*, std::unique_ptr<AttributeInterface>>
                     attributes = {});
   ServerAddress(const void* address, size_t address_len,
-                grpc_channel_args* args,
+                const ChannelArgs& args,
                 std::map<const char*, std::unique_ptr<AttributeInterface>>
                     attributes = {});
 
-  ~ServerAddress() { grpc_channel_args_destroy(args_); }
-
   // Copyable.
   ServerAddress(const ServerAddress& other);
   ServerAddress& operator=(const ServerAddress& other);
@@ -93,7 +89,7 @@ class ServerAddress {
   int Cmp(const ServerAddress& other) const;
 
   const grpc_resolved_address& address() const { return address_; }
-  const grpc_channel_args* args() const { return args_; }
+  const ChannelArgs& args() const { return args_; }
 
   const AttributeInterface* GetAttribute(const char* key) const;
 
@@ -109,7 +105,7 @@ class ServerAddress {
 
  private:
   grpc_resolved_address address_;
-  grpc_channel_args* args_;
+  ChannelArgs args_;
   std::map<const char*, std::unique_ptr<AttributeInterface>> attributes_;
 };
 

data/src/core/lib/resource_quota/api.cc

@@ -44,7 +44,16 @@ ResourceQuotaRefPtr ResourceQuotaFromChannelArgs(
       ->Ref();
 }
 
-ChannelArgs EnsureResourceQuotaInChannelArgs(ChannelArgs args) {
+ResourceQuotaRefPtr ResourceQuotaFromEndpointConfig(
+    const grpc_event_engine::experimental::EndpointConfig& config) {
+  void* value = config.GetVoidPointer(GRPC_ARG_RESOURCE_QUOTA);
+  if (value != nullptr) {
+    return reinterpret_cast<ResourceQuota*>(value)->Ref();
+  }
+  return nullptr;
+}
+
+ChannelArgs EnsureResourceQuotaInChannelArgs(const ChannelArgs& args) {
   if (args.GetObject<ResourceQuota>() != nullptr) return args;
   // If there's no existing quota, add it to the default one - shared between
   // all channel args declared thusly. This prevents us from accidentally not

data/src/core/lib/resource_quota/api.h

@@ -19,6 +19,7 @@
 
 #include <stddef.h>
 
+#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/lib/config/core_configuration.h"
@@ -36,6 +37,11 @@ constexpr size_t kResourceQuotaChannelSize = 34 * 1024;
 // UB if not set.
 ResourceQuotaRefPtr ResourceQuotaFromChannelArgs(const grpc_channel_args* args);
 
+// Retrieve the resource quota from the EndpointConfig.
+// Returns nullptr if not set.
+ResourceQuotaRefPtr ResourceQuotaFromEndpointConfig(
+    const grpc_event_engine::experimental::EndpointConfig& config);
+
 void RegisterResourceQuota(CoreConfiguration::Builder* builder);
 
 }  // namespace grpc_core