grpc 1.75.0 → 1.78.1

data/src/core/lib/event_engine/slice.cc

@@ -22,9 +22,9 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_refcount.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_event_engine::experimental {
 
@@ -46,7 +46,7 @@ Slice CopyConstructors<Slice>::FromCopiedString(std::string s) {
 
 MutableSlice::MutableSlice(const grpc_slice& slice)
     : slice_detail::BaseSlice(slice) {
-  DCHECK(slice.refcount == nullptr || slice.refcount->IsUnique());
+  GRPC_DCHECK(slice.refcount == nullptr || slice.refcount->IsUnique());
 }
 
 MutableSlice::~MutableSlice() { grpc_core::CSliceUnref(c_slice()); }

data/src/core/lib/event_engine/tcp_socket_utils.cc

@@ -53,15 +53,15 @@
 
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
 #include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/uri.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 
 namespace grpc_event_engine::experimental {
 
@@ -216,7 +216,7 @@ bool ResolvedAddressIsV4Mapped(
 bool ResolvedAddressToV4Mapped(
     const EventEngine::ResolvedAddress& resolved_addr,
     EventEngine::ResolvedAddress* resolved_addr6_out) {
-  CHECK(&resolved_addr != resolved_addr6_out);
+  GRPC_CHECK(&resolved_addr != resolved_addr6_out);
   const sockaddr* addr = resolved_addr.address();
   sockaddr_in6* addr6_out = const_cast<sockaddr_in6*>(
       reinterpret_cast<const sockaddr_in6*>(resolved_addr6_out->address()));
@@ -238,8 +238,8 @@ EventEngine::ResolvedAddress ResolvedAddressMakeWild6(int port) {
   EventEngine::ResolvedAddress resolved_wild_out;
   sockaddr_in6* wild_out = reinterpret_cast<sockaddr_in6*>(
       const_cast<sockaddr*>(resolved_wild_out.address()));
-  CHECK_GE(port, 0);
-  CHECK_LT(port, 65536);
+  GRPC_CHECK_GE(port, 0);
+  GRPC_CHECK_LT(port, 65536);
   memset(wild_out, 0, sizeof(sockaddr_in6));
   wild_out->sin6_family = AF_INET6;
   wild_out->sin6_port = htons(static_cast<uint16_t>(port));
@@ -252,8 +252,8 @@ EventEngine::ResolvedAddress ResolvedAddressMakeWild4(int port) {
   EventEngine::ResolvedAddress resolved_wild_out;
   sockaddr_in* wild_out = reinterpret_cast<sockaddr_in*>(
       const_cast<sockaddr*>(resolved_wild_out.address()));
-  CHECK_GE(port, 0);
-  CHECK_LT(port, 65536);
+  GRPC_CHECK_GE(port, 0);
+  GRPC_CHECK_LT(port, 65536);
   memset(wild_out, 0, sizeof(sockaddr_in));
   wild_out->sin_family = AF_INET;
   wild_out->sin_port = htons(static_cast<uint16_t>(port));
@@ -289,14 +289,14 @@ void ResolvedAddressSetPort(EventEngine::ResolvedAddress& resolved_addr,
   sockaddr* addr = const_cast<sockaddr*>(resolved_addr.address());
   switch (addr->sa_family) {
     case AF_INET:
-      CHECK_GE(port, 0);
-      CHECK_LT(port, 65536);
+      GRPC_CHECK_GE(port, 0);
+      GRPC_CHECK_LT(port, 65536);
       (reinterpret_cast<sockaddr_in*>(addr))->sin_port =
           htons(static_cast<uint16_t>(port));
       return;
     case AF_INET6:
-      CHECK_GE(port, 0);
-      CHECK_LT(port, 65536);
+      GRPC_CHECK_GE(port, 0);
+      GRPC_CHECK_LT(port, 65536);
       (reinterpret_cast<sockaddr_in6*>(addr))->sin6_port =
           htons(static_cast<uint16_t>(port));
       return;
@@ -441,7 +441,7 @@ absl::StatusOr<EventEngine::ResolvedAddress> URIToResolvedAddress(
     LOG(ERROR) << "Failed to parse URI. Error: " << uri.status();
   }
   GRPC_RETURN_IF_ERROR(uri.status());
-  CHECK(grpc_parse_uri(*uri, &addr));
+  GRPC_CHECK(grpc_parse_uri(*uri, &addr));
   return EventEngine::ResolvedAddress(
       reinterpret_cast<const sockaddr*>(addr.addr), addr.len);
 }

data/src/core/lib/event_engine/thread_pool/thread_count.cc

@@ -18,12 +18,12 @@
 
 #include <cstddef>
 
+#include "src/core/util/time.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
-#include "src/core/util/time.h"
 
 namespace grpc_event_engine::experimental {
 

data/src/core/lib/event_engine/thread_pool/thread_count.h

@@ -24,10 +24,10 @@
 #include <utility>
 #include <vector>
 
-#include "absl/base/thread_annotations.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
 #include "src/core/util/useful.h"
+#include "absl/base/thread_annotations.h"
 
 namespace grpc_event_engine::experimental {
 

data/src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.cc

@@ -28,11 +28,6 @@
 #include <optional>
 #include <utility>
 
-#include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/time/clock.h"
-#include "absl/time/time.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/common_closures.h"
 #include "src/core/lib/event_engine/thread_local.h"
@@ -42,8 +37,13 @@
 #include "src/core/util/crash.h"
 #include "src/core/util/env.h"
 #include "src/core/util/examine_stack.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/thd.h"
 #include "src/core/util/time.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/log/log.h"
+#include "absl/time/clock.h"
+#include "absl/time/time.h"
 
 #ifdef GPR_POSIX_SYNC
 #include <csignal>
@@ -180,7 +180,7 @@ WorkStealingThreadPool::WorkStealingThreadPool(size_t reserve_threads)
 void WorkStealingThreadPool::Quiesce() { pool_->Quiesce(); }
 
 WorkStealingThreadPool::~WorkStealingThreadPool() {
-  CHECK(pool_->IsQuiesced());
+  GRPC_CHECK(pool_->IsQuiesced());
 }
 
 void WorkStealingThreadPool::Run(absl::AnyInvocable<void()> callback) {
@@ -237,7 +237,7 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Start() {
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Run(
     EventEngine::Closure* closure) {
-  CHECK(!IsQuiesced());
+  GRPC_CHECK(!IsQuiesced());
   if (g_local_queue != nullptr && g_local_queue->owner() == this) {
     g_local_queue->Add(closure);
   } else {
@@ -279,7 +279,7 @@ void WorkStealingThreadPool::WorkStealingThreadPoolImpl::Quiesce() {
   if (!threads_were_shut_down.ok() && g_log_verbose_failures) {
     DumpStacksAndCrash();
   }
-  CHECK(queue_.Empty());
+  GRPC_CHECK(queue_.Empty());
   quiesced_.store(true, std::memory_order_relaxed);
   grpc_core::MutexLock lock(&lifeguard_ptr_mu_);
   lifeguard_.reset();
@@ -293,14 +293,14 @@ bool WorkStealingThreadPool::WorkStealingThreadPoolImpl::SetThrottled(
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::SetShutdown(
     bool is_shutdown) {
   auto was_shutdown = shutdown_.exchange(is_shutdown);
-  CHECK(is_shutdown != was_shutdown);
+  GRPC_CHECK(is_shutdown != was_shutdown);
   work_signal_.SignalAll();
 }
 
 void WorkStealingThreadPool::WorkStealingThreadPoolImpl::SetForking(
     bool is_forking) {
   auto was_forking = forking_.exchange(is_forking);
-  CHECK(is_forking != was_forking);
+  GRPC_CHECK(is_forking != was_forking);
 }
 
 bool WorkStealingThreadPool::WorkStealingThreadPoolImpl::IsForking() {
@@ -510,7 +510,7 @@ void WorkStealingThreadPool::ThreadState::ThreadBody() {
   } else if (pool_->IsShutdown()) {
     FinishDraining();
   }
-  CHECK(g_local_queue->Empty());
+  GRPC_CHECK(g_local_queue->Empty());
   pool_->theft_registry()->Unenroll(g_local_queue);
   delete g_local_queue;
   if (g_log_verbose_failures) {

data/src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.h

@@ -27,9 +27,6 @@
 #include <atomic>
 #include <memory>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/container/flat_hash_set.h"
-#include "absl/functional/any_invocable.h"
 #include "src/core/lib/event_engine/thread_pool/thread_count.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/work_queue/basic_work_queue.h"
@@ -38,6 +35,9 @@
 #include "src/core/util/notification.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/functional/any_invocable.h"
 
 namespace grpc_event_engine::experimental {
 

data/src/core/lib/event_engine/utils.cc

@@ -23,13 +23,13 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/log.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 #include "src/core/lib/event_engine/extensions/blocking_dns.h"
 #include "src/core/lib/event_engine/query_extensions.h"
 #include "src/core/util/notification.h"
 #include "src/core/util/time.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_event_engine::experimental {
 

data/src/core/lib/event_engine/utils.h

@@ -21,9 +21,9 @@
 #include <string>
 #include <vector>
 
+#include "src/core/util/time.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "src/core/util/time.h"
 
 namespace grpc_event_engine::experimental {
 

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

@@ -21,11 +21,10 @@
 #include <grpc/support/log_windows.h>
 #include <winsock2.h>
 
+#include "src/core/lib/address_utils/sockaddr_utils.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"
 // We pull in ares.h transitively here, ares.h is not self-contained
 // w.r.t. windows headers though, so make sure pull them in above.
 #include "src/core/lib/event_engine/ares_resolver.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/grpc_polled_fd_windows.h

@@ -26,13 +26,13 @@
 
 #include <memory>
 
-#include "absl/functional/any_invocable.h"
-#include "absl/status/status.h"
 #include "src/core/lib/event_engine/common_closures.h"
 #include "src/core/lib/event_engine/grpc_polled_fd.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
 #include "src/core/lib/event_engine/windows/win_socket.h"
 #include "src/core/util/sync.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
 
 struct iovec;
 

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

@@ -20,14 +20,14 @@
 
 #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"
 #include "src/core/lib/event_engine/windows/iocp.h"
 #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"
+#include "absl/strings/str_format.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/iocp.h

@@ -20,10 +20,10 @@
 
 #include <grpc/event_engine/event_engine.h>
 
-#include "absl/status/status.h"
 #include "src/core/lib/event_engine/poller.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/windows/win_socket.h"
+#include "absl/status/status.h"
 
 namespace grpc_event_engine::experimental {
 

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

@@ -20,13 +20,16 @@
 #include <sys/types.h>
 
 #include <string>
+#include <vector>
 
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
 #include "src/core/lib/event_engine/windows/native_windows_dns_resolver.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/status_helper.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 
 namespace grpc_event_engine::experimental {
 

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

@@ -17,14 +17,14 @@
 #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"
+#include "absl/log/log.h"
 
 #if defined(__MSYS__) && defined(GPR_ARCH_64)
 // Nasty workaround for nasty bug when using the 64 bits msys compiler
@@ -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);
 }