Revert "All instances of exec_ctx being passed around in src/core removed"

4 files changed, 65 insertions, 45 deletions

diff --git a/test/core/channel/channel_args_test.cc b/test/core/channel/channel_args_test.cc
index 4a8195e984..e8b3334185 100644
--- a/test/core/channel/channel_args_test.cc
+++ b/test/core/channel/channel_args_test.cc
@@ -26,7 +26,7 @@
 #include "test/core/util/test_config.h"
 
 static void test_create(void) {
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
   grpc_arg arg_int;
   grpc_arg arg_string;
@@ -55,11 +55,12 @@ static void test_create(void) {
   GPR_ASSERT(strcmp(ch_args->args[1].value.string, arg_string.value.string) ==
              0);
 
-  grpc_channel_args_destroy(ch_args);
+  grpc_channel_args_destroy(&exec_ctx, ch_args);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void test_set_compression_algorithm(void) {
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_channel_args* ch_args;
 
   ch_args =
@@ -69,11 +70,12 @@ static void test_set_compression_algorithm(void) {
                     GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM) == 0);
   GPR_ASSERT(ch_args->args[0].type == GRPC_ARG_INTEGER);
 
-  grpc_channel_args_destroy(ch_args);
+  grpc_channel_args_destroy(&exec_ctx, ch_args);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void test_compression_algorithm_states(void) {
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_channel_args *ch_args, *ch_args_wo_gzip, *ch_args_wo_gzip_deflate;
   unsigned states_bitset;
   size_t i;
@@ -89,10 +91,10 @@ static void test_compression_algorithm_states(void) {
 
   /* disable gzip and deflate */
   ch_args_wo_gzip = grpc_channel_args_compression_algorithm_set_state(
-      &ch_args, GRPC_COMPRESS_GZIP, 0);
+      &exec_ctx, &ch_args, GRPC_COMPRESS_GZIP, 0);
   GPR_ASSERT(ch_args == ch_args_wo_gzip);
   ch_args_wo_gzip_deflate = grpc_channel_args_compression_algorithm_set_state(
-      &ch_args_wo_gzip, GRPC_COMPRESS_DEFLATE, 0);
+      &exec_ctx, &ch_args_wo_gzip, GRPC_COMPRESS_DEFLATE, 0);
   GPR_ASSERT(ch_args_wo_gzip == ch_args_wo_gzip_deflate);
 
   states_bitset = (unsigned)grpc_channel_args_compression_algorithm_get_states(
@@ -107,7 +109,7 @@ static void test_compression_algorithm_states(void) {
 
   /* re-enabled gzip only */
   ch_args_wo_gzip = grpc_channel_args_compression_algorithm_set_state(
-      &ch_args_wo_gzip_deflate, GRPC_COMPRESS_GZIP, 1);
+      &exec_ctx, &ch_args_wo_gzip_deflate, GRPC_COMPRESS_GZIP, 1);
   GPR_ASSERT(ch_args_wo_gzip == ch_args_wo_gzip_deflate);
 
   states_bitset = (unsigned)grpc_channel_args_compression_algorithm_get_states(
@@ -120,7 +122,8 @@ static void test_compression_algorithm_states(void) {
     }
   }
 
-  grpc_channel_args_destroy(ch_args);
+  grpc_channel_args_destroy(&exec_ctx, ch_args);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 static void test_set_socket_mutator(void) {
@@ -134,8 +137,9 @@ static void test_set_socket_mutator(void) {
   GPR_ASSERT(ch_args->args[0].type == GRPC_ARG_POINTER);
 
   {
-    grpc_core::ExecCtx exec_ctx;
-    grpc_channel_args_destroy(ch_args);
+    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+    grpc_channel_args_destroy(&exec_ctx, ch_args);
+    grpc_exec_ctx_finish(&exec_ctx);
   }
 }
 
diff --git a/test/core/channel/channel_stack_builder_test.cc b/test/core/channel/channel_stack_builder_test.cc
index ef6db81b0b..a67f0efafe 100644
--- a/test/core/channel/channel_stack_builder_test.cc
+++ b/test/core/channel/channel_stack_builder_test.cc
@@ -29,30 +29,34 @@
 #include "src/core/lib/surface/channel_init.h"
 #include "test/core/util/test_config.h"
 
-static grpc_error* channel_init_func(grpc_channel_element* elem,
+static grpc_error* channel_init_func(grpc_exec_ctx* exec_ctx,
+                                     grpc_channel_element* elem,
                                      grpc_channel_element_args* args) {
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* call_init_func(grpc_call_element* elem,
+static grpc_error* call_init_func(grpc_exec_ctx* exec_ctx,
+                                  grpc_call_element* elem,
                                   const grpc_call_element_args* args) {
   return GRPC_ERROR_NONE;
 }
 
-static void channel_destroy_func(grpc_channel_element* elem) {}
+static void channel_destroy_func(grpc_exec_ctx* exec_ctx,
+                                 grpc_channel_element* elem) {}
 
-static void call_destroy_func(grpc_call_element* elem,
+static void call_destroy_func(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
                               const grpc_call_final_info* final_info,
                               grpc_closure* ignored) {}
 
-static void call_func(grpc_call_element* elem,
+static void call_func(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
                       grpc_transport_stream_op_batch* op) {}
 
-static void channel_func(grpc_channel_element* elem, grpc_transport_op* op) {
+static void channel_func(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+                         grpc_transport_op* op) {
   if (op->disconnect_with_error != GRPC_ERROR_NONE) {
     GRPC_ERROR_UNREF(op->disconnect_with_error);
   }
-  GRPC_CLOSURE_SCHED(op->on_consumed, GRPC_ERROR_NONE);
+  GRPC_CLOSURE_SCHED(exec_ctx, op->on_consumed, GRPC_ERROR_NONE);
 }
 
 bool g_replacement_fn_called = false;
@@ -102,7 +106,8 @@ const grpc_channel_filter original_filter = {
     grpc_channel_next_get_info,
     "filter_name"};
 
-static bool add_replacement_filter(grpc_channel_stack_builder* builder,
+static bool add_replacement_filter(grpc_exec_ctx* exec_ctx,
+                                   grpc_channel_stack_builder* builder,
                                    void* arg) {
   const grpc_channel_filter* filter =
       static_cast<const grpc_channel_filter*>(arg);
@@ -113,7 +118,8 @@ static bool add_replacement_filter(grpc_channel_stack_builder* builder,
       builder, filter, set_arg_once_fn, &g_replacement_fn_called);
 }
 
-static bool add_original_filter(grpc_channel_stack_builder* builder,
+static bool add_original_filter(grpc_exec_ctx* exec_ctx,
+                                grpc_channel_stack_builder* builder,
                                 void* arg) {
   return grpc_channel_stack_builder_prepend_filter(
       builder, (const grpc_channel_filter*)arg, set_arg_once_fn,
diff --git a/test/core/channel/channel_stack_test.cc b/test/core/channel/channel_stack_test.cc
index ef43facd6e..988ea9bac9 100644
--- a/test/core/channel/channel_stack_test.cc
+++ b/test/core/channel/channel_stack_test.cc
@@ -27,7 +27,8 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "test/core/util/test_config.h"
 
-static grpc_error* channel_init_func(grpc_channel_element* elem,
+static grpc_error* channel_init_func(grpc_exec_ctx* exec_ctx,
+                                     grpc_channel_element* elem,
                                      grpc_channel_element_args* args) {
   GPR_ASSERT(args->channel_args->num_args == 1);
   GPR_ASSERT(args->channel_args->args[0].type == GRPC_ARG_INTEGER);
@@ -39,37 +40,42 @@ static grpc_error* channel_init_func(grpc_channel_element* elem,
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* call_init_func(grpc_call_element* elem,
+static grpc_error* call_init_func(grpc_exec_ctx* exec_ctx,
+                                  grpc_call_element* elem,
                                   const grpc_call_element_args* args) {
   ++*(int*)(elem->channel_data);
   *(int*)(elem->call_data) = 0;
   return GRPC_ERROR_NONE;
 }
 
-static void channel_destroy_func(grpc_channel_element* elem) {}
+static void channel_destroy_func(grpc_exec_ctx* exec_ctx,
+                                 grpc_channel_element* elem) {}
 
-static void call_destroy_func(grpc_call_element* elem,
+static void call_destroy_func(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
                               const grpc_call_final_info* final_info,
                               grpc_closure* ignored) {
   ++*(int*)(elem->channel_data);
 }
 
-static void call_func(grpc_call_element* elem,
+static void call_func(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
                       grpc_transport_stream_op_batch* op) {
   ++*(int*)(elem->call_data);
 }
 
-static void channel_func(grpc_channel_element* elem, grpc_transport_op* op) {
+static void channel_func(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+                         grpc_transport_op* op) {
   ++*(int*)(elem->channel_data);
 }
 
-static void free_channel(void* arg, grpc_error* error) {
-  grpc_channel_stack_destroy(static_cast<grpc_channel_stack*>(arg));
+static void free_channel(grpc_exec_ctx* exec_ctx, void* arg,
+                         grpc_error* error) {
+  grpc_channel_stack_destroy(exec_ctx, static_cast<grpc_channel_stack*>(arg));
   gpr_free(arg);
 }
 
-static void free_call(void* arg, grpc_error* error) {
-  grpc_call_stack_destroy(static_cast<grpc_call_stack*>(arg), nullptr, nullptr);
+static void free_call(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  grpc_call_stack_destroy(exec_ctx, static_cast<grpc_call_stack*>(arg), nullptr,
+                          nullptr);
   gpr_free(arg);
 }
 
@@ -95,7 +101,7 @@ static void test_create_channel_stack(void) {
   grpc_channel_args chan_args;
   int* channel_data;
   int* call_data;
-  grpc_core::ExecCtx exec_ctx;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_slice path = grpc_slice_from_static_string("/service/method");
 
   arg.type = GRPC_ARG_INTEGER;
@@ -107,8 +113,8 @@ static void test_create_channel_stack(void) {
 
   channel_stack = static_cast<grpc_channel_stack*>(
       gpr_malloc(grpc_channel_stack_size(&filters, 1)));
-  grpc_channel_stack_init(1, free_channel, channel_stack, &filters, 1,
-                          &chan_args, nullptr, "test", channel_stack);
+  grpc_channel_stack_init(&exec_ctx, 1, free_channel, channel_stack, &filters,
+                          1, &chan_args, nullptr, "test", channel_stack);
   GPR_ASSERT(channel_stack->count == 1);
   channel_elem = grpc_channel_stack_element(channel_stack, 0);
   channel_data = (int*)channel_elem->channel_data;
@@ -126,8 +132,8 @@ static void test_create_channel_stack(void) {
       nullptr,                      /* arena */
       nullptr                       /* call_combiner */
   };
-  grpc_error* error =
-      grpc_call_stack_init(channel_stack, 1, free_call, call_stack, &args);
+  grpc_error* error = grpc_call_stack_init(&exec_ctx, channel_stack, 1,
+                                           free_call, call_stack, &args);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(call_stack->count == 1);
   call_elem = grpc_call_stack_element(call_stack, 0);
@@ -137,13 +143,14 @@ static void test_create_channel_stack(void) {
   GPR_ASSERT(*call_data == 0);
   GPR_ASSERT(*channel_data == 1);
 
-  GRPC_CALL_STACK_UNREF(call_stack, "done");
-  grpc_core::ExecCtx::Get()->Flush();
+  GRPC_CALL_STACK_UNREF(&exec_ctx, call_stack, "done");
+  grpc_exec_ctx_flush(&exec_ctx);
   GPR_ASSERT(*channel_data == 2);
 
-  GRPC_CHANNEL_STACK_UNREF(channel_stack, "done");
+  GRPC_CHANNEL_STACK_UNREF(&exec_ctx, channel_stack, "done");
 
-  grpc_slice_unref_internal(path);
+  grpc_slice_unref_internal(&exec_ctx, path);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
 int main(int argc, char** argv) {
diff --git a/test/core/channel/minimal_stack_is_minimal_test.cc b/test/core/channel/minimal_stack_is_minimal_test.cc
index 3495f603e4..e0cffa39a8 100644
--- a/test/core/channel/minimal_stack_is_minimal_test.cc
+++ b/test/core/channel/minimal_stack_is_minimal_test.cc
@@ -125,10 +125,12 @@ static int check_stack(const char* file, int line, const char* transport_name,
     grpc_channel_stack_builder_set_transport(builder, &fake_transport);
   }
   {
-    grpc_core::ExecCtx exec_ctx;
-    grpc_channel_stack_builder_set_channel_arguments(builder, channel_args);
+    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+    grpc_channel_stack_builder_set_channel_arguments(&exec_ctx, builder,
+                                                     channel_args);
     GPR_ASSERT(grpc_channel_init_create_stack(
-        builder, (grpc_channel_stack_type)channel_stack_type));
+        &exec_ctx, builder, (grpc_channel_stack_type)channel_stack_type));
+    grpc_exec_ctx_finish(&exec_ctx);
   }
 
   // build up our expectation list
@@ -210,9 +212,10 @@ static int check_stack(const char* file, int line, const char* transport_name,
   gpr_free(expect);
 
   {
-    grpc_core::ExecCtx exec_ctx;
-    grpc_channel_stack_builder_destroy(builder);
-    grpc_channel_args_destroy(channel_args);
+    grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+    grpc_channel_stack_builder_destroy(&exec_ctx, builder);
+    grpc_channel_args_destroy(&exec_ctx, channel_args);
+    grpc_exec_ctx_finish(&exec_ctx);
   }
 
   return result;