grpc 1.50.0 → 1.51.0

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

@@ -30,7 +30,6 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/time_precise.h"
-#include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/fork.h"
 #include "src/core/lib/gprpp/time.h"
@@ -211,7 +210,7 @@ class ExecCtx {
   unsigned starting_cpu_ = std::numeric_limits<unsigned>::max();
 
   ScopedTimeCache time_cache_;
-  static GPR_THREAD_LOCAL(ExecCtx*) exec_ctx_;
+  static thread_local ExecCtx* exec_ctx_;
   ExecCtx* last_exec_ctx_ = Get();
 };
 
@@ -326,7 +325,7 @@ class ApplicationCallbackExecCtx {
   uintptr_t flags_{0u};
   grpc_completion_queue_functor* head_{nullptr};
   grpc_completion_queue_functor* tail_{nullptr};
-  static GPR_THREAD_LOCAL(ApplicationCallbackExecCtx*) callback_exec_ctx_;
+  static thread_local ApplicationCallbackExecCtx* callback_exec_ctx_;
 };
 
 }  // namespace grpc_core

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

@@ -27,7 +27,6 @@
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
-#include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
@@ -52,7 +51,7 @@
 namespace grpc_core {
 namespace {
 
-GPR_THREAD_LOCAL(ThreadState*) g_this_thread_state;
+thread_local ThreadState* g_this_thread_state;
 
 Executor* executors[static_cast<size_t>(ExecutorType::NUM_EXECUTORS)];
 

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

@@ -27,6 +27,8 @@
 #include <string.h>
 #include <sys/utsname.h>
 
+#include "src/core/lib/gprpp/strerror.h"
+
 namespace grpc_core {
 
 bool KernelSupportsErrqueue() {
@@ -36,7 +38,7 @@ bool KernelSupportsErrqueue() {
     // least 4.0.0
     struct utsname buffer;
     if (uname(&buffer) != 0) {
-      gpr_log(GPR_ERROR, "uname: %s", strerror(errno));
+      gpr_log(GPR_ERROR, "uname: %s", StrError(errno).c_str());
       return false;
     }
     char* release = buffer.release;

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

@@ -31,6 +31,7 @@
 #include <grpc/support/log_windows.h>
 
 #include "src/core/lib/debug/stats.h"
+#include "src/core/lib/debug/stats_data.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"

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

@@ -22,7 +22,6 @@
 
 #ifdef GRPC_POSIX_SOCKET_IOMGR
 
-#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/resolve_address.h"
@@ -39,6 +38,7 @@ extern grpc_pollset_vtable grpc_posix_pollset_vtable;
 extern grpc_pollset_set_vtable grpc_posix_pollset_set_vtable;
 
 static void iomgr_platform_init(void) {
+  grpc_core::ResetDNSResolver(std::make_unique<grpc_core::NativeDNSResolver>());
   grpc_wakeup_fd_global_init();
   grpc_event_engine_init();
   grpc_tcp_posix_init();
@@ -50,6 +50,7 @@ static void iomgr_platform_shutdown(void) {
   grpc_tcp_posix_shutdown();
   grpc_event_engine_shutdown();
   grpc_wakeup_fd_global_destroy();
+  grpc_core::ResetDNSResolver(nullptr);  // delete the resolver
 }
 
 static void iomgr_platform_shutdown_background_closure(void) {
@@ -79,7 +80,6 @@ void grpc_set_default_iomgr_platform() {
   grpc_set_timer_impl(&grpc_generic_timer_vtable);
   grpc_set_pollset_vtable(&grpc_posix_pollset_vtable);
   grpc_set_pollset_set_vtable(&grpc_posix_pollset_set_vtable);
-  grpc_core::SetDNSResolver(grpc_core::NativeDNSResolver::GetOrCreate());
   grpc_tcp_client_global_init();
   grpc_set_iomgr_platform_vtable(&vtable);
 }

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

@@ -63,6 +63,7 @@ static void apple_iomgr_platform_flush(void) {}
 
 static void apple_iomgr_platform_shutdown(void) {
   grpc_pollset_global_shutdown();
+  grpc_core::ResetDNSResolver(nullptr);  // delete the resolver
 }
 
 static void apple_iomgr_platform_shutdown_background_closure(void) {}
@@ -179,7 +180,7 @@ void grpc_set_default_iomgr_platform() {
   }
   grpc_tcp_client_global_init();
   grpc_set_timer_impl(&grpc_generic_timer_vtable);
-  grpc_core::SetDNSResolver(grpc_core::NativeDNSResolver::GetOrCreate());
+  grpc_core::ResetDNSResolver(std::make_unique<grpc_core::NativeDNSResolver>());
 }
 
 bool grpc_iomgr_run_in_background() {

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

@@ -61,6 +61,7 @@ static void iomgr_platform_init(void) {
   grpc_iocp_init();
   grpc_pollset_global_init();
   grpc_wsa_socket_flags_init();
+  grpc_core::ResetDNSResolver(std::make_unique<grpc_core::NativeDNSResolver>());
 }
 
 static void iomgr_platform_flush(void) { grpc_iocp_flush(); }
@@ -69,6 +70,7 @@ static void iomgr_platform_shutdown(void) {
   grpc_pollset_global_shutdown();
   grpc_iocp_shutdown();
   winsock_shutdown();
+  grpc_core::ResetDNSResolver(nullptr);  // delete the resolver
 }
 
 static void iomgr_platform_shutdown_background_closure(void) {}
@@ -96,7 +98,6 @@ void grpc_set_default_iomgr_platform() {
   grpc_set_timer_impl(&grpc_generic_timer_vtable);
   grpc_set_pollset_vtable(&grpc_windows_pollset_vtable);
   grpc_set_pollset_set_vtable(&grpc_windows_pollset_set_vtable);
-  grpc_core::SetDNSResolver(grpc_core::NativeDNSResolver::GetOrCreate());
   grpc_set_iomgr_platform_vtable(&vtable);
 }
 

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

@@ -37,7 +37,7 @@ grpc_error_handle grpc_load_file(const char* filename, int add_null_terminator,
   grpc_slice result = grpc_empty_slice();
   FILE* file;
   size_t bytes_read = 0;
-  grpc_error_handle error = GRPC_ERROR_NONE;
+  grpc_error_handle error;
 
   GRPC_SCHEDULING_START_BLOCKING_REGION;
   file = fopen(filename, "rb");
@@ -66,14 +66,10 @@ grpc_error_handle grpc_load_file(const char* filename, int add_null_terminator,
 end:
   *output = result;
   if (file != nullptr) fclose(file);
-  if (!GRPC_ERROR_IS_NONE(error)) {
-    grpc_error_handle error_out =
-        grpc_error_set_str(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                               "Failed to load file", &error, 1),
-                           GRPC_ERROR_STR_FILENAME,
-
-                           filename);
-    GRPC_ERROR_UNREF(error);
+  if (!error.ok()) {
+    grpc_error_handle error_out = grpc_error_set_str(
+        GRPC_ERROR_CREATE_REFERENCING("Failed to load file", &error, 1),
+        grpc_core::StatusStrProperty::kFilename, filename);
     error = error_out;
   }
   GRPC_SCHEDULING_END_BLOCKING_REGION_NO_EXEC_CTX;

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

@@ -127,7 +127,7 @@ void LockfreeEvent::NotifyOn(grpc_closure* closure) {
            closure when transitioning out of CLOSURE_NO_READY state (i.e there
            is no other code that needs to 'happen-after' this) */
         if (gpr_atm_no_barrier_cas(&state_, kClosureReady, kClosureNotReady)) {
-          ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
+          ExecCtx::Run(DEBUG_LOCATION, closure, absl::OkStatus());
           return; /* Successful. Return */
         }
 
@@ -141,9 +141,9 @@ void LockfreeEvent::NotifyOn(grpc_closure* closure) {
         if ((curr & kShutdownBit) > 0) {
           grpc_error_handle shutdown_err =
               internal::StatusGetFromHeapPtr(curr & ~kShutdownBit);
-          ExecCtx::Run(DEBUG_LOCATION, closure,
-                       GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                           "FD Shutdown", &shutdown_err, 1));
+          ExecCtx::Run(
+              DEBUG_LOCATION, closure,
+              GRPC_ERROR_CREATE_REFERENCING("FD Shutdown", &shutdown_err, 1));
           return;
         }
 
@@ -156,7 +156,7 @@ void LockfreeEvent::NotifyOn(grpc_closure* closure) {
     }
   }
 
-  GPR_UNREACHABLE_CODE(return );
+  GPR_UNREACHABLE_CODE(return);
 }
 
 bool LockfreeEvent::SetShutdown(grpc_error_handle shutdown_error) {
@@ -168,7 +168,7 @@ bool LockfreeEvent::SetShutdown(grpc_error_handle shutdown_error) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
       gpr_log(GPR_DEBUG,
               "LockfreeEvent::SetShutdown: %p curr=%" PRIxPTR " err=%s",
-              &state_, curr, grpc_error_std_string(shutdown_error).c_str());
+              &state_, curr, StatusToString(shutdown_error).c_str());
     }
     switch (curr) {
       case kClosureReady:
@@ -195,9 +195,9 @@ bool LockfreeEvent::SetShutdown(grpc_error_handle shutdown_error) {
            happens-after on that edge), and a release to pair with anything
            loading the shutdown state. */
         if (gpr_atm_full_cas(&state_, curr, new_state)) {
-          ExecCtx::Run(DEBUG_LOCATION, reinterpret_cast<grpc_closure*>(curr),
-                       GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                           "FD Shutdown", &shutdown_error, 1));
+          ExecCtx::Run(
+              DEBUG_LOCATION, reinterpret_cast<grpc_closure*>(curr),
+              GRPC_ERROR_CREATE_REFERENCING("FD Shutdown", &shutdown_error, 1));
           return true;
         }
 
@@ -246,7 +246,7 @@ void LockfreeEvent::SetReady() {
            notify_on (or set_shutdown) */
         else if (gpr_atm_full_cas(&state_, curr, kClosureNotReady)) {
           ExecCtx::Run(DEBUG_LOCATION, reinterpret_cast<grpc_closure*>(curr),
-                       GRPC_ERROR_NONE);
+                       absl::OkStatus());
           return;
         }
         /* else the state changed again (only possible by either a racing

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

@@ -98,7 +98,7 @@ static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
   pollset->shutting_down = 1;
   grpc_pollset_kick(pollset, GRPC_POLLSET_KICK_BROADCAST);
   if (!pollset->is_iocp_worker) {
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, absl::OkStatus());
   } else {
     pollset->on_shutdown = closure;
   }
@@ -147,7 +147,7 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
 
       if (pollset->shutting_down && pollset->on_shutdown != NULL) {
         grpc_core::ExecCtx::Run(DEBUG_LOCATION, pollset->on_shutdown,
-                                GRPC_ERROR_NONE);
+                                absl::OkStatus());
         pollset->on_shutdown = NULL;
       }
       goto done;
@@ -180,7 +180,7 @@ done:
   }
   gpr_cv_destroy(&worker.cv);
   if (worker_hdl) *worker_hdl = NULL;
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 static grpc_error_handle pollset_kick(grpc_pollset* p,
@@ -231,7 +231,7 @@ static grpc_error_handle pollset_kick(grpc_pollset* p,
       gpr_cv_signal(&next_global_worker->cv);
     }
   }
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 grpc_pollset_vtable grpc_windows_pollset_vtable = {

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

@@ -31,8 +31,8 @@
 // because Cython doesn't handle #defines well.
 
 inline grpc_error_handle grpc_socket_error(char* error) {
-  return grpc_error_set_int(GRPC_ERROR_CREATE_FROM_COPIED_STRING(error),
-                            GRPC_ERROR_INT_GRPC_STATUS,
+  return grpc_error_set_int(GRPC_ERROR_CREATE(error),
+                            grpc_core::StatusIntProperty::kRpcStatus,
                             GRPC_STATUS_UNAVAILABLE);
 }
 

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

@@ -23,19 +23,24 @@
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/gprpp/no_destruct.h"
 
 namespace grpc_core {
 const char* kDefaultSecurePort = "https";
 
 namespace {
-DNSResolver* g_dns_resolver;
+NoDestruct<std::shared_ptr<DNSResolver>> g_dns_resolver;
 }
 
 constexpr DNSResolver::TaskHandle DNSResolver::kNullHandle;
 
-void SetDNSResolver(DNSResolver* resolver) { g_dns_resolver = resolver; }
+void ResetDNSResolver(std::shared_ptr<DNSResolver> resolver) {
+  *g_dns_resolver = std::move(resolver);
+}
 
-DNSResolver* GetDNSResolver() { return g_dns_resolver; }
+std::shared_ptr<DNSResolver> GetDNSResolver() { return *g_dns_resolver; }
 
 std::string DNSResolver::HandleToString(TaskHandle handle) {
   return absl::StrCat("{", handle.keys[0], ",", handle.keys[1], "}");

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

@@ -104,13 +104,12 @@ class DNSResolver {
 };
 
 // Override the active DNS resolver which should be used for all DNS
-// resolution in gRPC. Note this should only be used during library
-// initialization or within tests.
-void SetDNSResolver(DNSResolver* resolver);
+// resolution in gRPC.
+void ResetDNSResolver(std::shared_ptr<DNSResolver> resolver);
 
 // Get the singleton DNS resolver instance which should be used for all
 // DNS resolution in gRPC.
-DNSResolver* GetDNSResolver();
+std::shared_ptr<DNSResolver> GetDNSResolver();
 
 }  // namespace grpc_core
 

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

@@ -37,7 +37,7 @@ class DNSCallbackExecCtxScheduler {
       absl::StatusOr<std::vector<grpc_resolved_address>> param)
       : on_done_(std::move(on_done)), param_(std::move(param)) {
     GRPC_CLOSURE_INIT(&closure_, RunCallback, this, grpc_schedule_on_exec_ctx);
-    ExecCtx::Run(DEBUG_LOCATION, &closure_, GRPC_ERROR_NONE);
+    ExecCtx::Run(DEBUG_LOCATION, &closure_, absl::OkStatus());
   }
 
  private:

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

@@ -47,8 +47,6 @@
 namespace grpc_core {
 namespace {
 
-using ::grpc_event_engine::experimental::GetDefaultEventEngine;
-
 class NativeDNSRequest {
  public:
   NativeDNSRequest(
@@ -57,7 +55,7 @@ class NativeDNSRequest {
           on_done)
       : name_(name), default_port_(default_port), on_done_(std::move(on_done)) {
     GRPC_CLOSURE_INIT(&request_closure_, DoRequestThread, this, nullptr);
-    Executor::Run(&request_closure_, GRPC_ERROR_NONE, ExecutorType::RESOLVER);
+    Executor::Run(&request_closure_, absl::OkStatus(), ExecutorType::RESOLVER);
   }
 
  private:
@@ -81,11 +79,6 @@ class NativeDNSRequest {
 
 }  // namespace
 
-NativeDNSResolver* NativeDNSResolver::GetOrCreate() {
-  static NativeDNSResolver* instance = new NativeDNSResolver();
-  return instance;
-}
-
 DNSResolver::TaskHandle NativeDNSResolver::LookupHostname(
     std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
         on_done,
@@ -112,16 +105,14 @@ NativeDNSResolver::LookupHostnameBlocking(absl::string_view name,
   // parse name, splitting it into host and port parts
   SplitHostPort(name, &host, &port);
   if (host.empty()) {
-    err = grpc_error_set_str(
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("unparseable host:port"),
-        GRPC_ERROR_STR_TARGET_ADDRESS, name);
+    err = grpc_error_set_str(GRPC_ERROR_CREATE("unparseable host:port"),
+                             StatusStrProperty::kTargetAddress, name);
     goto done;
   }
   if (port.empty()) {
     if (default_port.empty()) {
-      err = grpc_error_set_str(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("no port in name"),
-          GRPC_ERROR_STR_TARGET_ADDRESS, name);
+      err = grpc_error_set_str(GRPC_ERROR_CREATE("no port in name"),
+                               StatusStrProperty::kTargetAddress, name);
       goto done;
     }
     port = std::string(default_port);
@@ -150,12 +141,11 @@ NativeDNSResolver::LookupHostnameBlocking(absl::string_view name,
     err = grpc_error_set_str(
         grpc_error_set_str(
             grpc_error_set_str(
-                grpc_error_set_int(
-                    GRPC_ERROR_CREATE_FROM_STATIC_STRING(gai_strerror(s)),
-                    GRPC_ERROR_INT_ERRNO, s),
-                GRPC_ERROR_STR_OS_ERROR, gai_strerror(s)),
-            GRPC_ERROR_STR_SYSCALL, "getaddrinfo"),
-        GRPC_ERROR_STR_TARGET_ADDRESS, name);
+                grpc_error_set_int(GRPC_ERROR_CREATE(gai_strerror(s)),
+                                   StatusIntProperty::kErrorNo, s),
+                StatusStrProperty::kOsError, gai_strerror(s)),
+            StatusStrProperty::kSyscall, "getaddrinfo"),
+        StatusStrProperty::kTargetAddress, name);
     goto done;
   }
   // Success path: fill in addrs
@@ -165,16 +155,15 @@ NativeDNSResolver::LookupHostnameBlocking(absl::string_view name,
     addr.len = resp->ai_addrlen;
     addresses.push_back(addr);
   }
-  err = GRPC_ERROR_NONE;
+  err = absl::OkStatus();
 done:
   if (result) {
     freeaddrinfo(result);
   }
-  if (GRPC_ERROR_IS_NONE(err)) {
+  if (err.ok()) {
     return addresses;
   }
   auto error_result = grpc_error_to_absl_status(err);
-  GRPC_ERROR_UNREF(err);
   return error_result;
 }
 
@@ -184,7 +173,7 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupSRV(
     absl::string_view /* name */, Duration /* timeout */,
     grpc_pollset_set* /* interested_parties */,
     absl::string_view /* name_server */) {
-  GetDefaultEventEngine()->Run([on_resolved] {
+  grpc_event_engine::experimental::GetDefaultEventEngine()->Run([on_resolved] {
     ApplicationCallbackExecCtx app_exec_ctx;
     ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(
@@ -199,7 +188,7 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupTXT(
     grpc_pollset_set* /* interested_parties */,
     absl::string_view /* name_server */) {
   // Not supported
-  GetDefaultEventEngine()->Run([on_resolved] {
+  grpc_event_engine::experimental::GetDefaultEventEngine()->Run([on_resolved] {
     ApplicationCallbackExecCtx app_exec_ctx;
     ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(

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

@@ -29,8 +29,7 @@ namespace grpc_core {
 // A DNS resolver which uses the native platform's getaddrinfo API.
 class NativeDNSResolver : public DNSResolver {
  public:
-  // Gets the singleton instance, creating it first if it doesn't exist
-  static NativeDNSResolver* GetOrCreate();
+  NativeDNSResolver() = default;
 
   TaskHandle LookupHostname(
       std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>

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

@@ -50,8 +50,6 @@
 namespace grpc_core {
 namespace {
 
-using ::grpc_event_engine::experimental::GetDefaultEventEngine;
-
 class NativeDNSRequest {
  public:
   NativeDNSRequest(
@@ -60,7 +58,7 @@ class NativeDNSRequest {
           on_done)
       : name_(name), default_port_(default_port), on_done_(std::move(on_done)) {
     GRPC_CLOSURE_INIT(&request_closure_, DoRequestThread, this, nullptr);
-    Executor::Run(&request_closure_, GRPC_ERROR_NONE, ExecutorType::RESOLVER);
+    Executor::Run(&request_closure_, absl::OkStatus(), ExecutorType::RESOLVER);
   }
 
  private:
@@ -84,10 +82,7 @@ class NativeDNSRequest {
 
 }  // namespace
 
-NativeDNSResolver* NativeDNSResolver::GetOrCreate() {
-  static NativeDNSResolver* instance = new NativeDNSResolver();
-  return instance;
-}
+NativeDNSResolver::NativeDNSResolver() {}
 
 DNSResolver::TaskHandle NativeDNSResolver::LookupHostname(
     std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
@@ -106,8 +101,7 @@ NativeDNSResolver::LookupHostnameBlocking(absl::string_view name,
   struct addrinfo hints;
   struct addrinfo *result = NULL, *resp;
   int s;
-  size_t i;
-  grpc_error_handle error = GRPC_ERROR_NONE;
+  grpc_error_handle error;
   std::vector<grpc_resolved_address> addresses;
 
   // parse name, splitting it into host and port parts
@@ -115,14 +109,13 @@ NativeDNSResolver::LookupHostnameBlocking(absl::string_view name,
   std::string port;
   SplitHostPort(name, &host, &port);
   if (host.empty()) {
-    error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
-        absl::StrFormat("unparseable host:port: '%s'", name));
+    error =
+        GRPC_ERROR_CREATE(absl::StrFormat("unparseable host:port: '%s'", name));
     goto done;
   }
   if (port.empty()) {
     if (default_port.empty()) {
-      error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
-          absl::StrFormat("no port in name '%s'", name));
+      error = GRPC_ERROR_CREATE(absl::StrFormat("no port in name '%s'", name));
       goto done;
     }
     port = std::string(default_port);
@@ -154,21 +147,25 @@ done:
   if (result) {
     freeaddrinfo(result);
   }
-  if (GRPC_ERROR_IS_NONE(error)) {
+  if (error.ok()) {
     return addresses;
   }
   auto error_result = grpc_error_to_absl_status(error);
-  GRPC_ERROR_UNREF(error);
   return error_result;
 }
 
+void RunCallbackOnDefaultEventEngine(absl::AnyInvocable<void()> f) {
+  auto engine = grpc_event_engine::experimental::GetDefaultEventEngine();
+  engine->Run([f = std::move(f), engine]() mutable { f(); });
+}
+
 DNSResolver::TaskHandle NativeDNSResolver::LookupSRV(
     std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
         on_resolved,
     absl::string_view /* name */, Duration /* deadline */,
     grpc_pollset_set* /* interested_parties */,
     absl::string_view /* name_server */) {
-  GetDefaultEventEngine()->Run([on_resolved] {
+  RunCallbackOnDefaultEventEngine([on_resolved] {
     ApplicationCallbackExecCtx app_exec_ctx;
     ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(
@@ -183,7 +180,7 @@ DNSResolver::TaskHandle NativeDNSResolver::LookupTXT(
     grpc_pollset_set* /* interested_parties */,
     absl::string_view /* name_server */) {
   // Not supported
-  GetDefaultEventEngine()->Run([on_resolved] {
+  RunCallbackOnDefaultEventEngine([on_resolved] {
     ApplicationCallbackExecCtx app_exec_ctx;
     ExecCtx exec_ctx;
     on_resolved(absl::UnimplementedError(

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

@@ -29,8 +29,7 @@ namespace grpc_core {
 // A DNS resolver which uses the native platform's getaddrinfo API.
 class NativeDNSResolver : public DNSResolver {
  public:
-  // Gets the singleton instance, creating it first if it doesn't exist
-  static NativeDNSResolver* GetOrCreate();
+  NativeDNSResolver();
 
   TaskHandle LookupHostname(
       std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>