grpc 1.7.3 → 1.8.0

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

@@ -23,8 +23,8 @@
 void grpc_network_status_init(void);
 void grpc_network_status_shutdown(void);
 
-void grpc_network_status_register_endpoint(grpc_endpoint *ep);
-void grpc_network_status_unregister_endpoint(grpc_endpoint *ep);
+void grpc_network_status_register_endpoint(grpc_endpoint* ep);
+void grpc_network_status_unregister_endpoint(grpc_endpoint* ep);
 void grpc_network_status_shutdown_all_endpoints();
 
 #endif /* GRPC_CORE_LIB_IOMGR_NETWORK_STATUS_TRACKER_H */

data/src/core/lib/iomgr/{polling_entity.c → polling_entity.cc}

@@ -22,7 +22,7 @@
 #include "src/core/lib/iomgr/polling_entity.h"
 
 grpc_polling_entity grpc_polling_entity_create_from_pollset_set(
-    grpc_pollset_set *pollset_set) {
+    grpc_pollset_set* pollset_set) {
   grpc_polling_entity pollent;
   pollent.pollent.pollset_set = pollset_set;
   pollent.tag = GRPC_POLLS_POLLSET_SET;
@@ -30,40 +30,40 @@ grpc_polling_entity grpc_polling_entity_create_from_pollset_set(
 }
 
 grpc_polling_entity grpc_polling_entity_create_from_pollset(
-    grpc_pollset *pollset) {
+    grpc_pollset* pollset) {
   grpc_polling_entity pollent;
   pollent.pollent.pollset = pollset;
   pollent.tag = GRPC_POLLS_POLLSET;
   return pollent;
 }
 
-grpc_pollset *grpc_polling_entity_pollset(grpc_polling_entity *pollent) {
+grpc_pollset* grpc_polling_entity_pollset(grpc_polling_entity* pollent) {
   if (pollent->tag == GRPC_POLLS_POLLSET) {
     return pollent->pollent.pollset;
   }
-  return NULL;
+  return nullptr;
 }
 
-grpc_pollset_set *grpc_polling_entity_pollset_set(
-    grpc_polling_entity *pollent) {
+grpc_pollset_set* grpc_polling_entity_pollset_set(
+    grpc_polling_entity* pollent) {
   if (pollent->tag == GRPC_POLLS_POLLSET_SET) {
     return pollent->pollent.pollset_set;
   }
-  return NULL;
+  return nullptr;
 }
 
-bool grpc_polling_entity_is_empty(const grpc_polling_entity *pollent) {
+bool grpc_polling_entity_is_empty(const grpc_polling_entity* pollent) {
   return pollent->tag == GRPC_POLLS_NONE;
 }
 
-void grpc_polling_entity_add_to_pollset_set(grpc_exec_ctx *exec_ctx,
-                                            grpc_polling_entity *pollent,
-                                            grpc_pollset_set *pss_dst) {
+void grpc_polling_entity_add_to_pollset_set(grpc_exec_ctx* exec_ctx,
+                                            grpc_polling_entity* pollent,
+                                            grpc_pollset_set* pss_dst) {
   if (pollent->tag == GRPC_POLLS_POLLSET) {
-    GPR_ASSERT(pollent->pollent.pollset != NULL);
+    GPR_ASSERT(pollent->pollent.pollset != nullptr);
     grpc_pollset_set_add_pollset(exec_ctx, pss_dst, pollent->pollent.pollset);
   } else if (pollent->tag == GRPC_POLLS_POLLSET_SET) {
-    GPR_ASSERT(pollent->pollent.pollset_set != NULL);
+    GPR_ASSERT(pollent->pollent.pollset_set != nullptr);
     grpc_pollset_set_add_pollset_set(exec_ctx, pss_dst,
                                      pollent->pollent.pollset_set);
   } else {
@@ -72,14 +72,14 @@ void grpc_polling_entity_add_to_pollset_set(grpc_exec_ctx *exec_ctx,
   }
 }
 
-void grpc_polling_entity_del_from_pollset_set(grpc_exec_ctx *exec_ctx,
-                                              grpc_polling_entity *pollent,
-                                              grpc_pollset_set *pss_dst) {
+void grpc_polling_entity_del_from_pollset_set(grpc_exec_ctx* exec_ctx,
+                                              grpc_polling_entity* pollent,
+                                              grpc_pollset_set* pss_dst) {
   if (pollent->tag == GRPC_POLLS_POLLSET) {
-    GPR_ASSERT(pollent->pollent.pollset != NULL);
+    GPR_ASSERT(pollent->pollent.pollset != nullptr);
     grpc_pollset_set_del_pollset(exec_ctx, pss_dst, pollent->pollent.pollset);
   } else if (pollent->tag == GRPC_POLLS_POLLSET_SET) {
-    GPR_ASSERT(pollent->pollent.pollset_set != NULL);
+    GPR_ASSERT(pollent->pollent.pollset_set != nullptr);
     grpc_pollset_set_del_pollset_set(exec_ctx, pss_dst,
                                      pollent->pollent.pollset_set);
   } else {

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

@@ -22,6 +22,10 @@
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef enum grpc_pollset_tag {
   GRPC_POLLS_NONE,
   GRPC_POLLS_POLLSET,
@@ -34,34 +38,38 @@ typedef enum grpc_pollset_tag {
 
 typedef struct grpc_polling_entity {
   union {
-    grpc_pollset *pollset;
-    grpc_pollset_set *pollset_set;
+    grpc_pollset* pollset;
+    grpc_pollset_set* pollset_set;
   } pollent;
   grpc_pollset_tag tag;
 } grpc_polling_entity;
 
 grpc_polling_entity grpc_polling_entity_create_from_pollset_set(
-    grpc_pollset_set *pollset_set);
+    grpc_pollset_set* pollset_set);
 grpc_polling_entity grpc_polling_entity_create_from_pollset(
-    grpc_pollset *pollset);
+    grpc_pollset* pollset);
 
 /** If \a pollent contains a pollset, return it. Otherwise, return NULL */
-grpc_pollset *grpc_polling_entity_pollset(grpc_polling_entity *pollent);
+grpc_pollset* grpc_polling_entity_pollset(grpc_polling_entity* pollent);
 
 /** If \a pollent contains a pollset_set, return it. Otherwise, return NULL */
-grpc_pollset_set *grpc_polling_entity_pollset_set(grpc_polling_entity *pollent);
+grpc_pollset_set* grpc_polling_entity_pollset_set(grpc_polling_entity* pollent);
 
-bool grpc_polling_entity_is_empty(const grpc_polling_entity *pollent);
+bool grpc_polling_entity_is_empty(const grpc_polling_entity* pollent);
 
 /** Add the pollset or pollset_set in \a pollent to the destination pollset_set
  * \a * pss_dst */
-void grpc_polling_entity_add_to_pollset_set(grpc_exec_ctx *exec_ctx,
-                                            grpc_polling_entity *pollent,
-                                            grpc_pollset_set *pss_dst);
+void grpc_polling_entity_add_to_pollset_set(grpc_exec_ctx* exec_ctx,
+                                            grpc_polling_entity* pollent,
+                                            grpc_pollset_set* pss_dst);
 
 /** Delete the pollset or pollset_set in \a pollent from the destination
  * pollset_set \a * pss_dst */
-void grpc_polling_entity_del_from_pollset_set(grpc_exec_ctx *exec_ctx,
-                                              grpc_polling_entity *pollent,
-                                              grpc_pollset_set *pss_dst);
+void grpc_polling_entity_del_from_pollset_set(grpc_exec_ctx* exec_ctx,
+                                              grpc_polling_entity* pollent,
+                                              grpc_pollset_set* pss_dst);
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_IOMGR_POLLING_ENTITY_H */

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

@@ -25,10 +25,12 @@
 
 #include "src/core/lib/iomgr/exec_ctx.h"
 
-#ifndef NDEBUG
-extern grpc_tracer_flag grpc_trace_fd_refcount;
+#ifdef __cplusplus
+extern "C" {
 #endif
 
+extern grpc_core::DebugOnlyTraceFlag grpc_trace_fd_refcount;
+
 /* A grpc_pollset is a set of file descriptors that a higher level item is
    interested in. For example:
     - a server will typically keep a pollset containing all connected channels,
@@ -41,12 +43,12 @@ typedef struct grpc_pollset_worker grpc_pollset_worker;
 
 size_t grpc_pollset_size(void);
 /* Initialize a pollset: assumes *pollset contains all zeros */
-void grpc_pollset_init(grpc_pollset *pollset, gpr_mu **mu);
+void grpc_pollset_init(grpc_pollset* pollset, gpr_mu** mu);
 /* Begin shutting down the pollset, and call closure when done.
  * pollset's mutex must be held */
-void grpc_pollset_shutdown(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                           grpc_closure *closure);
-void grpc_pollset_destroy(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset);
+void grpc_pollset_shutdown(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+                           grpc_closure* closure);
+void grpc_pollset_destroy(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset);
 
 /* Do some work on a pollset.
    May involve invoking asynchronous callbacks, or actually polling file
@@ -70,14 +72,18 @@ void grpc_pollset_destroy(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset);
    May call grpc_closure_list_run on grpc_closure_list, without holding the
    pollset
    lock */
-grpc_error *grpc_pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                              grpc_pollset_worker **worker, gpr_timespec now,
-                              gpr_timespec deadline) GRPC_MUST_USE_RESULT;
+grpc_error* grpc_pollset_work(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+                              grpc_pollset_worker** worker,
+                              grpc_millis deadline) GRPC_MUST_USE_RESULT;
 
 /* Break one polling thread out of polling work for this pollset.
    If specific_worker is non-NULL, then kick that worker. */
-grpc_error *grpc_pollset_kick(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                              grpc_pollset_worker *specific_worker)
+grpc_error* grpc_pollset_kick(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+                              grpc_pollset_worker* specific_worker)
     GRPC_MUST_USE_RESULT;
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_IOMGR_POLLSET_H */

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

@@ -21,6 +21,10 @@
 
 #include "src/core/lib/iomgr/pollset.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* A grpc_pollset_set is a set of pollsets that are interested in an
    action. Adding a pollset to a pollset_set automatically adds any
    fd's (etc) that have been registered with the set_set to that pollset.
@@ -28,20 +32,24 @@
 
 typedef struct grpc_pollset_set grpc_pollset_set;
 
-grpc_pollset_set *grpc_pollset_set_create(void);
-void grpc_pollset_set_destroy(grpc_exec_ctx *exec_ctx,
-                              grpc_pollset_set *pollset_set);
-void grpc_pollset_set_add_pollset(grpc_exec_ctx *exec_ctx,
-                                  grpc_pollset_set *pollset_set,
-                                  grpc_pollset *pollset);
-void grpc_pollset_set_del_pollset(grpc_exec_ctx *exec_ctx,
-                                  grpc_pollset_set *pollset_set,
-                                  grpc_pollset *pollset);
-void grpc_pollset_set_add_pollset_set(grpc_exec_ctx *exec_ctx,
-                                      grpc_pollset_set *bag,
-                                      grpc_pollset_set *item);
-void grpc_pollset_set_del_pollset_set(grpc_exec_ctx *exec_ctx,
-                                      grpc_pollset_set *bag,
-                                      grpc_pollset_set *item);
+grpc_pollset_set* grpc_pollset_set_create(void);
+void grpc_pollset_set_destroy(grpc_exec_ctx* exec_ctx,
+                              grpc_pollset_set* pollset_set);
+void grpc_pollset_set_add_pollset(grpc_exec_ctx* exec_ctx,
+                                  grpc_pollset_set* pollset_set,
+                                  grpc_pollset* pollset);
+void grpc_pollset_set_del_pollset(grpc_exec_ctx* exec_ctx,
+                                  grpc_pollset_set* pollset_set,
+                                  grpc_pollset* pollset);
+void grpc_pollset_set_add_pollset_set(grpc_exec_ctx* exec_ctx,
+                                      grpc_pollset_set* bag,
+                                      grpc_pollset_set* item);
+void grpc_pollset_set_del_pollset_set(grpc_exec_ctx* exec_ctx,
+                                      grpc_pollset_set* bag,
+                                      grpc_pollset_set* item);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_IOMGR_POLLSET_SET_H */

data/src/core/lib/iomgr/{pollset_uv.c → pollset_uv.cc}

@@ -34,13 +34,10 @@
 
 #include "src/core/lib/debug/trace.h"
 
-#ifndef NDEBUG
-grpc_tracer_flag grpc_trace_fd_refcount =
-    GRPC_TRACER_INITIALIZER(false, "fd_refcount");
-#endif
+grpc_core::DebugOnlyTraceFlag grpc_trace_fd_refcount(false, "fd_refcount");
 
 struct grpc_pollset {
-  uv_timer_t timer;
+  uv_timer_t* timer;
   int shutting_down;
 };
 
@@ -55,17 +52,17 @@ gpr_mu grpc_polling_mu;
    immediately in the next loop iteration.
    Note: In the future, if there is a bug that involves missing wakeups in the
    future, try adding a uv_async_t to kick the loop differently */
-uv_timer_t *dummy_uv_handle;
+uv_timer_t* dummy_uv_handle;
 
 size_t grpc_pollset_size() { return sizeof(grpc_pollset); }
 
-void dummy_timer_cb(uv_timer_t *handle) {}
+void dummy_timer_cb(uv_timer_t* handle) {}
 
-void dummy_handle_close_cb(uv_handle_t *handle) { gpr_free(handle); }
+void dummy_handle_close_cb(uv_handle_t* handle) { gpr_free(handle); }
 
 void grpc_pollset_global_init(void) {
   gpr_mu_init(&grpc_polling_mu);
-  dummy_uv_handle = gpr_malloc(sizeof(uv_timer_t));
+  dummy_uv_handle = (uv_timer_t*)gpr_malloc(sizeof(uv_timer_t));
   uv_timer_init(uv_default_loop(), dummy_uv_handle);
   grpc_pollset_work_run_loop = 1;
 }
@@ -73,22 +70,26 @@ void grpc_pollset_global_init(void) {
 void grpc_pollset_global_shutdown(void) {
   GRPC_UV_ASSERT_SAME_THREAD();
   gpr_mu_destroy(&grpc_polling_mu);
-  uv_close((uv_handle_t *)dummy_uv_handle, dummy_handle_close_cb);
+  uv_close((uv_handle_t*)dummy_uv_handle, dummy_handle_close_cb);
 }
 
-static void timer_run_cb(uv_timer_t *timer) {}
+static void timer_run_cb(uv_timer_t* timer) {}
 
-static void timer_close_cb(uv_handle_t *handle) { handle->data = (void *)1; }
+static void timer_close_cb(uv_handle_t* handle) {
+  handle->data = (void*)1;
+  gpr_free(handle);
+}
 
-void grpc_pollset_init(grpc_pollset *pollset, gpr_mu **mu) {
+void grpc_pollset_init(grpc_pollset* pollset, gpr_mu** mu) {
   GRPC_UV_ASSERT_SAME_THREAD();
   *mu = &grpc_polling_mu;
-  uv_timer_init(uv_default_loop(), &pollset->timer);
+  pollset->timer = (uv_timer_t*)gpr_malloc(sizeof(uv_timer_t));
+  uv_timer_init(uv_default_loop(), pollset->timer);
   pollset->shutting_down = 0;
 }
 
-void grpc_pollset_shutdown(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                           grpc_closure *closure) {
+void grpc_pollset_shutdown(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+                           grpc_closure* closure) {
   GPR_ASSERT(!pollset->shutting_down);
   GRPC_UV_ASSERT_SAME_THREAD();
   pollset->shutting_down = 1;
@@ -102,38 +103,39 @@ void grpc_pollset_shutdown(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
   GRPC_CLOSURE_SCHED(exec_ctx, closure, GRPC_ERROR_NONE);
 }
 
-void grpc_pollset_destroy(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset) {
+void grpc_pollset_destroy(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset) {
   GRPC_UV_ASSERT_SAME_THREAD();
-  uv_close((uv_handle_t *)&pollset->timer, timer_close_cb);
+  uv_close((uv_handle_t*)pollset->timer, timer_close_cb);
   // timer.data is a boolean indicating that the timer has finished closing
-  pollset->timer.data = (void *)0;
+  pollset->timer->data = (void*)0;
   if (grpc_pollset_work_run_loop) {
-    while (!pollset->timer.data) {
+    while (!pollset->timer->data) {
       uv_run(uv_default_loop(), UV_RUN_NOWAIT);
     }
   }
 }
 
-grpc_error *grpc_pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                              grpc_pollset_worker **worker_hdl,
-                              gpr_timespec now, gpr_timespec deadline) {
+grpc_error* grpc_pollset_work(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+                              grpc_pollset_worker** worker_hdl,
+                              grpc_millis deadline) {
   uint64_t timeout;
   GRPC_UV_ASSERT_SAME_THREAD();
   gpr_mu_unlock(&grpc_polling_mu);
   if (grpc_pollset_work_run_loop) {
-    if (gpr_time_cmp(deadline, now) >= 0) {
-      timeout = (uint64_t)gpr_time_to_millis(gpr_time_sub(deadline, now));
+    grpc_millis now = grpc_exec_ctx_now(exec_ctx);
+    if (deadline >= now) {
+      timeout = deadline - now;
     } else {
       timeout = 0;
     }
     /* We special-case timeout=0 so that we don't bother with the timer when
        the loop won't block anyway */
     if (timeout > 0) {
-      uv_timer_start(&pollset->timer, timer_run_cb, timeout, 0);
+      uv_timer_start(pollset->timer, timer_run_cb, timeout, 0);
       /* Run until there is some I/O activity or the timer triggers. It doesn't
          matter which happens */
       uv_run(uv_default_loop(), UV_RUN_ONCE);
-      uv_timer_stop(&pollset->timer);
+      uv_timer_stop(pollset->timer);
     } else {
       uv_run(uv_default_loop(), UV_RUN_NOWAIT);
     }
@@ -145,8 +147,8 @@ grpc_error *grpc_pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
   return GRPC_ERROR_NONE;
 }
 
-grpc_error *grpc_pollset_kick(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                              grpc_pollset_worker *specific_worker) {
+grpc_error* grpc_pollset_kick(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+                              grpc_pollset_worker* specific_worker) {
   GRPC_UV_ASSERT_SAME_THREAD();
   uv_timer_start(dummy_uv_handle, dummy_timer_cb, 0, 0);
   return GRPC_ERROR_NONE;

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

@@ -19,9 +19,17 @@
 #ifndef GRPC_CORE_LIB_IOMGR_POLLSET_UV_H
 #define GRPC_CORE_LIB_IOMGR_POLLSET_UV_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 extern int grpc_pollset_work_run_loop;
 
 void grpc_pollset_global_init(void);
 void grpc_pollset_global_shutdown(void);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_IOMGR_POLLSET_UV_H */

data/src/core/lib/iomgr/{pollset_windows.c → pollset_windows.cc}

@@ -28,15 +28,12 @@
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/iomgr/pollset_windows.h"
 
-#define GRPC_POLLSET_KICK_BROADCAST ((grpc_pollset_worker *)1)
+#define GRPC_POLLSET_KICK_BROADCAST ((grpc_pollset_worker*)1)
 
-#ifndef NDEBUG
-grpc_tracer_flag grpc_trace_fd_refcount =
-    GRPC_TRACER_INITIALIZER(false, "fd_refcount");
-#endif
+grpc_core::DebugOnlyTraceFlag grpc_trace_fd_refcount(false, "fd_refcount");
 
 gpr_mu grpc_polling_mu;
-static grpc_pollset_worker *g_active_poller;
+static grpc_pollset_worker* g_active_poller;
 static grpc_pollset_worker g_global_root_worker;
 
 void grpc_pollset_global_init(void) {
@@ -49,22 +46,22 @@ void grpc_pollset_global_init(void) {
 
 void grpc_pollset_global_shutdown(void) { gpr_mu_destroy(&grpc_polling_mu); }
 
-static void remove_worker(grpc_pollset_worker *worker,
+static void remove_worker(grpc_pollset_worker* worker,
                           grpc_pollset_worker_link_type type) {
   worker->links[type].prev->links[type].next = worker->links[type].next;
   worker->links[type].next->links[type].prev = worker->links[type].prev;
   worker->links[type].next = worker->links[type].prev = worker;
 }
 
-static int has_workers(grpc_pollset_worker *root,
+static int has_workers(grpc_pollset_worker* root,
                        grpc_pollset_worker_link_type type) {
   return root->links[type].next != root;
 }
 
-static grpc_pollset_worker *pop_front_worker(
-    grpc_pollset_worker *root, grpc_pollset_worker_link_type type) {
+static grpc_pollset_worker* pop_front_worker(
+    grpc_pollset_worker* root, grpc_pollset_worker_link_type type) {
   if (has_workers(root, type)) {
-    grpc_pollset_worker *w = root->links[type].next;
+    grpc_pollset_worker* w = root->links[type].next;
     remove_worker(w, type);
     return w;
   } else {
@@ -72,9 +69,9 @@ static grpc_pollset_worker *pop_front_worker(
   }
 }
 
-static void push_front_worker(grpc_pollset_worker *root,
+static void push_front_worker(grpc_pollset_worker* root,
                               grpc_pollset_worker_link_type type,
-                              grpc_pollset_worker *worker) {
+                              grpc_pollset_worker* worker) {
   worker->links[type].prev = root;
   worker->links[type].next = worker->links[type].prev->links[type].next;
   worker->links[type].prev->links[type].next =
@@ -88,15 +85,15 @@ size_t grpc_pollset_size(void) { return sizeof(grpc_pollset); }
    set of features for the sake of the rest of grpc. But grpc_pollset_work
    won't actually do any polling, and return as quickly as possible. */
 
-void grpc_pollset_init(grpc_pollset *pollset, gpr_mu **mu) {
+void grpc_pollset_init(grpc_pollset* pollset, gpr_mu** mu) {
   *mu = &grpc_polling_mu;
   pollset->root_worker.links[GRPC_POLLSET_WORKER_LINK_POLLSET].next =
       pollset->root_worker.links[GRPC_POLLSET_WORKER_LINK_POLLSET].prev =
           &pollset->root_worker;
 }
 
-void grpc_pollset_shutdown(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                           grpc_closure *closure) {
+void grpc_pollset_shutdown(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+                           grpc_closure* closure) {
   pollset->shutting_down = 1;
   grpc_pollset_kick(exec_ctx, pollset, GRPC_POLLSET_KICK_BROADCAST);
   if (!pollset->is_iocp_worker) {
@@ -106,11 +103,11 @@ void grpc_pollset_shutdown(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
   }
 }
 
-void grpc_pollset_destroy(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset) {}
+void grpc_pollset_destroy(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset) {}
 
-grpc_error *grpc_pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                              grpc_pollset_worker **worker_hdl,
-                              gpr_timespec now, gpr_timespec deadline) {
+grpc_error* grpc_pollset_work(grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
+                              grpc_pollset_worker** worker_hdl,
+                              grpc_millis deadline) {
   grpc_pollset_worker worker;
   if (worker_hdl) *worker_hdl = &worker;
 
@@ -124,7 +121,7 @@ grpc_error *grpc_pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
   gpr_cv_init(&worker.cv);
   if (!pollset->kicked_without_pollers && !pollset->shutting_down) {
     if (g_active_poller == NULL) {
-      grpc_pollset_worker *next_worker;
+      grpc_pollset_worker* next_worker;
       /* become poller */
       pollset->is_iocp_worker = 1;
       g_active_poller = &worker;
@@ -159,9 +156,12 @@ grpc_error *grpc_pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
                       &worker);
     added_worker = 1;
     while (!worker.kicked) {
-      if (gpr_cv_wait(&worker.cv, &grpc_polling_mu, deadline)) {
+      if (gpr_cv_wait(&worker.cv, &grpc_polling_mu,
+                      grpc_millis_to_timespec(deadline, GPR_CLOCK_REALTIME))) {
+        grpc_exec_ctx_invalidate_now(exec_ctx);
         break;
       }
+      grpc_exec_ctx_invalidate_now(exec_ctx);
     }
   } else {
     pollset->kicked_without_pollers = 0;
@@ -181,8 +181,8 @@ done:
   return GRPC_ERROR_NONE;
 }
 
-grpc_error *grpc_pollset_kick(grpc_exec_ctx *exec_ctx, grpc_pollset *p,
-                              grpc_pollset_worker *specific_worker) {
+grpc_error* grpc_pollset_kick(grpc_exec_ctx* exec_ctx, grpc_pollset* p,
+                              grpc_pollset_worker* specific_worker) {
   if (specific_worker != NULL) {
     if (specific_worker == GRPC_POLLSET_KICK_BROADCAST) {
       for (specific_worker =