grpc 1.63.2 → 1.64.0.pre1

data/src/core/lib/gpr/alloc.cc

@@ -21,6 +21,8 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
@@ -59,7 +61,7 @@ void* gpr_realloc(void* p, size_t size) {
 }
 
 void* gpr_malloc_aligned(size_t size, size_t alignment) {
-  GPR_ASSERT(((alignment - 1) & alignment) == 0);  // Must be power of 2.
+  CHECK_EQ(((alignment - 1) & alignment), 0u);  // Must be power of 2.
   size_t extra = alignment - 1 + sizeof(void*);
   void* p = gpr_malloc(size + extra);
   void** ret = reinterpret_cast<void**>(

data/src/core/lib/gpr/posix/sync.cc

@@ -24,6 +24,8 @@
 #include <errno.h>
 #include <time.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
@@ -33,36 +35,36 @@
 
 void gpr_mu_init(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED
-  GPR_ASSERT(pthread_mutex_init(&mu->mutex, nullptr) == 0);
+  CHECK_EQ(pthread_mutex_init(&mu->mutex, nullptr), 0);
   mu->leak_checker = static_cast<int*>(malloc(sizeof(*mu->leak_checker)));
-  GPR_ASSERT(mu->leak_checker != nullptr);
+  CHECK_NE(mu->leak_checker, nullptr);
 #else
-  GPR_ASSERT(pthread_mutex_init(mu, nullptr) == 0);
+  CHECK_EQ(pthread_mutex_init(mu, nullptr), 0);
 #endif
 }
 
 void gpr_mu_destroy(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED
-  GPR_ASSERT(pthread_mutex_destroy(&mu->mutex) == 0);
+  CHECK_EQ(pthread_mutex_destroy(&mu->mutex), 0);
   free(mu->leak_checker);
 #else
-  GPR_ASSERT(pthread_mutex_destroy(mu) == 0);
+  CHECK_EQ(pthread_mutex_destroy(mu), 0);
 #endif
 }
 
 void gpr_mu_lock(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED
-  GPR_ASSERT(pthread_mutex_lock(&mu->mutex) == 0);
+  CHECK_EQ(pthread_mutex_lock(&mu->mutex), 0);
 #else
-  GPR_ASSERT(pthread_mutex_lock(mu) == 0);
+  CHECK_EQ(pthread_mutex_lock(mu), 0);
 #endif
 }
 
 void gpr_mu_unlock(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED
-  GPR_ASSERT(pthread_mutex_unlock(&mu->mutex) == 0);
+  CHECK_EQ(pthread_mutex_unlock(&mu->mutex), 0);
 #else
-  GPR_ASSERT(pthread_mutex_unlock(mu) == 0);
+  CHECK_EQ(pthread_mutex_unlock(mu), 0);
 #endif
 }
 
@@ -73,7 +75,7 @@ int gpr_mu_trylock(gpr_mu* mu) {
 #else
   err = pthread_mutex_trylock(mu);
 #endif
-  GPR_ASSERT(err == 0 || err == EBUSY);
+  CHECK(err == 0 || err == EBUSY);
   return err == 0;
 }
 
@@ -81,26 +83,26 @@ int gpr_mu_trylock(gpr_mu* mu) {
 
 void gpr_cv_init(gpr_cv* cv) {
   pthread_condattr_t attr;
-  GPR_ASSERT(pthread_condattr_init(&attr) == 0);
+  CHECK_EQ(pthread_condattr_init(&attr), 0);
 #if GPR_LINUX
-  GPR_ASSERT(pthread_condattr_setclock(&attr, CLOCK_MONOTONIC) == 0);
+  CHECK_EQ(pthread_condattr_setclock(&attr, CLOCK_MONOTONIC), 0);
 #endif  // GPR_LINUX
 
 #ifdef GRPC_ASAN_ENABLED
-  GPR_ASSERT(pthread_cond_init(&cv->cond_var, &attr) == 0);
+  CHECK_EQ(pthread_cond_init(&cv->cond_var, &attr), 0);
   cv->leak_checker = static_cast<int*>(malloc(sizeof(*cv->leak_checker)));
-  GPR_ASSERT(cv->leak_checker != nullptr);
+  CHECK_NE(cv->leak_checker, nullptr);
 #else
-  GPR_ASSERT(pthread_cond_init(cv, &attr) == 0);
+  CHECK_EQ(pthread_cond_init(cv, &attr), 0);
 #endif
 }
 
 void gpr_cv_destroy(gpr_cv* cv) {
 #ifdef GRPC_ASAN_ENABLED
-  GPR_ASSERT(pthread_cond_destroy(&cv->cond_var) == 0);
+  CHECK_EQ(pthread_cond_destroy(&cv->cond_var), 0);
   free(cv->leak_checker);
 #else
-  GPR_ASSERT(pthread_cond_destroy(cv) == 0);
+  CHECK_EQ(pthread_cond_destroy(cv), 0);
 #endif
 }
 
@@ -129,30 +131,30 @@ int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
     err = pthread_cond_timedwait(cv, mu, &abs_deadline_ts);
 #endif
   }
-  GPR_ASSERT(err == 0 || err == ETIMEDOUT || err == EAGAIN);
+  CHECK(err == 0 || err == ETIMEDOUT || err == EAGAIN);
   return err == ETIMEDOUT;
 }
 
 void gpr_cv_signal(gpr_cv* cv) {
 #ifdef GRPC_ASAN_ENABLED
-  GPR_ASSERT(pthread_cond_signal(&cv->cond_var) == 0);
+  CHECK_EQ(pthread_cond_signal(&cv->cond_var), 0);
 #else
-  GPR_ASSERT(pthread_cond_signal(cv) == 0);
+  CHECK_EQ(pthread_cond_signal(cv), 0);
 #endif
 }
 
 void gpr_cv_broadcast(gpr_cv* cv) {
 #ifdef GRPC_ASAN_ENABLED
-  GPR_ASSERT(pthread_cond_broadcast(&cv->cond_var) == 0);
+  CHECK_EQ(pthread_cond_broadcast(&cv->cond_var), 0);
 #else
-  GPR_ASSERT(pthread_cond_broadcast(cv) == 0);
+  CHECK_EQ(pthread_cond_broadcast(cv), 0);
 #endif
 }
 
 //----------------------------------------
 
 void gpr_once_init(gpr_once* once, void (*init_function)(void)) {
-  GPR_ASSERT(pthread_once(once, init_function) == 0);
+  CHECK_EQ(pthread_once(once, init_function), 0);
 }
 
 #endif  // defined(GPR_POSIX_SYNC) && !defined(GPR_ABSEIL_SYNC) &&

data/src/core/lib/gpr/posix/time.cc

@@ -28,6 +28,8 @@
 #ifdef __linux__
 #include <sys/syscall.h>
 #endif
+#include "absl/log/check.h"
+
 #include <grpc/support/atm.h>
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
@@ -38,7 +40,8 @@ static struct timespec timespec_from_gpr(gpr_timespec gts) {
   struct timespec rv;
   if (sizeof(time_t) < sizeof(int64_t)) {
     // fine to assert, as this is only used in gpr_sleep_until
-    GPR_ASSERT(gts.tv_sec <= INT32_MAX && gts.tv_sec >= INT32_MIN);
+    CHECK(gts.tv_sec <= INT32_MAX);
+    CHECK(gts.tv_sec >= INT32_MIN);
   }
   rv.tv_sec = static_cast<time_t>(gts.tv_sec);
   rv.tv_nsec = gts.tv_nsec;
@@ -67,7 +70,7 @@ void gpr_time_init(void) { gpr_precise_clock_init(); }
 
 static gpr_timespec now_impl(gpr_clock_type clock_type) {
   struct timespec now;
-  GPR_ASSERT(clock_type != GPR_TIMESPAN);
+  CHECK(clock_type != GPR_TIMESPAN);
   if (clock_type == GPR_CLOCK_PRECISE) {
     gpr_timespec ret;
     gpr_precise_clock_now(&ret);
@@ -87,12 +90,12 @@ gpr_timespec (*gpr_now_impl)(gpr_clock_type clock_type) = now_impl;
 
 gpr_timespec gpr_now(gpr_clock_type clock_type) {
   // validate clock type
-  GPR_ASSERT(clock_type == GPR_CLOCK_MONOTONIC ||
-             clock_type == GPR_CLOCK_REALTIME ||
-             clock_type == GPR_CLOCK_PRECISE);
+  CHECK(clock_type == GPR_CLOCK_MONOTONIC || clock_type == GPR_CLOCK_REALTIME ||
+        clock_type == GPR_CLOCK_PRECISE);
   gpr_timespec ts = gpr_now_impl(clock_type);
   // tv_nsecs must be in the range [0, 1e9).
-  GPR_ASSERT(ts.tv_nsec >= 0 && ts.tv_nsec < 1e9);
+  CHECK(ts.tv_nsec >= 0);
+  CHECK(ts.tv_nsec < 1e9);
   return ts;
 }
 

data/src/core/lib/gpr/posix/tmpfile.cc

@@ -25,6 +25,8 @@
 #include <string.h>
 #include <unistd.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -42,7 +44,7 @@ FILE* gpr_tmpfile(const char* prefix, char** tmp_filename) {
   if (tmp_filename != nullptr) *tmp_filename = nullptr;
 
   gpr_asprintf(&filename_template, "/tmp/%s_XXXXXX", prefix);
-  GPR_ASSERT(filename_template != nullptr);
+  CHECK_NE(filename_template, nullptr);
 
   fd = mkstemp(filename_template);
   if (fd == -1) {

data/src/core/lib/gpr/sync.cc

@@ -22,6 +22,8 @@
 
 #include <assert.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/atm.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
@@ -59,11 +61,11 @@ void gpr_event_init(gpr_event* ev) {
 void gpr_event_set(gpr_event* ev, void* value) {
   struct sync_array_s* s = hash(ev);
   gpr_mu_lock(&s->mu);
-  GPR_ASSERT(gpr_atm_acq_load(&ev->state) == 0);
+  CHECK_EQ(gpr_atm_acq_load(&ev->state), 0);
   gpr_atm_rel_store(&ev->state, (gpr_atm)value);
   gpr_cv_broadcast(&s->cv);
   gpr_mu_unlock(&s->mu);
-  GPR_ASSERT(value != nullptr);
+  CHECK_NE(value, nullptr);
 }
 
 void* gpr_event_get(gpr_event* ev) {
@@ -102,7 +104,7 @@ void gpr_refn(gpr_refcount* r, int n) {
 
 int gpr_unref(gpr_refcount* r) {
   gpr_atm prior = gpr_atm_full_fetch_add(&r->count, -1);
-  GPR_ASSERT(prior > 0);
+  CHECK_GT(prior, 0);
   return prior == 1;
 }
 

data/src/core/lib/gpr/time.cc

@@ -24,6 +24,8 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
@@ -31,7 +33,7 @@
 
 int gpr_time_cmp(gpr_timespec a, gpr_timespec b) {
   int cmp = (a.tv_sec > b.tv_sec) - (a.tv_sec < b.tv_sec);
-  GPR_ASSERT(a.clock_type == b.clock_type);
+  CHECK(a.clock_type == b.clock_type);
   if (cmp == 0 && a.tv_sec != INT64_MAX && a.tv_sec != INT64_MIN) {
     cmp = (a.tv_nsec > b.tv_nsec) - (a.tv_nsec < b.tv_nsec);
   }
@@ -79,7 +81,7 @@ static gpr_timespec to_seconds_from_sub_second_time(int64_t time_in_units,
   } else if (time_in_units == INT64_MIN) {
     out = gpr_inf_past(type);
   } else {
-    GPR_DEBUG_ASSERT(GPR_NS_PER_SEC % units_per_sec == 0);
+    DCHECK_EQ(GPR_NS_PER_SEC % units_per_sec, 0);
 
     out.tv_sec = time_in_units / units_per_sec;
     out.tv_nsec =
@@ -139,11 +141,11 @@ gpr_timespec gpr_time_from_hours(int64_t h, gpr_clock_type clock_type) {
 gpr_timespec gpr_time_add(gpr_timespec a, gpr_timespec b) {
   gpr_timespec sum;
   int64_t inc = 0;
-  GPR_ASSERT(b.clock_type == GPR_TIMESPAN);
+  CHECK(b.clock_type == GPR_TIMESPAN);
   // tv_nsec in a timespan is always +ve. -ve timespan is represented as (-ve
   // tv_sec, +ve tv_nsec). For example, timespan = -2.5 seconds is represented
   // as {-3, 5e8, GPR_TIMESPAN}
-  GPR_ASSERT(b.tv_nsec >= 0);
+  CHECK_GE(b.tv_nsec, 0);
   sum.clock_type = a.clock_type;
   sum.tv_nsec = a.tv_nsec + b.tv_nsec;
   if (sum.tv_nsec >= GPR_NS_PER_SEC) {
@@ -177,9 +179,9 @@ gpr_timespec gpr_time_sub(gpr_timespec a, gpr_timespec b) {
     // tv_nsec in a timespan is always +ve. -ve timespan is represented as (-ve
     // tv_sec, +ve tv_nsec). For example, timespan = -2.5 seconds is represented
     // as {-3, 5e8, GPR_TIMESPAN}
-    GPR_ASSERT(b.tv_nsec >= 0);
+    CHECK_GE(b.tv_nsec, 0);
   } else {
-    GPR_ASSERT(a.clock_type == b.clock_type);
+    CHECK(a.clock_type == b.clock_type);
     diff.clock_type = GPR_TIMESPAN;
   }
   diff.tv_nsec = a.tv_nsec - b.tv_nsec;
@@ -210,8 +212,8 @@ gpr_timespec gpr_time_sub(gpr_timespec a, gpr_timespec b) {
 int gpr_time_similar(gpr_timespec a, gpr_timespec b, gpr_timespec threshold) {
   int cmp_ab;
 
-  GPR_ASSERT(a.clock_type == b.clock_type);
-  GPR_ASSERT(threshold.clock_type == GPR_TIMESPAN);
+  CHECK(a.clock_type == b.clock_type);
+  CHECK(threshold.clock_type == GPR_TIMESPAN);
 
   cmp_ab = gpr_time_cmp(a, b);
   if (cmp_ab == 0) return 1;

data/src/core/lib/gpr/windows/sync.cc

@@ -23,6 +23,8 @@
 #if defined(GPR_WINDOWS) && !defined(GPR_ABSEIL_SYNC) && \
     !defined(GPR_CUSTOM_SYNC)
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
@@ -38,7 +40,7 @@ void gpr_mu_destroy(gpr_mu* mu) { DeleteCriticalSection(&mu->cs); }
 
 void gpr_mu_lock(gpr_mu* mu) {
   EnterCriticalSection(&mu->cs);
-  GPR_ASSERT(!mu->locked);
+  CHECK(!mu->locked);
   mu->locked = 1;
 }
 

data/src/core/lib/gpr/windows/time.cc

@@ -26,6 +26,8 @@
 #include <process.h>
 #include <sys/timeb.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
@@ -97,7 +99,8 @@ void gpr_sleep_until(gpr_timespec until) {
     delta = gpr_time_sub(until, now);
     sleep_millis =
         delta.tv_sec * GPR_MS_PER_SEC + delta.tv_nsec / GPR_NS_PER_MS;
-    GPR_ASSERT((sleep_millis >= 0) && (sleep_millis <= INT_MAX));
+    CHECK_GE(sleep_millis, 0);
+    CHECK_LE(sleep_millis, INT_MAX);
     Sleep((DWORD)sleep_millis);
   }
 }

data/src/core/lib/gprpp/atomic_utils.h

@@ -19,10 +19,10 @@
 #ifndef GRPC_SRC_CORE_LIB_GPRPP_ATOMIC_UTILS_H
 #define GRPC_SRC_CORE_LIB_GPRPP_ATOMIC_UTILS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <atomic>
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 // Atomically increment a counter only if the counter value is not zero.

data/src/core/lib/gprpp/bitset.h

@@ -15,13 +15,13 @@
 #ifndef GRPC_SRC_CORE_LIB_GPRPP_BITSET_H
 #define GRPC_SRC_CORE_LIB_GPRPP_BITSET_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 #include <stdint.h>
 
 #include <type_traits>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gpr/useful.h"
 
 namespace grpc_core {

data/src/core/lib/gprpp/chunked_vector.h

@@ -15,13 +15,14 @@
 #ifndef GRPC_SRC_CORE_LIB_GPRPP_CHUNKED_VECTOR_H
 #define GRPC_SRC_CORE_LIB_GPRPP_CHUNKED_VECTOR_H
 
-#include <grpc/support/port_platform.h>
-
 #include <cstddef>
 #include <iterator>
 #include <utility>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/resource_quota/arena.h"
@@ -87,9 +88,9 @@ class ChunkedVector {
 
   // Remove the last element and return it.
   T PopBack() {
-    GPR_ASSERT(append_ != nullptr);
+    CHECK_NE(append_, nullptr);
     if (append_->count == 0) {
-      GPR_ASSERT(first_ != append_);
+      CHECK(first_ != append_);
       Chunk* chunk = first_;
       while (chunk->next != append_) {
         chunk = chunk->next;
@@ -235,7 +236,7 @@ class ChunkedVector {
  private:
   ManualConstructor<T>* AppendSlot() {
     if (append_ == nullptr) {
-      GPR_ASSERT(first_ == nullptr);
+      CHECK_EQ(first_, nullptr);
       first_ = arena_->New<Chunk>();
       append_ = first_;
     } else if (append_->count == kChunkSize) {

data/src/core/lib/gprpp/construct_destruct.h

@@ -15,11 +15,11 @@
 #ifndef GRPC_SRC_CORE_LIB_GPRPP_CONSTRUCT_DESTRUCT_H
 #define GRPC_SRC_CORE_LIB_GPRPP_CONSTRUCT_DESTRUCT_H
 
-#include <grpc/support/port_platform.h>
-
 #include <new>
 #include <utility>
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 // Call the destructor of p without having to name the type of p.

data/src/core/lib/gprpp/crash.cc

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/gprpp/crash.h"
 
 #include <stdio.h>
@@ -24,6 +22,7 @@
 #include "absl/strings/str_cat.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 

data/src/core/lib/gprpp/crash.h

@@ -15,10 +15,10 @@
 #ifndef GRPC_SRC_CORE_LIB_GPRPP_CRASH_H
 #define GRPC_SRC_CORE_LIB_GPRPP_CRASH_H
 
-#include <grpc/support/port_platform.h>
-
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/debug_location.h"
 
 namespace grpc_core {

data/src/core/lib/gprpp/debug_location.h

@@ -19,10 +19,10 @@
 #ifndef GRPC_SRC_CORE_LIB_GPRPP_DEBUG_LOCATION_H
 #define GRPC_SRC_CORE_LIB_GPRPP_DEBUG_LOCATION_H
 
-#include <grpc/support/port_platform.h>
-
 #include <utility>
 
+#include <grpc/support/port_platform.h>
+
 #if defined(__has_builtin)
 #if __has_builtin(__builtin_FILE)
 #define GRPC_DEFAULT_FILE __builtin_FILE()

data/src/core/lib/gprpp/directory_reader.h

@@ -19,14 +19,14 @@
 #ifndef GRPC_SRC_CORE_LIB_GPRPP_DIRECTORY_READER_H
 #define GRPC_SRC_CORE_LIB_GPRPP_DIRECTORY_READER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <memory>
 
 #include "absl/functional/function_ref.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 class DirectoryReader {

data/src/core/lib/gprpp/down_cast.h

@@ -15,13 +15,13 @@
 #ifndef GRPC_SRC_CORE_LIB_GPRPP_DOWN_CAST_H
 #define GRPC_SRC_CORE_LIB_GPRPP_DOWN_CAST_H
 
-#include <grpc/support/port_platform.h>
-
 #include <type_traits>
 
 #include "absl/base/config.h"
+#include "absl/log/check.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 
@@ -33,7 +33,7 @@ inline To DownCast(From* f) {
 // If we have RTTI & we're in debug, assert that the cast is legal.
 #if ABSL_INTERNAL_HAS_RTTI
 #ifndef NDEBUG
-  if (f != nullptr) GPR_ASSERT(dynamic_cast<To>(f) != nullptr);
+  if (f != nullptr) CHECK_NE(dynamic_cast<To>(f), nullptr);
 #endif
 #endif
   return static_cast<To>(f);

data/src/core/lib/gprpp/dual_ref_counted.h

@@ -17,12 +17,13 @@
 #ifndef GRPC_SRC_CORE_LIB_GPRPP_DUAL_REF_COUNTED_H
 #define GRPC_SRC_CORE_LIB_GPRPP_DUAL_REF_COUNTED_H
 
-#include <grpc/support/port_platform.h>
-
 #include <atomic>
 #include <cstdint>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/down_cast.h"
@@ -93,7 +94,7 @@ class DualRefCounted {
       gpr_log(GPR_INFO, "%s:%p unref %d -> %d, weak_ref %d -> %d", trace_, this,
               strong_refs, strong_refs - 1, weak_refs, weak_refs + 1);
     }
-    GPR_ASSERT(strong_refs > 0);
+    CHECK_GT(strong_refs, 0u);
 #endif
     if (GPR_UNLIKELY(strong_refs == 1)) {
       Orphaned();
@@ -112,7 +113,7 @@ class DualRefCounted {
               trace_, this, location.file(), location.line(), strong_refs,
               strong_refs - 1, weak_refs, weak_refs + 1, reason);
     }
-    GPR_ASSERT(strong_refs > 0);
+    CHECK_GT(strong_refs, 0u);
 #else
     // Avoid unused-parameter warnings for debug-only parameters
     (void)location;
@@ -211,7 +212,7 @@ class DualRefCounted {
       gpr_log(GPR_INFO, "%s:%p weak_unref %d -> %d (refs=%d)", trace, this,
               weak_refs, weak_refs - 1, strong_refs);
     }
-    GPR_ASSERT(weak_refs > 0);
+    CHECK_GT(weak_refs, 0u);
 #endif
     if (GPR_UNLIKELY(prev_ref_pair == MakeRefPair(0, 1))) {
       delete static_cast<Child*>(this);
@@ -234,7 +235,7 @@ class DualRefCounted {
               this, location.file(), location.line(), weak_refs, weak_refs - 1,
               strong_refs, reason);
     }
-    GPR_ASSERT(weak_refs > 0);
+    CHECK_GT(weak_refs, 0u);
 #else
     // Avoid unused-parameter warnings for debug-only parameters
     (void)location;
@@ -290,7 +291,7 @@ class DualRefCounted {
         refs_.fetch_add(MakeRefPair(1, 0), std::memory_order_relaxed);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
-    GPR_ASSERT(strong_refs != 0);
+    CHECK_NE(strong_refs, 0u);
     if (trace_ != nullptr) {
       gpr_log(GPR_INFO, "%s:%p ref %d -> %d; (weak_refs=%d)", trace_, this,
               strong_refs, strong_refs + 1, weak_refs);
@@ -305,7 +306,7 @@ class DualRefCounted {
         refs_.fetch_add(MakeRefPair(1, 0), std::memory_order_relaxed);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
-    GPR_ASSERT(strong_refs != 0);
+    CHECK_NE(strong_refs, 0u);
     if (trace_ != nullptr) {
       gpr_log(GPR_INFO, "%s:%p %s:%d ref %d -> %d (weak_refs=%d) %s", trace_,
               this, location.file(), location.line(), strong_refs,

data/src/core/lib/gprpp/env.h

@@ -19,12 +19,12 @@
 #ifndef GRPC_SRC_CORE_LIB_GPRPP_ENV_H
 #define GRPC_SRC_CORE_LIB_GPRPP_ENV_H
 
-#include <grpc/support/port_platform.h>
-
 #include <string>
 
 #include "absl/types/optional.h"
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 // Gets the environment variable value with the specified name. */

data/src/core/lib/gprpp/examine_stack.cc

@@ -16,10 +16,10 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/gprpp/examine_stack.h"
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 gpr_current_stack_trace_func g_current_stack_trace_provider = nullptr;

data/src/core/lib/gprpp/examine_stack.h

@@ -19,12 +19,12 @@
 #ifndef GRPC_SRC_CORE_LIB_GPRPP_EXAMINE_STACK_H
 #define GRPC_SRC_CORE_LIB_GPRPP_EXAMINE_STACK_H
 
-#include <grpc/support/port_platform.h>
-
 #include <string>
 
 #include "absl/types/optional.h"
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 typedef std::string (*gpr_current_stack_trace_func)();

data/src/core/lib/gprpp/fork.cc

@@ -16,13 +16,12 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/gprpp/fork.h"
 
 #include <utility>
 
 #include <grpc/support/atm.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 

data/src/core/lib/gprpp/fork.h

@@ -19,11 +19,11 @@
 #ifndef GRPC_SRC_CORE_LIB_GPRPP_FORK_H
 #define GRPC_SRC_CORE_LIB_GPRPP_FORK_H
 
-#include <grpc/support/port_platform.h>
-
 #include <atomic>
 #include <set>
 
+#include <grpc/support/port_platform.h>
+
 //
 // NOTE: FORKING IS NOT GENERALLY SUPPORTED, THIS IS ONLY INTENDED TO WORK
 //       AROUND VERY SPECIFIC USE CASES.