Move arguments to the start of lists

9 files changed, 78 insertions, 78 deletions

diff --git a/src/core/channel/channel_stack.c b/src/core/channel/channel_stack.c
index aafc0ede9c..07b118f74a 100644
--- a/src/core/channel/channel_stack.c
+++ b/src/core/channel/channel_stack.c
@@ -104,7 +104,7 @@ grpc_call_stack_element (grpc_call_stack * call_stack, size_t index)
 }
 
 void
-grpc_channel_stack_init (const grpc_channel_filter ** filters, size_t filter_count, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * metadata_context, grpc_channel_stack * stack, grpc_closure_list * closure_list)
+grpc_channel_stack_init (grpc_exec_ctx * exec_ctx, const grpc_channel_filter ** filters, size_t filter_count, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * metadata_context, grpc_channel_stack * stack)
 {
   size_t call_size = ROUND_UP_TO_ALIGNMENT_SIZE (sizeof (grpc_call_stack)) + ROUND_UP_TO_ALIGNMENT_SIZE (filter_count * sizeof (grpc_call_element));
   grpc_channel_element *elems;
@@ -132,7 +132,7 @@ grpc_channel_stack_init (const grpc_channel_filter ** filters, size_t filter_cou
 }
 
 void
-grpc_channel_stack_destroy (grpc_channel_stack * stack, grpc_closure_list * closure_list)
+grpc_channel_stack_destroy (grpc_exec_ctx * exec_ctx, grpc_channel_stack * stack)
 {
   grpc_channel_element *channel_elems = CHANNEL_ELEMS_FROM_STACK (stack);
   size_t count = stack->count;
@@ -146,7 +146,7 @@ grpc_channel_stack_destroy (grpc_channel_stack * stack, grpc_closure_list * clos
 }
 
 void
-grpc_call_stack_init (grpc_channel_stack * channel_stack, const void *transport_server_data, grpc_transport_stream_op * initial_op, grpc_call_stack * call_stack, grpc_closure_list * closure_list)
+grpc_call_stack_init (grpc_exec_ctx * exec_ctx, grpc_channel_stack * channel_stack, const void *transport_server_data, grpc_transport_stream_op * initial_op, grpc_call_stack * call_stack)
 {
   grpc_channel_element *channel_elems = CHANNEL_ELEMS_FROM_STACK (channel_stack);
   size_t count = channel_stack->count;
@@ -170,7 +170,7 @@ grpc_call_stack_init (grpc_channel_stack * channel_stack, const void *transport_
 }
 
 void
-grpc_call_stack_destroy (grpc_call_stack * stack, grpc_closure_list * closure_list)
+grpc_call_stack_destroy (grpc_exec_ctx * exec_ctx, grpc_call_stack * stack)
 {
   grpc_call_element *elems = CALL_ELEMS_FROM_STACK (stack);
   size_t count = stack->count;
@@ -184,21 +184,21 @@ grpc_call_stack_destroy (grpc_call_stack * stack, grpc_closure_list * closure_li
 }
 
 void
-grpc_call_next_op (grpc_call_element * elem, grpc_transport_stream_op * op, grpc_closure_list * closure_list)
+grpc_call_next_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
 {
   grpc_call_element *next_elem = elem + 1;
   next_elem->filter->start_transport_stream_op (next_elem, op, closure_list);
 }
 
 char *
-grpc_call_next_get_peer (grpc_call_element * elem, grpc_closure_list * closure_list)
+grpc_call_next_get_peer (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
 {
   grpc_call_element *next_elem = elem + 1;
   return next_elem->filter->get_peer (next_elem, closure_list);
 }
 
 void
-grpc_channel_next_op (grpc_channel_element * elem, grpc_transport_op * op, grpc_closure_list * closure_list)
+grpc_channel_next_op (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_transport_op * op)
 {
   grpc_channel_element *next_elem = elem + 1;
   next_elem->filter->start_transport_op (next_elem, op, closure_list);
@@ -217,7 +217,7 @@ grpc_call_stack_from_top_element (grpc_call_element * elem)
 }
 
 void
-grpc_call_element_send_cancel (grpc_call_element * cur_elem, grpc_closure_list * closure_list)
+grpc_call_element_send_cancel (grpc_exec_ctx * exec_ctx, grpc_call_element * cur_elem)
 {
   grpc_transport_stream_op op;
   memset (&op, 0, sizeof (op));
diff --git a/src/core/channel/channel_stack.h b/src/core/channel/channel_stack.h
index 937bb04eda..0bfe326976 100644
--- a/src/core/channel/channel_stack.h
+++ b/src/core/channel/channel_stack.h
@@ -65,11 +65,11 @@ typedef struct
 {
   /* Called to eg. send/receive data on a call.
      See grpc_call_next_op on how to call the next element in the stack */
-  void (*start_transport_stream_op) (grpc_call_element * elem, grpc_transport_stream_op * op, grpc_closure_list * closure_list);
+  void (*start_transport_stream_op) (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op);
   /* Called to handle channel level operations - e.g. new calls, or transport
      closure.
      See grpc_channel_next_op on how to call the next element in the stack */
-  void (*start_transport_op) (grpc_channel_element * elem, grpc_transport_op * op, grpc_closure_list * closure_list);
+  void (*start_transport_op) (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_transport_op * op);
 
   /* sizeof(per call data) */
   size_t sizeof_call_data;
@@ -81,10 +81,10 @@ typedef struct
      on a client; if it is non-NULL, then it points to memory owned by the
      transport and is on the server. Most filters want to ignore this
      argument. */
-  void (*init_call_elem) (grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op, grpc_closure_list * closure_list);
+  void (*init_call_elem) (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op);
   /* Destroy per call data.
      The filter does not need to do any chaining */
-  void (*destroy_call_elem) (grpc_call_element * elem, grpc_closure_list * closure_list);
+  void (*destroy_call_elem) (grpc_exec_ctx * exec_ctx, grpc_call_element * elem);
 
   /* sizeof(per channel data) */
   size_t sizeof_channel_data;
@@ -94,13 +94,13 @@ typedef struct
      is_first, is_last designate this elements position in the stack, and are
      useful for asserting correct configuration by upper layer code.
      The filter does not need to do any chaining */
-  void (*init_channel_elem) (grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * metadata_context, int is_first, int is_last, grpc_closure_list * closure_list);
+  void (*init_channel_elem) (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * metadata_context, int is_first, int is_last);
   /* Destroy per channel data.
      The filter does not need to do any chaining */
-  void (*destroy_channel_elem) (grpc_channel_element * elem, grpc_closure_list * closure_list);
+  void (*destroy_channel_elem) (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem);
 
   /* Implement grpc_call_get_peer() */
-  char *(*get_peer) (grpc_call_element * elem, grpc_closure_list * closure_list);
+  char *(*get_peer) (grpc_exec_ctx * exec_ctx, grpc_call_element * elem);
 
   /* The name of this filter */
   const char *name;
@@ -151,24 +151,24 @@ grpc_call_element *grpc_call_stack_element (grpc_call_stack * stack, size_t i);
 /* Determine memory required for a channel stack containing a set of filters */
 size_t grpc_channel_stack_size (const grpc_channel_filter ** filters, size_t filter_count);
 /* Initialize a channel stack given some filters */
-void grpc_channel_stack_init (const grpc_channel_filter ** filters, size_t filter_count, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * metadata_context, grpc_channel_stack * stack, grpc_closure_list * closure_list);
+void grpc_channel_stack_init (grpc_exec_ctx * exec_ctx, const grpc_channel_filter ** filters, size_t filter_count, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * metadata_context, grpc_channel_stack * stack);
 /* Destroy a channel stack */
-void grpc_channel_stack_destroy (grpc_channel_stack * stack, grpc_closure_list * closure_list);
+void grpc_channel_stack_destroy (grpc_exec_ctx * exec_ctx, grpc_channel_stack * stack);
 
 /* Initialize a call stack given a channel stack. transport_server_data is
    expected to be NULL on a client, or an opaque transport owned pointer on the
    server. */
-void grpc_call_stack_init (grpc_channel_stack * channel_stack, const void *transport_server_data, grpc_transport_stream_op * initial_op, grpc_call_stack * call_stack, grpc_closure_list * closure_list);
+void grpc_call_stack_init (grpc_exec_ctx * exec_ctx, grpc_channel_stack * channel_stack, const void *transport_server_data, grpc_transport_stream_op * initial_op, grpc_call_stack * call_stack);
 /* Destroy a call stack */
-void grpc_call_stack_destroy (grpc_call_stack * stack, grpc_closure_list * closure_list);
+void grpc_call_stack_destroy (grpc_exec_ctx * exec_ctx, grpc_call_stack * stack);
 
 /* Call the next operation in a call stack */
-void grpc_call_next_op (grpc_call_element * elem, grpc_transport_stream_op * op, grpc_closure_list * closure_list);
+void grpc_call_next_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op);
 /* Call the next operation (depending on call directionality) in a channel
    stack */
-void grpc_channel_next_op (grpc_channel_element * elem, grpc_transport_op * op, grpc_closure_list * closure_list);
+void grpc_channel_next_op (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_transport_op * op);
 /* Pass through a request to get_peer to the next child element */
-char *grpc_call_next_get_peer (grpc_call_element * elem, grpc_closure_list * closure_list);
+char *grpc_call_next_get_peer (grpc_exec_ctx * exec_ctx, grpc_call_element * elem);
 
 /* Given the top element of a channel stack, get the channel stack itself */
 grpc_channel_stack *grpc_channel_stack_from_top_element (grpc_channel_element * elem);
@@ -177,7 +177,7 @@ grpc_call_stack *grpc_call_stack_from_top_element (grpc_call_element * elem);
 
 void grpc_call_log_op (char *file, int line, gpr_log_severity severity, grpc_call_element * elem, grpc_transport_stream_op * op);
 
-void grpc_call_element_send_cancel (grpc_call_element * cur_elem, grpc_closure_list * closure_list);
+void grpc_call_element_send_cancel (grpc_exec_ctx * exec_ctx, grpc_call_element * cur_elem);
 
 extern int grpc_trace_channel;
 
diff --git a/src/core/channel/client_channel.c b/src/core/channel/client_channel.c
index 40b428cf3e..d0be3ca7b6 100644
--- a/src/core/channel/client_channel.c
+++ b/src/core/channel/client_channel.c
@@ -131,7 +131,7 @@ static grpc_closure *
 merge_into_waiting_op (grpc_call_element * elem, grpc_transport_stream_op * new_op)
   GRPC_MUST_USE_RESULT;
 
-     static void handle_op_after_cancellation (grpc_call_element * elem, grpc_transport_stream_op * op, grpc_closure_list * closure_list)
+     static void handle_op_after_cancellation (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
 {
   call_data *calld = elem->call_data;
   channel_data *chand = elem->channel_data;
@@ -170,10 +170,10 @@ typedef struct
   grpc_call_element *elem;
 } waiting_call;
 
-static void perform_transport_stream_op (grpc_call_element * elem, grpc_transport_stream_op * op, int continuation, grpc_closure_list * closure_list);
+static void perform_transport_stream_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op, int continuation);
 
 static void
-continue_with_pick (void *arg, int iomgr_success, grpc_closure_list * closure_list)
+continue_with_pick (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_success)
 {
   waiting_call *wc = arg;
   call_data *calld = wc->elem->call_data;
@@ -205,7 +205,7 @@ is_empty (void *p, int len)
 }
 
 static void
-started_call (void *arg, int iomgr_success, grpc_closure_list * closure_list)
+started_call (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_success)
 {
   call_data *calld = arg;
   grpc_transport_stream_op op;
@@ -249,7 +249,7 @@ started_call (void *arg, int iomgr_success, grpc_closure_list * closure_list)
 }
 
 static void
-picked_target (void *arg, int iomgr_success, grpc_closure_list * closure_list)
+picked_target (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_success)
 {
   call_data *calld = arg;
   grpc_pollset *pollset;
@@ -316,7 +316,7 @@ merge_into_waiting_op (grpc_call_element * elem, grpc_transport_stream_op * new_
 }
 
 static char *
-cc_get_peer (grpc_call_element * elem, grpc_closure_list * closure_list)
+cc_get_peer (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
 {
   call_data *calld = elem->call_data;
   channel_data *chand = elem->channel_data;
@@ -341,7 +341,7 @@ cc_get_peer (grpc_call_element * elem, grpc_closure_list * closure_list)
 }
 
 static void
-perform_transport_stream_op (grpc_call_element * elem, grpc_transport_stream_op * op, int continuation, grpc_closure_list * closure_list)
+perform_transport_stream_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op, int continuation)
 {
   call_data *calld = elem->call_data;
   channel_data *chand = elem->channel_data;
@@ -477,7 +477,7 @@ perform_transport_stream_op (grpc_call_element * elem, grpc_transport_stream_op
 }
 
 static void
-cc_start_transport_stream_op (grpc_call_element * elem, grpc_transport_stream_op * op, grpc_closure_list * closure_list)
+cc_start_transport_stream_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
 {
   perform_transport_stream_op (elem, op, 0, closure_list);
 }
@@ -499,7 +499,7 @@ on_lb_policy_state_changed_locked (lb_policy_connectivity_watcher * w, grpc_clos
 }
 
 static void
-on_lb_policy_state_changed (void *arg, int iomgr_success, grpc_closure_list * closure_list)
+on_lb_policy_state_changed (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_success)
 {
   lb_policy_connectivity_watcher *w = arg;
 
@@ -512,7 +512,7 @@ on_lb_policy_state_changed (void *arg, int iomgr_success, grpc_closure_list * cl
 }
 
 static void
-watch_lb_policy (channel_data * chand, grpc_lb_policy * lb_policy, grpc_connectivity_state current_state, grpc_closure_list * closure_list)
+watch_lb_policy (grpc_exec_ctx * exec_ctx, channel_data * chand, grpc_lb_policy * lb_policy, grpc_connectivity_state current_state)
 {
   lb_policy_connectivity_watcher *w = gpr_malloc (sizeof (*w));
   GRPC_CHANNEL_INTERNAL_REF (chand->master, "watch_lb_policy");
@@ -525,7 +525,7 @@ watch_lb_policy (channel_data * chand, grpc_lb_policy * lb_policy, grpc_connecti
 }
 
 static void
-cc_on_config_changed (void *arg, int iomgr_success, grpc_closure_list * closure_list)
+cc_on_config_changed (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_success)
 {
   channel_data *chand = arg;
   grpc_lb_policy *lb_policy = NULL;
@@ -611,7 +611,7 @@ cc_on_config_changed (void *arg, int iomgr_success, grpc_closure_list * closure_
 }
 
 static void
-cc_start_transport_op (grpc_channel_element * elem, grpc_transport_op * op, grpc_closure_list * closure_list)
+cc_start_transport_op (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_transport_op * op)
 {
   grpc_lb_policy *lb_policy = NULL;
   channel_data *chand = elem->channel_data;
@@ -668,7 +668,7 @@ cc_start_transport_op (grpc_channel_element * elem, grpc_transport_op * op, grpc
 
 /* Constructor for call_data */
 static void
-init_call_elem (grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op, grpc_closure_list * closure_list)
+init_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op)
 {
   call_data *calld = elem->call_data;
 
@@ -685,7 +685,7 @@ init_call_elem (grpc_call_element * elem, const void *server_transport_data, grp
 
 /* Destructor for call_data */
 static void
-destroy_call_elem (grpc_call_element * elem, grpc_closure_list * closure_list)
+destroy_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
 {
   call_data *calld = elem->call_data;
   grpc_subchannel_call *subchannel_call;
@@ -717,7 +717,7 @@ destroy_call_elem (grpc_call_element * elem, grpc_closure_list * closure_list)
 
 /* Constructor for channel_data */
 static void
-init_channel_elem (grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * metadata_context, int is_first, int is_last, grpc_closure_list * closure_list)
+init_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * metadata_context, int is_first, int is_last)
 {
   channel_data *chand = elem->channel_data;
 
@@ -737,7 +737,7 @@ init_channel_elem (grpc_channel_element * elem, grpc_channel * master, const grp
 
 /* Destructor for channel_data */
 static void
-destroy_channel_elem (grpc_channel_element * elem, grpc_closure_list * closure_list)
+destroy_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem)
 {
   channel_data *chand = elem->channel_data;
 
@@ -769,7 +769,7 @@ const grpc_channel_filter grpc_client_channel_filter = {
 };
 
 void
-grpc_client_channel_set_resolver (grpc_channel_stack * channel_stack, grpc_resolver * resolver, grpc_closure_list * closure_list)
+grpc_client_channel_set_resolver (grpc_exec_ctx * exec_ctx, grpc_channel_stack * channel_stack, grpc_resolver * resolver)
 {
   /* post construction initialization: set the transport setup pointer */
   grpc_channel_element *elem = grpc_channel_stack_last_element (channel_stack);
@@ -788,7 +788,7 @@ grpc_client_channel_set_resolver (grpc_channel_stack * channel_stack, grpc_resol
 }
 
 grpc_connectivity_state
-grpc_client_channel_check_connectivity_state (grpc_channel_element * elem, int try_to_connect, grpc_closure_list * closure_list)
+grpc_client_channel_check_connectivity_state (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, int try_to_connect)
 {
   channel_data *chand = elem->channel_data;
   grpc_connectivity_state out;
@@ -816,7 +816,7 @@ grpc_client_channel_check_connectivity_state (grpc_channel_element * elem, int t
 }
 
 void
-grpc_client_channel_watch_connectivity_state (grpc_channel_element * elem, grpc_connectivity_state * state, grpc_closure * on_complete, grpc_closure_list * closure_list)
+grpc_client_channel_watch_connectivity_state (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_connectivity_state * state, grpc_closure * on_complete)
 {
   channel_data *chand = elem->channel_data;
   gpr_mu_lock (&chand->mu_config);
@@ -832,14 +832,14 @@ grpc_client_channel_get_connecting_pollset_set (grpc_channel_element * elem)
 }
 
 void
-grpc_client_channel_add_interested_party (grpc_channel_element * elem, grpc_pollset * pollset, grpc_closure_list * closure_list)
+grpc_client_channel_add_interested_party (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_pollset * pollset)
 {
   channel_data *chand = elem->channel_data;
   grpc_pollset_set_add_pollset (&chand->pollset_set, pollset, closure_list);
 }
 
 void
-grpc_client_channel_del_interested_party (grpc_channel_element * elem, grpc_pollset * pollset, grpc_closure_list * closure_list)
+grpc_client_channel_del_interested_party (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_pollset * pollset)
 {
   channel_data *chand = elem->channel_data;
   grpc_pollset_set_del_pollset (&chand->pollset_set, pollset, closure_list);
diff --git a/src/core/channel/client_channel.h b/src/core/channel/client_channel.h
index 468cf5ef3e..5af9794727 100644
--- a/src/core/channel/client_channel.h
+++ b/src/core/channel/client_channel.h
@@ -49,15 +49,15 @@ extern const grpc_channel_filter grpc_client_channel_filter;
 /* post-construction initializer to let the client channel know which
    transport setup it should cancel upon destruction, or initiate when it needs
    a connection */
-void grpc_client_channel_set_resolver (grpc_channel_stack * channel_stack, grpc_resolver * resolver, grpc_closure_list * closure_list);
+void grpc_client_channel_set_resolver (grpc_exec_ctx * exec_ctx, grpc_channel_stack * channel_stack, grpc_resolver * resolver);
 
-grpc_connectivity_state grpc_client_channel_check_connectivity_state (grpc_channel_element * elem, int try_to_connect, grpc_closure_list * closure_list);
+grpc_connectivity_state grpc_client_channel_check_connectivity_state (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, int try_to_connect);
 
-void grpc_client_channel_watch_connectivity_state (grpc_channel_element * elem, grpc_connectivity_state * state, grpc_closure * on_complete, grpc_closure_list * closure_list);
+void grpc_client_channel_watch_connectivity_state (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_connectivity_state * state, grpc_closure * on_complete);
 
 grpc_pollset_set *grpc_client_channel_get_connecting_pollset_set (grpc_channel_element * elem);
 
-void grpc_client_channel_add_interested_party (grpc_channel_element * channel, grpc_pollset * pollset, grpc_closure_list * closure_list);
-void grpc_client_channel_del_interested_party (grpc_channel_element * channel, grpc_pollset * pollset, grpc_closure_list * closure_list);
+void grpc_client_channel_add_interested_party (grpc_exec_ctx * exec_ctx, grpc_channel_element * channel, grpc_pollset * pollset);
+void grpc_client_channel_del_interested_party (grpc_exec_ctx * exec_ctx, grpc_channel_element * channel, grpc_pollset * pollset);
 
 #endif /* GRPC_INTERNAL_CORE_CHANNEL_CLIENT_CHANNEL_H */
diff --git a/src/core/channel/compress_filter.c b/src/core/channel/compress_filter.c
index a1c03dc9d9..bf3c5a9457 100644
--- a/src/core/channel/compress_filter.c
+++ b/src/core/channel/compress_filter.c
@@ -275,7 +275,7 @@ process_send_ops (grpc_call_element * elem, grpc_stream_op_buffer * send_ops)
    op contains type and call direction information, in addition to the data
    that is being sent or received. */
 static void
-compress_start_transport_stream_op (grpc_call_element * elem, grpc_transport_stream_op * op, grpc_closure_list * closure_list)
+compress_start_transport_stream_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
 {
   if (op->send_ops && op->send_ops->nops > 0)
     {
@@ -288,7 +288,7 @@ compress_start_transport_stream_op (grpc_call_element * elem, grpc_transport_str
 
 /* Constructor for call_data */
 static void
-init_call_elem (grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op, grpc_closure_list * closure_list)
+init_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op)
 {
   /* grab pointers to our data from the call element */
   call_data *calld = elem->call_data;
@@ -309,7 +309,7 @@ init_call_elem (grpc_call_element * elem, const void *server_transport_data, grp
 
 /* Destructor for call_data */
 static void
-destroy_call_elem (grpc_call_element * elem, grpc_closure_list * closure_list)
+destroy_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
 {
   /* grab pointers to our data from the call element */
   call_data *calld = elem->call_data;
@@ -318,7 +318,7 @@ destroy_call_elem (grpc_call_element * elem, grpc_closure_list * closure_list)
 
 /* Constructor for channel_data */
 static void
-init_channel_elem (grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_first, int is_last, grpc_closure_list * closure_list)
+init_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_first, int is_last)
 {
   channel_data *channeld = elem->channel_data;
   grpc_compression_algorithm algo_idx;
@@ -369,7 +369,7 @@ init_channel_elem (grpc_channel_element * elem, grpc_channel * master, const grp
 
 /* Destructor for channel data */
 static void
-destroy_channel_elem (grpc_channel_element * elem, grpc_closure_list * closure_list)
+destroy_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem)
 {
   channel_data *channeld = elem->channel_data;
   grpc_compression_algorithm algo_idx;
diff --git a/src/core/channel/connected_channel.c b/src/core/channel/connected_channel.c
index 7ba412fe5c..2fd80d2207 100644
--- a/src/core/channel/connected_channel.c
+++ b/src/core/channel/connected_channel.c
@@ -66,7 +66,7 @@ typedef struct connected_channel_call_data
 /* Intercept a call operation and either push it directly up or translate it
    into transport stream operations */
 static void
-con_start_transport_stream_op (grpc_call_element * elem, grpc_transport_stream_op * op, grpc_closure_list * closure_list)
+con_start_transport_stream_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
 {
   call_data *calld = elem->call_data;
   channel_data *chand = elem->channel_data;
@@ -77,7 +77,7 @@ con_start_transport_stream_op (grpc_call_element * elem, grpc_transport_stream_o
 }
 
 static void
-con_start_transport_op (grpc_channel_element * elem, grpc_transport_op * op, grpc_closure_list * closure_list)
+con_start_transport_op (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_transport_op * op)
 {
   channel_data *chand = elem->channel_data;
   grpc_transport_perform_op (chand->transport, op, closure_list);
@@ -85,7 +85,7 @@ con_start_transport_op (grpc_channel_element * elem, grpc_transport_op * op, grp
 
 /* Constructor for call_data */
 static void
-init_call_elem (grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op, grpc_closure_list * closure_list)
+init_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op)
 {
   call_data *calld = elem->call_data;
   channel_data *chand = elem->channel_data;
@@ -98,7 +98,7 @@ init_call_elem (grpc_call_element * elem, const void *server_transport_data, grp
 
 /* Destructor for call_data */
 static void
-destroy_call_elem (grpc_call_element * elem, grpc_closure_list * closure_list)
+destroy_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
 {
   call_data *calld = elem->call_data;
   channel_data *chand = elem->channel_data;
@@ -108,7 +108,7 @@ destroy_call_elem (grpc_call_element * elem, grpc_closure_list * closure_list)
 
 /* Constructor for channel_data */
 static void
-init_channel_elem (grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_first, int is_last, grpc_closure_list * closure_list)
+init_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_first, int is_last)
 {
   channel_data *cd = (channel_data *) elem->channel_data;
   GPR_ASSERT (is_last);
@@ -118,7 +118,7 @@ init_channel_elem (grpc_channel_element * elem, grpc_channel * master, const grp
 
 /* Destructor for channel_data */
 static void
-destroy_channel_elem (grpc_channel_element * elem, grpc_closure_list * closure_list)
+destroy_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem)
 {
   channel_data *cd = (channel_data *) elem->channel_data;
   GPR_ASSERT (elem->filter == &grpc_connected_channel_filter);
@@ -126,7 +126,7 @@ destroy_channel_elem (grpc_channel_element * elem, grpc_closure_list * closure_l
 }
 
 static char *
-con_get_peer (grpc_call_element * elem, grpc_closure_list * closure_list)
+con_get_peer (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
 {
   channel_data *chand = elem->channel_data;
   return grpc_transport_get_peer (chand->transport, closure_list);
diff --git a/src/core/channel/http_client_filter.c b/src/core/channel/http_client_filter.c
index 1a166833e7..b2cc69bb4a 100644
--- a/src/core/channel/http_client_filter.c
+++ b/src/core/channel/http_client_filter.c
@@ -98,7 +98,7 @@ client_recv_filter (void *user_data, grpc_mdelem * md)
 }
 
 static void
-hc_on_recv (void *user_data, int success, grpc_closure_list * closure_list)
+hc_on_recv (grpc_exec_ctx * exec_ctx, void *user_data, int success)
 {
   grpc_call_element *elem = user_data;
   call_data *calld = elem->call_data;
@@ -177,7 +177,7 @@ hc_mutate_op (grpc_call_element * elem, grpc_transport_stream_op * op)
 }
 
 static void
-hc_start_transport_op (grpc_call_element * elem, grpc_transport_stream_op * op, grpc_closure_list * closure_list)
+hc_start_transport_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
 {
   GRPC_CALL_LOG_OP (GPR_INFO, elem, op);
   hc_mutate_op (elem, op);
@@ -186,7 +186,7 @@ hc_start_transport_op (grpc_call_element * elem, grpc_transport_stream_op * op,
 
 /* Constructor for call_data */
 static void
-init_call_elem (grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op, grpc_closure_list * closure_list)
+init_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op)
 {
   call_data *calld = elem->call_data;
   calld->sent_initial_metadata = 0;
@@ -199,7 +199,7 @@ init_call_elem (grpc_call_element * elem, const void *server_transport_data, grp
 
 /* Destructor for call_data */
 static void
-destroy_call_elem (grpc_call_element * elem, grpc_closure_list * closure_list)
+destroy_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
 {
 }
 
@@ -281,7 +281,7 @@ user_agent_from_args (grpc_mdctx * mdctx, const grpc_channel_args * args)
 
 /* Constructor for channel_data */
 static void
-init_channel_elem (grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * channel_args, grpc_mdctx * mdctx, int is_first, int is_last, grpc_closure_list * closure_list)
+init_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * channel_args, grpc_mdctx * mdctx, int is_first, int is_last)
 {
   /* grab pointers to our data from the channel element */
   channel_data *channeld = elem->channel_data;
@@ -302,7 +302,7 @@ init_channel_elem (grpc_channel_element * elem, grpc_channel * master, const grp
 
 /* Destructor for channel data */
 static void
-destroy_channel_elem (grpc_channel_element * elem, grpc_closure_list * closure_list)
+destroy_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem)
 {
   /* grab pointers to our data from the channel element */
   channel_data *channeld = elem->channel_data;
diff --git a/src/core/channel/http_server_filter.c b/src/core/channel/http_server_filter.c
index 949868b403..62be4167f7 100644
--- a/src/core/channel/http_server_filter.c
+++ b/src/core/channel/http_server_filter.c
@@ -169,7 +169,7 @@ server_filter (void *user_data, grpc_mdelem * md)
 }
 
 static void
-hs_on_recv (void *user_data, int success, grpc_closure_list * closure_list)
+hs_on_recv (grpc_exec_ctx * exec_ctx, void *user_data, int success)
 {
   grpc_call_element *elem = user_data;
   call_data *calld = elem->call_data;
@@ -260,7 +260,7 @@ hs_mutate_op (grpc_call_element * elem, grpc_transport_stream_op * op)
 }
 
 static void
-hs_start_transport_op (grpc_call_element * elem, grpc_transport_stream_op * op, grpc_closure_list * closure_list)
+hs_start_transport_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
 {
   GRPC_CALL_LOG_OP (GPR_INFO, elem, op);
   hs_mutate_op (elem, op);
@@ -269,7 +269,7 @@ hs_start_transport_op (grpc_call_element * elem, grpc_transport_stream_op * op,
 
 /* Constructor for call_data */
 static void
-init_call_elem (grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op, grpc_closure_list * closure_list)
+init_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op)
 {
   /* grab pointers to our data from the call element */
   call_data *calld = elem->call_data;
@@ -282,13 +282,13 @@ init_call_elem (grpc_call_element * elem, const void *server_transport_data, grp
 
 /* Destructor for call_data */
 static void
-destroy_call_elem (grpc_call_element * elem, grpc_closure_list * closure_list)
+destroy_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
 {
 }
 
 /* Constructor for channel_data */
 static void
-init_channel_elem (grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_first, int is_last, grpc_closure_list * closure_list)
+init_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_first, int is_last)
 {
   /* grab pointers to our data from the channel element */
   channel_data *channeld = elem->channel_data;
@@ -317,7 +317,7 @@ init_channel_elem (grpc_channel_element * elem, grpc_channel * master, const grp
 
 /* Destructor for channel data */
 static void
-destroy_channel_elem (grpc_channel_element * elem, grpc_closure_list * closure_list)
+destroy_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem)
 {
   /* grab pointers to our data from the channel element */
   channel_data *channeld = elem->channel_data;
diff --git a/src/core/channel/noop_filter.c b/src/core/channel/noop_filter.c
index a93497c509..3a3f1254bd 100644
--- a/src/core/channel/noop_filter.c
+++ b/src/core/channel/noop_filter.c
@@ -69,7 +69,7 @@ noop_mutate_op (grpc_call_element * elem, grpc_transport_stream_op * op)
    op contains type and call direction information, in addition to the data
    that is being sent or received. */
 static void
-noop_start_transport_stream_op (grpc_call_element * elem, grpc_transport_stream_op * op, grpc_closure_list * closure_list)
+noop_start_transport_stream_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
 {
   noop_mutate_op (elem, op);
 
@@ -79,7 +79,7 @@ noop_start_transport_stream_op (grpc_call_element * elem, grpc_transport_stream_
 
 /* Constructor for call_data */
 static void
-init_call_elem (grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op, grpc_closure_list * closure_list)
+init_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op)
 {
   /* grab pointers to our data from the call element */
   call_data *calld = elem->call_data;
@@ -94,13 +94,13 @@ init_call_elem (grpc_call_element * elem, const void *server_transport_data, grp
 
 /* Destructor for call_data */
 static void
-destroy_call_elem (grpc_call_element * elem, grpc_closure_list * closure_list)
+destroy_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
 {
 }
 
 /* Constructor for channel_data */
 static void
-init_channel_elem (grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_first, int is_last, grpc_closure_list * closure_list)
+init_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_first, int is_last)
 {
   /* grab pointers to our data from the channel element */
   channel_data *channeld = elem->channel_data;
@@ -117,7 +117,7 @@ init_channel_elem (grpc_channel_element * elem, grpc_channel * master, const grp
 
 /* Destructor for channel data */
 static void
-destroy_channel_elem (grpc_channel_element * elem, grpc_closure_list * closure_list)
+destroy_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem)
 {
   /* grab pointers to our data from the channel element */
   channel_data *channeld = elem->channel_data;