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

1 files changed, 22 insertions, 14 deletions

diff --git a/src/core/ext/filters/message_size/message_size_filter.cc b/src/core/ext/filters/message_size/message_size_filter.cc
index f8487f9a9e..3d2252af2e 100644
--- a/src/core/ext/filters/message_size/message_size_filter.cc
+++ b/src/core/ext/filters/message_size/message_size_filter.cc
@@ -47,7 +47,8 @@ static void* refcounted_message_size_limits_ref(void* value) {
   return value;
 }
 
-static void refcounted_message_size_limits_unref(void* value) {
+static void refcounted_message_size_limits_unref(grpc_exec_ctx* exec_ctx,
+                                                 void* value) {
   refcounted_message_size_limits* limits =
       (refcounted_message_size_limits*)value;
   if (gpr_unref(&limits->refs)) {
@@ -107,7 +108,8 @@ typedef struct channel_data {
 
 // Callback invoked when we receive a message.  Here we check the max
 // receive message size.
-static void recv_message_ready(void* user_data, grpc_error* error) {
+static void recv_message_ready(grpc_exec_ctx* exec_ctx, void* user_data,
+                               grpc_error* error) {
   grpc_call_element* elem = (grpc_call_element*)user_data;
   call_data* calld = (call_data*)elem->call_data;
   if (*calld->recv_message != nullptr && calld->limits.max_recv_size >= 0 &&
@@ -130,12 +132,13 @@ static void recv_message_ready(void* user_data, grpc_error* error) {
     GRPC_ERROR_REF(error);
   }
   // Invoke the next callback.
-  GRPC_CLOSURE_RUN(calld->next_recv_message_ready, error);
+  GRPC_CLOSURE_RUN(exec_ctx, calld->next_recv_message_ready, error);
 }
 
 // Start transport stream op.
 static void start_transport_stream_op_batch(
-    grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
+    grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+    grpc_transport_stream_op_batch* op) {
   call_data* calld = (call_data*)elem->call_data;
   // Check max send message size.
   if (op->send_message && calld->limits.max_send_size >= 0 &&
@@ -146,7 +149,7 @@ static void start_transport_stream_op_batch(
                  op->payload->send_message.send_message->length,
                  calld->limits.max_send_size);
     grpc_transport_stream_op_batch_finish_with_failure(
-        op,
+        exec_ctx, op,
         grpc_error_set_int(GRPC_ERROR_CREATE_FROM_COPIED_STRING(message_string),
                            GRPC_ERROR_INT_GRPC_STATUS,
                            GRPC_STATUS_RESOURCE_EXHAUSTED),
@@ -162,11 +165,12 @@ static void start_transport_stream_op_batch(
     op->payload->recv_message.recv_message_ready = &calld->recv_message_ready;
   }
   // Chain to the next filter.
-  grpc_call_next_op(elem, op);
+  grpc_call_next_op(exec_ctx, elem, op);
 }
 
 // Constructor for call_data.
-static grpc_error* init_call_elem(grpc_call_element* elem,
+static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
+                                  grpc_call_element* elem,
                                   const grpc_call_element_args* args) {
   channel_data* chand = (channel_data*)elem->channel_data;
   call_data* calld = (call_data*)elem->call_data;
@@ -182,7 +186,7 @@ static grpc_error* init_call_elem(grpc_call_element* elem,
   if (chand->method_limit_table != nullptr) {
     refcounted_message_size_limits* limits =
         (refcounted_message_size_limits*)grpc_method_config_table_get(
-            chand->method_limit_table, args->path);
+            exec_ctx, chand->method_limit_table, args->path);
     if (limits != nullptr) {
       if (limits->limits.max_send_size >= 0 &&
           (limits->limits.max_send_size < calld->limits.max_send_size ||
@@ -200,7 +204,7 @@ static grpc_error* init_call_elem(grpc_call_element* elem,
 }
 
 // Destructor for call_data.
-static void destroy_call_elem(grpc_call_element* elem,
+static void destroy_call_elem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
                               const grpc_call_final_info* final_info,
                               grpc_closure* ignored) {}
 
@@ -237,7 +241,8 @@ message_size_limits get_message_size_limits(
 }
 
 // Constructor for channel_data.
-static grpc_error* init_channel_elem(grpc_channel_element* elem,
+static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
+                                     grpc_channel_element* elem,
                                      grpc_channel_element_args* args) {
   GPR_ASSERT(!args->is_last);
   channel_data* chand = (channel_data*)elem->channel_data;
@@ -252,7 +257,8 @@ static grpc_error* init_channel_elem(grpc_channel_element* elem,
     if (service_config != nullptr) {
       chand->method_limit_table =
           grpc_service_config_create_method_config_table(
-              service_config, refcounted_message_size_limits_create_from_json,
+              exec_ctx, service_config,
+              refcounted_message_size_limits_create_from_json,
               refcounted_message_size_limits_ref,
               refcounted_message_size_limits_unref);
       grpc_service_config_destroy(service_config);
@@ -262,9 +268,10 @@ static grpc_error* init_channel_elem(grpc_channel_element* elem,
 }
 
 // Destructor for channel_data.
-static void destroy_channel_elem(grpc_channel_element* elem) {
+static void destroy_channel_elem(grpc_exec_ctx* exec_ctx,
+                                 grpc_channel_element* elem) {
   channel_data* chand = (channel_data*)elem->channel_data;
-  grpc_slice_hash_table_unref(chand->method_limit_table);
+  grpc_slice_hash_table_unref(exec_ctx, chand->method_limit_table);
 }
 
 const grpc_channel_filter grpc_message_size_filter = {
@@ -280,7 +287,8 @@ const grpc_channel_filter grpc_message_size_filter = {
     grpc_channel_next_get_info,
     "message_size"};
 
-static bool maybe_add_message_size_filter(grpc_channel_stack_builder* builder,
+static bool maybe_add_message_size_filter(grpc_exec_ctx* exec_ctx,
+                                          grpc_channel_stack_builder* builder,
                                           void* arg) {
   const grpc_channel_args* channel_args =
       grpc_channel_stack_builder_get_channel_arguments(builder);