Merge pull request #11336 from ctiller/ALL-the-things

Roll-up of threading changes

23 files changed, 368 insertions, 349 deletions

diff --git a/test/core/bad_client/bad_client.c b/test/core/bad_client/bad_client.c
index cfe1ce51f8..4f8e428278 100644
--- a/test/core/bad_client/bad_client.c
+++ b/test/core/bad_client/bad_client.c
@@ -169,8 +169,13 @@ void grpc_run_bad_client_test(
       grpc_endpoint_read(&exec_ctx, sfd.client, &args.incoming,
                          &read_done_closure);
       grpc_exec_ctx_finish(&exec_ctx);
-      GPR_ASSERT(
-          gpr_event_wait(&args.read_done, grpc_timeout_seconds_to_deadline(5)));
+      gpr_timespec deadline = grpc_timeout_seconds_to_deadline(5);
+      while (!gpr_event_get(&args.read_done)) {
+        GPR_ASSERT(gpr_time_cmp(deadline, gpr_now(deadline.clock_type)) > 0);
+        GPR_ASSERT(grpc_completion_queue_next(
+                       a.cq, grpc_timeout_milliseconds_to_deadline(100), NULL)
+                       .type == GRPC_QUEUE_TIMEOUT);
+      }
       grpc_slice_buffer_destroy_internal(&exec_ctx, &args.incoming);
     }
     // Shutdown.
diff --git a/test/core/bad_client/tests/server_registered_method.c b/test/core/bad_client/tests/server_registered_method.c
index 20cc714cc0..f52350302b 100644
--- a/test/core/bad_client/tests/server_registered_method.c
+++ b/test/core/bad_client/tests/server_registered_method.c
@@ -68,27 +68,11 @@ static void verifier_succeeds(grpc_server *server, grpc_completion_queue *cq,
 
 static void verifier_fails(grpc_server *server, grpc_completion_queue *cq,
                            void *registered_method) {
-  grpc_call_error error;
-  grpc_call *s;
-  cq_verifier *cqv = cq_verifier_create(cq);
-  grpc_metadata_array request_metadata_recv;
-  gpr_timespec deadline;
-  grpc_byte_buffer *payload = NULL;
-
-  grpc_metadata_array_init(&request_metadata_recv);
-
-  error = grpc_server_request_registered_call(server, registered_method, &s,
-                                              &deadline, &request_metadata_recv,
-                                              &payload, cq, cq, tag(101));
-  GPR_ASSERT(GRPC_CALL_OK == error);
-  CQ_EXPECT_COMPLETION(cqv, tag(101), 1);
-  cq_verify(cqv);
-
-  GPR_ASSERT(payload == NULL);
-
-  grpc_metadata_array_destroy(&request_metadata_recv);
-  grpc_call_unref(s);
-  cq_verifier_destroy(cqv);
+  while (grpc_server_has_open_connections(server)) {
+    GPR_ASSERT(grpc_completion_queue_next(
+                   cq, grpc_timeout_milliseconds_to_deadline(20), NULL)
+                   .type == GRPC_QUEUE_TIMEOUT);
+  }
 }
 
 int main(int argc, char **argv) {
diff --git a/test/core/client_channel/resolvers/dns_resolver_connectivity_test.c b/test/core/client_channel/resolvers/dns_resolver_connectivity_test.c
index 1407628198..43dc7e9084 100644
--- a/test/core/client_channel/resolvers/dns_resolver_connectivity_test.c
+++ b/test/core/client_channel/resolvers/dns_resolver_connectivity_test.c
@@ -133,11 +133,10 @@ static void call_resolver_next_after_locking(grpc_exec_ctx *exec_ctx,
   a->resolver = resolver;
   a->result = result;
   a->on_complete = on_complete;
-  grpc_closure_sched(
-      exec_ctx,
-      grpc_closure_create(call_resolver_next_now_lock_taken, a,
-                          grpc_combiner_scheduler(resolver->combiner, false)),
-      GRPC_ERROR_NONE);
+  grpc_closure_sched(exec_ctx, grpc_closure_create(
+                                   call_resolver_next_now_lock_taken, a,
+                                   grpc_combiner_scheduler(resolver->combiner)),
+                     GRPC_ERROR_NONE);
 }
 
 int main(int argc, char **argv) {
@@ -145,7 +144,7 @@ int main(int argc, char **argv) {
 
   grpc_init();
   gpr_mu_init(&g_mu);
-  g_combiner = grpc_combiner_create(NULL);
+  g_combiner = grpc_combiner_create();
   grpc_resolve_address = my_resolve_address;
   grpc_dns_lookup_ares = my_dns_lookup_ares;
   grpc_channel_args *result = (grpc_channel_args *)1;
diff --git a/test/core/client_channel/resolvers/dns_resolver_test.c b/test/core/client_channel/resolvers/dns_resolver_test.c
index 877f8d9e88..a14926f173 100644
--- a/test/core/client_channel/resolvers/dns_resolver_test.c
+++ b/test/core/client_channel/resolvers/dns_resolver_test.c
@@ -67,7 +67,7 @@ int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
   grpc_init();
 
-  g_combiner = grpc_combiner_create(NULL);
+  g_combiner = grpc_combiner_create();
 
   dns = grpc_resolver_factory_lookup("dns");
 
diff --git a/test/core/client_channel/resolvers/fake_resolver_test.c b/test/core/client_channel/resolvers/fake_resolver_test.c
index d77e4551c1..74aabffeca 100644
--- a/test/core/client_channel/resolvers/fake_resolver_test.c
+++ b/test/core/client_channel/resolvers/fake_resolver_test.c
@@ -52,12 +52,11 @@ static grpc_resolver *build_fake_resolver(
 typedef struct on_resolution_arg {
   grpc_channel_args *resolver_result;
   grpc_channel_args *expected_resolver_result;
-  bool was_called;
+  gpr_event ev;
 } on_resolution_arg;
 
 void on_resolution_cb(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
   on_resolution_arg *res = arg;
-  res->was_called = true;
   // We only check the addresses channel arg because that's the only one
   // explicitly set by the test via
   // grpc_fake_resolver_response_generator_set_response.
@@ -69,11 +68,12 @@ void on_resolution_cb(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
       grpc_lb_addresses_cmp(actual_lb_addresses, expected_lb_addresses) == 0);
   grpc_channel_args_destroy(exec_ctx, res->resolver_result);
   grpc_channel_args_destroy(exec_ctx, res->expected_resolver_result);
+  gpr_event_set(&res->ev, (void *)1);
 }
 
 static void test_fake_resolver() {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_combiner *combiner = grpc_combiner_create(NULL);
+  grpc_combiner *combiner = grpc_combiner_create();
   // Create resolver.
   grpc_fake_resolver_response_generator *response_generator =
       grpc_fake_resolver_response_generator_create();
@@ -100,8 +100,9 @@ static void test_fake_resolver() {
   on_resolution_arg on_res_arg;
   memset(&on_res_arg, 0, sizeof(on_res_arg));
   on_res_arg.expected_resolver_result = results;
+  gpr_event_init(&on_res_arg.ev);
   grpc_closure *on_resolution = grpc_closure_create(
-      on_resolution_cb, &on_res_arg, grpc_combiner_scheduler(combiner, false));
+      on_resolution_cb, &on_res_arg, grpc_combiner_scheduler(combiner));
 
   // Set resolver results and trigger first resolution. on_resolution_cb
   // performs the checks.
@@ -110,7 +111,8 @@ static void test_fake_resolver() {
   grpc_resolver_next_locked(&exec_ctx, resolver, &on_res_arg.resolver_result,
                             on_resolution);
   grpc_exec_ctx_flush(&exec_ctx);
-  GPR_ASSERT(on_res_arg.was_called);
+  GPR_ASSERT(gpr_event_wait(&on_res_arg.ev,
+                            grpc_timeout_seconds_to_deadline(5)) != NULL);
 
   // Setup update.
   grpc_uri *uris_update[] = {
@@ -135,8 +137,9 @@ static void test_fake_resolver() {
   on_resolution_arg on_res_arg_update;
   memset(&on_res_arg_update, 0, sizeof(on_res_arg_update));
   on_res_arg_update.expected_resolver_result = results_update;
+  gpr_event_init(&on_res_arg_update.ev);
   on_resolution = grpc_closure_create(on_resolution_cb, &on_res_arg_update,
-                                      grpc_combiner_scheduler(combiner, false));
+                                      grpc_combiner_scheduler(combiner));
 
   // Set updated resolver results and trigger a second resolution.
   grpc_fake_resolver_response_generator_set_response(
@@ -144,7 +147,8 @@ static void test_fake_resolver() {
   grpc_resolver_next_locked(&exec_ctx, resolver,
                             &on_res_arg_update.resolver_result, on_resolution);
   grpc_exec_ctx_flush(&exec_ctx);
-  GPR_ASSERT(on_res_arg.was_called);
+  GPR_ASSERT(gpr_event_wait(&on_res_arg_update.ev,
+                            grpc_timeout_seconds_to_deadline(5)) != NULL);
 
   // Requesting a new resolution without re-senting the response shouldn't
   // trigger the resolution callback.
@@ -152,7 +156,9 @@ static void test_fake_resolver() {
   grpc_resolver_next_locked(&exec_ctx, resolver, &on_res_arg.resolver_result,
                             on_resolution);
   grpc_exec_ctx_flush(&exec_ctx);
-  GPR_ASSERT(!on_res_arg.was_called);
+  GPR_ASSERT(gpr_event_wait(&on_res_arg.ev,
+                            grpc_timeout_milliseconds_to_deadline(100)) ==
+             NULL);
 
   GRPC_COMBINER_UNREF(&exec_ctx, combiner, "test_fake_resolver");
   GRPC_RESOLVER_UNREF(&exec_ctx, resolver, "test_fake_resolver");
diff --git a/test/core/client_channel/resolvers/sockaddr_resolver_test.c b/test/core/client_channel/resolvers/sockaddr_resolver_test.c
index 74af64eae9..11d09acaa1 100644
--- a/test/core/client_channel/resolvers/sockaddr_resolver_test.c
+++ b/test/core/client_channel/resolvers/sockaddr_resolver_test.c
@@ -89,7 +89,7 @@ int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
   grpc_init();
 
-  g_combiner = grpc_combiner_create(NULL);
+  g_combiner = grpc_combiner_create();
 
   ipv4 = grpc_resolver_factory_lookup("ipv4");
   ipv6 = grpc_resolver_factory_lookup("ipv6");
diff --git a/test/core/end2end/fixtures/http_proxy_fixture.c b/test/core/end2end/fixtures/http_proxy_fixture.c
index 5a9bb3b18a..c0641a8cff 100644
--- a/test/core/end2end/fixtures/http_proxy_fixture.c
+++ b/test/core/end2end/fixtures/http_proxy_fixture.c
@@ -388,19 +388,19 @@ static void on_accept(grpc_exec_ctx* exec_ctx, void* arg,
   grpc_pollset_set_add_pollset(exec_ctx, conn->pollset_set, proxy->pollset);
   grpc_endpoint_add_to_pollset_set(exec_ctx, endpoint, conn->pollset_set);
   grpc_closure_init(&conn->on_read_request_done, on_read_request_done, conn,
-                    grpc_combiner_scheduler(conn->proxy->combiner, false));
+                    grpc_combiner_scheduler(conn->proxy->combiner));
   grpc_closure_init(&conn->on_server_connect_done, on_server_connect_done, conn,
-                    grpc_combiner_scheduler(conn->proxy->combiner, false));
+                    grpc_combiner_scheduler(conn->proxy->combiner));
   grpc_closure_init(&conn->on_write_response_done, on_write_response_done, conn,
-                    grpc_combiner_scheduler(conn->proxy->combiner, false));
+                    grpc_combiner_scheduler(conn->proxy->combiner));
   grpc_closure_init(&conn->on_client_read_done, on_client_read_done, conn,
-                    grpc_combiner_scheduler(conn->proxy->combiner, false));
+                    grpc_combiner_scheduler(conn->proxy->combiner));
   grpc_closure_init(&conn->on_client_write_done, on_client_write_done, conn,
-                    grpc_combiner_scheduler(conn->proxy->combiner, false));
+                    grpc_combiner_scheduler(conn->proxy->combiner));
   grpc_closure_init(&conn->on_server_read_done, on_server_read_done, conn,
-                    grpc_combiner_scheduler(conn->proxy->combiner, false));
+                    grpc_combiner_scheduler(conn->proxy->combiner));
   grpc_closure_init(&conn->on_server_write_done, on_server_write_done, conn,
-                    grpc_combiner_scheduler(conn->proxy->combiner, false));
+                    grpc_combiner_scheduler(conn->proxy->combiner));
   grpc_slice_buffer_init(&conn->client_read_buffer);
   grpc_slice_buffer_init(&conn->client_deferred_write_buffer);
   grpc_slice_buffer_init(&conn->client_write_buffer);
@@ -441,7 +441,7 @@ grpc_end2end_http_proxy* grpc_end2end_http_proxy_create(void) {
   grpc_end2end_http_proxy* proxy =
       (grpc_end2end_http_proxy*)gpr_malloc(sizeof(*proxy));
   memset(proxy, 0, sizeof(*proxy));
-  proxy->combiner = grpc_combiner_create(NULL);
+  proxy->combiner = grpc_combiner_create();
   gpr_ref_init(&proxy->users, 1);
   // Construct proxy address.
   const int proxy_port = grpc_pick_unused_port_or_die();
diff --git a/test/core/end2end/fuzzers/api_fuzzer.c b/test/core/end2end/fuzzers/api_fuzzer.c
index d742c3d838..1e9e7e6194 100644
--- a/test/core/end2end/fuzzers/api_fuzzer.c
+++ b/test/core/end2end/fuzzers/api_fuzzer.c
@@ -28,6 +28,7 @@
 #include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h"
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/timer.h"
@@ -736,6 +737,11 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   gpr_now_impl = now_impl;
   grpc_init();
   grpc_timer_manager_set_threading(false);
+  {
+    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+    grpc_executor_set_threading(&exec_ctx, false);
+    grpc_exec_ctx_finish(&exec_ctx);
+  }
   grpc_resolve_address = my_resolve_address;
   grpc_dns_lookup_ares = my_dns_lookup_ares;
 
diff --git a/test/core/end2end/fuzzers/client_fuzzer.c b/test/core/end2end/fuzzers/client_fuzzer.c
index 9314db01f3..88ba6bad83 100644
--- a/test/core/end2end/fuzzers/client_fuzzer.c
+++ b/test/core/end2end/fuzzers/client_fuzzer.c
@@ -22,6 +22,7 @@
 #include <grpc/support/alloc.h>
 
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
+#include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/channel.h"
 #include "test/core/util/memory_counters.h"
@@ -43,6 +44,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   if (leak_check) grpc_memory_counters_init();
   grpc_init();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_executor_set_threading(&exec_ctx, false);
 
   grpc_resource_quota *resource_quota =
       grpc_resource_quota_create("client_fuzzer");
diff --git a/test/core/end2end/fuzzers/server_fuzzer.c b/test/core/end2end/fuzzers/server_fuzzer.c
index a38d60c7c6..3ddc1ae907 100644
--- a/test/core/end2end/fuzzers/server_fuzzer.c
+++ b/test/core/end2end/fuzzers/server_fuzzer.c
@@ -19,6 +19,7 @@
 #include <grpc/grpc.h>
 
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
+#include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/server.h"
 #include "test/core/util/memory_counters.h"
@@ -41,6 +42,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   if (leak_check) grpc_memory_counters_init();
   grpc_init();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_executor_set_threading(&exec_ctx, false);
 
   grpc_resource_quota *resource_quota =
       grpc_resource_quota_create("server_fuzzer");
diff --git a/test/core/iomgr/combiner_test.c b/test/core/iomgr/combiner_test.c
index e0371f8e5f..82e692902e 100644
--- a/test/core/iomgr/combiner_test.c
+++ b/test/core/iomgr/combiner_test.c
@@ -29,27 +29,29 @@
 static void test_no_op(void) {
   gpr_log(GPR_DEBUG, "test_no_op");
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  GRPC_COMBINER_UNREF(&exec_ctx, grpc_combiner_create(NULL), "test_no_op");
+  GRPC_COMBINER_UNREF(&exec_ctx, grpc_combiner_create(), "test_no_op");
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void set_bool_to_true(grpc_exec_ctx *exec_ctx, void *value,
-                             grpc_error *error) {
-  *(bool *)value = true;
+static void set_event_to_true(grpc_exec_ctx *exec_ctx, void *value,
+                              grpc_error *error) {
+  gpr_event_set(value, (void *)1);
 }
 
 static void test_execute_one(void) {
   gpr_log(GPR_DEBUG, "test_execute_one");
 
-  grpc_combiner *lock = grpc_combiner_create(NULL);
-  bool done = false;
+  grpc_combiner *lock = grpc_combiner_create();
+  gpr_event done;
+  gpr_event_init(&done);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_closure_sched(&exec_ctx,
-                     grpc_closure_create(set_bool_to_true, &done,
-                                         grpc_combiner_scheduler(lock, false)),
+                     grpc_closure_create(set_event_to_true, &done,
+                                         grpc_combiner_scheduler(lock)),
                      GRPC_ERROR_NONE);
   grpc_exec_ctx_flush(&exec_ctx);
-  GPR_ASSERT(done);
+  GPR_ASSERT(gpr_event_wait(&done, grpc_timeout_seconds_to_deadline(5)) !=
+             NULL);
   GRPC_COMBINER_UNREF(&exec_ctx, lock, "test_execute_one");
   grpc_exec_ctx_finish(&exec_ctx);
 }
@@ -57,6 +59,7 @@ static void test_execute_one(void) {
 typedef struct {
   size_t ctr;
   grpc_combiner *lock;
+  gpr_event done;
 } thd_args;
 
 typedef struct {
@@ -80,23 +83,27 @@ static void execute_many_loop(void *a) {
       ex_args *c = gpr_malloc(sizeof(*c));
       c->ctr = &args->ctr;
       c->value = n++;
-      grpc_closure_sched(
-          &exec_ctx, grpc_closure_create(check_one, c, grpc_combiner_scheduler(
-                                                           args->lock, false)),
-          GRPC_ERROR_NONE);
+      grpc_closure_sched(&exec_ctx,
+                         grpc_closure_create(
+                             check_one, c, grpc_combiner_scheduler(args->lock)),
+                         GRPC_ERROR_NONE);
       grpc_exec_ctx_flush(&exec_ctx);
     }
     // sleep for a little bit, to test a combiner draining and another thread
     // picking it up
     gpr_sleep_until(grpc_timeout_milliseconds_to_deadline(100));
   }
+  grpc_closure_sched(&exec_ctx,
+                     grpc_closure_create(set_event_to_true, &args->done,
+                                         grpc_combiner_scheduler(args->lock)),
+                     GRPC_ERROR_NONE);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void test_execute_many(void) {
   gpr_log(GPR_DEBUG, "test_execute_many");
 
-  grpc_combiner *lock = grpc_combiner_create(NULL);
+  grpc_combiner *lock = grpc_combiner_create();
   gpr_thd_id thds[100];
   thd_args ta[GPR_ARRAY_SIZE(thds)];
   for (size_t i = 0; i < GPR_ARRAY_SIZE(thds); i++) {
@@ -104,9 +111,12 @@ static void test_execute_many(void) {
     gpr_thd_options_set_joinable(&options);
     ta[i].ctr = 0;
     ta[i].lock = lock;
+    gpr_event_init(&ta[i].done);
     GPR_ASSERT(gpr_thd_new(&thds[i], execute_many_loop, &ta[i], &options));
   }
   for (size_t i = 0; i < GPR_ARRAY_SIZE(thds); i++) {
+    GPR_ASSERT(gpr_event_wait(&ta[i].done,
+                              gpr_inf_future(GPR_CLOCK_REALTIME)) != NULL);
     gpr_thd_join(thds[i]);
   }
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -114,30 +124,32 @@ static void test_execute_many(void) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static bool got_in_finally = false;
+static gpr_event got_in_finally;
 
 static void in_finally(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  got_in_finally = true;
+  gpr_event_set(&got_in_finally, (void *)1);
 }
 
 static void add_finally(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  grpc_closure_sched(exec_ctx, grpc_closure_create(
-                                   in_finally, NULL,
-                                   grpc_combiner_finally_scheduler(arg, false)),
+  grpc_closure_sched(exec_ctx,
+                     grpc_closure_create(in_finally, arg,
+                                         grpc_combiner_finally_scheduler(arg)),
                      GRPC_ERROR_NONE);
 }
 
 static void test_execute_finally(void) {
   gpr_log(GPR_DEBUG, "test_execute_finally");
 
-  grpc_combiner *lock = grpc_combiner_create(NULL);
+  grpc_combiner *lock = grpc_combiner_create();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_closure_sched(&exec_ctx,
-                     grpc_closure_create(add_finally, lock,
-                                         grpc_combiner_scheduler(lock, false)),
-                     GRPC_ERROR_NONE);
+  gpr_event_init(&got_in_finally);
+  grpc_closure_sched(
+      &exec_ctx,
+      grpc_closure_create(add_finally, lock, grpc_combiner_scheduler(lock)),
+      GRPC_ERROR_NONE);
   grpc_exec_ctx_flush(&exec_ctx);
-  GPR_ASSERT(got_in_finally);
+  GPR_ASSERT(gpr_event_wait(&got_in_finally,
+                            grpc_timeout_seconds_to_deadline(5)) != NULL);
   GRPC_COMBINER_UNREF(&exec_ctx, lock, "test_execute_finally");
   grpc_exec_ctx_finish(&exec_ctx);
 }
diff --git a/test/core/iomgr/endpoint_tests.c b/test/core/iomgr/endpoint_tests.c
index f647310736..d6477a6a87 100644
--- a/test/core/iomgr/endpoint_tests.c
+++ b/test/core/iomgr/endpoint_tests.c
@@ -250,25 +250,30 @@ static void read_and_write_test(grpc_endpoint_test_config config,
 
 static void inc_on_failure(grpc_exec_ctx *exec_ctx, void *arg,
                            grpc_error *error) {
+  gpr_mu_lock(g_mu);
   *(int *)arg += (error != GRPC_ERROR_NONE);
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("kick", grpc_pollset_kick(g_pollset, NULL)));
+  gpr_mu_unlock(g_mu);
 }
 
 static void wait_for_fail_count(grpc_exec_ctx *exec_ctx, int *fail_count,
                                 int want_fail_count) {
   grpc_exec_ctx_flush(exec_ctx);
-  for (int i = 0; i < 5 && *fail_count < want_fail_count; i++) {
+  gpr_mu_lock(g_mu);
+  gpr_timespec deadline = grpc_timeout_seconds_to_deadline(10);
+  while (gpr_time_cmp(gpr_now(deadline.clock_type), deadline) < 0 &&
+         *fail_count < want_fail_count) {
     grpc_pollset_worker *worker = NULL;
-    gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME);
-    gpr_timespec deadline =
-        gpr_time_add(now, gpr_time_from_seconds(1, GPR_TIMESPAN));
-    gpr_mu_lock(g_mu);
     GPR_ASSERT(GRPC_LOG_IF_ERROR(
         "pollset_work",
-        grpc_pollset_work(exec_ctx, g_pollset, &worker, now, deadline)));
+        grpc_pollset_work(exec_ctx, g_pollset, &worker,
+                          gpr_now(deadline.clock_type), deadline)));
     gpr_mu_unlock(g_mu);
     grpc_exec_ctx_flush(exec_ctx);
+    gpr_mu_lock(g_mu);
   }
   GPR_ASSERT(*fail_count == want_fail_count);
+  gpr_mu_unlock(g_mu);
 }
 
 static void multiple_shutdown_test(grpc_endpoint_test_config config) {
diff --git a/test/core/iomgr/ev_epollsig_linux_test.c b/test/core/iomgr/ev_epollsig_linux_test.c
index df6156d823..85f933651d 100644
--- a/test/core/iomgr/ev_epollsig_linux_test.c
+++ b/test/core/iomgr/ev_epollsig_linux_test.c
@@ -32,7 +32,6 @@
 #include <grpc/support/useful.h>
 
 #include "src/core/lib/iomgr/iomgr.h"
-#include "src/core/lib/iomgr/workqueue.h"
 #include "test/core/util/test_config.h"
 
 typedef struct test_pollset {
@@ -116,86 +115,6 @@ static void test_pollset_cleanup(grpc_exec_ctx *exec_ctx,
   }
 }
 
-static void increment(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  ++*(int *)arg;
-}
-
-/*
- * Validate that merging two workqueues preserves the closures in each queue.
- * This is a regression test for a bug in
- * polling_island_merge()[ev_epoll_linux.c], where the parent relationship was
- * inverted.
- */
-
-#define NUM_FDS 2
-#define NUM_POLLSETS 2
-#define NUM_CLOSURES 4
-
-static void test_pollset_queue_merge_items() {
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  test_fd tfds[NUM_FDS];
-  int fds[NUM_FDS];
-  test_pollset pollsets[NUM_POLLSETS];
-  grpc_closure closures[NUM_CLOSURES];
-  int i;
-  int result = 0;
-
-  test_fd_init(tfds, fds, NUM_FDS);
-  test_pollset_init(pollsets, NUM_POLLSETS);
-
-  /* Two distinct polling islands, each with their own FD and pollset. */
-  for (i = 0; i < NUM_FDS; i++) {
-    grpc_pollset_add_fd(&exec_ctx, pollsets[i].pollset, tfds[i].fd);
-    grpc_exec_ctx_flush(&exec_ctx);
-  }
-
-  /* Enqeue the closures, 3 to polling island 0 and 1 to polling island 1. */
-  grpc_closure_init(
-      closures, increment, &result,
-      grpc_workqueue_scheduler(grpc_fd_get_polling_island(tfds[0].fd)));
-  grpc_closure_init(
-      closures + 1, increment, &result,
-      grpc_workqueue_scheduler(grpc_fd_get_polling_island(tfds[0].fd)));
-  grpc_closure_init(
-      closures + 2, increment, &result,
-      grpc_workqueue_scheduler(grpc_fd_get_polling_island(tfds[0].fd)));
-  grpc_closure_init(
-      closures + 3, increment, &result,
-      grpc_workqueue_scheduler(grpc_fd_get_polling_island(tfds[1].fd)));
-  for (i = 0; i < NUM_CLOSURES; ++i) {
-    grpc_closure_sched(&exec_ctx, closures + i, GRPC_ERROR_NONE);
-  }
-
-  /* Merge the two polling islands. */
-  grpc_pollset_add_fd(&exec_ctx, pollsets[0].pollset, tfds[1].fd);
-  grpc_exec_ctx_flush(&exec_ctx);
-
-  /*
-   * Execute the closures, verify we see each one execute when executing work on
-   * the merged polling island.
-   */
-  grpc_pollset_worker *worker = NULL;
-  for (i = 0; i < NUM_CLOSURES; ++i) {
-    const gpr_timespec deadline = gpr_time_add(
-        gpr_now(GPR_CLOCK_MONOTONIC), gpr_time_from_seconds(2, GPR_TIMESPAN));
-    gpr_mu_lock(pollsets[1].mu);
-    GRPC_LOG_IF_ERROR(
-        "grpc_pollset_work",
-        grpc_pollset_work(&exec_ctx, pollsets[1].pollset, &worker,
-                          gpr_now(GPR_CLOCK_MONOTONIC), deadline));
-    gpr_mu_unlock(pollsets[1].mu);
-  }
-  GPR_ASSERT(result == NUM_CLOSURES);
-
-  test_fd_cleanup(&exec_ctx, tfds, NUM_FDS);
-  test_pollset_cleanup(&exec_ctx, pollsets, NUM_POLLSETS);
-  grpc_exec_ctx_finish(&exec_ctx);
-}
-
-#undef NUM_FDS
-#undef NUM_POLLSETS
-#undef NUM_CLOSURES
-
 /*
  * Cases to test:
  *  case 1) Polling islands of both fd and pollset are NULL
@@ -387,13 +306,13 @@ static void test_threading(void) {
 int main(int argc, char **argv) {
   const char *poll_strategy = NULL;
   grpc_test_init(argc, argv);
-  grpc_iomgr_init();
-  grpc_iomgr_start();
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_iomgr_init(&exec_ctx);
+  grpc_iomgr_start(&exec_ctx);
 
   poll_strategy = grpc_get_poll_strategy_name();
   if (poll_strategy != NULL && strcmp(poll_strategy, "epollsig") == 0) {
     test_add_fd_to_pollset();
-    test_pollset_queue_merge_items();
     test_threading();
   } else {
     gpr_log(GPR_INFO,
@@ -402,11 +321,8 @@ int main(int argc, char **argv) {
             poll_strategy);
   }
 
-  {
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_iomgr_shutdown(&exec_ctx);
-    grpc_exec_ctx_finish(&exec_ctx);
-  }
+  grpc_iomgr_shutdown(&exec_ctx);
+  grpc_exec_ctx_finish(&exec_ctx);
   return 0;
 }
 #else /* defined(GRPC_LINUX_EPOLL) */
diff --git a/test/core/iomgr/fd_conservation_posix_test.c b/test/core/iomgr/fd_conservation_posix_test.c
index de09aa4e98..3c61173ecd 100644
--- a/test/core/iomgr/fd_conservation_posix_test.c
+++ b/test/core/iomgr/fd_conservation_posix_test.c
@@ -30,8 +30,9 @@ int main(int argc, char **argv) {
   grpc_endpoint_pair p;
 
   grpc_test_init(argc, argv);
-  grpc_iomgr_init();
-  grpc_iomgr_start();
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_iomgr_init(&exec_ctx);
+  grpc_iomgr_start(&exec_ctx);
 
   /* set max # of file descriptors to a low value, and
      verify we can create and destroy many more than this number
@@ -42,19 +43,15 @@ int main(int argc, char **argv) {
       grpc_resource_quota_create("fd_conservation_posix_test");
 
   for (i = 0; i < 100; i++) {
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     p = grpc_iomgr_create_endpoint_pair("test", NULL);
     grpc_endpoint_destroy(&exec_ctx, p.client);
     grpc_endpoint_destroy(&exec_ctx, p.server);
-    grpc_exec_ctx_finish(&exec_ctx);
+    grpc_exec_ctx_flush(&exec_ctx);
   }
 
   grpc_resource_quota_unref(resource_quota);
 
-  {
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_iomgr_shutdown(&exec_ctx);
-    grpc_exec_ctx_finish(&exec_ctx);
-  }
+  grpc_iomgr_shutdown(&exec_ctx);
+  grpc_exec_ctx_finish(&exec_ctx);
   return 0;
 }
diff --git a/test/core/iomgr/fd_posix_test.c b/test/core/iomgr/fd_posix_test.c
index fca3d2759f..54c71b8a1f 100644
--- a/test/core/iomgr/fd_posix_test.c
+++ b/test/core/iomgr/fd_posix_test.c
@@ -527,8 +527,8 @@ int main(int argc, char **argv) {
   grpc_closure destroyed;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_test_init(argc, argv);
-  grpc_iomgr_init();
-  grpc_iomgr_start();
+  grpc_iomgr_init(&exec_ctx);
+  grpc_iomgr_start(&exec_ctx);
   g_pollset = gpr_zalloc(grpc_pollset_size());
   grpc_pollset_init(g_pollset, &g_mu);
   test_grpc_fd();
diff --git a/test/core/iomgr/pollset_set_test.c b/test/core/iomgr/pollset_set_test.c
index 0afbf31c69..4486586992 100644
--- a/test/core/iomgr/pollset_set_test.c
+++ b/test/core/iomgr/pollset_set_test.c
@@ -432,8 +432,8 @@ int main(int argc, char **argv) {
   const char *poll_strategy = grpc_get_poll_strategy_name();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_test_init(argc, argv);
-  grpc_iomgr_init();
-  grpc_iomgr_start();
+  grpc_iomgr_init(&exec_ctx);
+  grpc_iomgr_start(&exec_ctx);
 
   if (poll_strategy != NULL &&
       (strcmp(poll_strategy, "epoll") == 0 ||
diff --git a/test/core/iomgr/resolve_address_posix_test.c b/test/core/iomgr/resolve_address_posix_test.c
index 6ab4ace99d..be193deca3 100644
--- a/test/core/iomgr/resolve_address_posix_test.c
+++ b/test/core/iomgr/resolve_address_posix_test.c
@@ -159,16 +159,13 @@ static void test_unix_socket_path_name_too_long(void) {
 
 int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
-  grpc_executor_init();
-  grpc_iomgr_init();
-  grpc_iomgr_start();
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_iomgr_init(&exec_ctx);
+  grpc_iomgr_start(&exec_ctx);
   test_unix_socket();
   test_unix_socket_path_name_too_long();
-  {
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_executor_shutdown(&exec_ctx);
-    grpc_iomgr_shutdown(&exec_ctx);
-    grpc_exec_ctx_finish(&exec_ctx);
-  }
+  grpc_executor_shutdown(&exec_ctx);
+  grpc_iomgr_shutdown(&exec_ctx);
+  grpc_exec_ctx_finish(&exec_ctx);
   return 0;
 }
diff --git a/test/core/iomgr/resolve_address_test.c b/test/core/iomgr/resolve_address_test.c
index e09bc266bf..dfcc5ad9de 100644
--- a/test/core/iomgr/resolve_address_test.c
+++ b/test/core/iomgr/resolve_address_test.c
@@ -58,7 +58,9 @@ void args_finish(grpc_exec_ctx *exec_ctx, args_struct *args) {
   grpc_closure do_nothing_cb;
   grpc_closure_init(&do_nothing_cb, do_nothing, NULL,
                     grpc_schedule_on_exec_ctx);
+  gpr_mu_lock(args->mu);
   grpc_pollset_shutdown(exec_ctx, args->pollset, &do_nothing_cb);
+  gpr_mu_unlock(args->mu);
   // exec_ctx needs to be flushed before calling grpc_pollset_destroy()
   grpc_exec_ctx_flush(exec_ctx);
   grpc_pollset_destroy(exec_ctx, args->pollset);
@@ -248,9 +250,9 @@ static void test_unparseable_hostports(void) {
 
 int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
-  grpc_executor_init();
-  grpc_iomgr_init();
-  grpc_iomgr_start();
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_iomgr_init(&exec_ctx);
+  grpc_iomgr_start(&exec_ctx);
   test_localhost();
   test_default_port();
   test_non_numeric_default_port();
@@ -259,11 +261,8 @@ int main(int argc, char **argv) {
   test_ipv6_without_port();
   test_invalid_ip_addresses();
   test_unparseable_hostports();
-  {
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_executor_shutdown(&exec_ctx);
-    grpc_iomgr_shutdown(&exec_ctx);
-    grpc_exec_ctx_finish(&exec_ctx);
-  }
+  grpc_executor_shutdown(&exec_ctx);
+  grpc_iomgr_shutdown(&exec_ctx);
+  grpc_exec_ctx_finish(&exec_ctx);
   return 0;
 }
diff --git a/test/core/iomgr/resource_quota_test.c b/test/core/iomgr/resource_quota_test.c
index f2bd8ae1b5..a3a0db59f5 100644
--- a/test/core/iomgr/resource_quota_test.c
+++ b/test/core/iomgr/resource_quota_test.c
@@ -24,15 +24,30 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "test/core/util/test_config.h"
 
+gpr_mu g_mu;
+gpr_cv g_cv;
+
 static void inc_int_cb(grpc_exec_ctx *exec_ctx, void *a, grpc_error *error) {
+  gpr_mu_lock(&g_mu);
   ++*(int *)a;
+  gpr_cv_signal(&g_cv);
+  gpr_mu_unlock(&g_mu);
+}
+
+static void assert_counter_becomes(int *ctr, int value) {
+  gpr_mu_lock(&g_mu);
+  gpr_timespec deadline = grpc_timeout_seconds_to_deadline(5);
+  while (*ctr != value) {
+    GPR_ASSERT(!gpr_cv_wait(&g_cv, &g_mu, deadline));
+  }
+  gpr_mu_unlock(&g_mu);
 }
 
-static void set_bool_cb(grpc_exec_ctx *exec_ctx, void *a, grpc_error *error) {
-  *(bool *)a = true;
+static void set_event_cb(grpc_exec_ctx *exec_ctx, void *a, grpc_error *error) {
+  gpr_event_set((gpr_event *)a, (void *)1);
 }
-grpc_closure *set_bool(bool *p) {
-  return grpc_closure_create(set_bool_cb, p, grpc_schedule_on_exec_ctx);
+grpc_closure *set_event(gpr_event *ev) {
+  return grpc_closure_create(set_event_cb, ev, grpc_schedule_on_exec_ctx);
 }
 
 typedef struct {
@@ -139,11 +154,13 @@ static void test_simple_async_alloc(void) {
   grpc_resource_quota_resize(q, 1024 * 1024);
   grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -160,15 +177,18 @@ static void test_async_alloc_blocked_by_size(void) {
       grpc_resource_quota_create("test_async_alloc_blocked_by_size");
   grpc_resource_quota_resize(q, 1);
   grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
-  bool done = false;
+  gpr_event ev;
+  gpr_event_init(&ev);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(!done);
+    GPR_ASSERT(gpr_event_wait(
+                   &ev, grpc_timeout_milliseconds_to_deadline(100)) == NULL);
   }
   grpc_resource_quota_resize(q, 1024);
-  GPR_ASSERT(done);
+  GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) != NULL);
+  ;
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_free(&exec_ctx, usr, 1024);
@@ -185,11 +205,14 @@ static void test_scavenge(void) {
   grpc_resource_user *usr1 = grpc_resource_user_create(q, "usr1");
   grpc_resource_user *usr2 = grpc_resource_user_create(q, "usr2");
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -197,11 +220,14 @@ static void test_scavenge(void) {
     grpc_exec_ctx_finish(&exec_ctx);
   }
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -219,26 +245,31 @@ static void test_scavenge_blocked(void) {
   grpc_resource_quota_resize(q, 1024);
   grpc_resource_user *usr1 = grpc_resource_user_create(q, "usr1");
   grpc_resource_user *usr2 = grpc_resource_user_create(q, "usr2");
-  bool done;
+  gpr_event ev;
   {
-    done = false;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
-    done = false;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(!done);
+    GPR_ASSERT(gpr_event_wait(
+                   &ev, grpc_timeout_milliseconds_to_deadline(100)) == NULL);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_free(&exec_ctx, usr1, 1024);
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -257,27 +288,35 @@ static void test_blocked_until_scheduled_reclaim(void) {
   grpc_resource_quota_resize(q, 1024);
   grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
-  bool reclaim_done = false;
+  gpr_event reclaim_done;
+  gpr_event_init(&reclaim_done);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_post_reclaimer(
         &exec_ctx, usr, false,
-        make_reclaimer(usr, 1024, set_bool(&reclaim_done)));
+        make_reclaimer(usr, 1024, set_event(&reclaim_done)));
     grpc_exec_ctx_finish(&exec_ctx);
   }
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(reclaim_done);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&reclaim_done,
+                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -296,27 +335,35 @@ static void test_blocked_until_scheduled_reclaim_and_scavenge(void) {
   grpc_resource_user *usr1 = grpc_resource_user_create(q, "usr1");
   grpc_resource_user *usr2 = grpc_resource_user_create(q, "usr2");
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
-  bool reclaim_done = false;
+  gpr_event reclaim_done;
+  gpr_event_init(&reclaim_done);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_post_reclaimer(
         &exec_ctx, usr1, false,
-        make_reclaimer(usr1, 1024, set_bool(&reclaim_done)));
+        make_reclaimer(usr1, 1024, set_event(&reclaim_done)));
     grpc_exec_ctx_finish(&exec_ctx);
   }
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(reclaim_done);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&reclaim_done,
+                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -335,27 +382,35 @@ static void test_blocked_until_scheduled_destructive_reclaim(void) {
   grpc_resource_quota_resize(q, 1024);
   grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
-  bool reclaim_done = false;
+  gpr_event reclaim_done;
+  gpr_event_init(&reclaim_done);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_post_reclaimer(
         &exec_ctx, usr, true,
-        make_reclaimer(usr, 1024, set_bool(&reclaim_done)));
+        make_reclaimer(usr, 1024, set_event(&reclaim_done)));
     grpc_exec_ctx_finish(&exec_ctx);
   }
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(reclaim_done);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&reclaim_done,
+                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -372,23 +427,31 @@ static void test_unused_reclaim_is_cancelled(void) {
       grpc_resource_quota_create("test_unused_reclaim_is_cancelled");
   grpc_resource_quota_resize(q, 1024);
   grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
-  bool benign_done = false;
-  bool destructive_done = false;
+  gpr_event benign_done;
+  gpr_event_init(&benign_done);
+  gpr_event destructive_done;
+  gpr_event_init(&destructive_done);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_post_reclaimer(
-        &exec_ctx, usr, false, make_unused_reclaimer(set_bool(&benign_done)));
+        &exec_ctx, usr, false, make_unused_reclaimer(set_event(&benign_done)));
     grpc_resource_user_post_reclaimer(
         &exec_ctx, usr, true,
-        make_unused_reclaimer(set_bool(&destructive_done)));
+        make_unused_reclaimer(set_event(&destructive_done)));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(!benign_done);
-    GPR_ASSERT(!destructive_done);
+    GPR_ASSERT(gpr_event_wait(&benign_done,
+                              grpc_timeout_milliseconds_to_deadline(100)) ==
+               NULL);
+    GPR_ASSERT(gpr_event_wait(&destructive_done,
+                              grpc_timeout_milliseconds_to_deadline(100)) ==
+               NULL);
   }
   grpc_resource_quota_unref(q);
   destroy_user(usr);
-  GPR_ASSERT(benign_done);
-  GPR_ASSERT(destructive_done);
+  GPR_ASSERT(gpr_event_wait(&benign_done,
+                            grpc_timeout_seconds_to_deadline(5)) != NULL);
+  GPR_ASSERT(gpr_event_wait(&destructive_done,
+                            grpc_timeout_seconds_to_deadline(5)) != NULL);
 }
 
 static void test_benign_reclaim_is_preferred(void) {
@@ -397,35 +460,49 @@ static void test_benign_reclaim_is_preferred(void) {
       grpc_resource_quota_create("test_benign_reclaim_is_preferred");
   grpc_resource_quota_resize(q, 1024);
   grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
-  bool benign_done = false;
-  bool destructive_done = false;
+  gpr_event benign_done;
+  gpr_event_init(&benign_done);
+  gpr_event destructive_done;
+  gpr_event_init(&destructive_done);
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_post_reclaimer(
         &exec_ctx, usr, false,
-        make_reclaimer(usr, 1024, set_bool(&benign_done)));
+        make_reclaimer(usr, 1024, set_event(&benign_done)));
     grpc_resource_user_post_reclaimer(
         &exec_ctx, usr, true,
-        make_unused_reclaimer(set_bool(&destructive_done)));
+        make_unused_reclaimer(set_event(&destructive_done)));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(!benign_done);
-    GPR_ASSERT(!destructive_done);
+    GPR_ASSERT(gpr_event_wait(&benign_done,
+                              grpc_timeout_milliseconds_to_deadline(100)) ==
+               NULL);
+    GPR_ASSERT(gpr_event_wait(&destructive_done,
+                              grpc_timeout_milliseconds_to_deadline(100)) ==
+               NULL);
   }
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(benign_done);
-    GPR_ASSERT(!destructive_done);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&benign_done,
+                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+    GPR_ASSERT(gpr_event_wait(&destructive_done,
+                              grpc_timeout_milliseconds_to_deadline(100)) ==
+               NULL);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -434,8 +511,10 @@ static void test_benign_reclaim_is_preferred(void) {
   }
   grpc_resource_quota_unref(q);
   destroy_user(usr);
-  GPR_ASSERT(benign_done);
-  GPR_ASSERT(destructive_done);
+  GPR_ASSERT(gpr_event_wait(&benign_done,
+                            grpc_timeout_seconds_to_deadline(5)) != NULL);
+  GPR_ASSERT(gpr_event_wait(&destructive_done,
+                            grpc_timeout_seconds_to_deadline(5)) != NULL);
 }
 
 static void test_multiple_reclaims_can_be_triggered(void) {
@@ -444,35 +523,49 @@ static void test_multiple_reclaims_can_be_triggered(void) {
       grpc_resource_quota_create("test_multiple_reclaims_can_be_triggered");
   grpc_resource_quota_resize(q, 1024);
   grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
-  bool benign_done = false;
-  bool destructive_done = false;
+  gpr_event benign_done;
+  gpr_event_init(&benign_done);
+  gpr_event destructive_done;
+  gpr_event_init(&destructive_done);
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_post_reclaimer(
         &exec_ctx, usr, false,
-        make_reclaimer(usr, 512, set_bool(&benign_done)));
+        make_reclaimer(usr, 512, set_event(&benign_done)));
     grpc_resource_user_post_reclaimer(
         &exec_ctx, usr, true,
-        make_reclaimer(usr, 512, set_bool(&destructive_done)));
+        make_reclaimer(usr, 512, set_event(&destructive_done)));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(!benign_done);
-    GPR_ASSERT(!destructive_done);
+    GPR_ASSERT(gpr_event_wait(&benign_done,
+                              grpc_timeout_milliseconds_to_deadline(100)) ==
+               NULL);
+    GPR_ASSERT(gpr_event_wait(&destructive_done,
+                              grpc_timeout_milliseconds_to_deadline(100)) ==
+               NULL);
   }
   {
-    bool done = false;
+    gpr_event ev;
+    gpr_event_init(&ev);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&done));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(benign_done);
-    GPR_ASSERT(destructive_done);
-    GPR_ASSERT(done);
+    GPR_ASSERT(gpr_event_wait(&benign_done,
+                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+    GPR_ASSERT(gpr_event_wait(&destructive_done,
+                              grpc_timeout_seconds_to_deadline(5)) != NULL);
+    GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+               NULL);
+    ;
   }
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -481,8 +574,10 @@ static void test_multiple_reclaims_can_be_triggered(void) {
   }
   grpc_resource_quota_unref(q);
   destroy_user(usr);
-  GPR_ASSERT(benign_done);
-  GPR_ASSERT(destructive_done);
+  GPR_ASSERT(gpr_event_wait(&benign_done,
+                            grpc_timeout_seconds_to_deadline(5)) != NULL);
+  GPR_ASSERT(gpr_event_wait(&destructive_done,
+                            grpc_timeout_seconds_to_deadline(5)) != NULL);
 }
 
 static void test_resource_user_stays_allocated_until_memory_released(void) {
@@ -523,34 +618,44 @@ test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_released(
   grpc_resource_quota_resize(q, 1024);
   for (int i = 0; i < 10; i++) {
     grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
-    bool reclaimer_cancelled = false;
+    gpr_event reclaimer_cancelled;
+    gpr_event_init(&reclaimer_cancelled);
     {
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
       grpc_resource_user_post_reclaimer(
           &exec_ctx, usr, false,
-          make_unused_reclaimer(set_bool(&reclaimer_cancelled)));
+          make_unused_reclaimer(set_event(&reclaimer_cancelled)));
       grpc_exec_ctx_finish(&exec_ctx);
-      GPR_ASSERT(!reclaimer_cancelled);
+      GPR_ASSERT(gpr_event_wait(&reclaimer_cancelled,
+                                grpc_timeout_milliseconds_to_deadline(100)) ==
+                 NULL);
     }
     {
-      bool allocated = false;
+      gpr_event allocated;
+      gpr_event_init(&allocated);
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-      grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&allocated));
+      grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&allocated));
       grpc_exec_ctx_finish(&exec_ctx);
-      GPR_ASSERT(allocated);
-      GPR_ASSERT(!reclaimer_cancelled);
+      GPR_ASSERT(gpr_event_wait(&allocated,
+                                grpc_timeout_seconds_to_deadline(5)) != NULL);
+      GPR_ASSERT(gpr_event_wait(&reclaimer_cancelled,
+                                grpc_timeout_milliseconds_to_deadline(100)) ==
+                 NULL);
     }
     {
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
       grpc_resource_user_unref(&exec_ctx, usr);
       grpc_exec_ctx_finish(&exec_ctx);
-      GPR_ASSERT(!reclaimer_cancelled);
+      GPR_ASSERT(gpr_event_wait(&reclaimer_cancelled,
+                                grpc_timeout_milliseconds_to_deadline(100)) ==
+                 NULL);
     }
     {
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
       grpc_resource_user_free(&exec_ctx, usr, 1024);
       grpc_exec_ctx_finish(&exec_ctx);
-      GPR_ASSERT(reclaimer_cancelled);
+      GPR_ASSERT(gpr_event_wait(&reclaimer_cancelled,
+                                grpc_timeout_seconds_to_deadline(5)) != NULL);
     }
   }
   grpc_resource_quota_unref(q);
@@ -563,29 +668,37 @@ static void test_reclaimers_can_be_posted_repeatedly(void) {
   grpc_resource_quota_resize(q, 1024);
   grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
   {
-    bool allocated = false;
+    gpr_event allocated;
+    gpr_event_init(&allocated);
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&allocated));
+    grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&allocated));
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(allocated);
+    GPR_ASSERT(gpr_event_wait(&allocated,
+                              grpc_timeout_seconds_to_deadline(5)) != NULL);
   }
   for (int i = 0; i < 10; i++) {
-    bool reclaimer_done = false;
+    gpr_event reclaimer_done;
+    gpr_event_init(&reclaimer_done);
     {
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
       grpc_resource_user_post_reclaimer(
           &exec_ctx, usr, false,
-          make_reclaimer(usr, 1024, set_bool(&reclaimer_done)));
+          make_reclaimer(usr, 1024, set_event(&reclaimer_done)));
       grpc_exec_ctx_finish(&exec_ctx);
-      GPR_ASSERT(!reclaimer_done);
+      GPR_ASSERT(gpr_event_wait(&reclaimer_done,
+                                grpc_timeout_milliseconds_to_deadline(100)) ==
+                 NULL);
     }
     {
-      bool allocated = false;
+      gpr_event allocated;
+      gpr_event_init(&allocated);
       grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-      grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_bool(&allocated));
+      grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&allocated));
       grpc_exec_ctx_finish(&exec_ctx);
-      GPR_ASSERT(allocated);
-      GPR_ASSERT(reclaimer_done);
+      GPR_ASSERT(gpr_event_wait(&allocated,
+                                grpc_timeout_seconds_to_deadline(5)) != NULL);
+      GPR_ASSERT(gpr_event_wait(&reclaimer_done,
+                                grpc_timeout_seconds_to_deadline(5)) != NULL);
     }
   }
   {
@@ -617,7 +730,7 @@ static void test_one_slice(void) {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_alloc_slices(&exec_ctx, &alloc, 1024, 1, &buffer);
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(num_allocs == start_allocs + 1);
+    assert_counter_becomes(&num_allocs, start_allocs + 1);
   }
 
   {
@@ -650,7 +763,7 @@ static void test_one_slice_deleted_late(void) {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_alloc_slices(&exec_ctx, &alloc, 1024, 1, &buffer);
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(num_allocs == start_allocs + 1);
+    assert_counter_becomes(&num_allocs, start_allocs + 1);
   }
 
   {
@@ -694,7 +807,7 @@ static void test_negative_rq_free_pool(void) {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     grpc_resource_user_alloc_slices(&exec_ctx, &alloc, 1024, 1, &buffer);
     grpc_exec_ctx_finish(&exec_ctx);
-    GPR_ASSERT(num_allocs == start_allocs + 1);
+    assert_counter_becomes(&num_allocs, start_allocs + 1);
   }
 
   grpc_resource_quota_resize(q, 512);
@@ -720,6 +833,8 @@ static void test_negative_rq_free_pool(void) {
 int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
   grpc_init();
+  gpr_mu_init(&g_mu);
+  gpr_cv_init(&g_cv);
   test_no_op();
   test_resize_then_destroy();
   test_resource_user_no_op();
@@ -742,6 +857,8 @@ int main(int argc, char **argv) {
   test_one_slice_deleted_late();
   test_resize_to_zero();
   test_negative_rq_free_pool();
+  gpr_mu_destroy(&g_mu);
+  gpr_cv_destroy(&g_cv);
   grpc_shutdown();
   return 0;
 }
diff --git a/test/core/iomgr/tcp_posix_test.c b/test/core/iomgr/tcp_posix_test.c
index 2945ed1c36..9ae03fc023 100644
--- a/test/core/iomgr/tcp_posix_test.c
+++ b/test/core/iomgr/tcp_posix_test.c
@@ -147,6 +147,7 @@ static void read_cb(grpc_exec_ctx *exec_ctx, void *user_data,
   gpr_log(GPR_INFO, "Read %" PRIuPTR " bytes of %" PRIuPTR, read_bytes,
           state->target_read_bytes);
   if (state->read_bytes >= state->target_read_bytes) {
+    GPR_ASSERT(GRPC_LOG_IF_ERROR("kick", grpc_pollset_kick(g_pollset, NULL)));
     gpr_mu_unlock(g_mu);
   } else {
     grpc_endpoint_read(exec_ctx, state->ep, &state->incoming, &state->read_cb);
diff --git a/test/core/util/mock_endpoint.c b/test/core/util/mock_endpoint.c
index 96d0ffa440..8cec085be5 100644
--- a/test/core/util/mock_endpoint.c
+++ b/test/core/util/mock_endpoint.c
@@ -102,18 +102,9 @@ static grpc_resource_user *me_get_resource_user(grpc_endpoint *ep) {
 
 static int me_get_fd(grpc_endpoint *ep) { return -1; }
 
-static grpc_workqueue *me_get_workqueue(grpc_endpoint *ep) { return NULL; }
-
 static const grpc_endpoint_vtable vtable = {
-    me_read,
-    me_write,
-    me_get_workqueue,
-    me_add_to_pollset,
-    me_add_to_pollset_set,
-    me_shutdown,
-    me_destroy,
-    me_get_resource_user,
-    me_get_peer,
+    me_read,     me_write,   me_add_to_pollset,    me_add_to_pollset_set,
+    me_shutdown, me_destroy, me_get_resource_user, me_get_peer,
     me_get_fd,
 };
 
diff --git a/test/core/util/passthru_endpoint.c b/test/core/util/passthru_endpoint.c
index 3d564fd853..187bc74ab1 100644
--- a/test/core/util/passthru_endpoint.c
+++ b/test/core/util/passthru_endpoint.c
@@ -154,23 +154,14 @@ static char *me_get_peer(grpc_endpoint *ep) {
 
 static int me_get_fd(grpc_endpoint *ep) { return -1; }
 
-static grpc_workqueue *me_get_workqueue(grpc_endpoint *ep) { return NULL; }
-
 static grpc_resource_user *me_get_resource_user(grpc_endpoint *ep) {
   half *m = (half *)ep;
   return m->resource_user;
 }
 
 static const grpc_endpoint_vtable vtable = {
-    me_read,
-    me_write,
-    me_get_workqueue,
-    me_add_to_pollset,
-    me_add_to_pollset_set,
-    me_shutdown,
-    me_destroy,
-    me_get_resource_user,
-    me_get_peer,
+    me_read,     me_write,   me_add_to_pollset,    me_add_to_pollset_set,
+    me_shutdown, me_destroy, me_get_resource_user, me_get_peer,
     me_get_fd,
 };
 
diff --git a/test/core/util/trickle_endpoint.c b/test/core/util/trickle_endpoint.c
index 5489b8d253..af4c003f80 100644
--- a/test/core/util/trickle_endpoint.c
+++ b/test/core/util/trickle_endpoint.c
@@ -77,11 +77,6 @@ static void te_write(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
   gpr_mu_unlock(&te->mu);
 }
 
-static grpc_workqueue *te_get_workqueue(grpc_endpoint *ep) {
-  trickle_endpoint *te = (trickle_endpoint *)ep;
-  return grpc_endpoint_get_workqueue(te->wrapped);
-}
-
 static void te_add_to_pollset(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
                               grpc_pollset *pollset) {
   trickle_endpoint *te = (trickle_endpoint *)ep;
@@ -140,16 +135,10 @@ static void te_finish_write(grpc_exec_ctx *exec_ctx, void *arg,
   gpr_mu_unlock(&te->mu);
 }
 
-static const grpc_endpoint_vtable vtable = {te_read,
-                                            te_write,
-                                            te_get_workqueue,
-                                            te_add_to_pollset,
-                                            te_add_to_pollset_set,
-                                            te_shutdown,
-                                            te_destroy,
-                                            te_get_resource_user,
-                                            te_get_peer,
-                                            te_get_fd};
+static const grpc_endpoint_vtable vtable = {
+    te_read,     te_write,   te_add_to_pollset,    te_add_to_pollset_set,
+    te_shutdown, te_destroy, te_get_resource_user, te_get_peer,
+    te_get_fd};
 
 grpc_endpoint *grpc_trickle_endpoint_create(grpc_endpoint *wrap,
                                             double bytes_per_second) {