Removing instances of exec_ctx being passed around in functions in

src/core. exec_ctx is now a thread_local pointer of type ExecCtx instead of
grpc_exec_ctx which is initialized whenever ExecCtx is instantiated. ExecCtx
also keeps track of the previous exec_ctx so that nesting of exec_ctx is
allowed. This means that there is only one exec_ctx being used at any
time. Also, grpc_exec_ctx_finish is called in the destructor of the
object, and the previous exec_ctx is restored to avoid breaking current
functionality. The code still explicitly calls grpc_exec_ctx_finish
because removing all such instances causes the code to break.

4 files changed, 83 insertions, 89 deletions

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 4597285063..3715fbdc02 100644
--- a/test/core/client_channel/resolvers/dns_resolver_connectivity_test.c
+++ b/test/core/client_channel/resolvers/dns_resolver_connectivity_test.c
@@ -35,8 +35,7 @@ static gpr_mu g_mu;
 static bool g_fail_resolution = true;
 static grpc_combiner *g_combiner;
 
-static void my_resolve_address(grpc_exec_ctx *exec_ctx, const char *addr,
-                               const char *default_port,
+static void my_resolve_address(const char *addr, const char *default_port,
                                grpc_pollset_set *interested_parties,
                                grpc_closure *on_done,
                                grpc_resolved_addresses **addrs) {
@@ -54,13 +53,13 @@ static void my_resolve_address(grpc_exec_ctx *exec_ctx, const char *addr,
     (*addrs)->addrs = gpr_malloc(sizeof(*(*addrs)->addrs));
     (*addrs)->addrs[0].len = 123;
   }
-  GRPC_CLOSURE_SCHED(exec_ctx, on_done, error);
+  GRPC_CLOSURE_SCHED(on_done, error);
 }
 
 static grpc_ares_request *my_dns_lookup_ares(
-    grpc_exec_ctx *exec_ctx, const char *dns_server, const char *addr,
-    const char *default_port, grpc_pollset_set *interested_parties,
-    grpc_closure *on_done, grpc_lb_addresses **lb_addrs, bool check_grpclb,
+    const char *dns_server, const char *addr, const char *default_port,
+    grpc_pollset_set *interested_parties, grpc_closure *on_done,
+    grpc_lb_addresses **lb_addrs, bool check_grpclb,
     char **service_config_json) {
   gpr_mu_lock(&g_mu);
   GPR_ASSERT(0 == strcmp("test", addr));
@@ -74,27 +73,26 @@ static grpc_ares_request *my_dns_lookup_ares(
     *lb_addrs = grpc_lb_addresses_create(1, NULL);
     grpc_lb_addresses_set_address(*lb_addrs, 0, NULL, 0, false, NULL, NULL);
   }
-  GRPC_CLOSURE_SCHED(exec_ctx, on_done, error);
+  GRPC_CLOSURE_SCHED(on_done, error);
   return NULL;
 }
 
-static grpc_resolver *create_resolver(grpc_exec_ctx *exec_ctx,
-                                      const char *name) {
+static grpc_resolver *create_resolver(const char *name) {
   grpc_resolver_factory *factory = grpc_resolver_factory_lookup("dns");
-  grpc_uri *uri = grpc_uri_parse(exec_ctx, name, 0);
+  grpc_uri *uri = grpc_uri_parse(name, 0);
   GPR_ASSERT(uri);
   grpc_resolver_args args;
   memset(&args, 0, sizeof(args));
   args.uri = uri;
   args.combiner = g_combiner;
   grpc_resolver *resolver =
-      grpc_resolver_factory_create_resolver(exec_ctx, factory, &args);
+      grpc_resolver_factory_create_resolver(factory, &args);
   grpc_resolver_factory_unref(factory);
   grpc_uri_destroy(uri);
   return resolver;
 }
 
-static void on_done(grpc_exec_ctx *exec_ctx, void *ev, grpc_error *error) {
+static void on_done(void *ev, grpc_error *error) {
   gpr_event_set(ev, (void *)1);
 }
 
@@ -105,9 +103,9 @@ static bool wait_loop(int deadline_seconds, gpr_event *ev) {
     if (gpr_event_wait(ev, grpc_timeout_seconds_to_deadline(1))) return true;
     deadline_seconds--;
 
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    grpc_timer_check(&exec_ctx, NULL);
-    grpc_exec_ctx_finish(&exec_ctx);
+    exec_ctx = GRPC_EXEC_CTX_INIT;
+    grpc_timer_check(NULL);
+    grpc_exec_ctx_finish();
   }
   return false;
 }
@@ -118,26 +116,24 @@ typedef struct next_args {
   grpc_closure *on_complete;
 } next_args;
 
-static void call_resolver_next_now_lock_taken(grpc_exec_ctx *exec_ctx,
-                                              void *arg,
+static void call_resolver_next_now_lock_taken(void *arg,
                                               grpc_error *error_unused) {
   next_args *a = arg;
-  grpc_resolver_next_locked(exec_ctx, a->resolver, a->result, a->on_complete);
+  grpc_resolver_next_locked(a->resolver, a->result, a->on_complete);
   gpr_free(a);
 }
 
-static void call_resolver_next_after_locking(grpc_exec_ctx *exec_ctx,
-                                             grpc_resolver *resolver,
+static void call_resolver_next_after_locking(grpc_resolver *resolver,
                                              grpc_channel_args **result,
                                              grpc_closure *on_complete) {
   next_args *a = gpr_malloc(sizeof(*a));
   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)),
-                     GRPC_ERROR_NONE);
+  GRPC_CLOSURE_SCHED(
+      GRPC_CLOSURE_CREATE(call_resolver_next_now_lock_taken, a,
+                          grpc_combiner_scheduler(resolver->combiner)),
+      GRPC_ERROR_NONE);
 }
 
 int main(int argc, char **argv) {
@@ -150,30 +146,30 @@ int main(int argc, char **argv) {
   grpc_dns_lookup_ares = my_dns_lookup_ares;
   grpc_channel_args *result = (grpc_channel_args *)1;
 
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_resolver *resolver = create_resolver(&exec_ctx, "dns:test");
+  exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_resolver *resolver = create_resolver("dns:test");
   gpr_event ev1;
   gpr_event_init(&ev1);
   call_resolver_next_after_locking(
-      &exec_ctx, resolver, &result,
+      resolver, &result,
       GRPC_CLOSURE_CREATE(on_done, &ev1, grpc_schedule_on_exec_ctx));
-  grpc_exec_ctx_flush(&exec_ctx);
+  grpc_exec_ctx_flush();
   GPR_ASSERT(wait_loop(5, &ev1));
   GPR_ASSERT(result == NULL);
 
   gpr_event ev2;
   gpr_event_init(&ev2);
   call_resolver_next_after_locking(
-      &exec_ctx, resolver, &result,
+      resolver, &result,
       GRPC_CLOSURE_CREATE(on_done, &ev2, grpc_schedule_on_exec_ctx));
-  grpc_exec_ctx_flush(&exec_ctx);
+  grpc_exec_ctx_flush();
   GPR_ASSERT(wait_loop(30, &ev2));
   GPR_ASSERT(result != NULL);
 
-  grpc_channel_args_destroy(&exec_ctx, result);
-  GRPC_RESOLVER_UNREF(&exec_ctx, resolver, "test");
-  GRPC_COMBINER_UNREF(&exec_ctx, g_combiner, "test");
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_channel_args_destroy(result);
+  GRPC_RESOLVER_UNREF(resolver, "test");
+  GRPC_COMBINER_UNREF(g_combiner, "test");
+  grpc_exec_ctx_finish();
 
   grpc_shutdown();
   gpr_mu_destroy(&g_mu);
diff --git a/test/core/client_channel/resolvers/dns_resolver_test.c b/test/core/client_channel/resolvers/dns_resolver_test.c
index a14926f173..3717d0efd7 100644
--- a/test/core/client_channel/resolvers/dns_resolver_test.c
+++ b/test/core/client_channel/resolvers/dns_resolver_test.c
@@ -28,8 +28,8 @@
 static grpc_combiner *g_combiner;
 
 static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(&exec_ctx, string, 0);
+  exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_uri *uri = grpc_uri_parse(string, 0);
   grpc_resolver_args args;
   grpc_resolver *resolver;
   gpr_log(GPR_DEBUG, "test: '%s' should be valid for '%s'", string,
@@ -38,16 +38,16 @@ static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
   memset(&args, 0, sizeof(args));
   args.uri = uri;
   args.combiner = g_combiner;
-  resolver = grpc_resolver_factory_create_resolver(&exec_ctx, factory, &args);
+  resolver = grpc_resolver_factory_create_resolver(factory, &args);
   GPR_ASSERT(resolver != NULL);
-  GRPC_RESOLVER_UNREF(&exec_ctx, resolver, "test_succeeds");
+  GRPC_RESOLVER_UNREF(resolver, "test_succeeds");
   grpc_uri_destroy(uri);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
 }
 
 static void test_fails(grpc_resolver_factory *factory, const char *string) {
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(&exec_ctx, string, 0);
+  exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_uri *uri = grpc_uri_parse(string, 0);
   grpc_resolver_args args;
   grpc_resolver *resolver;
   gpr_log(GPR_DEBUG, "test: '%s' should be invalid for '%s'", string,
@@ -56,10 +56,10 @@ static void test_fails(grpc_resolver_factory *factory, const char *string) {
   memset(&args, 0, sizeof(args));
   args.uri = uri;
   args.combiner = g_combiner;
-  resolver = grpc_resolver_factory_create_resolver(&exec_ctx, factory, &args);
+  resolver = grpc_resolver_factory_create_resolver(factory, &args);
   GPR_ASSERT(resolver == NULL);
   grpc_uri_destroy(uri);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
 }
 
 int main(int argc, char **argv) {
@@ -82,9 +82,9 @@ int main(int argc, char **argv) {
 
   grpc_resolver_factory_unref(dns);
   {
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    GRPC_COMBINER_UNREF(&exec_ctx, g_combiner, "test");
-    grpc_exec_ctx_finish(&exec_ctx);
+    exec_ctx = GRPC_EXEC_CTX_INIT;
+    GRPC_COMBINER_UNREF(g_combiner, "test");
+    grpc_exec_ctx_finish();
   }
   grpc_shutdown();
 
diff --git a/test/core/client_channel/resolvers/fake_resolver_test.c b/test/core/client_channel/resolvers/fake_resolver_test.c
index 9b0854d6d8..8cc5fc6ce5 100644
--- a/test/core/client_channel/resolvers/fake_resolver_test.c
+++ b/test/core/client_channel/resolvers/fake_resolver_test.c
@@ -33,7 +33,7 @@
 #include "test/core/util/test_config.h"
 
 static grpc_resolver *build_fake_resolver(
-    grpc_exec_ctx *exec_ctx, grpc_combiner *combiner,
+    grpc_combiner *combiner,
     grpc_fake_resolver_response_generator *response_generator) {
   grpc_resolver_factory *factory = grpc_resolver_factory_lookup("fake");
   grpc_arg generator_arg =
@@ -44,7 +44,7 @@ static grpc_resolver *build_fake_resolver(
   args.args = &channel_args;
   args.combiner = combiner;
   grpc_resolver *resolver =
-      grpc_resolver_factory_create_resolver(exec_ctx, factory, &args);
+      grpc_resolver_factory_create_resolver(factory, &args);
   grpc_resolver_factory_unref(factory);
   return resolver;
 }
@@ -55,7 +55,7 @@ typedef struct on_resolution_arg {
   gpr_event ev;
 } on_resolution_arg;
 
-void on_resolution_cb(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
+void on_resolution_cb(void *arg, grpc_error *error) {
   on_resolution_arg *res = arg;
   // We only check the addresses channel arg because that's the only one
   // explicitly set by the test via
@@ -66,24 +66,23 @@ void on_resolution_cb(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
       grpc_lb_addresses_find_channel_arg(res->expected_resolver_result);
   GPR_ASSERT(
       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);
+  grpc_channel_args_destroy(res->resolver_result);
+  grpc_channel_args_destroy(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;
+  exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_combiner *combiner = grpc_combiner_create();
   // Create resolver.
   grpc_fake_resolver_response_generator *response_generator =
       grpc_fake_resolver_response_generator_create();
-  grpc_resolver *resolver =
-      build_fake_resolver(&exec_ctx, combiner, response_generator);
+  grpc_resolver *resolver = build_fake_resolver(combiner, response_generator);
   GPR_ASSERT(resolver != NULL);
 
   // Setup expectations.
-  grpc_uri *uris[] = {grpc_uri_parse(&exec_ctx, "ipv4:10.2.1.1:1234", true),
-                      grpc_uri_parse(&exec_ctx, "ipv4:127.0.0.1:4321", true)};
+  grpc_uri *uris[] = {grpc_uri_parse("ipv4:10.2.1.1:1234", true),
+                      grpc_uri_parse("ipv4:127.0.0.1:4321", true)};
   char *balancer_names[] = {"name1", "name2"};
   const bool is_balancer[] = {true, false};
   grpc_lb_addresses *addresses = grpc_lb_addresses_create(3, NULL);
@@ -96,7 +95,7 @@ static void test_fake_resolver() {
       grpc_lb_addresses_create_channel_arg(addresses);
   grpc_channel_args *results =
       grpc_channel_args_copy_and_add(NULL, &addresses_arg, 1);
-  grpc_lb_addresses_destroy(&exec_ctx, addresses);
+  grpc_lb_addresses_destroy(addresses);
   on_resolution_arg on_res_arg;
   memset(&on_res_arg, 0, sizeof(on_res_arg));
   on_res_arg.expected_resolver_result = results;
@@ -106,17 +105,16 @@ static void test_fake_resolver() {
 
   // Set resolver results and trigger first resolution. on_resolution_cb
   // performs the checks.
-  grpc_fake_resolver_response_generator_set_response(
-      &exec_ctx, response_generator, results);
-  grpc_resolver_next_locked(&exec_ctx, resolver, &on_res_arg.resolver_result,
+  grpc_fake_resolver_response_generator_set_response(response_generator,
+                                                     results);
+  grpc_resolver_next_locked(resolver, &on_res_arg.resolver_result,
                             on_resolution);
-  grpc_exec_ctx_flush(&exec_ctx);
+  grpc_exec_ctx_flush();
   GPR_ASSERT(gpr_event_wait(&on_res_arg.ev,
                             grpc_timeout_seconds_to_deadline(5)) != NULL);
 
   // Setup update.
-  grpc_uri *uris_update[] = {
-      grpc_uri_parse(&exec_ctx, "ipv4:192.168.1.0:31416", true)};
+  grpc_uri *uris_update[] = {grpc_uri_parse("ipv4:192.168.1.0:31416", true)};
   char *balancer_names_update[] = {"name3"};
   const bool is_balancer_update[] = {false};
   grpc_lb_addresses *addresses_update = grpc_lb_addresses_create(1, NULL);
@@ -131,7 +129,7 @@ static void test_fake_resolver() {
       grpc_lb_addresses_create_channel_arg(addresses_update);
   grpc_channel_args *results_update =
       grpc_channel_args_copy_and_add(NULL, &addresses_update_arg, 1);
-  grpc_lb_addresses_destroy(&exec_ctx, addresses_update);
+  grpc_lb_addresses_destroy(addresses_update);
 
   // Setup expectations for the update.
   on_resolution_arg on_res_arg_update;
@@ -142,27 +140,27 @@ static void test_fake_resolver() {
                                       grpc_combiner_scheduler(combiner));
 
   // Set updated resolver results and trigger a second resolution.
-  grpc_fake_resolver_response_generator_set_response(
-      &exec_ctx, response_generator, results_update);
-  grpc_resolver_next_locked(&exec_ctx, resolver,
-                            &on_res_arg_update.resolver_result, on_resolution);
-  grpc_exec_ctx_flush(&exec_ctx);
+  grpc_fake_resolver_response_generator_set_response(response_generator,
+                                                     results_update);
+  grpc_resolver_next_locked(resolver, &on_res_arg_update.resolver_result,
+                            on_resolution);
+  grpc_exec_ctx_flush();
   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.
   memset(&on_res_arg, 0, sizeof(on_res_arg));
-  grpc_resolver_next_locked(&exec_ctx, resolver, &on_res_arg.resolver_result,
+  grpc_resolver_next_locked(resolver, &on_res_arg.resolver_result,
                             on_resolution);
-  grpc_exec_ctx_flush(&exec_ctx);
+  grpc_exec_ctx_flush();
   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");
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_COMBINER_UNREF(combiner, "test_fake_resolver");
+  GRPC_RESOLVER_UNREF(resolver, "test_fake_resolver");
+  grpc_exec_ctx_finish();
   grpc_fake_resolver_response_generator_unref(response_generator);
 }
 
diff --git a/test/core/client_channel/resolvers/sockaddr_resolver_test.c b/test/core/client_channel/resolvers/sockaddr_resolver_test.c
index 8b88619164..e69c68141b 100644
--- a/test/core/client_channel/resolvers/sockaddr_resolver_test.c
+++ b/test/core/client_channel/resolvers/sockaddr_resolver_test.c
@@ -35,14 +35,14 @@ typedef struct on_resolution_arg {
   grpc_channel_args *resolver_result;
 } on_resolution_arg;
 
-void on_resolution_cb(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
+void on_resolution_cb(void *arg, grpc_error *error) {
   on_resolution_arg *res = arg;
-  grpc_channel_args_destroy(exec_ctx, res->resolver_result);
+  grpc_channel_args_destroy(res->resolver_result);
 }
 
 static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(&exec_ctx, string, 0);
+  exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_uri *uri = grpc_uri_parse(string, 0);
   grpc_resolver_args args;
   grpc_resolver *resolver;
   gpr_log(GPR_DEBUG, "test: '%s' should be valid for '%s'", string,
@@ -51,7 +51,7 @@ static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
   memset(&args, 0, sizeof(args));
   args.uri = uri;
   args.combiner = g_combiner;
-  resolver = grpc_resolver_factory_create_resolver(&exec_ctx, factory, &args);
+  resolver = grpc_resolver_factory_create_resolver(factory, &args);
   GPR_ASSERT(resolver != NULL);
 
   on_resolution_arg on_res_arg;
@@ -60,16 +60,16 @@ static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
   grpc_closure *on_resolution = GRPC_CLOSURE_CREATE(
       on_resolution_cb, &on_res_arg, grpc_schedule_on_exec_ctx);
 
-  grpc_resolver_next_locked(&exec_ctx, resolver, &on_res_arg.resolver_result,
+  grpc_resolver_next_locked(resolver, &on_res_arg.resolver_result,
                             on_resolution);
-  GRPC_RESOLVER_UNREF(&exec_ctx, resolver, "test_succeeds");
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_RESOLVER_UNREF(resolver, "test_succeeds");
+  grpc_exec_ctx_finish();
   grpc_uri_destroy(uri);
 }
 
 static void test_fails(grpc_resolver_factory *factory, const char *string) {
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_uri *uri = grpc_uri_parse(&exec_ctx, string, 0);
+  exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_uri *uri = grpc_uri_parse(string, 0);
   grpc_resolver_args args;
   grpc_resolver *resolver;
   gpr_log(GPR_DEBUG, "test: '%s' should be invalid for '%s'", string,
@@ -78,10 +78,10 @@ static void test_fails(grpc_resolver_factory *factory, const char *string) {
   memset(&args, 0, sizeof(args));
   args.uri = uri;
   args.combiner = g_combiner;
-  resolver = grpc_resolver_factory_create_resolver(&exec_ctx, factory, &args);
+  resolver = grpc_resolver_factory_create_resolver(factory, &args);
   GPR_ASSERT(resolver == NULL);
   grpc_uri_destroy(uri);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_exec_ctx_finish();
 }
 
 int main(int argc, char **argv) {
@@ -112,9 +112,9 @@ int main(int argc, char **argv) {
   grpc_resolver_factory_unref(ipv6);
 
   {
-    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    GRPC_COMBINER_UNREF(&exec_ctx, g_combiner, "test");
-    grpc_exec_ctx_finish(&exec_ctx);
+    exec_ctx = GRPC_EXEC_CTX_INIT;
+    GRPC_COMBINER_UNREF(g_combiner, "test");
+    grpc_exec_ctx_finish();
   }
   grpc_shutdown();