grpc 1.75.0.pre1 → 1.76.0.pre1

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

@@ -25,7 +25,6 @@
 #include <fcntl.h>
 #include <string.h>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -38,6 +37,7 @@
 #include "src/core/lib/iomgr/socket_windows.h"
 #include "src/core/lib/iomgr/tcp_windows.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 
 static void create_sockets(SOCKET sv[2]) {
   SOCKET svr_sock = INVALID_SOCKET;
@@ -48,25 +48,26 @@ static void create_sockets(SOCKET sv[2]) {
 
   lst_sock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
                        grpc_get_default_wsa_socket_flags());
-  CHECK(lst_sock != INVALID_SOCKET);
+  GRPC_CHECK(lst_sock != INVALID_SOCKET);
 
   memset(&addr, 0, sizeof(addr));
   addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
   addr.sin_family = AF_INET;
-  CHECK(bind(lst_sock, (grpc_sockaddr*)&addr, sizeof(addr)) != SOCKET_ERROR);
-  CHECK(listen(lst_sock, SOMAXCONN) != SOCKET_ERROR);
-  CHECK(getsockname(lst_sock, (grpc_sockaddr*)&addr, &addr_len) !=
-        SOCKET_ERROR);
+  GRPC_CHECK(bind(lst_sock, (grpc_sockaddr*)&addr, sizeof(addr)) !=
+             SOCKET_ERROR);
+  GRPC_CHECK(listen(lst_sock, SOMAXCONN) != SOCKET_ERROR);
+  GRPC_CHECK(getsockname(lst_sock, (grpc_sockaddr*)&addr, &addr_len) !=
+             SOCKET_ERROR);
 
   cli_sock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
                        grpc_get_default_wsa_socket_flags());
-  CHECK(cli_sock != INVALID_SOCKET);
+  GRPC_CHECK(cli_sock != INVALID_SOCKET);
 
-  CHECK_EQ(WSAConnect(cli_sock, (grpc_sockaddr*)&addr, addr_len, NULL, NULL,
-                      NULL, NULL),
-           0);
+  GRPC_CHECK_EQ(WSAConnect(cli_sock, (grpc_sockaddr*)&addr, addr_len, NULL,
+                           NULL, NULL, NULL),
+                0);
   svr_sock = accept(lst_sock, (grpc_sockaddr*)&addr, &addr_len);
-  CHECK_NE(svr_sock, INVALID_SOCKET);
+  GRPC_CHECK_NE(svr_sock, INVALID_SOCKET);
 
   closesocket(lst_sock);
   grpc_error_handle error = grpc_tcp_prepare_socket(cli_sock);
@@ -100,20 +101,20 @@ grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(
             new_args
                 .GetObjectRef<grpc_event_engine::experimental::EventEngine>()
                 .get());
-    CHECK_NE(event_engine_supports_win_sockets, nullptr)
+    GRPC_CHECK_NE(event_engine_supports_win_sockets, nullptr)
         << "EventEngine does not support windows SOCKETS, so an endpoint pair "
            "cannot be created.";
     auto client_endpoint =
         event_engine_supports_win_sockets->CreateEndpointFromWinSocket(
             sv[1], grpc_event_engine::experimental::ChannelArgsEndpointConfig(
                        new_args));
-    CHECK_NE(client_endpoint.get(), nullptr)
+    GRPC_CHECK_NE(client_endpoint.get(), nullptr)
         << "Failed to create client endpoint";
     auto server_endpoint =
         event_engine_supports_win_sockets->CreateEndpointFromWinSocket(
             sv[0], grpc_event_engine::experimental::ChannelArgsEndpointConfig(
                        new_args));
-    CHECK_NE(server_endpoint.get(), nullptr)
+    GRPC_CHECK_NE(server_endpoint.get(), nullptr)
         << "Failed to create server endpoint";
     p.client = grpc_event_engine_endpoint_create(std::move(client_endpoint));
     p.server = grpc_event_engine_endpoint_create(std::move(server_endpoint));

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

@@ -40,7 +40,6 @@
 #include <string>
 #include <vector>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
@@ -55,6 +54,7 @@
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/manual_constructor.h"
 #include "src/core/util/strerror.h"
 #include "src/core/util/string.h"
@@ -421,8 +421,8 @@ static void fd_orphan(grpc_fd* fd, grpc_closure* on_done, int* release_fd,
   if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled() &&
       !grpc_event_engine::experimental::
           EventEngineExperimentDisabledForPython()) {
-    CHECK_NE(release_fd, nullptr);
-    CHECK_EQ(on_done, nullptr);
+    GRPC_CHECK_NE(release_fd, nullptr);
+    GRPC_CHECK_EQ(on_done, nullptr);
     *release_fd = fd->fd;
     gpr_free(fd);
     return;
@@ -647,8 +647,8 @@ static void pollset_maybe_finish_shutdown(grpc_pollset* pollset) {
 }
 
 static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
-  CHECK_EQ(pollset->shutdown_closure, nullptr);
-  CHECK(!pollset->shutting_down);
+  GRPC_CHECK_EQ(pollset->shutdown_closure, nullptr);
+  GRPC_CHECK(!pollset->shutting_down);
   pollset->shutdown_closure = closure;
   pollset->shutting_down = true;
   GRPC_LOG_IF_ERROR("pollset_shutdown", pollset_kick_all(pollset));
@@ -816,7 +816,7 @@ static bool begin_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
       }
     }
     if (is_reassigning) {
-      CHECK(pollset->reassigning_neighborhood);
+      GRPC_CHECK(pollset->reassigning_neighborhood);
       pollset->reassigning_neighborhood = false;
     }
     gpr_mu_unlock(&neighborhood->mu);
@@ -825,7 +825,7 @@ static bool begin_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
   worker_insert(pollset, worker);
   pollset->begin_refs--;
   if (worker->state == UNKICKED && !pollset->kicked_without_poller) {
-    CHECK(gpr_atm_no_barrier_load(&g_active_poller) != (gpr_atm)worker);
+    GRPC_CHECK(gpr_atm_no_barrier_load(&g_active_poller) != (gpr_atm)worker);
     worker->initialized_cv = true;
     gpr_cv_init(&worker->cv);
     while (worker->state == UNKICKED && !pollset->shutting_down) {
@@ -877,7 +877,7 @@ static bool check_neighborhood_for_available_poller(
       break;
     }
     gpr_mu_lock(&inspect->mu);
-    CHECK(!inspect->seen_inactive);
+    GRPC_CHECK(!inspect->seen_inactive);
     grpc_pollset_worker* inspect_worker = inspect->root_worker;
     if (inspect_worker != nullptr) {
       do {
@@ -939,7 +939,7 @@ static void end_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
     if (worker->next != worker && worker->next->state == UNKICKED) {
       GRPC_TRACE_LOG(polling, INFO)
           << " .. choose next poller to be peer " << worker;
-      CHECK(worker->next->initialized_cv);
+      GRPC_CHECK(worker->next->initialized_cv);
       gpr_atm_no_barrier_store(&g_active_poller, (gpr_atm)worker->next);
       SET_KICK_STATE(worker->next, DESIGNATED_POLLER);
       gpr_cv_signal(&worker->next->cv);
@@ -991,7 +991,7 @@ static void end_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
   if (EMPTIED == worker_remove(pollset, worker)) {
     pollset_maybe_finish_shutdown(pollset);
   }
-  CHECK(gpr_atm_no_barrier_load(&g_active_poller) != (gpr_atm)worker);
+  GRPC_CHECK(gpr_atm_no_barrier_load(&g_active_poller) != (gpr_atm)worker);
 }
 
 // pollset->po.mu lock must be held by the caller before calling this.
@@ -1012,8 +1012,8 @@ static grpc_error_handle pollset_work(grpc_pollset* ps,
   if (begin_worker(ps, &worker, worker_hdl, deadline)) {
     g_current_thread_pollset = ps;
     g_current_thread_worker = &worker;
-    CHECK(!ps->shutting_down);
-    CHECK(!ps->seen_inactive);
+    GRPC_CHECK(!ps->shutting_down);
+    GRPC_CHECK(!ps->seen_inactive);
 
     gpr_mu_unlock(&ps->mu);  // unlock
     // This is the designated polling thread at this point and should ideally do
@@ -1099,7 +1099,7 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
         goto done;
       } else if (next_worker->state == UNKICKED) {
         GRPC_TRACE_LOG(polling, INFO) << " .. kicked " << next_worker;
-        CHECK(next_worker->initialized_cv);
+        GRPC_CHECK(next_worker->initialized_cv);
         SET_KICK_STATE(next_worker, KICKED);
         gpr_cv_signal(&next_worker->cv);
         goto done;
@@ -1122,7 +1122,7 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
           goto done;
         }
       } else {
-        CHECK(next_worker->state == KICKED);
+        GRPC_CHECK(next_worker->state == KICKED);
         SET_KICK_STATE(next_worker, KICKED);
         goto done;
       }
@@ -1251,7 +1251,7 @@ const grpc_event_engine_vtable grpc_ev_epoll1_posix = {
     /* check_engine_available = */
     [](bool) { return init_epoll1_linux(); },
     /* init_engine = */
-    []() { CHECK(init_epoll1_linux()); },
+    []() { GRPC_CHECK(init_epoll1_linux()); },
     shutdown_background_closure,
     /* shutdown_engine = */
     []() { shutdown_engine(); },

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

@@ -34,7 +34,6 @@
 
 #include <string>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
@@ -47,6 +46,7 @@
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/thd.h"
 #include "src/core/util/useful.h"
 
@@ -350,7 +350,7 @@ static void ref_by(grpc_fd* fd, int n, const char* reason, const char* file,
   } while (0)
 static void ref_by(grpc_fd* fd, int n) {
 #endif
-  CHECK_GT(gpr_atm_no_barrier_fetch_add(&fd->refst, n), 0);
+  GRPC_CHECK_GT(gpr_atm_no_barrier_fetch_add(&fd->refst, n), 0);
 }
 
 #ifndef NDEBUG
@@ -374,7 +374,7 @@ static void unref_by(grpc_fd* fd, int n) {
     fd->shutdown_error.~Status();
     gpr_free(fd);
   } else {
-    CHECK(old > n);
+    GRPC_CHECK(old > n);
   }
 }
 
@@ -392,7 +392,7 @@ static grpc_fd* fd_create(int fd, const char* name, bool track_err) {
   }
   // Avoid unused-parameter warning for debug-only parameter
   (void)track_err;
-  DCHECK(track_err == false);
+  GRPC_DCHECK(track_err == false);
   grpc_fd* r = static_cast<grpc_fd*>(gpr_malloc(sizeof(*r)));
   gpr_mu_init(&r->mu);
   gpr_atm_rel_store(&r->refst, 1);
@@ -422,7 +422,7 @@ static bool fd_is_orphaned(grpc_fd* fd) {
 
 static grpc_error_handle pollset_kick_locked(grpc_fd_watcher* watcher) {
   gpr_mu_lock(&watcher->pollset->mu);
-  CHECK(watcher->worker);
+  GRPC_CHECK(watcher->worker);
   grpc_error_handle err =
       pollset_kick_ext(watcher->pollset, watcher->worker,
                        GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP);
@@ -483,8 +483,8 @@ static void fd_orphan(grpc_fd* fd, grpc_closure* on_done, int* release_fd,
   if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled() &&
       !grpc_event_engine::experimental::
           EventEngineExperimentDisabledForPython()) {
-    CHECK_NE(release_fd, nullptr);
-    CHECK_EQ(on_done, nullptr);
+    GRPC_CHECK_NE(release_fd, nullptr);
+    GRPC_CHECK_EQ(on_done, nullptr);
     *release_fd = fd->fd;
     gpr_free(fd);
     return;
@@ -805,7 +805,7 @@ static grpc_error_handle pollset_kick_ext(grpc_pollset* p,
   // pollset->mu already held
   if (specific_worker != nullptr) {
     if (specific_worker == GRPC_POLLSET_KICK_BROADCAST) {
-      CHECK_EQ((flags & GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP), 0u);
+      GRPC_CHECK_EQ((flags & GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP), 0u);
       for (specific_worker = p->root_worker.next;
            specific_worker != &p->root_worker;
            specific_worker = specific_worker->next) {
@@ -829,7 +829,7 @@ static grpc_error_handle pollset_kick_ext(grpc_pollset* p,
                         grpc_wakeup_fd_wakeup(&specific_worker->wakeup_fd->fd));
     }
   } else if (g_current_thread_poller != p) {
-    CHECK_EQ((flags & GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP), 0u);
+    GRPC_CHECK_EQ((flags & GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP), 0u);
     specific_worker = pop_front_worker(p);
     if (specific_worker != nullptr) {
       if (g_current_thread_worker == specific_worker) {
@@ -882,7 +882,7 @@ static void pollset_init(grpc_pollset* pollset, gpr_mu** mu) {
 }
 
 static void pollset_destroy(grpc_pollset* pollset) {
-  CHECK(!pollset_has_workers(pollset));
+  GRPC_CHECK(!pollset_has_workers(pollset));
   while (pollset->local_wakeup_cache) {
     grpc_cached_wakeup_fd* next = pollset->local_wakeup_cache->next;
     fork_fd_list_remove_wakeup_fd(pollset->local_wakeup_cache);
@@ -1160,7 +1160,7 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
 }
 
 static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
-  CHECK(!pollset->shutting_down);
+  GRPC_CHECK(!pollset->shutting_down);
   pollset->shutting_down = 1;
   pollset->shutdown_done = closure;
   (void)pollset_kick(pollset, GRPC_POLLSET_KICK_BROADCAST);

data/src/core/lib/iomgr/event_engine_shims/endpoint.cc

@@ -25,7 +25,6 @@
 #include <utility>
 
 #include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -45,6 +44,7 @@
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/util/construct_destruct.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/string.h"
 #include "src/core/util/sync.h"
 
@@ -412,9 +412,10 @@ EventEngineEndpointWrapper::EventEngineEndpointWrapper(
 }  // namespace
 
 grpc_endpoint* grpc_event_engine_endpoint_create(
-    std::unique_ptr<EventEngine::Endpoint> ee_endpoint) {
-  DCHECK(ee_endpoint != nullptr);
-  auto wrapper = new EventEngineEndpointWrapper(std::move(ee_endpoint));
+    absl::StatusOr<std::unique_ptr<EventEngine::Endpoint>> ee_endpoint) {
+  GRPC_DCHECK(ee_endpoint.ok()) << ee_endpoint.status();
+  GRPC_DCHECK(ee_endpoint.value() != nullptr);
+  auto wrapper = new EventEngineEndpointWrapper(std::move(ee_endpoint).value());
   return wrapper->GetGrpcEndpoint();
 }
 

data/src/core/lib/iomgr/event_engine_shims/endpoint.h

@@ -27,7 +27,7 @@ namespace experimental {
 /// Server code needs to create grpc_endpoints after the EventEngine has made
 /// connections.
 grpc_endpoint* grpc_event_engine_endpoint_create(
-    std::unique_ptr<EventEngine::Endpoint> ee_endpoint);
+    absl::StatusOr<std::unique_ptr<EventEngine::Endpoint>> ee_endpoint);
 
 /// Returns true if the passed endpoint is an event engine shim endpoint.
 bool grpc_is_event_engine_endpoint(grpc_endpoint* ep);

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

@@ -28,7 +28,6 @@
 
 #include <limits>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
@@ -37,6 +36,7 @@
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/thd.h"
 
 static ULONG g_iocp_kick_token;
@@ -73,8 +73,8 @@ grpc_iocp_work_status grpc_iocp_work(grpc_core::Timestamp deadline) {
   if (success == 0 && overlapped == NULL) {
     return GRPC_IOCP_WORK_TIMEOUT;
   }
-  CHECK(completion_key);
-  CHECK(overlapped);
+  GRPC_CHECK(completion_key);
+  GRPC_CHECK(overlapped);
   if (overlapped == &g_iocp_custom_overlap) {
     gpr_atm_full_fetch_add(&g_custom_events, -1);
     if (completion_key == (ULONG_PTR)&g_iocp_kick_token) {
@@ -102,7 +102,7 @@ grpc_iocp_work_status grpc_iocp_work(grpc_core::Timestamp deadline) {
     info->bytes_transferred = bytes;
     info->wsa_error = success ? 0 : WSAGetLastError();
   }
-  CHECK(overlapped == &info->overlapped);
+  GRPC_CHECK(overlapped == &info->overlapped);
   bool should_destroy = grpc_socket_become_ready(socket, info);
   gpr_mu_unlock(&socket->state_mu);
   if (should_destroy) {
@@ -114,7 +114,7 @@ grpc_iocp_work_status grpc_iocp_work(grpc_core::Timestamp deadline) {
 void grpc_iocp_init(void) {
   g_iocp =
       CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, (ULONG_PTR)NULL, 0);
-  CHECK(g_iocp);
+  GRPC_CHECK(g_iocp);
 }
 
 void grpc_iocp_kick(void) {
@@ -123,7 +123,7 @@ void grpc_iocp_kick(void) {
   gpr_atm_full_fetch_add(&g_custom_events, 1);
   success = PostQueuedCompletionStatus(g_iocp, 0, (ULONG_PTR)&g_iocp_kick_token,
                                        &g_iocp_custom_overlap);
-  CHECK(success);
+  GRPC_CHECK(success);
 }
 
 void grpc_iocp_flush(void) {
@@ -145,7 +145,7 @@ void grpc_iocp_shutdown(void) {
     grpc_core::ExecCtx::Get()->Flush();
   }
 
-  CHECK(CloseHandle(g_iocp));
+  GRPC_CHECK(CloseHandle(g_iocp));
 }
 
 void grpc_iocp_add_socket(grpc_winsocket* socket) {
@@ -161,7 +161,7 @@ void grpc_iocp_add_socket(grpc_winsocket* socket) {
     abort();
   }
   socket->added_to_iocp = 1;
-  CHECK(ret == g_iocp);
+  GRPC_CHECK(ret == g_iocp);
 }
 
 void grpc_iocp_register_socket_shutdown_socket_locked(grpc_winsocket* socket) {

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

@@ -22,7 +22,6 @@
 
 #ifdef GRPC_WINSOCK_SOCKET
 
-#include "absl/log/check.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/iomgr.h"
@@ -35,6 +34,7 @@
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 
 extern grpc_tcp_server_vtable grpc_windows_tcp_server_vtable;
 extern grpc_tcp_server_vtable grpc_windows_event_engine_tcp_server_vtable;
@@ -50,12 +50,12 @@ extern grpc_pollset_set_vtable grpc_windows_pollset_set_vtable;
 static void winsock_init(void) {
   WSADATA wsaData;
   int status = WSAStartup(MAKEWORD(2, 0), &wsaData);
-  CHECK_EQ(status, 0);
+  GRPC_CHECK_EQ(status, 0);
 }
 
 static void winsock_shutdown(void) {
   int status = WSACleanup();
-  CHECK_EQ(status, 0);
+  GRPC_CHECK_EQ(status, 0);
 }
 
 static void iomgr_platform_init(void) {

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

@@ -20,11 +20,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 
 // 'state' holds the to call when the fd is readable or writable respectively.
 // It can contain one of the following values:
@@ -78,7 +78,7 @@ void LockfreeEvent::DestroyEvent() {
     if (curr & kShutdownBit) {
       internal::StatusFreeHeapPtr(curr & ~kShutdownBit);
     } else {
-      CHECK(curr == kClosureNotReady || curr == kClosureReady);
+      GRPC_CHECK(curr == kClosureNotReady || curr == kClosureReady);
     }
     // we CAS in a shutdown, no error value here. If this event is interacted
     // with post-deletion (see the note in the constructor) we want the bit

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

@@ -21,9 +21,9 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/port_platform.h>
 
-#include "absl/log/check.h"
 #include "absl/strings/str_format.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 
 grpc_polling_entity grpc_polling_entity_create_from_pollset_set(
     grpc_pollset_set* pollset_set) {
@@ -72,7 +72,7 @@ void grpc_polling_entity_add_to_pollset_set(grpc_polling_entity* pollent,
       grpc_pollset_set_add_pollset(pss_dst, pollent->pollent.pollset);
     }
   } else if (pollent->tag == GRPC_POLLS_POLLSET_SET) {
-    CHECK_NE(pollent->pollent.pollset_set, nullptr);
+    GRPC_CHECK_NE(pollent->pollent.pollset_set, nullptr);
     grpc_pollset_set_add_pollset_set(pss_dst, pollent->pollent.pollset_set);
   } else if (pollent->tag == GRPC_POLLS_NONE) {
     // Do nothing.
@@ -90,7 +90,7 @@ void grpc_polling_entity_del_from_pollset_set(grpc_polling_entity* pollent,
       grpc_pollset_set_del_pollset(pss_dst, pollent->pollent.pollset);
     }
   } else if (pollent->tag == GRPC_POLLS_POLLSET_SET) {
-    CHECK_NE(pollent->pollent.pollset_set, nullptr);
+    GRPC_CHECK_NE(pollent->pollent.pollset_set, nullptr);
     grpc_pollset_set_del_pollset_set(pss_dst, pollent->pollent.pollset_set);
   } else if (pollent->tag == GRPC_POLLS_NONE) {
     // Do nothing.

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

@@ -46,13 +46,13 @@
 
 #include <string>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_factory_posix.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/strerror.h"
 #include "src/core/util/string.h"
 
@@ -416,7 +416,7 @@ grpc_error_handle grpc_set_socket_tcp_user_timeout(
 // set a socket using a grpc_socket_mutator
 grpc_error_handle grpc_set_socket_with_mutator(int fd, grpc_fd_usage usage,
                                                grpc_socket_mutator* mutator) {
-  CHECK(mutator);
+  GRPC_CHECK(mutator);
   if (!grpc_socket_mutator_mutate_fd(mutator, fd, usage)) {
     return GRPC_ERROR_CREATE("grpc_socket_mutator failed.");
   }

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

@@ -29,7 +29,6 @@
 #include <grpc/support/log_windows.h>
 #include <mswsock.h>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_format.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
@@ -39,6 +38,7 @@
 #include "src/core/lib/iomgr/sockaddr_windows.h"
 #include "src/core/lib/iomgr/socket_windows.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 
 static DWORD s_wsa_socket_flags;
 
@@ -157,7 +157,7 @@ void grpc_winsocket_finish(grpc_winsocket* winsocket) {
 
 void grpc_winsocket_destroy(grpc_winsocket* winsocket) {
   gpr_mu_lock(&winsocket->state_mu);
-  CHECK(!winsocket->destroy_called);
+  GRPC_CHECK(!winsocket->destroy_called);
   winsocket->destroy_called = true;
   bool should_destroy = check_destroyable(winsocket);
   gpr_mu_unlock(&winsocket->state_mu);
@@ -172,7 +172,7 @@ void grpc_winsocket_destroy(grpc_winsocket* winsocket) {
 //-) The IOCP hasn't completed yet, and we're queuing it for later.
 static void socket_notify_on_iocp(grpc_winsocket* socket, grpc_closure* closure,
                                   grpc_winsocket_callback_info* info) {
-  CHECK(info->closure == NULL);
+  GRPC_CHECK(info->closure == NULL);
   gpr_mu_lock(&socket->state_mu);
   if (info->has_pending_iocp) {
     info->has_pending_iocp = 0;
@@ -194,7 +194,7 @@ void grpc_socket_notify_on_read(grpc_winsocket* socket, grpc_closure* closure) {
 
 bool grpc_socket_become_ready(grpc_winsocket* socket,
                               grpc_winsocket_callback_info* info) {
-  CHECK(!info->has_pending_iocp);
+  GRPC_CHECK(!info->has_pending_iocp);
   if (info->closure) {
     // Only run the closure once at shutdown.
     if (!info->closure_already_executed_at_shutdown) {

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

@@ -33,7 +33,6 @@
 #include <memory>
 
 #include "absl/container/flat_hash_map.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -53,6 +52,7 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/net/socket_mutator.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/string.h"
 
@@ -103,7 +103,7 @@ static grpc_error_handle prepare_socket(
     const grpc_core::PosixTcpOptions& options) {
   grpc_error_handle err;
 
-  CHECK_GE(fd, 0);
+  GRPC_CHECK_GE(fd, 0);
 
   err = grpc_set_socket_nonblocking(fd, 1);
   if (!err.ok()) goto error;
@@ -187,7 +187,7 @@ static void on_writable(void* acp, grpc_error_handle error) {
       << ": on_writable: error=" << grpc_core::StatusToString(error);
 
   gpr_mu_lock(&ac->mu);
-  CHECK(ac->fd);
+  GRPC_CHECK(ac->fd);
   fd = ac->fd;
   ac->fd = nullptr;
   bool connect_cancelled = ac->connect_cancelled;
@@ -438,7 +438,7 @@ static bool tcp_cancel_connect(int64_t connection_handle) {
     auto it = shard->pending_connections.find(connection_handle);
     if (it != shard->pending_connections.end()) {
       ac = it->second;
-      CHECK_NE(ac, nullptr);
+      GRPC_CHECK_NE(ac, nullptr);
       // Trying to acquire ac->mu here would could cause a deadlock because
       // the on_writable method tries to acquire the two mutexes used
       // here in the reverse order. But we dont need to acquire ac->mu before

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

@@ -28,7 +28,6 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log_windows.h>
 
-#include "absl/log/check.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/iomgr/event_engine_shims/tcp_client.h"
@@ -42,6 +41,7 @@
 #include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 
 using ::grpc_event_engine::experimental::EndpointConfig;
 
@@ -82,7 +82,7 @@ static void on_alarm(void* acp, grpc_error_handle /* error */) {
 static void on_connect(void* acp, grpc_error_handle error) {
   async_connect* ac = (async_connect*)acp;
   grpc_endpoint** ep = ac->endpoint;
-  CHECK(*ep == NULL);
+  GRPC_CHECK(*ep == NULL);
   grpc_closure* on_done = ac->on_done;
 
   gpr_mu_lock(&ac->mu);
@@ -101,7 +101,7 @@ static void on_connect(void* acp, grpc_error_handle error) {
       BOOL wsa_success =
           WSAGetOverlappedResult(socket->socket, &socket->write_info.overlapped,
                                  &transferred_bytes, FALSE, &flags);
-      CHECK_EQ(transferred_bytes, 0);
+      GRPC_CHECK_EQ(transferred_bytes, 0);
       if (!wsa_success) {
         error = GRPC_WSA_ERROR(WSAGetLastError(), "ConnectEx");
         closesocket(socket->socket);
@@ -242,7 +242,7 @@ static int64_t tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
   return 0;
 
 failure:
-  CHECK(!error.ok());
+  GRPC_CHECK(!error.ok());
   grpc_error_handle final_error =
       GRPC_ERROR_CREATE_REFERENCING("Failed to connect", &error, 1);
   if (socket != NULL) {