grpc 1.75.0 → 1.78.1

data/src/core/lib/iomgr/timer_generic.cc

@@ -24,21 +24,21 @@
 
 #include <string>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/timer_heap.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/manual_constructor.h"
 #include "src/core/util/spinlock.h"
 #include "src/core/util/time.h"
 #include "src/core/util/time_averaged_stats.h"
 #include "src/core/util/useful.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 
 #define INVALID_HEAP_INDEX 0xffffffffu
 
@@ -116,7 +116,7 @@ static bool is_in_ht(grpc_timer* t) {
 }
 
 static void add_to_ht(grpc_timer* t) {
-  CHECK(!t->hash_table_next);
+  GRPC_CHECK(!t->hash_table_next);
   size_t i = grpc_core::HashPointer(t, NUM_HASH_BUCKETS);
 
   gpr_mu_lock(&g_hash_mu[i]);

data/src/core/lib/iomgr/timer_manager.cc

@@ -22,12 +22,12 @@
 #include <grpc/support/port_platform.h>
 #include <inttypes.h>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/thd.h"
+#include "absl/log/log.h"
 
 struct completed_thread {
   grpc_core::Thread thd;
@@ -80,7 +80,7 @@ static void gc_completed_threads(void) {
 }
 
 static void start_timer_thread_and_unlock(void) {
-  CHECK(g_threaded);
+  GRPC_CHECK(g_threaded);
   ++g_waiter_count;
   ++g_thread_count;
   gpr_mu_unlock(&g_mu);

data/src/core/lib/iomgr/unix_sockets_posix.cc

@@ -35,20 +35,20 @@
 
 #include <grpc/support/alloc.h>
 
-#include "absl/log/check.h"
-#include "absl/strings/str_cat.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/useful.h"
+#include "absl/strings/str_cat.h"
 
 void grpc_create_socketpair_if_unix(int sv[2]) {
 #ifdef GPR_WINDOWS
   grpc_core::Crash("AF_UNIX socket pairs are not supported on Windows");
 #else
-  CHECK_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sv), 0);
+  GRPC_CHECK_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sv), 0);
 #endif
 }
 

data/src/core/lib/iomgr/unix_sockets_posix.h

@@ -24,9 +24,9 @@
 
 #include <string>
 
-#include "absl/strings/string_view.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "absl/strings/string_view.h"
 
 void grpc_create_socketpair_if_unix(int sv[2]);
 

data/src/core/lib/iomgr/unix_sockets_posix_noop.cc

@@ -24,13 +24,13 @@
 
 #include <string>
 
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 
 void grpc_create_socketpair_if_unix(int /* sv */[2]) {
   // TODO: Either implement this for the non-Unix socket case or make
   // sure that it is never called in any such case. Until then, leave an
   // assertion to notify if this gets called inadvertently
-  CHECK(0);
+  GRPC_CHECK(0);
 }
 
 absl::StatusOr<std::vector<grpc_resolved_address>>

data/src/core/lib/iomgr/vsock.cc

@@ -26,12 +26,12 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 
-#include "absl/strings/str_cat.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/useful.h"
+#include "absl/strings/str_cat.h"
 
 absl::StatusOr<std::vector<grpc_resolved_address>> grpc_resolve_vsock_address(
     absl::string_view name) {

data/src/core/lib/iomgr/vsock.h

@@ -24,9 +24,9 @@
 
 #include <string>
 
-#include "absl/strings/string_view.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "absl/strings/string_view.h"
 
 absl::StatusOr<std::vector<grpc_resolved_address>> grpc_resolve_vsock_address(
     absl::string_view name);

data/src/core/lib/iomgr/wakeup_fd_pipe.cc

@@ -26,12 +26,12 @@
 #include <string.h>
 #include <unistd.h>
 
-#include "absl/log/log.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/wakeup_fd_pipe.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/strerror.h"
+#include "absl/log/log.h"
 
 static grpc_error_handle pipe_init(grpc_wakeup_fd* fd_info) {
   int pipefd[2];

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

@@ -19,11 +19,11 @@
 
 #include <vector>
 
-#include "absl/log/check.h"
+#include "src/core/util/atomic_utils.h"
+#include "src/core/util/grpc_check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
-#include "src/core/util/atomic_utils.h"
 
 namespace grpc_core {
 
@@ -55,7 +55,7 @@ class FreestandingActivity::Handle final : public Wakeable {
   // Activity is going away... drop its reference and sever the connection back.
   void DropActivity() ABSL_LOCKS_EXCLUDED(mu_) {
     mu_.Lock();
-    CHECK_NE(activity_, nullptr);
+    GRPC_CHECK_NE(activity_, nullptr);
     activity_ = nullptr;
     mu_.Unlock();
     Unref();

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

@@ -25,10 +25,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/log/check.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
@@ -36,10 +32,14 @@
 #include "src/core/lib/promise/poll.h"
 #include "src/core/util/construct_destruct.h"
 #include "src/core/util/dump_args.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/latent_see.h"
 #include "src/core/util/no_destruct.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/sync.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 
@@ -99,8 +99,9 @@ class Waker {
   }
 
   // Wake the underlying activity.
+  // A Waker object can only be woken up once. Calling Wakeup() or WakeupAsync()
+  // consumes the waker, rendering subsequent calls no-ops.
   void Wakeup() { Take().Wakeup(); }
-
   void WakeupAsync() { Take().WakeupAsync(); }
 
   template <typename H>
@@ -512,11 +513,11 @@ class PromiseActivity final
     // We shouldn't destruct without calling Cancel() first, and that must get
     // us to be done_, so we assume that and have no logic to destruct the
     // promise here.
-    CHECK(done_);
+    GRPC_CHECK(done_);
   }
 
   void RunScheduledWakeup() {
-    CHECK(wakeup_scheduled_.exchange(false, std::memory_order_acq_rel));
+    GRPC_CHECK(wakeup_scheduled_.exchange(false, std::memory_order_acq_rel));
     Step();
     WakeupComplete();
   }
@@ -582,7 +583,7 @@ class PromiseActivity final
   // Notification that we're no longer executing - it's ok to destruct the
   // promise.
   void MarkDone() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
-    CHECK(!std::exchange(done_, true));
+    GRPC_CHECK(!std::exchange(done_, true));
     ScopedContext contexts(this);
     Destruct(&promise_holder_.promise);
   }
@@ -629,10 +630,10 @@ class PromiseActivity final
   // Until there are no wakeups from within and the promise is incomplete:
   // poll the promise.
   std::optional<ResultType> StepLoop() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu()) {
-    CHECK(is_current());
+    GRPC_CHECK(is_current());
     while (true) {
       // Run the promise.
-      CHECK(!done_);
+      GRPC_CHECK(!done_);
       auto r = promise_holder_.promise();
       if (auto* status = r.value_if_ready()) {
         // If complete, destroy the promise, flag done, and exit this loop.

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

@@ -20,14 +20,14 @@
 #include <tuple>
 #include <variant>
 
-#include "absl/meta/type_traits.h"
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
 #include "src/core/lib/promise/detail/join_state.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/status_flag.h"
+#include "absl/meta/type_traits.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 
 namespace grpc_core {
 // AllOk promise combinator.

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

@@ -23,11 +23,11 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/meta/type_traits.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/util/construct_destruct.h"
+#include "absl/meta/type_traits.h"
 
 namespace grpc_core {
 
@@ -44,6 +44,13 @@ T*& ArgAsPtr(ArgType* arg) {
   return *reinterpret_cast<T**>(arg);
 }
 
+template <typename T>
+T const* const& ArgAsPtr(ArgType const* arg) {
+  static_assert(sizeof(ArgType) >= sizeof(T**),
+                "Must have ArgType of at least one pointer size");
+  return *reinterpret_cast<T const* const*>(arg);
+}
+
 template <typename T>
 struct Vtable {
   // Poll the promise, once.
@@ -54,6 +61,9 @@ struct Vtable {
   // Since we don't delete (the arena owns the memory) but we may need to call a
   // destructor, we expose this for when the ArenaPromise object is destroyed.
   void (*destroy)(ArgType* arg);
+  // Get the proto representation of the promise.
+  void (*to_proto)(const ArgType* arg, grpc_channelz_v2_Promise* promise_proto,
+                   upb_Arena* arena);
 };
 
 template <typename T>
@@ -77,10 +87,14 @@ struct Null {
 
   static void Move(ArgType*, ArgType*) {}
   static void Destroy(ArgType*) {}
+  static void ToProto(const ArgType*, grpc_channelz_v2_Promise* p, upb_Arena*) {
+    grpc_channelz_v2_Promise_set_unknown_promise(
+        p, StdStringToUpbString(TypeName<T>()));
+  }
 };
 
 template <typename T>
-const Vtable<T> Null<T>::vtable = {PollOnce, Move, Destroy};
+const Vtable<T> Null<T>::vtable = {PollOnce, Move, Destroy, ToProto};
 
 // Implementation of ImplInterface for a callable object.
 template <typename T, typename Callable>
@@ -96,11 +110,17 @@ struct AllocatedCallable {
   }
 
   static void Destroy(ArgType* arg) { Destruct(ArgAsPtr<Callable>(arg)); }
+
+  static void ToProto(const ArgType* arg,
+                      grpc_channelz_v2_Promise* promise_proto,
+                      upb_Arena* arena) {
+    PromiseAsProto(*ArgAsPtr<Callable>(arg), promise_proto, arena);
+  }
 };
 
 template <typename T, typename Callable>
 const Vtable<T> AllocatedCallable<T, Callable>::vtable = {PollOnce, Move,
-                                                          Destroy};
+                                                          Destroy, ToProto};
 
 // Implementation of ImplInterface for a small callable object (one that fits
 // within the ArgType arg)
@@ -119,10 +139,18 @@ struct Inlined {
   static void Destroy(ArgType* arg) {
     Destruct(reinterpret_cast<Callable*>(arg));
   }
+
+  static void ToProto(const ArgType* arg,
+                      grpc_channelz_v2_Promise* promise_proto,
+                      upb_Arena* arena) {
+    PromiseAsProto(*reinterpret_cast<Callable const*>(arg), promise_proto,
+                   arena);
+  }
 };
 
 template <typename T, typename Callable>
-const Vtable<T> Inlined<T, Callable>::vtable = {PollOnce, Move, Destroy};
+const Vtable<T> Inlined<T, Callable>::vtable = {PollOnce, Move, Destroy,
+                                                ToProto};
 
 // If a callable object is empty we can substitute any instance of that callable
 // for the one we call (for how could we tell the difference)?
@@ -138,11 +166,18 @@ struct SharedCallable {
   static Poll<T> PollOnce(ArgType* arg) {
     return (*reinterpret_cast<Callable*>(arg))();
   }
+
+  static void ToProto(const ArgType* arg,
+                      grpc_channelz_v2_Promise* promise_proto,
+                      upb_Arena* arena) {
+    PromiseAsProto(*reinterpret_cast<const Callable*>(arg), promise_proto,
+                   arena);
+  }
 };
 
 template <typename T, typename Callable>
-const Vtable<T> SharedCallable<T, Callable>::vtable = {PollOnce, Null<T>::Move,
-                                                       Null<T>::Destroy};
+const Vtable<T> SharedCallable<T, Callable>::vtable = {
+    PollOnce, Null<T>::Move, Null<T>::Destroy, ToProto};
 
 // Redirector type: given a callable type, expose a Make() function that creates
 // the appropriate underlying implementation.
@@ -238,6 +273,12 @@ class ArenaPromise {
     return vtable_and_arg_.vtable != &arena_promise_detail::Null<T>::vtable;
   }
 
+  void ToProto(grpc_channelz_v2_Promise* promise_proto,
+               upb_Arena* arena) const {
+    vtable_and_arg_.vtable->to_proto(&vtable_and_arg_.arg, promise_proto,
+                                     arena);
+  }
+
  private:
   // Underlying impl object.
   arena_promise_detail::VtableAndArg<T> vtable_and_arg_ = {

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

@@ -19,9 +19,9 @@
 
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/meta/type_traits.h"
 #include "src/core/util/down_cast.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/meta/type_traits.h"
 
 namespace grpc_core {
 
@@ -113,7 +113,7 @@ GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline bool HasContext() {
 template <typename T>
 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline T* GetContext() {
   auto* p = promise_detail::Context<T>::get();
-  DCHECK_NE(p, nullptr);
+  GRPC_DCHECK_NE(p, nullptr);
   return p;
 }
 

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

@@ -23,13 +23,13 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/util/bitset.h"
 #include "src/core/util/construct_destruct.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/log/log.h"
 
 namespace grpc_core {
 namespace promise_detail {
@@ -62,7 +62,7 @@ struct JoinState<Traits, P0, P1> {
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
-    DCHECK(other.ready.none());
+    GRPC_DCHECK(other.ready.none());
     Construct(&promise0, std::move(other.promise0));
     Construct(&promise1, std::move(other.promise1));
   }
@@ -165,7 +165,7 @@ struct JoinState<Traits, P0, P1, P2> {
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
-    DCHECK(other.ready.none());
+    GRPC_DCHECK(other.ready.none());
     Construct(&promise0, std::move(other.promise0));
     Construct(&promise1, std::move(other.promise1));
     Construct(&promise2, std::move(other.promise2));
@@ -305,7 +305,7 @@ struct JoinState<Traits, P0, P1, P2, P3> {
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
-    DCHECK(other.ready.none());
+    GRPC_DCHECK(other.ready.none());
     Construct(&promise0, std::move(other.promise0));
     Construct(&promise1, std::move(other.promise1));
     Construct(&promise2, std::move(other.promise2));
@@ -481,7 +481,7 @@ struct JoinState<Traits, P0, P1, P2, P3, P4> {
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
-    DCHECK(other.ready.none());
+    GRPC_DCHECK(other.ready.none());
     Construct(&promise0, std::move(other.promise0));
     Construct(&promise1, std::move(other.promise1));
     Construct(&promise2, std::move(other.promise2));
@@ -693,7 +693,7 @@ struct JoinState<Traits, P0, P1, P2, P3, P4, P5> {
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
-    DCHECK(other.ready.none());
+    GRPC_DCHECK(other.ready.none());
     Construct(&promise0, std::move(other.promise0));
     Construct(&promise1, std::move(other.promise1));
     Construct(&promise2, std::move(other.promise2));
@@ -941,7 +941,7 @@ struct JoinState<Traits, P0, P1, P2, P3, P4, P5, P6> {
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
-    DCHECK(other.ready.none());
+    GRPC_DCHECK(other.ready.none());
     Construct(&promise0, std::move(other.promise0));
     Construct(&promise1, std::move(other.promise1));
     Construct(&promise2, std::move(other.promise2));
@@ -1225,7 +1225,7 @@ struct JoinState<Traits, P0, P1, P2, P3, P4, P5, P6, P7> {
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
-    DCHECK(other.ready.none());
+    GRPC_DCHECK(other.ready.none());
     Construct(&promise0, std::move(other.promise0));
     Construct(&promise1, std::move(other.promise1));
     Construct(&promise2, std::move(other.promise2));
@@ -1544,7 +1544,7 @@ struct JoinState<Traits, P0, P1, P2, P3, P4, P5, P6, P7, P8> {
   JoinState& operator=(const JoinState& other) = delete;
   JoinState& operator=(JoinState&& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION JoinState(JoinState&& other) noexcept {
-    DCHECK(other.ready.none());
+    GRPC_DCHECK(other.ready.none());
     Construct(&promise0, std::move(other.promise0));
     Construct(&promise1, std::move(other.promise1));
     Construct(&promise2, std::move(other.promise2));

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

@@ -21,8 +21,8 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/meta/type_traits.h"
 #include "src/core/lib/promise/detail/promise_like.h"
+#include "absl/meta/type_traits.h"
 
 // PromiseFactory is an adaptor class.
 //

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

@@ -20,7 +20,6 @@
 #include <cstddef>
 #include <utility>
 
-#include "absl/meta/type_traits.h"
 #include "src/core/channelz/property_list.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/util/function_signature.h"
@@ -28,6 +27,7 @@
 #include "src/proto/grpc/channelz/v2/promise.upb.h"
 #include "src/proto/grpc/channelz/v2/promise.upbdefs.h"
 #include "upb/reflection/def.hpp"
+#include "absl/meta/type_traits.h"
 
 // A Promise is a callable object that returns Poll<T> for some T.
 // Often when we're writing code that uses promises, we end up wanting to also

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

@@ -22,10 +22,6 @@
 
 #include <utility>
 
-#include "absl/base/attributes.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/strings/str_cat.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/detail/promise_factory.h"
 #include "src/core/lib/promise/detail/promise_like.h"
@@ -33,6 +29,10 @@
 #include "src/core/lib/promise/promise.h"
 #include "src/core/util/construct_destruct.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/base/attributes.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
 
 // A sequence under some traits for some set of callables P, Fs.
 // P should be a promise-like object that yields a value.
@@ -124,7 +124,7 @@ struct SeqState<Traits, P, F0> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(&prior.current_promise, std::move(other.prior.current_promise));
     Construct(&prior.next_factory, std::move(other.prior.next_factory));
   }
@@ -272,7 +272,7 @@ struct SeqState<Traits, P, F0, F1> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(&prior.prior.current_promise,
               std::move(other.prior.prior.current_promise));
     Construct(&prior.prior.next_factory,
@@ -479,7 +479,7 @@ struct SeqState<Traits, P, F0, F1, F2> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(&prior.prior.prior.current_promise,
               std::move(other.prior.prior.prior.current_promise));
     Construct(&prior.prior.prior.next_factory,
@@ -743,7 +743,7 @@ struct SeqState<Traits, P, F0, F1, F2, F3> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(&prior.prior.prior.prior.current_promise,
               std::move(other.prior.prior.prior.prior.current_promise));
     Construct(&prior.prior.prior.prior.next_factory,
@@ -1073,7 +1073,7 @@ struct SeqState<Traits, P, F0, F1, F2, F3, F4> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(&prior.prior.prior.prior.prior.current_promise,
               std::move(other.prior.prior.prior.prior.prior.current_promise));
     Construct(&prior.prior.prior.prior.prior.next_factory,
@@ -1464,7 +1464,7 @@ struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(
         &prior.prior.prior.prior.prior.prior.current_promise,
         std::move(other.prior.prior.prior.prior.prior.prior.current_promise));
@@ -1918,7 +1918,7 @@ struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5, F6> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(
         &prior.prior.prior.prior.prior.prior.prior.current_promise,
         std::move(
@@ -2438,7 +2438,7 @@ struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5, F6, F7> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(&prior.prior.prior.prior.prior.prior.prior.prior.current_promise,
               std::move(other.prior.prior.prior.prior.prior.prior.prior.prior
                             .current_promise));
@@ -3027,7 +3027,7 @@ struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5, F6, F7, F8> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(
         &prior.prior.prior.prior.prior.prior.prior.prior.prior.current_promise,
         std::move(other.prior.prior.prior.prior.prior.prior.prior.prior.prior
@@ -3688,7 +3688,7 @@ struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior
                    .current_promise,
               std::move(other.prior.prior.prior.prior.prior.prior.prior.prior
@@ -4421,7 +4421,7 @@ struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior
                    .current_promise,
               std::move(other.prior.prior.prior.prior.prior.prior.prior.prior
@@ -5229,7 +5229,7 @@ struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> {
   SeqState& operator=(const SeqState& other) = delete;
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept
       : state(other.state), whence(other.whence) {
-    DCHECK(state == State::kState0);
+    GRPC_DCHECK(state == State::kState0);
     Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior
                    .prior.current_promise,
               std::move(other.prior.prior.prior.prior.prior.prior.prior.prior