grpc 1.72.0 → 1.78.1

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 {
 
@@ -133,9 +133,10 @@ absl::StatusOr<std::string> ResolvedAddrToUriUnixIfPossible(
     path_string = std::move(*path);
   }
 
-  absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Create(
-      std::move(scheme), /*authority=*/"", std::move(path_string),
-      /*query_parameter_pairs=*/{}, /*fragment=*/"");
+  absl::StatusOr<grpc_core::URI> uri =
+      grpc_core::URI::Create(std::move(scheme), /*user_info=*/"",
+                             /*host_port=*/"", std::move(path_string),
+                             /*query_parameter_pairs=*/{}, /*fragment=*/"");
   if (!uri.ok()) return uri.status();
   return uri->ToString();
 }
@@ -161,9 +162,9 @@ absl::StatusOr<std::string> ResolvedAddrToVsockPathIfPossible(
 absl::StatusOr<std::string> ResolvedAddrToUriVsockIfPossible(
     const EventEngine::ResolvedAddress* resolved_addr) {
   auto path = ResolvedAddrToVsockPathIfPossible(resolved_addr);
-  absl::StatusOr<grpc_core::URI> uri =
-      grpc_core::URI::Create("vsock", /*authority=*/"", std::move(*path),
-                             /*query_parameter_pairs=*/{}, /*fragment=*/"");
+  absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Create(
+      "vsock", /*user_info=*/"", /*host_port=*/"", std::move(*path),
+      /*query_parameter_pairs=*/{}, /*fragment=*/"");
   if (!uri.ok()) return uri.status();
   return uri->ToString();
 }
@@ -215,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()));
@@ -237,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));
@@ -251,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));
@@ -288,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;
@@ -425,9 +426,9 @@ absl::StatusOr<std::string> ResolvedAddressToURI(
   }
   auto path = ResolvedAddressToString(addr);
   GRPC_RETURN_IF_ERROR(path.status());
-  absl::StatusOr<grpc_core::URI> uri =
-      grpc_core::URI::Create(*scheme, /*authority=*/"", std::move(path.value()),
-                             /*query_parameter_pairs=*/{}, /*fragment=*/"");
+  absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Create(
+      *scheme, /*user_info=*/"", /*host_port=*/"", std::move(path.value()),
+      /*query_parameter_pairs=*/{}, /*fragment=*/"");
   if (!uri.ok()) return uri.status();
   return uri->ToString();
 }
@@ -440,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/thread_pool.h

@@ -20,21 +20,25 @@
 #include <memory>
 
 #include "absl/functional/any_invocable.h"
-#include "src/core/lib/event_engine/forkable.h"
 
 namespace grpc_event_engine::experimental {
 
 // Interface for all EventEngine ThreadPool implementations
-class ThreadPool : public Forkable {
+class ThreadPool {
  public:
   // Asserts Quiesce was called.
-  ~ThreadPool() override = default;
+  virtual ~ThreadPool() = default;
   // Shut down the pool, and wait for all threads to exit.
   // This method is safe to call from within a ThreadPool thread.
   virtual void Quiesce() = 0;
   // Run must not be called after Quiesce completes
   virtual void Run(absl::AnyInvocable<void()> callback) = 0;
   virtual void Run(EventEngine::Closure* closure) = 0;
+
+#if GRPC_ENABLE_FORK_SUPPORT
+  virtual void PrepareFork() = 0;
+  virtual void PostFork() = 0;
+#endif  // GRPC_ENABLE_FORK_SUPPORT
 };
 
 // Creates a default thread pool.

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

@@ -16,30 +16,13 @@
 
 #include <memory>
 
-#include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
 #include "src/core/lib/event_engine/thread_pool/work_stealing_thread_pool.h"
-#include "src/core/util/no_destruct.h"
 
 namespace grpc_event_engine::experimental {
 
-namespace {
-grpc_core::NoDestruct<ObjectGroupForkHandler> g_thread_pool_fork_manager;
-
-class ThreadPoolForkCallbackMethods {
- public:
-  static void Prefork() { g_thread_pool_fork_manager->Prefork(); }
-  static void PostforkParent() { g_thread_pool_fork_manager->PostforkParent(); }
-  static void PostforkChild() { g_thread_pool_fork_manager->PostforkChild(); }
-};
-}  // namespace
-
 std::shared_ptr<ThreadPool> MakeThreadPool(size_t reserve_threads) {
   auto thread_pool = std::make_shared<WorkStealingThreadPool>(reserve_threads);
-  g_thread_pool_fork_manager->RegisterForkable(
-      thread_pool, ThreadPoolForkCallbackMethods::Prefork,
-      ThreadPoolForkCallbackMethods::PostforkParent,
-      ThreadPoolForkCallbackMethods::PostforkChild);
   return thread_pool;
 }
 

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) {
@@ -213,11 +213,13 @@ EventEngine::Closure* WorkStealingThreadPool::TheftRegistry::StealOne() {
   return nullptr;
 }
 
+#if GRPC_ENABLE_FORK_SUPPORT
+
 void WorkStealingThreadPool::PrepareFork() { pool_->PrepareFork(); }
 
-void WorkStealingThreadPool::PostforkParent() { pool_->Postfork(); }
+void WorkStealingThreadPool::PostFork() { pool_->Postfork(); }
 
-void WorkStealingThreadPool::PostforkChild() { pool_->Postfork(); }
+#endif  // GRPC_ENABLE_FORK_SUPPORT
 
 // -------- WorkStealingThreadPool::WorkStealingThreadPoolImpl --------
 
@@ -235,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 {
@@ -277,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();
@@ -291,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() {
@@ -508,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 {
 
@@ -53,11 +53,12 @@ class WorkStealingThreadPool final : public ThreadPool {
   void Run(absl::AnyInvocable<void()> callback) override;
   void Run(EventEngine::Closure* closure) override;
 
+#if GRPC_ENABLE_FORK_SUPPORT
   // Forkable
   // These methods are exposed on the public object to allow for testing.
   void PrepareFork() override;
-  void PostforkParent() override;
-  void PostforkChild() override;
+  void PostFork() override;
+#endif  // GRPC_ENABLE_FORK_SUPPORT
 
  private:
   // A basic communication mechanism to signal waiting threads that work is

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

@@ -14,14 +14,22 @@
 #include "src/core/lib/event_engine/utils.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/internal/write_event.h>
 #include <grpc/support/port_platform.h>
 #include <stdint.h>
 
 #include <algorithm>
+#include <string>
+#include <utility>
+#include <vector>
 
-#include "absl/strings/str_cat.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 {
 
@@ -41,6 +49,12 @@ grpc_core::Timestamp ToTimestamp(grpc_core::Timestamp now,
 absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
 LookupHostnameBlocking(EventEngine::DNSResolver* dns_resolver,
                        absl::string_view name, absl::string_view default_port) {
+  auto* blocking_resolver =
+      QueryExtension<ResolverSupportsBlockingLookups>(dns_resolver);
+  if (blocking_resolver != nullptr) {
+    return blocking_resolver->LookupHostnameBlocking(name, default_port);
+  }
+
   absl::StatusOr<std::vector<EventEngine::ResolvedAddress>> results;
   grpc_core::Notification done;
   dns_resolver->LookupHostname(
@@ -53,4 +67,24 @@ LookupHostnameBlocking(EventEngine::DNSResolver* dns_resolver,
   return results;
 }
 
+absl::string_view WriteEventToString(
+    grpc_event_engine::experimental::internal::WriteEvent event) {
+  switch (event) {
+    case grpc_event_engine::experimental::internal::WriteEvent::kSendMsg:
+      return "SENDMSG";
+    case grpc_event_engine::experimental::internal::WriteEvent::kScheduled:
+      return "SCHEDULED";
+    case grpc_event_engine::experimental::internal::WriteEvent::kSent:
+      return "SENT";
+    case grpc_event_engine::experimental::internal::WriteEvent::kAcked:
+      return "ACKED";
+    case grpc_event_engine::experimental::internal::WriteEvent::kClosed:
+      return "CLOSED";
+    case grpc_event_engine::experimental::internal::WriteEvent::kCount:
+      break;
+  }
+  LOG(FATAL) << "WriteEventToString called with " << static_cast<int>(event);
+  return "UNKNOWN";
+}
+
 }  // 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 {
 
@@ -42,6 +42,9 @@ absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
 LookupHostnameBlocking(EventEngine::DNSResolver* dns_resolver,
                        absl::string_view name, absl::string_view default_port);
 
+absl::string_view WriteEventToString(
+    grpc_event_engine::experimental::internal::WriteEvent event);
+
 }  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_UTILS_H

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

@@ -18,15 +18,15 @@
 
 #if GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
 
-#include <ares.h>
 #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"
 #include "src/core/lib/event_engine/grpc_polled_fd.h"
 #include "src/core/lib/event_engine/windows/grpc_polled_fd_windows.h"
@@ -34,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.
@@ -129,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");
     }
@@ -138,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;
     }
   }
@@ -158,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();
@@ -178,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;
     }
@@ -223,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_;
     }
@@ -267,6 +268,8 @@ class GrpcPolledFdWindows : public GrpcPolledFd {
     }
   }
 
+  bool IsCurrent() const override { return true; }
+
  private:
   enum WriteState {
     WRITE_IDLE,
@@ -292,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;
@@ -329,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"));
@@ -339,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:
@@ -388,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;
@@ -439,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);
@@ -463,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 {
@@ -474,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_);
@@ -497,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);
@@ -636,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,
@@ -648,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(
@@ -735,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;
   }
 
@@ -745,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);
   }
 
@@ -755,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);
   }
 
@@ -766,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);
   }
@@ -809,6 +812,8 @@ class GrpcPolledFdWrapper : public GrpcPolledFd {
 
   const char* GetName() const override { return polled_fd_->GetName(); }
 
+  bool IsCurrent() const override { return true; }
+
  private:
   GrpcPolledFdWindows* polled_fd_;
 };
@@ -827,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());
 }