grpc 1.28.0 → 1.31.0.pre2

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver.cc

@@ -23,6 +23,8 @@
 #include <ares.h>
 #include <string.h>
 
+#include "absl/strings/str_cat.h"
+
 #include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver.h"
 
 #include <grpc/support/alloc.h>
@@ -31,7 +33,6 @@
 #include <grpc/support/time.h>
 #include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h"
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/timer.h"
@@ -66,8 +67,8 @@ struct grpc_ares_ev_driver {
   /** refcount of the event driver */
   gpr_refcount refs;
 
-  /** combiner to synchronize c-ares and I/O callbacks on */
-  grpc_core::Combiner* combiner;
+  /** work_serializer to synchronize c-ares and I/O callbacks on */
+  std::shared_ptr<grpc_core::WorkSerializer> work_serializer;
   /** a list of grpc_fd that this event driver is currently using. */
   fd_node* fds;
   /** is this event driver currently working? */
@@ -107,7 +108,6 @@ static void grpc_ares_ev_driver_unref(grpc_ares_ev_driver* ev_driver) {
     GRPC_CARES_TRACE_LOG("request:%p destroy ev_driver %p", ev_driver->request,
                          ev_driver);
     GPR_ASSERT(ev_driver->fds == nullptr);
-    GRPC_COMBINER_UNREF(ev_driver->combiner, "free ares event driver");
     ares_destroy(ev_driver->channel);
     grpc_ares_complete_request_locked(ev_driver->request);
     delete ev_driver;
@@ -133,21 +133,22 @@ static void fd_node_shutdown_locked(fd_node* fdn, const char* reason) {
 }
 
 static void on_timeout(void* arg, grpc_error* error);
-static void on_timeout_locked(void* arg, grpc_error* error);
+static void on_timeout_locked(grpc_ares_ev_driver* arg, grpc_error* error);
 
 static void on_ares_backup_poll_alarm(void* arg, grpc_error* error);
-static void on_ares_backup_poll_alarm_locked(void* arg, grpc_error* error);
+static void on_ares_backup_poll_alarm_locked(grpc_ares_ev_driver* arg,
+                                             grpc_error* error);
 
 static void noop_inject_channel_config(ares_channel /*channel*/) {}
 
 void (*grpc_ares_test_only_inject_config)(ares_channel channel) =
     noop_inject_channel_config;
 
-grpc_error* grpc_ares_ev_driver_create_locked(grpc_ares_ev_driver** ev_driver,
-                                              grpc_pollset_set* pollset_set,
-                                              int query_timeout_ms,
-                                              grpc_core::Combiner* combiner,
-                                              grpc_ares_request* request) {
+grpc_error* grpc_ares_ev_driver_create_locked(
+    grpc_ares_ev_driver** ev_driver, grpc_pollset_set* pollset_set,
+    int query_timeout_ms,
+    std::shared_ptr<grpc_core::WorkSerializer> work_serializer,
+    grpc_ares_request* request) {
   *ev_driver = new grpc_ares_ev_driver();
   ares_options opts;
   memset(&opts, 0, sizeof(opts));
@@ -156,15 +157,14 @@ grpc_error* grpc_ares_ev_driver_create_locked(grpc_ares_ev_driver** ev_driver,
   grpc_ares_test_only_inject_config((*ev_driver)->channel);
   GRPC_CARES_TRACE_LOG("request:%p grpc_ares_ev_driver_create_locked", request);
   if (status != ARES_SUCCESS) {
-    char* err_msg;
-    gpr_asprintf(&err_msg, "Failed to init ares channel. C-ares error: %s",
-                 ares_strerror(status));
-    grpc_error* err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(err_msg);
-    gpr_free(err_msg);
+    grpc_error* err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+        absl::StrCat("Failed to init ares channel. C-ares error: ",
+                     ares_strerror(status))
+            .c_str());
     gpr_free(*ev_driver);
     return err;
   }
-  (*ev_driver)->combiner = GRPC_COMBINER_REF(combiner, "ares event driver");
+  (*ev_driver)->work_serializer = std::move(work_serializer);
   gpr_ref_init(&(*ev_driver)->refs, 1);
   (*ev_driver)->pollset_set = pollset_set;
   (*ev_driver)->fds = nullptr;
@@ -172,7 +172,7 @@ grpc_error* grpc_ares_ev_driver_create_locked(grpc_ares_ev_driver** ev_driver,
   (*ev_driver)->shutting_down = false;
   (*ev_driver)->request = request;
   (*ev_driver)->polled_fd_factory =
-      grpc_core::NewGrpcPolledFdFactory((*ev_driver)->combiner);
+      grpc_core::NewGrpcPolledFdFactory((*ev_driver)->work_serializer);
   (*ev_driver)
       ->polled_fd_factory->ConfigureAresChannelLocked((*ev_driver)->channel);
   (*ev_driver)->query_timeout_ms = query_timeout_ms;
@@ -234,13 +234,12 @@ static grpc_millis calculate_next_ares_backup_poll_alarm_ms(
 
 static void on_timeout(void* arg, grpc_error* error) {
   grpc_ares_ev_driver* driver = static_cast<grpc_ares_ev_driver*>(arg);
-  driver->combiner->Run(GRPC_CLOSURE_INIT(&driver->on_timeout_locked,
-                                          on_timeout_locked, driver, nullptr),
-                        GRPC_ERROR_REF(error));
+  GRPC_ERROR_REF(error);  // ref owned by lambda
+  driver->work_serializer->Run(
+      [driver, error]() { on_timeout_locked(driver, error); }, DEBUG_LOCATION);
 }
 
-static void on_timeout_locked(void* arg, grpc_error* error) {
-  grpc_ares_ev_driver* driver = static_cast<grpc_ares_ev_driver*>(arg);
+static void on_timeout_locked(grpc_ares_ev_driver* driver, grpc_error* error) {
   GRPC_CARES_TRACE_LOG(
       "request:%p ev_driver=%p on_timeout_locked. driver->shutting_down=%d. "
       "err=%s",
@@ -249,14 +248,15 @@ static void on_timeout_locked(void* arg, grpc_error* error) {
     grpc_ares_ev_driver_shutdown_locked(driver);
   }
   grpc_ares_ev_driver_unref(driver);
+  GRPC_ERROR_UNREF(error);
 }
 
 static void on_ares_backup_poll_alarm(void* arg, grpc_error* error) {
   grpc_ares_ev_driver* driver = static_cast<grpc_ares_ev_driver*>(arg);
-  driver->combiner->Run(
-      GRPC_CLOSURE_INIT(&driver->on_ares_backup_poll_alarm_locked,
-                        on_ares_backup_poll_alarm_locked, driver, nullptr),
-      GRPC_ERROR_REF(error));
+  GRPC_ERROR_REF(error);
+  driver->work_serializer->Run(
+      [driver, error]() { on_ares_backup_poll_alarm_locked(driver, error); },
+      DEBUG_LOCATION);
 }
 
 /* In case of non-responsive DNS servers, dropped packets, etc., c-ares has
@@ -267,8 +267,8 @@ static void on_ares_backup_poll_alarm(void* arg, grpc_error* error) {
  *   b) when some time has passed without fd events having happened
  * For the latter, we use this backup poller. Also see
  * https://github.com/grpc/grpc/pull/17688 description for more details. */
-static void on_ares_backup_poll_alarm_locked(void* arg, grpc_error* error) {
-  grpc_ares_ev_driver* driver = static_cast<grpc_ares_ev_driver*>(arg);
+static void on_ares_backup_poll_alarm_locked(grpc_ares_ev_driver* driver,
+                                             grpc_error* error) {
   GRPC_CARES_TRACE_LOG(
       "request:%p ev_driver=%p on_ares_backup_poll_alarm_locked. "
       "driver->shutting_down=%d. "
@@ -301,10 +301,10 @@ static void on_ares_backup_poll_alarm_locked(void* arg, grpc_error* error) {
     grpc_ares_notify_on_event_locked(driver);
   }
   grpc_ares_ev_driver_unref(driver);
+  GRPC_ERROR_UNREF(error);
 }
 
-static void on_readable_locked(void* arg, grpc_error* error) {
-  fd_node* fdn = static_cast<fd_node*>(arg);
+static void on_readable_locked(fd_node* fdn, grpc_error* error) {
   GPR_ASSERT(fdn->readable_registered);
   grpc_ares_ev_driver* ev_driver = fdn->ev_driver;
   const ares_socket_t as = fdn->grpc_polled_fd->GetWrappedAresSocketLocked();
@@ -326,17 +326,17 @@ static void on_readable_locked(void* arg, grpc_error* error) {
   }
   grpc_ares_notify_on_event_locked(ev_driver);
   grpc_ares_ev_driver_unref(ev_driver);
+  GRPC_ERROR_UNREF(error);
 }
 
 static void on_readable(void* arg, grpc_error* error) {
   fd_node* fdn = static_cast<fd_node*>(arg);
-  fdn->ev_driver->combiner->Run(
-      GRPC_CLOSURE_INIT(&fdn->read_closure, on_readable_locked, fdn, nullptr),
-      GRPC_ERROR_REF(error));
+  GRPC_ERROR_REF(error); /* ref owned by lambda */
+  fdn->ev_driver->work_serializer->Run(
+      [fdn, error]() { on_readable_locked(fdn, error); }, DEBUG_LOCATION);
 }
 
-static void on_writable_locked(void* arg, grpc_error* error) {
-  fd_node* fdn = static_cast<fd_node*>(arg);
+static void on_writable_locked(fd_node* fdn, grpc_error* error) {
   GPR_ASSERT(fdn->writable_registered);
   grpc_ares_ev_driver* ev_driver = fdn->ev_driver;
   const ares_socket_t as = fdn->grpc_polled_fd->GetWrappedAresSocketLocked();
@@ -356,13 +356,14 @@ static void on_writable_locked(void* arg, grpc_error* error) {
   }
   grpc_ares_notify_on_event_locked(ev_driver);
   grpc_ares_ev_driver_unref(ev_driver);
+  GRPC_ERROR_UNREF(error);
 }
 
 static void on_writable(void* arg, grpc_error* error) {
   fd_node* fdn = static_cast<fd_node*>(arg);
-  fdn->ev_driver->combiner->Run(
-      GRPC_CLOSURE_INIT(&fdn->write_closure, on_writable_locked, fdn, nullptr),
-      GRPC_ERROR_REF(error));
+  GRPC_ERROR_REF(error); /* ref owned by lambda */
+  fdn->ev_driver->work_serializer->Run(
+      [fdn, error]() { on_writable_locked(fdn, error); }, DEBUG_LOCATION);
 }
 
 ares_channel* grpc_ares_ev_driver_get_channel_locked(
@@ -387,7 +388,7 @@ static void grpc_ares_notify_on_event_locked(grpc_ares_ev_driver* ev_driver) {
           fdn = static_cast<fd_node*>(gpr_malloc(sizeof(fd_node)));
           fdn->grpc_polled_fd =
               ev_driver->polled_fd_factory->NewGrpcPolledFdLocked(
-                  socks[i], ev_driver->pollset_set, ev_driver->combiner);
+                  socks[i], ev_driver->pollset_set, ev_driver->work_serializer);
           GRPC_CARES_TRACE_LOG("request:%p new fd: %s", ev_driver->request,
                                fdn->grpc_polled_fd->GetName());
           fdn->ev_driver = ev_driver;

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver.h

@@ -40,11 +40,11 @@ ares_channel* grpc_ares_ev_driver_get_channel_locked(
 
 /* Creates a new grpc_ares_ev_driver. Returns GRPC_ERROR_NONE if \a ev_driver is
    created successfully. */
-grpc_error* grpc_ares_ev_driver_create_locked(grpc_ares_ev_driver** ev_driver,
-                                              grpc_pollset_set* pollset_set,
-                                              int query_timeout_ms,
-                                              grpc_core::Combiner* combiner,
-                                              grpc_ares_request* request);
+grpc_error* grpc_ares_ev_driver_create_locked(
+    grpc_ares_ev_driver** ev_driver, grpc_pollset_set* pollset_set,
+    int query_timeout_ms,
+    std::shared_ptr<grpc_core::WorkSerializer> work_serializer,
+    grpc_ares_request* request);
 
 /* Called back when all DNS lookups have completed. */
 void grpc_ares_ev_driver_on_queries_complete_locked(
@@ -90,12 +90,13 @@ class GrpcPolledFdFactory {
   /* Creates a new wrapped fd for the current platform */
   virtual GrpcPolledFd* NewGrpcPolledFdLocked(
       ares_socket_t as, grpc_pollset_set* driver_pollset_set,
-      Combiner* combiner) = 0;
+      std::shared_ptr<grpc_core::WorkSerializer> work_serializer) = 0;
   /* Optionally configures the ares channel after creation */
   virtual void ConfigureAresChannelLocked(ares_channel channel) = 0;
 };
 
-std::unique_ptr<GrpcPolledFdFactory> NewGrpcPolledFdFactory(Combiner* combiner);
+std::unique_ptr<GrpcPolledFdFactory> NewGrpcPolledFdFactory(
+    std::shared_ptr<grpc_core::WorkSerializer> work_serializer);
 
 }  // namespace grpc_core
 

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver_libuv.cc

@@ -20,6 +20,8 @@
 #include "src/core/lib/iomgr/port.h"
 #if GRPC_ARES == 1 && defined(GRPC_UV)
 
+#include "absl/strings/str_format.h"
+
 #include <ares.h>
 #include <uv.h>
 
@@ -31,7 +33,7 @@
 #include <grpc/support/time.h>
 #include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h"
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/iomgr/combiner.h"
+#include "src/core/lib/iomgr/work_serializer.h"
 
 namespace grpc_core {
 
@@ -41,18 +43,14 @@ void ares_uv_poll_close_cb(uv_handle_t* handle) { delete handle; }
 
 class GrpcPolledFdLibuv : public GrpcPolledFd {
  public:
-  GrpcPolledFdLibuv(ares_socket_t as, Combiner* combiner)
-      : as_(as), combiner_(combiner) {
-    gpr_asprintf(&name_, "c-ares socket: %" PRIdPTR, (intptr_t)as);
+  GrpcPolledFdLibuv(ares_socket_t as,
+                    std::shared_ptr<WorkSerializer> work_serializer)
+      : name_(absl::StrFormat("c-ares socket: %" PRIdPTR, (intptr_t)as)),
+        as_(as),
+        work_serializer_(std::move(work_serializer)) {
     handle_ = new uv_poll_t();
     uv_poll_init_socket(uv_default_loop(), handle_, as);
     handle_->data = this;
-    GRPC_COMBINER_REF(combiner_, "libuv ares event driver");
-  }
-
-  ~GrpcPolledFdLibuv() {
-    gpr_free(name_);
-    GRPC_COMBINER_UNREF(combiner_, "libuv ares event driver");
   }
 
   void RegisterForOnReadableLocked(grpc_closure* read_closure) override {
@@ -101,15 +99,16 @@ class GrpcPolledFdLibuv : public GrpcPolledFd {
 
   ares_socket_t GetWrappedAresSocketLocked() override { return as_; }
 
-  const char* GetName() override { return name_; }
+  const char* GetName() override { return name_.c_str(); }
 
-  char* name_;
+  // TODO(apolcyn): Data members should be private.
+  std::string name_;
   ares_socket_t as_;
   uv_poll_t* handle_;
   grpc_closure* read_closure_ = nullptr;
   grpc_closure* write_closure_ = nullptr;
   int poll_events_ = 0;
-  Combiner* combiner_;
+  std::shared_ptr<WorkSerializer> work_serializer_;
 };
 
 struct AresUvPollCbArg {
@@ -121,14 +120,14 @@ struct AresUvPollCbArg {
   int events;
 };
 
-static void ares_uv_poll_cb_locked(void* arg, grpc_error* error) {
-  std::unique_ptr<AresUvPollCbArg> arg_struct(
-      reinterpret_cast<AresUvPollCbArg*>(arg));
+static void ares_uv_poll_cb_locked(AresUvPollCbArg* arg) {
+  std::unique_ptr<AresUvPollCbArg> arg_struct(arg);
   uv_poll_t* handle = arg_struct->handle;
   int status = arg_struct->status;
   int events = arg_struct->events;
   GrpcPolledFdLibuv* polled_fd =
       reinterpret_cast<GrpcPolledFdLibuv*>(handle->data);
+  grpc_error* error = GRPC_ERROR_NONE;
   if (status < 0) {
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("cares polling error");
     error =
@@ -155,24 +154,23 @@ void ares_uv_poll_cb(uv_poll_t* handle, int status, int events) {
   GrpcPolledFdLibuv* polled_fd =
       reinterpret_cast<GrpcPolledFdLibuv*>(handle->data);
   AresUvPollCbArg* arg = new AresUvPollCbArg(handle, status, events);
-  polled_fd->combiner_->Run(
-      GRPC_CLOSURE_CREATE(ares_uv_poll_cb_locked, arg, nullptr),
-      GRPC_ERROR_NONE);
+  polled_fd->work_serializer_->Run([arg]() { ares_uv_poll_cb_locked(arg); },
+                                   DEBUG_LOCATION);
 }
 
 class GrpcPolledFdFactoryLibuv : public GrpcPolledFdFactory {
  public:
-  GrpcPolledFd* NewGrpcPolledFdLocked(ares_socket_t as,
-                                      grpc_pollset_set* driver_pollset_set,
-                                      Combiner* combiner) override {
-    return new GrpcPolledFdLibuv(as, combiner);
+  GrpcPolledFd* NewGrpcPolledFdLocked(
+      ares_socket_t as, grpc_pollset_set* driver_pollset_set,
+      std::shared_ptr<WorkSerializer> work_serializer) override {
+    return new GrpcPolledFdLibuv(as, std::move(work_serializer));
   }
 
   void ConfigureAresChannelLocked(ares_channel channel) override {}
 };
 
 std::unique_ptr<GrpcPolledFdFactory> NewGrpcPolledFdFactory(
-    Combiner* combiner) {
+    std::shared_ptr<WorkSerializer> work_serializer) {
   return absl::make_unique<GrpcPolledFdFactoryLibuv>();
 }
 

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver_posix.cc

@@ -24,6 +24,8 @@
 #include <string.h>
 #include <sys/ioctl.h>
 
+#include "absl/strings/str_cat.h"
+
 #include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver.h"
 
 #include <grpc/support/alloc.h>
@@ -41,15 +43,13 @@ namespace grpc_core {
 class GrpcPolledFdPosix : public GrpcPolledFd {
  public:
   GrpcPolledFdPosix(ares_socket_t as, grpc_pollset_set* driver_pollset_set)
-      : as_(as) {
-    gpr_asprintf(&name_, "c-ares fd: %d", (int)as);
-    fd_ = grpc_fd_create((int)as, name_, false);
+      : name_(absl::StrCat("c-ares fd: ", (int)as)), as_(as) {
+    fd_ = grpc_fd_create((int)as, name_.c_str(), false);
     driver_pollset_set_ = driver_pollset_set;
     grpc_pollset_set_add_fd(driver_pollset_set_, fd_);
   }
 
   ~GrpcPolledFdPosix() {
-    gpr_free(name_);
     grpc_pollset_set_del_fd(driver_pollset_set_, fd_);
     /* c-ares library will close the fd inside grpc_fd. This fd may be picked up
        immediately by another thread, and should not be closed by the following
@@ -78,9 +78,10 @@ class GrpcPolledFdPosix : public GrpcPolledFd {
 
   ares_socket_t GetWrappedAresSocketLocked() override { return as_; }
 
-  const char* GetName() override { return name_; }
+  const char* GetName() override { return name_.c_str(); }
 
-  char* name_;
+ private:
+  std::string name_;
   ares_socket_t as_;
   grpc_fd* fd_;
   grpc_pollset_set* driver_pollset_set_;
@@ -88,9 +89,9 @@ class GrpcPolledFdPosix : public GrpcPolledFd {
 
 class GrpcPolledFdFactoryPosix : public GrpcPolledFdFactory {
  public:
-  GrpcPolledFd* NewGrpcPolledFdLocked(ares_socket_t as,
-                                      grpc_pollset_set* driver_pollset_set,
-                                      Combiner* /*combiner*/) override {
+  GrpcPolledFd* NewGrpcPolledFdLocked(
+      ares_socket_t as, grpc_pollset_set* driver_pollset_set,
+      std::shared_ptr<WorkSerializer> /*work_serializer*/) override {
     return new GrpcPolledFdPosix(as, driver_pollset_set);
   }
 
@@ -98,7 +99,8 @@ class GrpcPolledFdFactoryPosix : public GrpcPolledFdFactory {
 };
 
 std::unique_ptr<GrpcPolledFdFactory> NewGrpcPolledFdFactory(
-    Combiner* /*combiner*/) {
+    std::shared_ptr<WorkSerializer> work_serializer) {
+  (void)work_serializer;
   return absl::make_unique<GrpcPolledFdFactoryPosix>();
 }
 

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver_windows.cc

@@ -20,6 +20,8 @@
 #include "src/core/lib/iomgr/port.h"
 #if GRPC_ARES == 1 && defined(GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER)
 
+#include "absl/strings/str_format.h"
+
 #include <ares.h>
 
 #include <grpc/support/alloc.h>
@@ -30,12 +32,12 @@
 #include <string.h>
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/sockaddr_windows.h"
 #include "src/core/lib/iomgr/socket_windows.h"
 #include "src/core/lib/iomgr/tcp_windows.h"
+#include "src/core/lib/iomgr/work_serializer.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 #include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver.h"
@@ -97,34 +99,36 @@ class GrpcPolledFdWindows {
     WRITE_WAITING_FOR_VERIFICATION_UPON_RETRY,
   };
 
-  GrpcPolledFdWindows(ares_socket_t as, Combiner* combiner, int address_family,
-                      int socket_type)
-      : read_buf_(grpc_empty_slice()),
+  GrpcPolledFdWindows(ares_socket_t as,
+                      std::shared_ptr<WorkSerializer> work_serializer,
+                      int address_family, int socket_type)
+      : work_serializer_(std::move(work_serializer)),
+        read_buf_(grpc_empty_slice()),
         write_buf_(grpc_empty_slice()),
         tcp_write_state_(WRITE_IDLE),
+        name_(absl::StrFormat("c-ares socket: %" PRIdPTR, as)),
         gotten_into_driver_list_(false),
         address_family_(address_family),
         socket_type_(socket_type) {
-    gpr_asprintf(&name_, "c-ares socket: %" PRIdPTR, as);
-    winsocket_ = grpc_winsocket_create(as, name_);
-    combiner_ = GRPC_COMBINER_REF(combiner, name_);
-    GRPC_CLOSURE_INIT(&continue_register_for_on_readable_locked_,
-                      &GrpcPolledFdWindows::ContinueRegisterForOnReadableLocked,
-                      this, nullptr);
-    GRPC_CLOSURE_INIT(
-        &continue_register_for_on_writeable_locked_,
-        &GrpcPolledFdWindows::ContinueRegisterForOnWriteableLocked, this,
-        nullptr);
+    // Closure Initialization
+    GRPC_CLOSURE_INIT(&outer_read_closure_,
+                      &GrpcPolledFdWindows::OnIocpReadable, this,
+                      grpc_schedule_on_exec_ctx);
+    GRPC_CLOSURE_INIT(&outer_write_closure_,
+                      &GrpcPolledFdWindows::OnIocpWriteable, this,
+                      grpc_schedule_on_exec_ctx);
+    GRPC_CLOSURE_INIT(&on_tcp_connect_locked_,
+                      &GrpcPolledFdWindows::OnTcpConnect, this,
+                      grpc_schedule_on_exec_ctx);
+    winsocket_ = grpc_winsocket_create(as, name_.c_str());
   }
 
   ~GrpcPolledFdWindows() {
-    GRPC_COMBINER_UNREF(combiner_, name_);
     grpc_slice_unref_internal(read_buf_);
     grpc_slice_unref_internal(write_buf_);
     GPR_ASSERT(read_closure_ == nullptr);
     GPR_ASSERT(write_closure_ == nullptr);
     grpc_winsocket_destroy(winsocket_);
-    gpr_free(name_);
   }
 
   void ScheduleAndNullReadClosure(grpc_error* error) {
@@ -145,23 +149,15 @@ class GrpcPolledFdWindows {
     GPR_ASSERT(!read_buf_has_data_);
     read_buf_ = GRPC_SLICE_MALLOC(4192);
     if (connect_done_) {
-      combiner_->Run(&continue_register_for_on_readable_locked_,
-                     GRPC_ERROR_NONE);
+      work_serializer_->Run([this]() { ContinueRegisterForOnReadableLocked(); },
+                            DEBUG_LOCATION);
     } else {
-      GPR_ASSERT(pending_continue_register_for_on_readable_locked_ == nullptr);
-      pending_continue_register_for_on_readable_locked_ =
-          &continue_register_for_on_readable_locked_;
+      GPR_ASSERT(pending_continue_register_for_on_readable_locked_ == false);
+      pending_continue_register_for_on_readable_locked_ = true;
     }
   }
 
-  static void ContinueRegisterForOnReadableLocked(void* arg,
-                                                  grpc_error* unused_error) {
-    GrpcPolledFdWindows* grpc_polled_fd =
-        static_cast<GrpcPolledFdWindows*>(arg);
-    grpc_polled_fd->InnerContinueRegisterForOnReadableLocked(GRPC_ERROR_NONE);
-  }
-
-  void InnerContinueRegisterForOnReadableLocked(grpc_error* unused_error) {
+  void ContinueRegisterForOnReadableLocked() {
     GRPC_CARES_TRACE_LOG(
         "fd:|%s| InnerContinueRegisterForOnReadableLocked "
         "wsa_connect_error_:%d",
@@ -194,10 +190,7 @@ class GrpcPolledFdWindows {
         return;
       }
     }
-    grpc_socket_notify_on_read(
-        winsocket_, GRPC_CLOSURE_INIT(&outer_read_closure_,
-                                      &GrpcPolledFdWindows::OnIocpReadable,
-                                      this, grpc_schedule_on_exec_ctx));
+    grpc_socket_notify_on_read(winsocket_, &outer_read_closure_);
   }
 
   void RegisterForOnWriteableLocked(grpc_closure* write_closure) {
@@ -213,23 +206,15 @@ class GrpcPolledFdWindows {
     GPR_ASSERT(write_closure_ == nullptr);
     write_closure_ = write_closure;
     if (connect_done_) {
-      combiner_->Run(&continue_register_for_on_writeable_locked_,
-                     GRPC_ERROR_NONE);
+      work_serializer_->Run(
+          [this]() { ContinueRegisterForOnWriteableLocked(); }, DEBUG_LOCATION);
     } else {
-      GPR_ASSERT(pending_continue_register_for_on_writeable_locked_ == nullptr);
-      pending_continue_register_for_on_writeable_locked_ =
-          &continue_register_for_on_writeable_locked_;
+      GPR_ASSERT(pending_continue_register_for_on_writeable_locked_ == false);
+      pending_continue_register_for_on_writeable_locked_ = true;
     }
   }
 
-  static void ContinueRegisterForOnWriteableLocked(void* arg,
-                                                   grpc_error* unused_error) {
-    GrpcPolledFdWindows* grpc_polled_fd =
-        static_cast<GrpcPolledFdWindows*>(arg);
-    grpc_polled_fd->InnerContinueRegisterForOnWriteableLocked(GRPC_ERROR_NONE);
-  }
-
-  void InnerContinueRegisterForOnWriteableLocked(grpc_error* unused_error) {
+  void ContinueRegisterForOnWriteableLocked() {
     GRPC_CARES_TRACE_LOG(
         "fd:|%s| InnerContinueRegisterForOnWriteableLocked "
         "wsa_connect_error_:%d",
@@ -256,11 +241,7 @@ class GrpcPolledFdWindows {
             ScheduleAndNullWriteClosure(
                 GRPC_WSA_ERROR(wsa_error_code, "WSASend (overlapped)"));
           } else {
-            grpc_socket_notify_on_write(
-                winsocket_,
-                GRPC_CLOSURE_INIT(&outer_write_closure_,
-                                  &GrpcPolledFdWindows::OnIocpWriteable, this,
-                                  grpc_schedule_on_exec_ctx));
+            grpc_socket_notify_on_write(winsocket_, &outer_write_closure_);
           }
           break;
         case WRITE_PENDING:
@@ -280,7 +261,7 @@ class GrpcPolledFdWindows {
     return grpc_winsocket_wrapped_socket(winsocket_);
   }
 
-  const char* GetName() { return name_; }
+  const char* GetName() { return name_.c_str(); }
 
   ares_ssize_t RecvFrom(WSAErrorContext* wsa_error_ctx, void* data,
                         ares_socket_t data_len, int flags,
@@ -440,24 +421,19 @@ class GrpcPolledFdWindows {
   static void OnTcpConnect(void* arg, grpc_error* error) {
     GrpcPolledFdWindows* grpc_polled_fd =
         static_cast<GrpcPolledFdWindows*>(arg);
-    grpc_polled_fd->combiner_->Run(
-        GRPC_CLOSURE_INIT(&grpc_polled_fd->on_tcp_connect_locked_,
-                          &GrpcPolledFdWindows::OnTcpConnectLocked,
-                          grpc_polled_fd, nullptr),
-        GRPC_ERROR_REF(error));
-  }
-
-  static void OnTcpConnectLocked(void* arg, grpc_error* error) {
-    GrpcPolledFdWindows* grpc_polled_fd =
-        static_cast<GrpcPolledFdWindows*>(arg);
-    grpc_polled_fd->InnerOnTcpConnectLocked(error);
+    GRPC_ERROR_REF(error);  // ref owned by lambda
+    grpc_polled_fd->work_serializer_->Run(
+        [grpc_polled_fd, error]() {
+          grpc_polled_fd->OnTcpConnectLocked(error);
+        },
+        DEBUG_LOCATION);
   }
 
-  void InnerOnTcpConnectLocked(grpc_error* error) {
+  void OnTcpConnectLocked(grpc_error* error) {
     GRPC_CARES_TRACE_LOG(
         "fd:%s InnerOnTcpConnectLocked error:|%s| "
-        "pending_register_for_readable:%" PRIdPTR
-        " pending_register_for_writeable:%" PRIdPTR,
+        "pending_register_for_readable:%d"
+        " pending_register_for_writeable:%d",
         GetName(), grpc_error_string(error),
         pending_continue_register_for_on_readable_locked_,
         pending_continue_register_for_on_writeable_locked_);
@@ -486,14 +462,15 @@ class GrpcPolledFdWindows {
       // this fd to abort.
       wsa_connect_error_ = WSA_OPERATION_ABORTED;
     }
-    if (pending_continue_register_for_on_readable_locked_ != nullptr) {
-      combiner_->Run(pending_continue_register_for_on_readable_locked_,
-                     GRPC_ERROR_NONE);
+    if (pending_continue_register_for_on_readable_locked_) {
+      work_serializer_->Run([this]() { ContinueRegisterForOnReadableLocked(); },
+                            DEBUG_LOCATION);
     }
-    if (pending_continue_register_for_on_writeable_locked_ != nullptr) {
-      combiner_->Run(pending_continue_register_for_on_writeable_locked_,
-                     GRPC_ERROR_NONE);
+    if (pending_continue_register_for_on_writeable_locked_) {
+      work_serializer_->Run(
+          [this]() { ContinueRegisterForOnWriteableLocked(); }, DEBUG_LOCATION);
     }
+    GRPC_ERROR_UNREF(error);
   }
 
   int Connect(WSAErrorContext* wsa_error_ctx, const struct sockaddr* target,
@@ -593,25 +570,16 @@ class GrpcPolledFdWindows {
         return -1;
       }
     }
-    GRPC_CLOSURE_INIT(&on_tcp_connect_locked_,
-                      &GrpcPolledFdWindows::OnTcpConnect, this,
-                      grpc_schedule_on_exec_ctx);
     grpc_socket_notify_on_write(winsocket_, &on_tcp_connect_locked_);
     return out;
   }
 
   static void OnIocpReadable(void* arg, grpc_error* error) {
     GrpcPolledFdWindows* polled_fd = static_cast<GrpcPolledFdWindows*>(arg);
-    polled_fd->combiner_->Run(
-        GRPC_CLOSURE_INIT(&polled_fd->outer_read_closure_,
-                          &GrpcPolledFdWindows::OnIocpReadableLocked, polled_fd,
-                          nullptr),
-        GRPC_ERROR_REF(error));
-  }
-
-  static void OnIocpReadableLocked(void* arg, grpc_error* error) {
-    GrpcPolledFdWindows* polled_fd = static_cast<GrpcPolledFdWindows*>(arg);
-    polled_fd->OnIocpReadableInner(error);
+    GRPC_ERROR_REF(error);  // ref owned by lambda
+    polled_fd->work_serializer_->Run(
+        [polled_fd, error]() { polled_fd->OnIocpReadableLocked(error); },
+        DEBUG_LOCATION);
   }
 
   // TODO(apolcyn): improve this error handling to be less conversative.
@@ -619,7 +587,7 @@ class GrpcPolledFdWindows {
   // c-ares reads from this socket later, but it shouldn't necessarily cancel
   // the entire resolution attempt. Doing so will allow the "inject broken
   // nameserver list" test to pass on Windows.
-  void OnIocpReadableInner(grpc_error* error) {
+  void OnIocpReadableLocked(grpc_error* error) {
     if (error == GRPC_ERROR_NONE) {
       if (winsocket_->read_info.wsa_error != 0) {
         /* WSAEMSGSIZE would be due to receiving more data
@@ -627,7 +595,6 @@ class GrpcPolledFdWindows {
          * the connection is TCP and read the leftovers
          * in subsequent c-ares reads. */
         if (winsocket_->read_info.wsa_error != WSAEMSGSIZE) {
-          GRPC_ERROR_UNREF(error);
           error = GRPC_WSA_ERROR(winsocket_->read_info.wsa_error,
                                  "OnIocpReadableInner");
           GRPC_CARES_TRACE_LOG(
@@ -654,24 +621,17 @@ class GrpcPolledFdWindows {
 
   static void OnIocpWriteable(void* arg, grpc_error* error) {
     GrpcPolledFdWindows* polled_fd = static_cast<GrpcPolledFdWindows*>(arg);
-    polled_fd->combiner_->Run(
-        GRPC_CLOSURE_INIT(&polled_fd->outer_write_closure_,
-                          &GrpcPolledFdWindows::OnIocpWriteableLocked,
-                          polled_fd, nullptr),
-        GRPC_ERROR_REF(error));
-  }
-
-  static void OnIocpWriteableLocked(void* arg, grpc_error* error) {
-    GrpcPolledFdWindows* polled_fd = static_cast<GrpcPolledFdWindows*>(arg);
-    polled_fd->OnIocpWriteableInner(error);
+    GRPC_ERROR_REF(error);  // error owned by lambda
+    polled_fd->work_serializer_->Run(
+        [polled_fd, error]() { polled_fd->OnIocpWriteableLocked(error); },
+        DEBUG_LOCATION);
   }
 
-  void OnIocpWriteableInner(grpc_error* error) {
+  void OnIocpWriteableLocked(grpc_error* error) {
     GRPC_CARES_TRACE_LOG("OnIocpWriteableInner. fd:|%s|", GetName());
     GPR_ASSERT(socket_type_ == SOCK_STREAM);
     if (error == GRPC_ERROR_NONE) {
       if (winsocket_->write_info.wsa_error != 0) {
-        GRPC_ERROR_UNREF(error);
         error = GRPC_WSA_ERROR(winsocket_->write_info.wsa_error,
                                "OnIocpWriteableInner");
         GRPC_CARES_TRACE_LOG(
@@ -698,7 +658,8 @@ class GrpcPolledFdWindows {
   bool gotten_into_driver_list() const { return gotten_into_driver_list_; }
   void set_gotten_into_driver_list() { gotten_into_driver_list_ = true; }
 
-  Combiner* combiner_;
+ private:
+  std::shared_ptr<WorkSerializer> work_serializer_;
   char recv_from_source_addr_[200];
   ares_socklen_t recv_from_source_addr_len_;
   grpc_slice read_buf_;
@@ -711,7 +672,7 @@ class GrpcPolledFdWindows {
   grpc_winsocket* winsocket_;
   // tcp_write_state_ is only used on TCP GrpcPolledFds
   WriteState tcp_write_state_;
-  char* name_ = nullptr;
+  std::string name_;
   bool gotten_into_driver_list_;
   int address_family_;
   int socket_type_;
@@ -721,10 +682,8 @@ class GrpcPolledFdWindows {
   // We don't run register_for_{readable,writeable} logic until
   // a socket is connected. In the interim, we queue readable/writeable
   // registrations with the following state.
-  grpc_closure continue_register_for_on_readable_locked_;
-  grpc_closure continue_register_for_on_writeable_locked_;
-  grpc_closure* pending_continue_register_for_on_readable_locked_ = nullptr;
-  grpc_closure* pending_continue_register_for_on_writeable_locked_ = nullptr;
+  bool pending_continue_register_for_on_readable_locked_ = false;
+  bool pending_continue_register_for_on_writeable_locked_ = false;
 };
 
 struct SockToPolledFdEntry {
@@ -742,14 +701,10 @@ struct SockToPolledFdEntry {
  * with a GrpcPolledFdWindows factory and event driver */
 class SockToPolledFdMap {
  public:
-  SockToPolledFdMap(Combiner* combiner) {
-    combiner_ = GRPC_COMBINER_REF(combiner, "sock to polled fd map");
-  }
+  explicit SockToPolledFdMap(std::shared_ptr<WorkSerializer> work_serializer)
+      : work_serializer_(std::move(work_serializer)) {}
 
-  ~SockToPolledFdMap() {
-    GPR_ASSERT(head_ == nullptr);
-    GRPC_COMBINER_UNREF(combiner_, "sock to polled fd map");
-  }
+  ~SockToPolledFdMap() { GPR_ASSERT(head_ == nullptr); }
 
   void AddNewSocket(SOCKET s, GrpcPolledFdWindows* polled_fd) {
     SockToPolledFdEntry* new_node = new SockToPolledFdEntry(s, polled_fd);
@@ -805,7 +760,7 @@ class SockToPolledFdMap {
     }
     grpc_tcp_set_non_block(s);
     GrpcPolledFdWindows* polled_fd =
-        new GrpcPolledFdWindows(s, map->combiner_, af, type);
+        new GrpcPolledFdWindows(s, map->work_serializer_, af, type);
     GRPC_CARES_TRACE_LOG(
         "fd:|%s| created with params af:%d type:%d protocol:%d",
         polled_fd->GetName(), af, type, protocol);
@@ -861,7 +816,7 @@ class SockToPolledFdMap {
 
  private:
   SockToPolledFdEntry* head_ = nullptr;
-  Combiner* combiner_;
+  std::shared_ptr<WorkSerializer> work_serializer_;
 };
 
 const struct ares_socket_functions custom_ares_sock_funcs = {
@@ -877,7 +832,7 @@ const struct ares_socket_functions custom_ares_sock_funcs = {
    so that c-ares can close it via usual socket teardown. */
 class GrpcPolledFdWindowsWrapper : public GrpcPolledFd {
  public:
-  GrpcPolledFdWindowsWrapper(GrpcPolledFdWindows* wrapped)
+  explicit GrpcPolledFdWindowsWrapper(GrpcPolledFdWindows* wrapped)
       : wrapped_(wrapped) {}
 
   ~GrpcPolledFdWindowsWrapper() {}
@@ -910,12 +865,13 @@ class GrpcPolledFdWindowsWrapper : public GrpcPolledFd {
 
 class GrpcPolledFdFactoryWindows : public GrpcPolledFdFactory {
  public:
-  GrpcPolledFdFactoryWindows(Combiner* combiner)
-      : sock_to_polled_fd_map_(combiner) {}
+  explicit GrpcPolledFdFactoryWindows(
+      std::shared_ptr<WorkSerializer> work_serializer)
+      : sock_to_polled_fd_map_(std::move(work_serializer)) {}
 
-  GrpcPolledFd* NewGrpcPolledFdLocked(ares_socket_t as,
-                                      grpc_pollset_set* driver_pollset_set,
-                                      Combiner* combiner) override {
+  GrpcPolledFd* NewGrpcPolledFdLocked(
+      ares_socket_t as, grpc_pollset_set* driver_pollset_set,
+      std::shared_ptr<WorkSerializer> work_serializer) override {
     GrpcPolledFdWindows* polled_fd = sock_to_polled_fd_map_.LookupPolledFd(as);
     // Set a flag so that the virtual socket "close" method knows it
     // doesn't need to call ShutdownLocked, since now the driver will.
@@ -933,8 +889,9 @@ class GrpcPolledFdFactoryWindows : public GrpcPolledFdFactory {
 };
 
 std::unique_ptr<GrpcPolledFdFactory> NewGrpcPolledFdFactory(
-    Combiner* combiner) {
-  return absl::make_unique<GrpcPolledFdFactoryWindows>(combiner);
+    std::shared_ptr<WorkSerializer> work_serializer) {
+  return absl::make_unique<GrpcPolledFdFactoryWindows>(
+      std::move(work_serializer));
 }
 
 }  // namespace grpc_core