grpc 1.63.0 → 1.64.0.pre1

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

@@ -16,11 +16,10 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <utility>
 
 #include <grpc/support/atm.h>
+#include <grpc/support/port_platform.h>
 
 // FIXME: "posix" files shouldn't be depending on _GNU_SOURCE
 #ifndef _GNU_SOURCE
@@ -44,6 +43,7 @@
 
 #include <string>
 
+#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
@@ -90,7 +90,7 @@ using ::grpc_event_engine::experimental::SliceBuffer;
 
 static void finish_shutdown(grpc_tcp_server* s) {
   gpr_mu_lock(&s->mu);
-  GPR_ASSERT(s->shutdown);
+  CHECK(s->shutdown);
   gpr_mu_unlock(&s->mu);
   if (s->shutdown_complete != nullptr) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, s->shutdown_complete,
@@ -235,7 +235,7 @@ static grpc_error_handle CreateEventEngineListener(
     listener = engine->CreateListener(
         std::move(accept_cb),
         [s, ee = keeper, shutdown_complete](absl::Status status) {
-          GPR_ASSERT(gpr_atm_no_barrier_load(&s->refs.count) == 0);
+          CHECK_EQ(gpr_atm_no_barrier_load(&s->refs.count), 0);
           grpc_event_engine::experimental::RunEventEngineClosure(
               shutdown_complete, absl_status_to_grpc_error(status));
           finish_shutdown(s);
@@ -288,8 +288,8 @@ static grpc_error_handle tcp_server_create(grpc_closure* shutdown_complete,
   s->nports = 0;
   s->options = ::TcpOptionsFromEndpointConfig(config);
   s->fd_handler = nullptr;
-  GPR_ASSERT(s->options.resource_quota != nullptr);
-  GPR_ASSERT(s->on_accept_cb);
+  CHECK(s->options.resource_quota != nullptr);
+  CHECK(s->on_accept_cb);
   s->memory_quota = s->options.resource_quota->memory_quota();
   s->pre_allocated_fd = -1;
   gpr_atm_no_barrier_store(&s->next_pollset_to_assign, 0);
@@ -311,7 +311,7 @@ static void destroyed_port(void* server, grpc_error_handle /*error*/) {
     gpr_mu_unlock(&s->mu);
     finish_shutdown(s);
   } else {
-    GPR_ASSERT(s->destroyed_ports < s->nports);
+    CHECK(s->destroyed_ports < s->nports);
     gpr_mu_unlock(&s->mu);
   }
 }
@@ -323,7 +323,7 @@ static void deactivated_all_ports(grpc_tcp_server* s) {
   // delete ALL the things
   gpr_mu_lock(&s->mu);
 
-  GPR_ASSERT(s->shutdown);
+  CHECK(s->shutdown);
 
   if (s->head) {
     grpc_tcp_listener* sp;
@@ -352,7 +352,7 @@ static void deactivated_all_ports(grpc_tcp_server* s) {
 
 static void tcp_server_destroy(grpc_tcp_server* s) {
   gpr_mu_lock(&s->mu);
-  GPR_ASSERT(!s->shutdown);
+  CHECK(!s->shutdown);
   s->shutdown = true;
   // shutdown all fd's
   if (s->active_ports) {
@@ -564,7 +564,8 @@ static grpc_error_handle add_wildcard_addrs_to_server(grpc_tcp_server* s,
   } else {
     grpc_error_handle root_err =
         GRPC_ERROR_CREATE("Failed to add any wildcard listeners");
-    GPR_ASSERT(!v6_err.ok() && !v4_err.ok());
+    CHECK(!v6_err.ok());
+    CHECK(!v4_err.ok());
     root_err = grpc_error_add_child(root_err, v6_err);
     root_err = grpc_error_add_child(root_err, v4_err);
     return root_err;
@@ -615,7 +616,7 @@ static grpc_error_handle clone_port(grpc_tcp_listener* listener,
     sp->port = port;
     sp->port_index = listener->port_index;
     sp->fd_index = listener->fd_index + count - i;
-    GPR_ASSERT(sp->emfd);
+    CHECK(sp->emfd);
     grpc_tcp_server_listener_initialize_retry_timer(sp);
     while (listener->server->tail->next != nullptr) {
       listener->server->tail = listener->server->tail->next;
@@ -647,7 +648,7 @@ static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
             if (!listen_fd.ok()) {
               return;
             }
-            GPR_DEBUG_ASSERT(*listen_fd > 0);
+            DCHECK_GT(*listen_fd, 0);
             s->listen_fd_to_index_map.insert_or_assign(
                 *listen_fd, std::make_tuple(s->n_bind_ports, fd_index++));
           });
@@ -662,7 +663,7 @@ static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
     gpr_mu_unlock(&s->mu);
     return port.status();
   }
-  GPR_ASSERT(addr->len <= GRPC_MAX_SOCKADDR_SIZE);
+  CHECK(addr->len <= GRPC_MAX_SOCKADDR_SIZE);
   grpc_tcp_listener* sp;
   grpc_resolved_address sockname_temp;
   grpc_resolved_address addr6_v4mapped;
@@ -790,12 +791,12 @@ static void tcp_server_start(grpc_tcp_server* s,
   size_t i;
   grpc_tcp_listener* sp;
   gpr_mu_lock(&s->mu);
-  GPR_ASSERT(s->on_accept_cb);
-  GPR_ASSERT(s->active_ports == 0);
+  CHECK(s->on_accept_cb);
+  CHECK_EQ(s->active_ports, 0u);
   s->pollsets = pollsets;
   if (grpc_event_engine::experimental::UseEventEngineListener()) {
-    GPR_ASSERT(!s->shutdown_listeners);
-    GPR_ASSERT(GRPC_LOG_IF_ERROR("listener_start", s->ee_listener->Start()));
+    CHECK(!s->shutdown_listeners);
+    CHECK(GRPC_LOG_IF_ERROR("listener_start", s->ee_listener->Start()));
     gpr_mu_unlock(&s->mu);
     return;
   }
@@ -803,7 +804,7 @@ static void tcp_server_start(grpc_tcp_server* s,
   while (sp != nullptr) {
     if (s->so_reuseport && !grpc_is_unix_socket(&sp->addr) &&
         !grpc_is_vsock(&sp->addr) && pollsets->size() > 1) {
-      GPR_ASSERT(GRPC_LOG_IF_ERROR(
+      CHECK(GRPC_LOG_IF_ERROR(
           "clone_port", clone_port(sp, (unsigned)(pollsets->size() - 1))));
       for (i = 0; i < pollsets->size(); i++) {
         grpc_pollset_add_fd((*pollsets)[i], sp->emfd);
@@ -895,17 +896,16 @@ class ExternalConnectionHandler : public grpc_core::TcpServerFdHandler {
           grpc_event_engine::experimental::QueryExtension<
               grpc_event_engine::experimental::ListenerSupportsFdExtension>(
               s_->ee_listener.get());
-      GPR_ASSERT(listener_supports_fd != nullptr);
+      CHECK_NE(listener_supports_fd, nullptr);
       grpc_event_engine::experimental::SliceBuffer pending_data;
       if (buf != nullptr) {
         pending_data =
             grpc_event_engine::experimental::SliceBuffer::TakeCSliceBuffer(
                 buf->data.raw.slice_buffer);
       }
-      GPR_ASSERT(
-          GRPC_LOG_IF_ERROR("listener_handle_external_connection",
-                            listener_supports_fd->HandleExternalConnection(
-                                listener_fd, fd, &pending_data)));
+      CHECK(GRPC_LOG_IF_ERROR("listener_handle_external_connection",
+                              listener_supports_fd->HandleExternalConnection(
+                                  listener_fd, fd, &pending_data)));
       return;
     }
     grpc_pollset* read_notifier_pollset;

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

@@ -19,12 +19,12 @@
 #ifndef GRPC_SRC_CORE_LIB_IOMGR_TCP_SERVER_UTILS_POSIX_H
 #define GRPC_SRC_CORE_LIB_IOMGR_TCP_SERVER_UTILS_POSIX_H
 
-#include <grpc/support/port_platform.h>
-
 #include <memory>
 
 #include "absl/container/flat_hash_map.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/event_engine/posix.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/resolve_address.h"

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

@@ -16,9 +16,8 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <grpc/support/atm.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/iomgr/port.h"
 
@@ -32,6 +31,7 @@
 
 #include <string>
 
+#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 
 #include <grpc/support/alloc.h>
@@ -113,7 +113,7 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, int fd,
   grpc_error_handle err =
       grpc_tcp_server_prepare_socket(s, fd, addr, s->so_reuseport, &port);
   if (!err.ok()) return err;
-  GPR_ASSERT(port > 0);
+  CHECK_GT(port, 0);
   absl::StatusOr<std::string> addr_str = grpc_sockaddr_to_string(addr, true);
   if (!addr_str.ok()) {
     return GRPC_ERROR_CREATE(addr_str.status().ToString());
@@ -146,7 +146,7 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, int fd,
   sp->fd_index = fd_index;
   sp->is_sibling = 0;
   sp->sibling = nullptr;
-  GPR_ASSERT(sp->emfd);
+  CHECK(sp->emfd);
   gpr_mu_unlock(&s->mu);
 
   *listener = sp;
@@ -210,7 +210,7 @@ grpc_error_handle grpc_tcp_server_prepare_socket(
   grpc_resolved_address sockname_temp;
   grpc_error_handle err;
 
-  GPR_ASSERT(fd >= 0);
+  CHECK_GE(fd, 0);
 
   if (so_reuseport && !grpc_is_unix_socket(addr) && !grpc_is_vsock(addr)) {
     err = grpc_set_socket_reuse_port(fd, 1);
@@ -273,7 +273,7 @@ grpc_error_handle grpc_tcp_server_prepare_socket(
   return absl::OkStatus();
 
 error:
-  GPR_ASSERT(!err.ok());
+  CHECK(!err.ok());
   if (fd >= 0) {
     close(fd);
   }

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

@@ -30,6 +30,7 @@
 
 #include <string>
 
+#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 
 #include <grpc/support/alloc.h>
@@ -166,7 +167,7 @@ grpc_error_handle grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
       err = grpc_error_add_child(root_err, err);
       break;
     } else {
-      GPR_ASSERT(requested_port == new_sp->port);
+      CHECK(requested_port == new_sp->port);
       ++fd_index;
       if (sp != nullptr) {
         new_sp->is_sibling = 1;

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

@@ -27,6 +27,7 @@
 
 #include <vector>
 
+#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 
 #include <grpc/event_engine/endpoint_config.h>
@@ -292,7 +293,7 @@ static grpc_error_handle prepare_socket(SOCKET sock,
   return absl::OkStatus();
 
 failure:
-  GPR_ASSERT(!error.ok());
+  CHECK(!error.ok());
   auto addr_uri = grpc_sockaddr_to_uri(addr);
   error = grpc_error_set_int(
       grpc_error_set_str(
@@ -307,7 +308,7 @@ failure:
 
 static void decrement_active_ports_and_notify_locked(grpc_tcp_listener* sp) {
   sp->shutting_down = 0;
-  GPR_ASSERT(sp->server->active_ports > 0);
+  CHECK_GT(sp->server->active_ports, 0u);
   if (0 == --sp->server->active_ports) {
     finish_shutdown_locked(sp->server);
   }
@@ -365,7 +366,7 @@ static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
   return error;
 
 failure:
-  GPR_ASSERT(!error.ok());
+  CHECK(!error.ok());
   if (sock != INVALID_SOCKET) closesocket(sock);
   return error;
 }
@@ -458,7 +459,7 @@ static void on_accept(void* arg, grpc_error_handle error) {
   // the former socked we created has now either been destroy or assigned
   // to the new connection. We need to create a new one for the next
   // connection.
-  GPR_ASSERT(GRPC_LOG_IF_ERROR("start_accept", start_accept_locked(sp)));
+  CHECK(GRPC_LOG_IF_ERROR("start_accept", start_accept_locked(sp)));
   if (0 == --sp->outstanding_calls) {
     decrement_active_ports_and_notify_locked(sp);
   }
@@ -494,7 +495,7 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
     return error;
   }
 
-  GPR_ASSERT(port >= 0);
+  CHECK_GE(port, 0);
   gpr_mu_lock(&s->mu);
   sp = (grpc_tcp_listener*)gpr_malloc(sizeof(grpc_tcp_listener));
   sp->next = NULL;
@@ -514,7 +515,7 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
   sp->port = port;
   sp->port_index = port_index;
   GRPC_CLOSURE_INIT(&sp->on_accept, on_accept, sp, grpc_schedule_on_exec_ctx);
-  GPR_ASSERT(sp->socket);
+  CHECK(sp->socket);
   gpr_mu_unlock(&s->mu);
   *listener = sp;
 
@@ -591,7 +592,7 @@ done:
     error = error_out;
     *port = -1;
   } else {
-    GPR_ASSERT(sp != NULL);
+    CHECK(sp != NULL);
     *port = sp->port;
   }
   return error;
@@ -601,9 +602,9 @@ static void tcp_server_start(grpc_tcp_server* s,
                              const std::vector<grpc_pollset*>* /*pollsets*/) {
   grpc_tcp_listener* sp;
   gpr_mu_lock(&s->mu);
-  GPR_ASSERT(s->active_ports == 0);
+  CHECK_EQ(s->active_ports, 0u);
   for (sp = s->head; sp; sp = sp->next) {
-    GPR_ASSERT(GRPC_LOG_IF_ERROR("start_accept", start_accept_locked(sp)));
+    CHECK(GRPC_LOG_IF_ERROR("start_accept", start_accept_locked(sp)));
     s->active_ports++;
   }
   gpr_mu_unlock(&s->mu);
@@ -653,7 +654,7 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
   WindowsEventEngine* engine_ptr = reinterpret_cast<WindowsEventEngine*>(
       config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE));
   grpc_tcp_server* s = (grpc_tcp_server*)gpr_malloc(sizeof(grpc_tcp_server));
-  GPR_ASSERT(on_accept_cb != nullptr);
+  CHECK_NE(on_accept_cb, nullptr);
   auto accept_cb = [s, on_accept_cb, on_accept_cb_arg](
                        std::unique_ptr<EventEngine::Endpoint> endpoint,
                        MemoryAllocator memory_allocator) {
@@ -675,7 +676,7 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
   grpc_core::RefCountedPtr<grpc_core::ResourceQuota> resource_quota;
   {
     void* tmp_quota = config.GetVoidPointer(GRPC_ARG_RESOURCE_QUOTA);
-    GPR_ASSERT(tmp_quota != nullptr);
+    CHECK_NE(tmp_quota, nullptr);
     resource_quota =
         reinterpret_cast<grpc_core::ResourceQuota*>(tmp_quota)->Ref();
   }
@@ -706,13 +707,13 @@ static grpc_error_handle event_engine_create(grpc_closure* shutdown_complete,
 
 static void event_engine_start(grpc_tcp_server* s,
                                const std::vector<grpc_pollset*>* /*pollsets*/) {
-  GPR_ASSERT(s->ee_listener->Start().ok());
+  CHECK(s->ee_listener->Start().ok());
 }
 
 static grpc_error_handle event_engine_add_port(
     grpc_tcp_server* s, const grpc_resolved_address* addr, int* port) {
-  GPR_ASSERT(addr != nullptr);
-  GPR_ASSERT(port != nullptr);
+  CHECK_NE(addr, nullptr);
+  CHECK_NE(port, nullptr);
   auto ee_addr = CreateResolvedAddress(*addr);
   auto out_port = s->ee_listener->Bind(ee_addr);
   *port = out_port.ok() ? *out_port : -1;

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

@@ -24,6 +24,8 @@
 
 #include <limits.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -190,7 +192,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
       grpc_slice_buffer_reset_and_unref(tcp->read_slices);
     } else {
       if (info->bytes_transferred != 0 && !tcp->shutting_down) {
-        GPR_ASSERT((size_t)info->bytes_transferred <= tcp->read_slices->length);
+        CHECK((size_t)info->bytes_transferred <= tcp->read_slices->length);
         if (static_cast<size_t>(info->bytes_transferred) !=
             tcp->read_slices->length) {
           grpc_slice_buffer_trim_end(
@@ -199,7 +201,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
                   static_cast<size_t>(info->bytes_transferred),
               &tcp->last_read_buffer);
         }
-        GPR_ASSERT((size_t)info->bytes_transferred == tcp->read_slices->length);
+        CHECK((size_t)info->bytes_transferred == tcp->read_slices->length);
 
         if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) &&
             gpr_should_log(GPR_LOG_SEVERITY_INFO)) {
@@ -272,7 +274,7 @@ static void win_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
                           GRPC_SLICE_MALLOC(DEFAULT_TARGET_READ_SIZE));
   }
 
-  GPR_ASSERT(tcp->read_slices->count <= MAX_WSABUF_COUNT);
+  CHECK(tcp->read_slices->count <= MAX_WSABUF_COUNT);
   for (i = 0; i < tcp->read_slices->count; i++) {
     buffers[i].len = (ULONG)GRPC_SLICE_LENGTH(
         tcp->read_slices->slices[i]);  // we know slice size fits in 32bit.
@@ -331,7 +333,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
     if (info->wsa_error != 0) {
       error = GRPC_WSA_ERROR(info->wsa_error, "WSASend");
     } else {
-      GPR_ASSERT(info->bytes_transferred <= tcp->write_slices->length);
+      CHECK(info->bytes_transferred <= tcp->write_slices->length);
     }
   }
 
@@ -378,7 +380,7 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
 
   tcp->write_cb = cb;
   tcp->write_slices = slices;
-  GPR_ASSERT(tcp->write_slices->count <= UINT_MAX);
+  CHECK(tcp->write_slices->count <= UINT_MAX);
   if (tcp->write_slices->count > GPR_ARRAY_SIZE(local_buffers)) {
     buffers = (WSABUF*)gpr_malloc(sizeof(WSABUF) * tcp->write_slices->count);
     allocated = buffers;
@@ -386,7 +388,7 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
 
   for (i = 0; i < tcp->write_slices->count; i++) {
     len = GRPC_SLICE_LENGTH(tcp->write_slices->slices[i]);
-    GPR_ASSERT(len <= ULONG_MAX);
+    CHECK(len <= ULONG_MAX);
     buffers[i].len = (ULONG)len;
     buffers[i].buf = (char*)GRPC_SLICE_START_PTR(tcp->write_slices->slices[i]);
   }

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

@@ -16,10 +16,10 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/iomgr/timer.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/iomgr/timer_manager.h"
 
 grpc_timer_vtable* grpc_timer_impl;

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

@@ -19,11 +19,10 @@
 #ifndef GRPC_SRC_CORE_LIB_IOMGR_TIMER_H
 #define GRPC_SRC_CORE_LIB_IOMGR_TIMER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <cstdint>
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/iomgr/exec_ctx.h"

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

@@ -16,18 +16,18 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <inttypes.h>
 
 #include <string>
 
+#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/cpu.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/debug/trace.h"
@@ -121,7 +121,7 @@ static bool is_in_ht(grpc_timer* t) {
 }
 
 static void add_to_ht(grpc_timer* t) {
-  GPR_ASSERT(!t->hash_table_next);
+  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_generic.h

@@ -20,7 +20,6 @@
 #define GRPC_SRC_CORE_LIB_IOMGR_TIMER_GENERIC_H
 
 #include <grpc/support/port_platform.h>
-
 #include <grpc/support/time.h>
 
 #include "src/core/lib/iomgr/exec_ctx.h"

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

@@ -16,13 +16,12 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/iomgr/timer_heap.h"
 
 #include <string.h>
 
 #include <grpc/support/alloc.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/port.h"

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

@@ -16,14 +16,15 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/iomgr/timer_manager.h"
 
 #include <inttypes.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/crash.h"
@@ -83,7 +84,7 @@ static void gc_completed_threads(void) {
 }
 
 static void start_timer_thread_and_unlock(void) {
-  GPR_ASSERT(g_threaded);
+  CHECK(g_threaded);
   ++g_waiter_count;
   ++g_thread_count;
   gpr_mu_unlock(&g_mu);

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

@@ -19,10 +19,10 @@
 #ifndef GRPC_SRC_CORE_LIB_IOMGR_TIMER_MANAGER_H
 #define GRPC_SRC_CORE_LIB_IOMGR_TIMER_MANAGER_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdbool.h>
 
+#include <grpc/support/port_platform.h>
+
 // Timer Manager tries to keep only one thread waiting for the next timeout at
 // all times, and thus effectively preventing the thundering herd problem.
 

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

@@ -33,6 +33,7 @@
 #include <sys/un.h>
 #endif  // GPR_WINDOWS
 
+#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 
 #include <grpc/support/alloc.h>
@@ -49,7 +50,7 @@ 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
-  GPR_ASSERT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
+  CHECK_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sv), 0);
 #endif
 }
 

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

@@ -19,12 +19,11 @@
 #ifndef GRPC_SRC_CORE_LIB_IOMGR_UNIX_SOCKETS_POSIX_H
 #define GRPC_SRC_CORE_LIB_IOMGR_UNIX_SOCKETS_POSIX_H
 
-#include <grpc/support/port_platform.h>
-
 #include <string>
 
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/iomgr/port.h"

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

@@ -24,6 +24,8 @@
 
 #include <string>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/crash.h"
@@ -32,7 +34,7 @@ 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
-  GPR_ASSERT(0);
+  CHECK(0);
 }
 
 absl::StatusOr<std::vector<grpc_resolved_address>>

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

@@ -15,10 +15,10 @@
 // limitations under the License.
 //
 //
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/iomgr/vsock.h"
 
+#include <grpc/support/port_platform.h>
+
 #ifdef GRPC_HAVE_VSOCK
 
 #include <string.h>

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

@@ -19,12 +19,11 @@
 #ifndef GRPC_SRC_CORE_LIB_IOMGR_VSOCK_H
 #define GRPC_SRC_CORE_LIB_IOMGR_VSOCK_H
 
-#include <grpc/support/port_platform.h>
-
 #include <string>
 
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/iomgr/port.h"

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

@@ -17,9 +17,8 @@
 #ifndef GRPC_SRC_CORE_LIB_JSON_JSON_H
 #define GRPC_SRC_CORE_LIB_JSON_JSON_H
 
-#include <grpc/support/port_platform.h>
-
 #include <grpc/support/json.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 

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

@@ -15,10 +15,10 @@
 #ifndef GRPC_SRC_CORE_LIB_JSON_JSON_ARGS_H
 #define GRPC_SRC_CORE_LIB_JSON_JSON_ARGS_H
 
-#include <grpc/support/port_platform.h>
-
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 class JsonArgs {

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

@@ -15,11 +15,11 @@
 #ifndef GRPC_SRC_CORE_LIB_JSON_JSON_CHANNEL_ARGS_H
 #define GRPC_SRC_CORE_LIB_JSON_JSON_CHANNEL_ARGS_H
 
-#include <grpc/support/port_platform.h>
-
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/json/json_args.h"