grpc 1.75.0.pre1 → 1.76.0.pre1

data/src/core/lib/event_engine/windows/grpc_polled_fd_windows.cc

@@ -22,7 +22,6 @@
 #include <winsock2.h>
 
 #include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -35,6 +34,7 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/sync.h"
 
 // TODO(apolcyn): remove this hack after fixing upstream.
@@ -130,8 +130,8 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
         << "| ~GrpcPolledFdWindows shutdown_called_: " << shutdown_called_;
     grpc_core::CSliceUnref(read_buf_);
     grpc_core::CSliceUnref(write_buf_);
-    CHECK(read_closure_ == nullptr);
-    CHECK(write_closure_ == nullptr);
+    GRPC_CHECK(read_closure_ == nullptr);
+    GRPC_CHECK(write_closure_ == nullptr);
     if (!shutdown_called_) {
       winsocket_->Shutdown(DEBUG_LOCATION, "~GrpcPolledFdWindows");
     }
@@ -139,15 +139,15 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
 
   void RegisterForOnReadableLocked(
       absl::AnyInvocable<void(absl::Status)> read_closure) override {
-    CHECK(read_closure_ == nullptr);
+    GRPC_CHECK(read_closure_ == nullptr);
     read_closure_ = std::move(read_closure);
     grpc_core::CSliceUnref(read_buf_);
-    CHECK(!read_buf_has_data_);
+    GRPC_CHECK(!read_buf_has_data_);
     read_buf_ = GRPC_SLICE_MALLOC(kReadBufferSize);
     if (connect_done_) {
       ContinueRegisterForOnReadableLocked();
     } else {
-      CHECK(pending_continue_register_for_on_readable_locked_ == false);
+      GRPC_CHECK(pending_continue_register_for_on_readable_locked_ == false);
       pending_continue_register_for_on_readable_locked_ = true;
     }
   }
@@ -159,17 +159,17 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
           << "(EventEngine c-ares resolver) fd:|" << GetName()
           << "| RegisterForOnWriteableLocked called";
     } else {
-      CHECK(socket_type_ == SOCK_STREAM);
+      GRPC_CHECK(socket_type_ == SOCK_STREAM);
       GRPC_TRACE_LOG(cares_resolver, INFO)
           << "(EventEngine c-ares resolver) fd:|" << GetName()
           << "| RegisterForOnWriteableLocked called tcp_write_state_: "
           << static_cast<int>(tcp_write_state_)
           << " connect_done_: " << connect_done_;
     }
-    CHECK(write_closure_ == nullptr);
+    GRPC_CHECK(write_closure_ == nullptr);
     write_closure_ = std::move(write_closure);
     if (!connect_done_) {
-      CHECK(!pending_continue_register_for_on_writeable_locked_);
+      GRPC_CHECK(!pending_continue_register_for_on_writeable_locked_);
       pending_continue_register_for_on_writeable_locked_ = true;
     } else {
       ContinueRegisterForOnWriteableLocked();
@@ -179,7 +179,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
   bool IsFdStillReadableLocked() override { return read_buf_has_data_; }
 
   bool ShutdownLocked(absl::Status error) override {
-    CHECK(!shutdown_called_);
+    GRPC_CHECK(!shutdown_called_);
     if (!absl::IsCancelled(error)) {
       return false;
     }
@@ -224,7 +224,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
     // c-ares overloads this recv_from virtual socket function to receive
     // data on both UDP and TCP sockets, and from is nullptr for TCP.
     if (from != nullptr) {
-      CHECK(*from_len >= recv_from_source_addr_len_);
+      GRPC_CHECK(*from_len >= recv_from_source_addr_len_);
       memcpy(from, &recv_from_source_addr_, recv_from_source_addr_len_);
       *from_len = recv_from_source_addr_len_;
     }
@@ -295,7 +295,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
         << "(EventEngine c-ares resolver) fd:|" << GetName()
         << "| ContinueRegisterForOnReadableLocked wsa_connect_error_:"
         << wsa_connect_error_;
-    CHECK(connect_done_);
+    GRPC_CHECK(connect_done_);
     if (wsa_connect_error_ != 0) {
       ScheduleAndNullReadClosure(GRPC_WSA_ERROR(wsa_connect_error_, "connect"));
       return;
@@ -332,7 +332,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
         << "(EventEngine c-ares resolver) fd:|" << GetName()
         << "| ContinueRegisterForOnWriteableLocked wsa_connect_error_:"
         << wsa_connect_error_;
-    CHECK(connect_done_);
+    GRPC_CHECK(connect_done_);
     if (wsa_connect_error_ != 0) {
       ScheduleAndNullWriteClosure(
           GRPC_WSA_ERROR(wsa_connect_error_, "connect"));
@@ -342,7 +342,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
       ScheduleAndNullWriteClosure(absl::OkStatus());
       return;
     }
-    CHECK(socket_type_ == SOCK_STREAM);
+    GRPC_CHECK(socket_type_ == SOCK_STREAM);
     int wsa_error_code = 0;
     switch (tcp_write_state_) {
       case WRITE_IDLE:
@@ -391,7 +391,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
     // to write everything inline.
     GRPC_TRACE_LOG(cares_resolver, INFO) << "(EventEngine c-ares resolver) fd:|"
                                          << GetName() << "| SendVUDP called";
-    CHECK_EQ(GRPC_SLICE_LENGTH(write_buf_), 0);
+    GRPC_CHECK_EQ(GRPC_SLICE_LENGTH(write_buf_), 0);
     grpc_core::CSliceUnref(write_buf_);
     write_buf_ = FlattenIovec(iov, iov_count);
     DWORD bytes_sent = 0;
@@ -442,12 +442,12 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
         // send again. If c-ares still needs to send even more data, we'll get
         // to it eventually.
         grpc_slice currently_attempted = FlattenIovec(iov, iov_count);
-        CHECK(GRPC_SLICE_LENGTH(currently_attempted) >=
-              GRPC_SLICE_LENGTH(write_buf_));
+        GRPC_CHECK(GRPC_SLICE_LENGTH(currently_attempted) >=
+                   GRPC_SLICE_LENGTH(write_buf_));
         ares_ssize_t total_sent = 0;
         for (size_t i = 0; i < GRPC_SLICE_LENGTH(write_buf_); i++) {
-          CHECK(GRPC_SLICE_START_PTR(currently_attempted)[i] ==
-                GRPC_SLICE_START_PTR(write_buf_)[i]);
+          GRPC_CHECK(GRPC_SLICE_START_PTR(currently_attempted)[i] ==
+                     GRPC_SLICE_START_PTR(write_buf_)[i]);
           total_sent++;
         }
         grpc_core::CSliceUnref(currently_attempted);
@@ -466,9 +466,9 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
         << pending_continue_register_for_on_readable_locked_
         << " pending_register_for_writeable:"
         << pending_continue_register_for_on_writeable_locked_;
-    CHECK(!connect_done_);
+    GRPC_CHECK(!connect_done_);
     connect_done_ = true;
-    CHECK_EQ(wsa_connect_error_, 0);
+    GRPC_CHECK_EQ(wsa_connect_error_, 0);
     if (shutdown_called_) {
       wsa_connect_error_ = WSA_OPERATION_ABORTED;
     } else {
@@ -477,7 +477,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
       BOOL wsa_success = WSAGetOverlappedResult(
           winsocket_->raw_socket(), winsocket_->write_info()->overlapped(),
           &transferred_bytes, FALSE, &flags);
-      CHECK_EQ(transferred_bytes, 0);
+      GRPC_CHECK_EQ(transferred_bytes, 0);
       if (!wsa_success) {
         wsa_connect_error_ = WSAGetLastError();
         char* msg = gpr_format_message(wsa_connect_error_);
@@ -500,8 +500,8 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
                  ares_socklen_t target_len) {
     GRPC_TRACE_LOG(cares_resolver, INFO)
         << "(EventEngine c-ares resolver) fd:" << GetName() << " ConnectUDP";
-    CHECK(!connect_done_);
-    CHECK_EQ(wsa_connect_error_, 0);
+    GRPC_CHECK(!connect_done_);
+    GRPC_CHECK_EQ(wsa_connect_error_, 0);
     SOCKET s = winsocket_->raw_socket();
     int out =
         WSAConnect(s, target, target_len, nullptr, nullptr, nullptr, nullptr);
@@ -639,7 +639,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
     GRPC_TRACE_LOG(cares_resolver, INFO)
         << "(EventEngine c-ares resolver) OnIocpWriteableInner. fd:|"
         << GetName() << "|";
-    CHECK(socket_type_ == SOCK_STREAM);
+    GRPC_CHECK(socket_type_ == SOCK_STREAM);
     absl::Status error;
     if (winsocket_->write_info()->result().wsa_error != 0) {
       error = GRPC_WSA_ERROR(winsocket_->write_info()->result().wsa_error,
@@ -651,7 +651,7 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
           << winsocket_->write_info()->result().wsa_error << "| msg:|"
           << grpc_core::StatusToString(error) << "|";
     }
-    CHECK(tcp_write_state_ == WRITE_PENDING);
+    GRPC_CHECK(tcp_write_state_ == WRITE_PENDING);
     if (error.ok()) {
       tcp_write_state_ = WRITE_WAITING_FOR_VERIFICATION_UPON_RETRY;
       write_buf_ = grpc_slice_sub_no_ref(
@@ -738,7 +738,7 @@ class CustomSockFuncs {
         << "(EventEngine c-ares resolver) fd:" << polled_fd->GetName()
         << " created with params af:" << af << " type:" << type
         << " protocol:" << protocol;
-    CHECK(self->sockets_.insert({s, std::move(polled_fd)}).second);
+    GRPC_CHECK(self->sockets_.insert({s, std::move(polled_fd)}).second);
     return s;
   }
 
@@ -748,7 +748,7 @@ class CustomSockFuncs {
     GrpcPolledFdFactoryWindows* self =
         static_cast<GrpcPolledFdFactoryWindows*>(user_data);
     auto it = self->sockets_.find(as);
-    CHECK(it != self->sockets_.end());
+    GRPC_CHECK(it != self->sockets_.end());
     return it->second->Connect(&wsa_error_ctx, target, target_len);
   }
 
@@ -758,7 +758,7 @@ class CustomSockFuncs {
     GrpcPolledFdFactoryWindows* self =
         static_cast<GrpcPolledFdFactoryWindows*>(user_data);
     auto it = self->sockets_.find(as);
-    CHECK(it != self->sockets_.end());
+    GRPC_CHECK(it != self->sockets_.end());
     return it->second->SendV(&wsa_error_ctx, iov, iovec_count);
   }
 
@@ -769,7 +769,7 @@ class CustomSockFuncs {
     GrpcPolledFdFactoryWindows* self =
         static_cast<GrpcPolledFdFactoryWindows*>(user_data);
     auto it = self->sockets_.find(as);
-    CHECK(it != self->sockets_.end());
+    GRPC_CHECK(it != self->sockets_.end());
     return it->second->RecvFrom(&wsa_error_ctx, data, data_len, flags, from,
                                 from_len);
   }
@@ -832,7 +832,7 @@ void GrpcPolledFdFactoryWindows::Initialize(grpc_core::Mutex* mutex,
 std::unique_ptr<GrpcPolledFd> GrpcPolledFdFactoryWindows::NewGrpcPolledFdLocked(
     ares_socket_t as) {
   auto it = sockets_.find(as);
-  CHECK(it != sockets_.end());
+  GRPC_CHECK(it != sockets_.end());
   return std::make_unique<GrpcPolledFdWrapper>(it->second.get());
 }
 

data/src/core/lib/event_engine/windows/iocp.cc

@@ -20,7 +20,6 @@
 
 #include <chrono>
 
-#include "absl/log/check.h"
 #include "absl/strings/str_format.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/time_util.h"
@@ -28,6 +27,7 @@
 #include "src/core/lib/event_engine/windows/win_socket.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_event_engine::experimental {
 
@@ -35,7 +35,7 @@ IOCP::IOCP(ThreadPool* thread_pool) noexcept
     : thread_pool_(thread_pool),
       iocp_handle_(CreateIoCompletionPort(INVALID_HANDLE_VALUE, nullptr,
                                           (ULONG_PTR) nullptr, 0)) {
-  CHECK(iocp_handle_);
+  GRPC_CHECK(iocp_handle_);
   WSASocketFlagsInit();
 }
 
@@ -52,7 +52,7 @@ std::unique_ptr<WinSocket> IOCP::Watch(SOCKET socket) {
         GRPC_WSA_ERROR(WSAGetLastError(), "Unable to add socket to iocp")
             .ToString());
   }
-  CHECK(ret == iocp_handle_);
+  GRPC_CHECK(ret == iocp_handle_);
   return wrapped_socket;
 }
 
@@ -63,7 +63,7 @@ void IOCP::Shutdown() {
   while (outstanding_kicks_.load() > 0) {
     Work(std::chrono::hours(42), []() {});
   }
-  CHECK(CloseHandle(iocp_handle_));
+  GRPC_CHECK(CloseHandle(iocp_handle_));
 }
 
 Poller::WorkResult IOCP::Work(EventEngine::Duration timeout,
@@ -81,8 +81,8 @@ Poller::WorkResult IOCP::Work(EventEngine::Duration timeout,
         << "IOCP::" << this << " deadline exceeded";
     return Poller::WorkResult::kDeadlineExceeded;
   }
-  CHECK(completion_key);
-  CHECK(overlapped);
+  GRPC_CHECK(completion_key);
+  GRPC_CHECK(overlapped);
   if (overlapped == &kick_overlap_) {
     GRPC_TRACE_LOG(event_engine_poller, INFO) << "IOCP::" << this << " kicked";
     outstanding_kicks_.fetch_sub(1);
@@ -101,7 +101,7 @@ Poller::WorkResult IOCP::Work(EventEngine::Duration timeout,
   // about to register for notification of an overlapped event.
   auto* socket = reinterpret_cast<WinSocket*>(completion_key);
   WinSocket::OpState* info = socket->GetOpInfoForOverlapped(overlapped);
-  CHECK_NE(info, nullptr);
+  GRPC_CHECK_NE(info, nullptr);
   info->GetOverlappedResult();
   info->SetReady();
   schedule_poll_again();
@@ -110,9 +110,9 @@ Poller::WorkResult IOCP::Work(EventEngine::Duration timeout,
 
 void IOCP::Kick() {
   outstanding_kicks_.fetch_add(1);
-  CHECK(PostQueuedCompletionStatus(iocp_handle_, 0,
-                                   reinterpret_cast<ULONG_PTR>(&kick_token_),
-                                   &kick_overlap_));
+  GRPC_CHECK(PostQueuedCompletionStatus(
+      iocp_handle_, 0, reinterpret_cast<ULONG_PTR>(&kick_token_),
+      &kick_overlap_));
 }
 
 DWORD IOCP::GetDefaultSocketFlags() {

data/src/core/lib/event_engine/windows/win_socket.cc

@@ -17,13 +17,13 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log_windows.h>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/windows/win_socket.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/sync.h"
 
 #if defined(__MSYS__) && defined(GPR_ARCH_64)
@@ -45,7 +45,7 @@ WinSocket::WinSocket(SOCKET socket, ThreadPool* thread_pool) noexcept
       write_info_(this) {}
 
 WinSocket::~WinSocket() {
-  CHECK(is_shutdown_.load());
+  GRPC_CHECK(is_shutdown_.load());
   GRPC_TRACE_LOG(event_engine_endpoint, INFO)
       << "WinSocket::" << this << " destroyed";
 }
@@ -103,7 +103,7 @@ void WinSocket::NotifyOnReady(OpState& info, EventEngine::Closure* closure) {
     return;
   };
   // It is an error if any notification is already registered for this socket.
-  CHECK_EQ(std::exchange(info.closure_, closure), nullptr);
+  GRPC_CHECK_EQ(std::exchange(info.closure_, closure), nullptr);
 }
 
 void WinSocket::NotifyOnRead(EventEngine::Closure* on_read) {
@@ -115,11 +115,11 @@ void WinSocket::NotifyOnWrite(EventEngine::Closure* on_write) {
 }
 
 void WinSocket::UnregisterReadCallback() {
-  CHECK_NE(std::exchange(read_info_.closure_, nullptr), nullptr);
+  GRPC_CHECK_NE(std::exchange(read_info_.closure_, nullptr), nullptr);
 }
 
 void WinSocket::UnregisterWriteCallback() {
-  CHECK_NE(std::exchange(write_info_.closure_, nullptr), nullptr);
+  GRPC_CHECK_NE(std::exchange(write_info_.closure_, nullptr), nullptr);
 }
 
 // ---- WinSocket::OpState ----
@@ -133,7 +133,7 @@ void WinSocket::OpState::SetReady() {
   auto* closure = std::exchange(closure_, nullptr);
   // If an IOCP event is returned for a socket, and no callback has been
   // registered for notification, this is invalid usage.
-  CHECK_NE(closure, nullptr);
+  GRPC_CHECK_NE(closure, nullptr);
   win_socket_->thread_pool_->Run(closure);
 }
 

data/src/core/lib/event_engine/windows/windows_endpoint.cc

@@ -20,7 +20,6 @@
 
 #include "absl/cleanup/cleanup.h"
 #include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
@@ -30,6 +29,7 @@
 #include "src/core/lib/event_engine/windows/windows_endpoint.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/status_helper.h"
 
 namespace grpc_event_engine::experimental {
@@ -59,7 +59,7 @@ WindowsEndpoint::WindowsEndpoint(
       io_state_(std::make_shared<AsyncIOState>(
           this, std::move(socket), std::move(engine), thread_pool)) {
   auto local_address = SocketToAddress(io_state_->socket->raw_socket());
-  CHECK(local_address.ok())
+  GRPC_CHECK(local_address.ok())
       << "Failed to get local socket address: " << local_address.status();
   local_address_ = std::move(*local_address);
   local_address_string_ = *ResolvedAddressToURI(local_address_);
@@ -81,7 +81,7 @@ void WindowsEndpoint::AsyncIOState::DoTcpRead(SliceBuffer* buffer) {
     return;
   }
   // Prepare the WSABUF struct
-  CHECK(buffer->Count() <= kMaxWSABUFCount);
+  GRPC_CHECK(buffer->Count() <= kMaxWSABUFCount);
   WSABUF wsa_buffers[kMaxWSABUFCount];
   for (size_t i = 0; i < buffer->Count(); i++) {
     auto& slice = buffer->MutableSliceAt(i);
@@ -160,11 +160,11 @@ bool WindowsEndpoint::Write(absl::AnyInvocable<void(absl::Status)> on_writable,
           << " WRITE (peer=" << peer_address_string_ << "): " << str;
     }
   }
-  CHECK(data->Count() <= UINT_MAX);
+  GRPC_CHECK(data->Count() <= UINT_MAX);
   absl::InlinedVector<WSABUF, kMaxWSABUFCount> buffers(data->Count());
   for (size_t i = 0; i < data->Count(); i++) {
     auto& slice = data->MutableSliceAt(i);
-    CHECK(slice.size() <= ULONG_MAX);
+    GRPC_CHECK(slice.size() <= ULONG_MAX);
     buffers[i].len = slice.size();
     buffers[i].buf = (char*)slice.begin();
   }
@@ -289,7 +289,7 @@ void WindowsEndpoint::HandleReadClosure::Run() {
     return ResetAndReturnCallback()(status);
   }
   if (result.bytes_transferred == 0) {
-    DCHECK_GT(io_state.use_count(), 0);
+    GRPC_DCHECK_GT(io_state.use_count(), 0);
     // Either the endpoint is shut down or we've seen the end of the stream
     if (GRPC_TRACE_FLAG_ENABLED(event_engine_endpoint_data)) {
       LOG(INFO) << "WindowsEndpoint::" << this << " read 0 bytes.";
@@ -308,8 +308,8 @@ void WindowsEndpoint::HandleReadClosure::Run() {
     }
     return ResetAndReturnCallback()(status);
   }
-  DCHECK_GT(result.bytes_transferred, 0);
-  DCHECK(result.bytes_transferred <= buffer_->Length());
+  GRPC_DCHECK_GT(result.bytes_transferred, 0);
+  GRPC_DCHECK(result.bytes_transferred <= buffer_->Length());
   buffer_->MoveFirstNBytesIntoSliceBuffer(result.bytes_transferred,
                                           last_read_buffer_);
   if (buffer_->Length() == 0) {
@@ -340,9 +340,9 @@ bool WindowsEndpoint::HandleReadClosure::MaybeFinishIfDataHasAlreadyBeenRead() {
 void WindowsEndpoint::HandleReadClosure::DonateSpareSlices(
     SliceBuffer* buffer) {
   // Donee buffer must be empty.
-  CHECK_EQ(buffer->Length(), 0);
+  GRPC_CHECK_EQ(buffer->Length(), 0);
   // HandleReadClosure must be in the reset state.
-  CHECK_EQ(buffer_, nullptr);
+  GRPC_CHECK_EQ(buffer_, nullptr);
   buffer->Swap(last_read_buffer_);
 }
 
@@ -360,7 +360,7 @@ void WindowsEndpoint::HandleWriteClosure::Run() {
   if (result.wsa_error != 0) {
     status = GRPC_WSA_ERROR(result.wsa_error, "WSASend");
   } else {
-    CHECK(result.bytes_transferred == buffer_->Length());
+    GRPC_CHECK(result.bytes_transferred == buffer_->Length());
   }
   return ResetAndReturnCallback()(status);
 }

data/src/core/lib/event_engine/windows/windows_engine.cc

@@ -24,7 +24,6 @@
 #include <memory>
 #include <ostream>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -46,6 +45,7 @@
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/dump_args.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
 
@@ -75,7 +75,7 @@ WindowsEventEngine::ConnectionState::ConnectionState(
       allocator_(std::move(allocator)),
       on_connect_user_callback_(std::move(on_connect_user_callback)),
       engine_(std::move(engine)) {
-  CHECK(socket_ != nullptr);
+  GRPC_CHECK(socket_ != nullptr);
   connection_handle_ = ConnectionHandle{reinterpret_cast<intptr_t>(this),
                                         engine_->aba_token_.fetch_add(1)};
 }
@@ -112,7 +112,7 @@ void WindowsEventEngine::ConnectionState::AbortDeadlineTimer() {
 }
 
 void WindowsEventEngine::ConnectionState::OnConnectedCallback::Run() {
-  DCHECK_NE(connection_state_, nullptr)
+  GRPC_DCHECK_NE(connection_state_, nullptr)
       << "ConnectionState::OnConnectedCallback::" << this
       << " has already run. It should only ever run once.";
   bool has_run;
@@ -131,7 +131,7 @@ void WindowsEventEngine::ConnectionState::OnConnectedCallback::Run() {
 }
 
 void WindowsEventEngine::ConnectionState::DeadlineTimerCallback::Run() {
-  DCHECK_NE(connection_state_, nullptr)
+  GRPC_DCHECK_NE(connection_state_, nullptr)
       << "ConnectionState::DeadlineTimerCallback::" << this
       << " has already run. It should only ever run once.";
   bool has_run;
@@ -207,7 +207,7 @@ WindowsEventEngine::WindowsEventEngine()
       iocp_worker_(thread_pool_.get(), &iocp_) {
   WSADATA wsaData;
   int status = WSAStartup(MAKEWORD(2, 0), &wsaData);
-  CHECK_EQ(status, 0);
+  GRPC_CHECK_EQ(status, 0);
 }
 
 WindowsEventEngine::~WindowsEventEngine() {
@@ -235,13 +235,13 @@ WindowsEventEngine::~WindowsEventEngine() {
         task_mu_.Lock();
       }
     }
-    CHECK(GPR_LIKELY(known_handles_.empty()));
+    GRPC_CHECK(GPR_LIKELY(known_handles_.empty()));
     task_mu_.Unlock();
   }
   iocp_.Kick();
   iocp_worker_.WaitForShutdown();
   iocp_.Shutdown();
-  CHECK_EQ(WSACleanup(), 0);
+  GRPC_CHECK_EQ(WSACleanup(), 0);
   timer_manager_.Shutdown();
   thread_pool_->Quiesce();
 }
@@ -287,9 +287,10 @@ WindowsEventEngine::CreateEndpointFromWinSocket(SOCKET socket,
                     ->CreateMemoryAllocator(local_address_string);
   } else {
     auto* rqv = config.GetVoidPointer(GRPC_ARG_RESOURCE_QUOTA);
-    CHECK_NE(rqv, nullptr) << "WindowsEventEngine::" << this
-                           << ": config does not contain a resource quota. "
-                              "This should not happen.";
+    GRPC_CHECK_NE(rqv, nullptr)
+        << "WindowsEventEngine::" << this
+        << ": config does not contain a resource quota. "
+           "This should not happen.";
     allocator = static_cast<grpc_core::ResourceQuota*>(rqv)
                     ->memory_quota()
                     ->CreateMemoryAllocator(local_address_string);
@@ -552,10 +553,11 @@ EventEngine::ConnectionHandle WindowsEventEngine::Connect(
     erased_handles =
         known_connection_handles_.erase(connection_state->connection_handle());
   }
-  CHECK_EQ(erased_handles, 1) << "Did not find connection handle "
-                              << connection_state->connection_handle()
-                              << " after a synchronous connection failure. "
-                                 "This should not be possible.";
+  GRPC_CHECK_EQ(erased_handles, 1)
+      << "Did not find connection handle "
+      << connection_state->connection_handle()
+      << " after a synchronous connection failure. "
+         "This should not be possible.";
   connection_state->socket()->Shutdown(DEBUG_LOCATION, "ConnectEx");
   if (!Cancel(connection_state->timer_handle())) {
     // The deadline timer will run, or is running.

data/src/core/lib/event_engine/windows/windows_listener.cc

@@ -15,7 +15,6 @@
 
 #ifdef GPR_WINDOWS
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
@@ -28,6 +27,7 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/sync.h"
 
 namespace grpc_event_engine::experimental {
@@ -47,7 +47,7 @@ WindowsEventEngineListener::SinglePortSocketListener::AsyncIOState::
 
 void WindowsEventEngineListener::SinglePortSocketListener::
     OnAcceptCallbackWrapper::Run() {
-  CHECK_NE(io_state_, nullptr);
+  GRPC_CHECK_NE(io_state_, nullptr);
   grpc_core::ReleasableMutexLock lock(&io_state_->mu);
   if (io_state_->listener_socket->IsShutdown()) {
     GRPC_TRACE_LOG(event_engine, INFO)
@@ -135,7 +135,7 @@ WindowsEventEngineListener::SinglePortSocketListener::Create(
   }
   auto result = SinglePortSocketListener::PrepareListenerSocket(sock, addr);
   GRPC_RETURN_IF_ERROR(result.status());
-  CHECK_GE(result->port, 0);
+  GRPC_CHECK_GE(result->port, 0);
   // Using `new` to access non-public constructor
   return absl::WrapUnique(new SinglePortSocketListener(
       listener, AcceptEx, /*win_socket=*/listener->iocp_->Watch(sock),
@@ -201,8 +201,8 @@ void WindowsEventEngineListener::SinglePortSocketListener::
           ABSL_EXCLUSIVE_LOCKS_REQUIRED(io_state_->mu) {
             if (do_close_socket) closesocket(io_state_->accept_socket);
             io_state_->accept_socket = INVALID_SOCKET;
-            CHECK(GRPC_LOG_IF_ERROR("SinglePortSocketListener::Start",
-                                    StartLocked()));
+            GRPC_CHECK(GRPC_LOG_IF_ERROR("SinglePortSocketListener::Start",
+                                         StartLocked()));
           };
   const auto& overlapped_result =
       io_state_->listener_socket->read_info()->result();
@@ -269,7 +269,7 @@ absl::StatusOr<WindowsEventEngineListener::SinglePortSocketListener::
 WindowsEventEngineListener::SinglePortSocketListener::PrepareListenerSocket(
     SOCKET sock, const EventEngine::ResolvedAddress& addr) {
   auto fail = [&](absl::Status error) -> absl::Status {
-    CHECK(!error.ok());
+    GRPC_CHECK(!error.ok());
     error = GRPC_ERROR_CREATE_REFERENCING("Failed to prepare server socket",
                                           &error, 1);
     if (sock != INVALID_SOCKET) closesocket(sock);
@@ -371,7 +371,7 @@ absl::StatusOr<int> WindowsEventEngineListener::Bind(
 }
 
 absl::Status WindowsEventEngineListener::Start() {
-  CHECK(!started_.exchange(true));
+  GRPC_CHECK(!started_.exchange(true));
   grpc_core::MutexLock lock(&port_listeners_mu_);
   for (auto& port_listener : port_listeners_) {
     GRPC_RETURN_IF_ERROR(port_listener->Start());