13 files changed, 110 insertions, 110 deletions

diff --git a/src/core/surface/call.c b/src/core/surface/call.c
index 5a76245a65..5360abdfa9 100644
--- a/src/core/surface/call.c
+++ b/src/core/surface/call.c
@@ -283,18 +283,18 @@ struct grpc_call
 #define CALL_FROM_TOP_ELEM(top_elem) \
   CALL_FROM_CALL_STACK(grpc_call_stack_from_top_element(top_elem))
 
-static void set_deadline_alarm (grpc_call * call, gpr_timespec deadline, grpc_closure_list * closure_list);
-static void call_on_done_recv (void *call, int success, grpc_closure_list * closure_list);
-static void call_on_done_send (void *call, int success, grpc_closure_list * closure_list);
+static void set_deadline_alarm (grpc_exec_ctx * exec_ctx, grpc_call * call, gpr_timespec deadline);
+static void call_on_done_recv (grpc_exec_ctx * exec_ctx, void *call, int success);
+static void call_on_done_send (grpc_exec_ctx * exec_ctx, void *call, int success);
 static int fill_send_ops (grpc_call * call, grpc_transport_stream_op * op);
-static void execute_op (grpc_call * call, grpc_transport_stream_op * op, grpc_closure_list * closure_list);
-static void recv_metadata (grpc_call * call, grpc_metadata_batch * metadata, grpc_closure_list * closure_list);
+static void execute_op (grpc_exec_ctx * exec_ctx, grpc_call * call, grpc_transport_stream_op * op);
+static void recv_metadata (grpc_exec_ctx * exec_ctx, grpc_call * call, grpc_metadata_batch * metadata);
 static void finish_read_ops (grpc_call * call);
 static grpc_call_error cancel_with_status (grpc_call * c, grpc_status_code status, const char *description);
-static void finished_loose_op (void *call, int success, grpc_closure_list * closure_list);
+static void finished_loose_op (grpc_exec_ctx * exec_ctx, void *call, int success);
 
 static void lock (grpc_call * call);
-static void unlock (grpc_call * call, grpc_closure_list * closure_list);
+static void unlock (grpc_exec_ctx * exec_ctx, grpc_call * call);
 
 grpc_call *
 grpc_call_create (grpc_channel * channel, grpc_call * parent_call, gpr_uint32 propagation_mask, grpc_completion_queue * cq, const void *server_transport_data, grpc_mdelem ** add_initial_metadata, size_t add_initial_metadata_count, gpr_timespec send_deadline)
@@ -409,7 +409,7 @@ grpc_call_create (grpc_channel * channel, grpc_call * parent_call, gpr_uint32 pr
 }
 
 void
-grpc_call_set_completion_queue (grpc_call * call, grpc_completion_queue * cq, grpc_closure_list * closure_list)
+grpc_call_set_completion_queue (grpc_exec_ctx * exec_ctx, grpc_call * call, grpc_completion_queue * cq)
 {
   lock (call);
   call->cq = cq;
@@ -446,7 +446,7 @@ allocate_completion (grpc_call * call)
 }
 
 static void
-done_completion (void *call, grpc_cq_completion * completion, grpc_closure_list * closure_list)
+done_completion (grpc_exec_ctx * exec_ctx, void *call, grpc_cq_completion * completion)
 {
   grpc_call *c = call;
   gpr_mu_lock (&c->completion_mu);
@@ -469,7 +469,7 @@ grpc_call_internal_ref (grpc_call * c)
 }
 
 static void
-destroy_call (grpc_call * call, grpc_closure_list * closure_list)
+destroy_call (grpc_exec_ctx * exec_ctx, grpc_call * call)
 {
   size_t i;
   grpc_call *c = call;
@@ -517,12 +517,12 @@ destroy_call (grpc_call * call, grpc_closure_list * closure_list)
 
 #ifdef GRPC_CALL_REF_COUNT_DEBUG
 void
-grpc_call_internal_unref (grpc_call * c, const char *reason, grpc_closure_list * closure_list)
+grpc_call_internal_unref (grpc_exec_ctx * exec_ctx, grpc_call * c, const char *reason)
 {
   gpr_log (GPR_DEBUG, "CALL: unref %p %d -> %d [%s]", c, c->internal_refcount.count, c->internal_refcount.count - 1, reason);
 #else
 void
-grpc_call_internal_unref (grpc_call * c, grpc_closure_list * closure_list)
+grpc_call_internal_unref (grpc_exec_ctx * exec_ctx, grpc_call * c)
 {
 #endif
   if (gpr_unref (&c->internal_refcount))
@@ -638,7 +638,7 @@ need_more_data (grpc_call * call)
 }
 
 static void
-unlock (grpc_call * call, grpc_closure_list * closure_list)
+unlock (grpc_exec_ctx * exec_ctx, grpc_call * call)
 {
   grpc_transport_stream_op op;
   completed_request completed_requests[GRPC_IOREQ_OP_COUNT];
@@ -889,7 +889,7 @@ early_out_write_ops (grpc_call * call)
 }
 
 static void
-call_on_done_send (void *pc, int success, grpc_closure_list * closure_list)
+call_on_done_send (grpc_exec_ctx * exec_ctx, void *pc, int success)
 {
   grpc_call *call = pc;
   lock (call);
@@ -1036,7 +1036,7 @@ add_slice_to_message (grpc_call * call, gpr_slice slice)
 }
 
 static void
-call_on_done_recv (void *pc, int success, grpc_closure_list * closure_list)
+call_on_done_recv (grpc_exec_ctx * exec_ctx, void *pc, int success)
 {
   grpc_call *call = pc;
   grpc_call *child_call;
@@ -1381,7 +1381,7 @@ start_ioreq (grpc_call * call, const grpc_ioreq * reqs, size_t nreqs, grpc_ioreq
 }
 
 grpc_call_error
-grpc_call_start_ioreq_and_call_back (grpc_call * call, const grpc_ioreq * reqs, size_t nreqs, grpc_ioreq_completion_func on_complete, void *user_data, grpc_closure_list * closure_list)
+grpc_call_start_ioreq_and_call_back (grpc_exec_ctx * exec_ctx, grpc_call * call, const grpc_ioreq * reqs, size_t nreqs, grpc_ioreq_completion_func on_complete, void *user_data)
 {
   grpc_call_error err;
   lock (call);
@@ -1465,7 +1465,7 @@ cancel_with_status (grpc_call * c, grpc_status_code status, const char *descript
 }
 
 static void
-finished_loose_op (void *call, int success_ignored, grpc_closure_list * closure_list)
+finished_loose_op (grpc_exec_ctx * exec_ctx, void *call, int success_ignored)
 {
   GRPC_CALL_INTERNAL_UNREF (call, "loose-op", closure_list);
 }
@@ -1477,7 +1477,7 @@ typedef struct
 } finished_loose_op_allocated_args;
 
 static void
-finished_loose_op_allocated (void *alloc, int success, grpc_closure_list * closure_list)
+finished_loose_op_allocated (grpc_exec_ctx * exec_ctx, void *alloc, int success)
 {
   finished_loose_op_allocated_args *args = alloc;
   finished_loose_op (args->call, success, closure_list);
@@ -1485,7 +1485,7 @@ finished_loose_op_allocated (void *alloc, int success, grpc_closure_list * closu
 }
 
 static void
-execute_op (grpc_call * call, grpc_transport_stream_op * op, grpc_closure_list * closure_list)
+execute_op (grpc_exec_ctx * exec_ctx, grpc_call * call, grpc_transport_stream_op * op)
 {
   grpc_call_element *elem;
 
@@ -1528,7 +1528,7 @@ grpc_call_from_top_element (grpc_call_element * elem)
 }
 
 static void
-call_alarm (void *arg, int success, grpc_closure_list * closure_list)
+call_alarm (grpc_exec_ctx * exec_ctx, void *arg, int success)
 {
   grpc_call *call = arg;
   lock (call);
@@ -1543,7 +1543,7 @@ call_alarm (void *arg, int success, grpc_closure_list * closure_list)
 }
 
 static void
-set_deadline_alarm (grpc_call * call, gpr_timespec deadline, grpc_closure_list * closure_list)
+set_deadline_alarm (grpc_exec_ctx * exec_ctx, grpc_call * call, gpr_timespec deadline)
 {
   if (call->have_alarm)
     {
@@ -1617,7 +1617,7 @@ decode_compression (grpc_mdelem * md)
 }
 
 static void
-recv_metadata (grpc_call * call, grpc_metadata_batch * md, grpc_closure_list * closure_list)
+recv_metadata (grpc_exec_ctx * exec_ctx, grpc_call * call, grpc_metadata_batch * md)
 {
   grpc_linked_mdelem *l;
   grpc_metadata_array *dest;
@@ -1712,13 +1712,13 @@ set_cancelled_value (grpc_status_code status, void *dest)
 }
 
 static void
-finish_batch (grpc_call * call, int success, void *tag, grpc_closure_list * closure_list)
+finish_batch (grpc_exec_ctx * exec_ctx, grpc_call * call, int success, void *tag)
 {
   grpc_cq_end_op (call->cq, tag, success, done_completion, call, allocate_completion (call), closure_list);
 }
 
 static void
-finish_batch_with_close (grpc_call * call, int success, void *tag, grpc_closure_list * closure_list)
+finish_batch_with_close (grpc_exec_ctx * exec_ctx, grpc_call * call, int success, void *tag)
 {
   grpc_cq_end_op (call->cq, tag, 1, done_completion, call, allocate_completion (call), closure_list);
 }
diff --git a/src/core/surface/call.h b/src/core/surface/call.h
index a859fbf218..29a3e11354 100644
--- a/src/core/surface/call.h
+++ b/src/core/surface/call.h
@@ -95,29 +95,29 @@ extern "C"
     grpc_ioreq_data data;
   } grpc_ioreq;
 
-  typedef void (*grpc_ioreq_completion_func) (grpc_call * call, int success, void *user_data, grpc_closure_list * closure_list);
+  typedef void (*grpc_ioreq_completion_func) (grpc_exec_ctx * exec_ctx, grpc_call * call, int success, void *user_data);
 
   grpc_call *grpc_call_create (grpc_channel * channel, grpc_call * parent_call, gpr_uint32 propagation_mask, grpc_completion_queue * cq, const void *server_transport_data, grpc_mdelem ** add_initial_metadata, size_t add_initial_metadata_count, gpr_timespec send_deadline);
 
-  void grpc_call_set_completion_queue (grpc_call * call, grpc_completion_queue * cq, grpc_closure_list * closure_list);
+  void grpc_call_set_completion_queue (grpc_exec_ctx * exec_ctx, grpc_call * call, grpc_completion_queue * cq);
   grpc_completion_queue *grpc_call_get_completion_queue (grpc_call * call);
 
 #ifdef GRPC_CALL_REF_COUNT_DEBUG
   void grpc_call_internal_ref (grpc_call * call, const char *reason);
-  void grpc_call_internal_unref (grpc_call * call, const char *reason, grpc_closure_list * closure_list);
+  void grpc_call_internal_unref (grpc_exec_ctx * exec_ctx, grpc_call * call, const char *reason);
 #define GRPC_CALL_INTERNAL_REF(call, reason) \
   grpc_call_internal_ref(call, reason)
 #define GRPC_CALL_INTERNAL_UNREF(call, reason, closure_list) \
   grpc_call_internal_unref(call, reason, closure_list)
 #else
   void grpc_call_internal_ref (grpc_call * call);
-  void grpc_call_internal_unref (grpc_call * call, grpc_closure_list * closure_list);
+  void grpc_call_internal_unref (grpc_exec_ctx * exec_ctx, grpc_call * call);
 #define GRPC_CALL_INTERNAL_REF(call, reason) grpc_call_internal_ref(call)
 #define GRPC_CALL_INTERNAL_UNREF(call, reason, closure_list) \
   grpc_call_internal_unref(call, closure_list)
 #endif
 
-  grpc_call_error grpc_call_start_ioreq_and_call_back (grpc_call * call, const grpc_ioreq * reqs, size_t nreqs, grpc_ioreq_completion_func on_complete, void *user_data, grpc_closure_list * closure_list);
+  grpc_call_error grpc_call_start_ioreq_and_call_back (grpc_exec_ctx * exec_ctx, grpc_call * call, const grpc_ioreq * reqs, size_t nreqs, grpc_ioreq_completion_func on_complete, void *user_data);
 
   grpc_call_stack *grpc_call_get_call_stack (grpc_call * call);
 
diff --git a/src/core/surface/channel.c b/src/core/surface/channel.c
index 440b6494f1..82a463dd75 100644
--- a/src/core/surface/channel.c
+++ b/src/core/surface/channel.c
@@ -92,7 +92,7 @@ struct grpc_channel
 #define DEFAULT_MAX_MESSAGE_LENGTH (100 * 1024 * 1024)
 
 grpc_channel *
-grpc_channel_create_from_filters (const char *target, const grpc_channel_filter ** filters, size_t num_filters, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_client, grpc_closure_list * closure_list)
+grpc_channel_create_from_filters (grpc_exec_ctx * exec_ctx, const char *target, const grpc_channel_filter ** filters, size_t num_filters, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_client)
 {
   size_t i;
   size_t size = sizeof (grpc_channel) + grpc_channel_stack_size (filters, num_filters);
@@ -262,7 +262,7 @@ grpc_channel_internal_ref (grpc_channel * c)
 }
 
 static void
-destroy_channel (grpc_channel * channel, grpc_closure_list * closure_list)
+destroy_channel (grpc_exec_ctx * exec_ctx, grpc_channel * channel)
 {
   size_t i;
   grpc_channel_stack_destroy (CHANNEL_STACK_FROM_CHANNEL (channel), closure_list);
@@ -299,12 +299,12 @@ destroy_channel (grpc_channel * channel, grpc_closure_list * closure_list)
 
 #ifdef GRPC_CHANNEL_REF_COUNT_DEBUG
 void
-grpc_channel_internal_unref (grpc_channel * channel, const char *reason, grpc_closure_list * closure_list)
+grpc_channel_internal_unref (grpc_exec_ctx * exec_ctx, grpc_channel * channel, const char *reason)
 {
   gpr_log (GPR_DEBUG, "CHANNEL: unref %p %d -> %d [%s]", channel, channel->refs.count, channel->refs.count - 1, reason);
 #else
 void
-grpc_channel_internal_unref (grpc_channel * channel, grpc_closure_list * closure_list)
+grpc_channel_internal_unref (grpc_exec_ctx * exec_ctx, grpc_channel * channel)
 {
 #endif
   if (gpr_unref (&channel->refs))
diff --git a/src/core/surface/channel.h b/src/core/surface/channel.h
index 91a038892e..982986e966 100644
--- a/src/core/surface/channel.h
+++ b/src/core/surface/channel.h
@@ -37,7 +37,7 @@
 #include "src/core/channel/channel_stack.h"
 #include "src/core/client_config/subchannel_factory.h"
 
-grpc_channel *grpc_channel_create_from_filters (const char *target, const grpc_channel_filter ** filters, size_t count, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_client, grpc_closure_list * closure_list);
+grpc_channel *grpc_channel_create_from_filters (grpc_exec_ctx * exec_ctx, const char *target, const grpc_channel_filter ** filters, size_t count, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_client);
 
 /** Get a (borrowed) pointer to this channels underlying channel stack */
 grpc_channel_stack *grpc_channel_get_channel_stack (grpc_channel * channel);
@@ -58,14 +58,14 @@ gpr_uint32 grpc_channel_get_max_message_length (grpc_channel * channel);
 
 #ifdef GRPC_CHANNEL_REF_COUNT_DEBUG
 void grpc_channel_internal_ref (grpc_channel * channel, const char *reason);
-void grpc_channel_internal_unref (grpc_channel * channel, const char *reason, grpc_closure_list * closure_list);
+void grpc_channel_internal_unref (grpc_exec_ctx * exec_ctx, grpc_channel * channel, const char *reason);
 #define GRPC_CHANNEL_INTERNAL_REF(channel, reason) \
   grpc_channel_internal_ref(channel, reason)
 #define GRPC_CHANNEL_INTERNAL_UNREF(channel, reason, closure_list) \
   grpc_channel_internal_unref(channel, reason, closure_list)
 #else
 void grpc_channel_internal_ref (grpc_channel * channel);
-void grpc_channel_internal_unref (grpc_channel * channel, grpc_closure_list * closure_list);
+void grpc_channel_internal_unref (grpc_exec_ctx * exec_ctx, grpc_channel * channel);
 #define GRPC_CHANNEL_INTERNAL_REF(channel, reason) \
   grpc_channel_internal_ref(channel)
 #define GRPC_CHANNEL_INTERNAL_UNREF(channel, reason, closure_list) \
diff --git a/src/core/surface/channel_connectivity.c b/src/core/surface/channel_connectivity.c
index 0a7e8e3837..7c174aa47f 100644
--- a/src/core/surface/channel_connectivity.c
+++ b/src/core/surface/channel_connectivity.c
@@ -81,7 +81,7 @@ typedef struct
 } state_watcher;
 
 static void
-delete_state_watcher (state_watcher * w, grpc_closure_list * closure_list)
+delete_state_watcher (grpc_exec_ctx * exec_ctx, state_watcher * w)
 {
   GRPC_CHANNEL_INTERNAL_UNREF (w->channel, "watch_connectivity", closure_list);
   gpr_mu_destroy (&w->mu);
@@ -89,7 +89,7 @@ delete_state_watcher (state_watcher * w, grpc_closure_list * closure_list)
 }
 
 static void
-finished_completion (void *pw, grpc_cq_completion * ignored, grpc_closure_list * closure_list)
+finished_completion (grpc_exec_ctx * exec_ctx, void *pw, grpc_cq_completion * ignored)
 {
   int delete = 0;
   state_watcher *w = pw;
@@ -117,7 +117,7 @@ finished_completion (void *pw, grpc_cq_completion * ignored, grpc_closure_list *
 }
 
 static void
-partly_done (state_watcher * w, int due_to_completion, grpc_closure_list * closure_list)
+partly_done (grpc_exec_ctx * exec_ctx, state_watcher * w, int due_to_completion)
 {
   int delete = 0;
   grpc_channel_element *client_channel_elem = NULL;
@@ -165,13 +165,13 @@ partly_done (state_watcher * w, int due_to_completion, grpc_closure_list * closu
 }
 
 static void
-watch_complete (void *pw, int success, grpc_closure_list * closure_list)
+watch_complete (grpc_exec_ctx * exec_ctx, void *pw, int success)
 {
   partly_done (pw, 1, closure_list);
 }
 
 static void
-timeout_complete (void *pw, int success, grpc_closure_list * closure_list)
+timeout_complete (grpc_exec_ctx * exec_ctx, void *pw, int success)
 {
   partly_done (pw, 0, closure_list);
 }
diff --git a/src/core/surface/channel_create.c b/src/core/surface/channel_create.c
index c45ebf324f..a8c9f1749f 100644
--- a/src/core/surface/channel_create.c
+++ b/src/core/surface/channel_create.c
@@ -72,7 +72,7 @@ connector_ref (grpc_connector * con)
 }
 
 static void
-connector_unref (grpc_connector * con, grpc_closure_list * closure_list)
+connector_unref (grpc_exec_ctx * exec_ctx, grpc_connector * con)
 {
   connector *c = (connector *) con;
   if (gpr_unref (&c->refs))
@@ -83,7 +83,7 @@ connector_unref (grpc_connector * con, grpc_closure_list * closure_list)
 }
 
 static void
-connected (void *arg, int success, grpc_closure_list * closure_list)
+connected (grpc_exec_ctx * exec_ctx, void *arg, int success)
 {
   connector *c = arg;
   grpc_closure *notify;
@@ -107,12 +107,12 @@ connected (void *arg, int success, grpc_closure_list * closure_list)
 }
 
 static void
-connector_shutdown (grpc_connector * con, grpc_closure_list * closure_list)
+connector_shutdown (grpc_exec_ctx * exec_ctx, grpc_connector * con)
 {
 }
 
 static void
-connector_connect (grpc_connector * con, const grpc_connect_in_args * args, grpc_connect_out_args * result, grpc_closure * notify, grpc_closure_list * closure_list)
+connector_connect (grpc_exec_ctx * exec_ctx, grpc_connector * con, const grpc_connect_in_args * args, grpc_connect_out_args * result, grpc_closure * notify)
 {
   connector *c = (connector *) con;
   GPR_ASSERT (c->notify == NULL);
@@ -146,7 +146,7 @@ subchannel_factory_ref (grpc_subchannel_factory * scf)
 }
 
 static void
-subchannel_factory_unref (grpc_subchannel_factory * scf, grpc_closure_list * closure_list)
+subchannel_factory_unref (grpc_exec_ctx * exec_ctx, grpc_subchannel_factory * scf)
 {
   subchannel_factory *f = (subchannel_factory *) scf;
   if (gpr_unref (&f->refs))
@@ -159,7 +159,7 @@ subchannel_factory_unref (grpc_subchannel_factory * scf, grpc_closure_list * clo
 }
 
 static grpc_subchannel *
-subchannel_factory_create_subchannel (grpc_subchannel_factory * scf, grpc_subchannel_args * args, grpc_closure_list * closure_list)
+subchannel_factory_create_subchannel (grpc_exec_ctx * exec_ctx, grpc_subchannel_factory * scf, grpc_subchannel_args * args)
 {
   subchannel_factory *f = (subchannel_factory *) scf;
   connector *c = gpr_malloc (sizeof (*c));
diff --git a/src/core/surface/completion_queue.c b/src/core/surface/completion_queue.c
index ab9a323c7a..2410ad6fb5 100644
--- a/src/core/surface/completion_queue.c
+++ b/src/core/surface/completion_queue.c
@@ -72,7 +72,7 @@ struct grpc_completion_queue
   grpc_closure pollset_destroy_done;
 };
 
-static void on_pollset_destroy_done (void *cc, int success, grpc_closure_list * closure_list);
+static void on_pollset_destroy_done (grpc_exec_ctx * exec_ctx, void *cc, int success);
 
 grpc_completion_queue *
 grpc_completion_queue_create (void *reserved)
@@ -105,7 +105,7 @@ grpc_cq_internal_ref (grpc_completion_queue * cc)
 }
 
 static void
-on_pollset_destroy_done (void *arg, int success, grpc_closure_list * closure_list)
+on_pollset_destroy_done (grpc_exec_ctx * exec_ctx, void *arg, int success)
 {
   grpc_completion_queue *cc = arg;
   GRPC_CQ_INTERNAL_UNREF (cc, "pollset_destroy");
@@ -144,7 +144,7 @@ grpc_cq_begin_op (grpc_completion_queue * cc)
    event, then enter shutdown mode */
 /* Queue a GRPC_OP_COMPLETED operation */
 void
-grpc_cq_end_op (grpc_completion_queue * cc, void *tag, int success, void (*done) (void *done_arg, grpc_cq_completion * storage, grpc_closure_list * closure_list), void *done_arg, grpc_cq_completion * storage, grpc_closure_list * closure_list)
+grpc_cq_end_op (grpc_completion_queue * cc, void *tag, int success, void (*done) (grpc_exec_ctx * exec_ctx, void *done_arg, grpc_cq_completion * storage, grpc_closure_list * closure_list), void *done_arg, grpc_cq_completion * storage)
 {
   int shutdown;
   int i;
diff --git a/src/core/surface/completion_queue.h b/src/core/surface/completion_queue.h
index 7ef4ed7c49..1f3f0d197b 100644
--- a/src/core/surface/completion_queue.h
+++ b/src/core/surface/completion_queue.h
@@ -45,7 +45,7 @@ typedef struct grpc_cq_completion
   void *tag;
   /** done callback - called when this queue element is no longer
       needed by the completion queue */
-  void (*done) (void *done_arg, struct grpc_cq_completion * c, grpc_closure_list * closure_list);
+  void (*done) (grpc_exec_ctx * exec_ctx, void *done_arg, struct grpc_cq_completion * c);
   void *done_arg;
   /** next pointer; low bit is used to indicate success or not */
   gpr_uintptr next;
@@ -70,7 +70,7 @@ void grpc_cq_internal_unref (grpc_completion_queue * cc);
 void grpc_cq_begin_op (grpc_completion_queue * cc);
 
 /* Queue a GRPC_OP_COMPLETED operation */
-void grpc_cq_end_op (grpc_completion_queue * cc, void *tag, int success, void (*done) (void *done_arg, grpc_cq_completion * storage, grpc_closure_list * closure_list), void *done_arg, grpc_cq_completion * storage, grpc_closure_list * closure_list);
+void grpc_cq_end_op (grpc_completion_queue * cc, void *tag, int success, void (*done) (grpc_exec_ctx * exec_ctx, void *done_arg, grpc_cq_completion * storage, grpc_closure_list * closure_list), void *done_arg, grpc_cq_completion * storage);
 
 grpc_pollset *grpc_cq_pollset (grpc_completion_queue * cc);
 
diff --git a/src/core/surface/lame_client.c b/src/core/surface/lame_client.c
index d8cf7db601..be3a308f0f 100644
--- a/src/core/surface/lame_client.c
+++ b/src/core/surface/lame_client.c
@@ -57,7 +57,7 @@ typedef struct
 } channel_data;
 
 static void
-lame_start_transport_stream_op (grpc_call_element * elem, grpc_transport_stream_op * op, grpc_closure_list * closure_list)
+lame_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;
@@ -92,14 +92,14 @@ lame_start_transport_stream_op (grpc_call_element * elem, grpc_transport_stream_
 }
 
 static char *
-lame_get_peer (grpc_call_element * elem, grpc_closure_list * closure_list)
+lame_get_peer (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
 {
   channel_data *chand = elem->channel_data;
   return grpc_channel_get_target (chand->master);
 }
 
 static void
-lame_start_transport_op (grpc_channel_element * elem, grpc_transport_op * op, grpc_closure_list * closure_list)
+lame_start_transport_op (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_transport_op * op)
 {
   if (op->on_connectivity_state_change)
     {
@@ -114,7 +114,7 @@ lame_start_transport_op (grpc_channel_element * elem, grpc_transport_op * op, gr
 }
 
 static void
-init_call_elem (grpc_call_element * elem, const void *transport_server_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 *transport_server_data, grpc_transport_stream_op * initial_op)
 {
   if (initial_op)
     {
@@ -123,12 +123,12 @@ init_call_elem (grpc_call_element * elem, const void *transport_server_data, grp
 }
 
 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)
 {
 }
 
 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 *chand = elem->channel_data;
   GPR_ASSERT (is_first);
@@ -138,7 +138,7 @@ init_channel_elem (grpc_channel_element * elem, grpc_channel * master, const grp
 }
 
 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)
 {
 }
 
diff --git a/src/core/surface/secure_channel_create.c b/src/core/surface/secure_channel_create.c
index 64a2d14a49..b65b03a002 100644
--- a/src/core/surface/secure_channel_create.c
+++ b/src/core/surface/secure_channel_create.c
@@ -79,7 +79,7 @@ connector_ref (grpc_connector * con)
 }
 
 static void
-connector_unref (grpc_connector * con, grpc_closure_list * closure_list)
+connector_unref (grpc_exec_ctx * exec_ctx, grpc_connector * con)
 {
   connector *c = (connector *) con;
   if (gpr_unref (&c->refs))
@@ -90,7 +90,7 @@ connector_unref (grpc_connector * con, grpc_closure_list * closure_list)
 }
 
 static void
-on_secure_handshake_done (void *arg, grpc_security_status status, grpc_endpoint * wrapped_endpoint, grpc_endpoint * secure_endpoint, grpc_closure_list * closure_list)
+on_secure_handshake_done (grpc_exec_ctx * exec_ctx, void *arg, grpc_security_status status, grpc_endpoint * wrapped_endpoint, grpc_endpoint * secure_endpoint)
 {
   connector *c = arg;
   grpc_closure *notify;
@@ -126,7 +126,7 @@ on_secure_handshake_done (void *arg, grpc_security_status status, grpc_endpoint
 }
 
 static void
-connected (void *arg, int success, grpc_closure_list * closure_list)
+connected (grpc_exec_ctx * exec_ctx, void *arg, int success)
 {
   connector *c = arg;
   grpc_closure *notify;
@@ -149,7 +149,7 @@ connected (void *arg, int success, grpc_closure_list * closure_list)
 }
 
 static void
-connector_shutdown (grpc_connector * con, grpc_closure_list * closure_list)
+connector_shutdown (grpc_exec_ctx * exec_ctx, grpc_connector * con)
 {
   connector *c = (connector *) con;
   grpc_endpoint *ep;
@@ -164,7 +164,7 @@ connector_shutdown (grpc_connector * con, grpc_closure_list * closure_list)
 }
 
 static void
-connector_connect (grpc_connector * con, const grpc_connect_in_args * args, grpc_connect_out_args * result, grpc_closure * notify, grpc_closure_list * closure_list)
+connector_connect (grpc_exec_ctx * exec_ctx, grpc_connector * con, const grpc_connect_in_args * args, grpc_connect_out_args * result, grpc_closure * notify)
 {
   connector *c = (connector *) con;
   GPR_ASSERT (c->notify == NULL);
@@ -201,7 +201,7 @@ subchannel_factory_ref (grpc_subchannel_factory * scf)
 }
 
 static void
-subchannel_factory_unref (grpc_subchannel_factory * scf, grpc_closure_list * closure_list)
+subchannel_factory_unref (grpc_exec_ctx * exec_ctx, grpc_subchannel_factory * scf)
 {
   subchannel_factory *f = (subchannel_factory *) scf;
   if (gpr_unref (&f->refs))
@@ -215,7 +215,7 @@ subchannel_factory_unref (grpc_subchannel_factory * scf, grpc_closure_list * clo
 }
 
 static grpc_subchannel *
-subchannel_factory_create_subchannel (grpc_subchannel_factory * scf, grpc_subchannel_args * args, grpc_closure_list * closure_list)
+subchannel_factory_create_subchannel (grpc_exec_ctx * exec_ctx, grpc_subchannel_factory * scf, grpc_subchannel_args * args)
 {
   subchannel_factory *f = (subchannel_factory *) scf;
   connector *c = gpr_malloc (sizeof (*c));
diff --git a/src/core/surface/server.c b/src/core/surface/server.c
index 8df578d192..793d485dfb 100644
--- a/src/core/surface/server.c
+++ b/src/core/surface/server.c
@@ -57,8 +57,8 @@
 typedef struct listener
 {
   void *arg;
-  void (*start) (grpc_server * server, void *arg, grpc_pollset ** pollsets, size_t pollset_count, grpc_closure_list * closure_list);
-  void (*destroy) (grpc_server * server, void *arg, grpc_closure * closure, grpc_closure_list * closure_list);
+  void (*start) (grpc_exec_ctx * exec_ctx, grpc_server * server, void *arg, grpc_pollset ** pollsets, size_t pollset_count);
+  void (*destroy) (grpc_exec_ctx * exec_ctx, grpc_server * server, void *arg, grpc_closure * closure);
   struct listener *next;
   grpc_closure destroy_done;
 } listener;
@@ -240,11 +240,11 @@ struct grpc_server
 #define SERVER_FROM_CALL_ELEM(elem) \
   (((channel_data *)(elem)->channel_data)->server)
 
-static void begin_call (grpc_server * server, call_data * calld, requested_call * rc, grpc_closure_list * closure_list);
-static void fail_call (grpc_server * server, requested_call * rc, grpc_closure_list * closure_list);
+static void begin_call (grpc_exec_ctx * exec_ctx, grpc_server * server, call_data * calld, requested_call * rc);
+static void fail_call (grpc_exec_ctx * exec_ctx, grpc_server * server, requested_call * rc);
 /* Before calling maybe_finish_shutdown, we must hold mu_global and not
    hold mu_call */
-static void maybe_finish_shutdown (grpc_server * server, grpc_closure_list * closure_list);
+static void maybe_finish_shutdown (grpc_exec_ctx * exec_ctx, grpc_server * server);
 
 /*
  * channel broadcaster
@@ -277,7 +277,7 @@ struct shutdown_cleanup_args
 };
 
 static void
-shutdown_cleanup (void *arg, int iomgr_status_ignored, grpc_closure_list * closure_list)
+shutdown_cleanup (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_status_ignored)
 {
   struct shutdown_cleanup_args *a = arg;
   gpr_slice_unref (a->slice);
@@ -285,7 +285,7 @@ shutdown_cleanup (void *arg, int iomgr_status_ignored, grpc_closure_list * closu
 }
 
 static void
-send_shutdown (grpc_channel * channel, int send_goaway, int send_disconnect, grpc_closure_list * closure_list)
+send_shutdown (grpc_exec_ctx * exec_ctx, grpc_channel * channel, int send_goaway, int send_disconnect)
 {
   grpc_transport_op op;
   struct shutdown_cleanup_args *sc;
@@ -306,7 +306,7 @@ send_shutdown (grpc_channel * channel, int send_goaway, int send_disconnect, grp
 }
 
 static void
-channel_broadcaster_shutdown (channel_broadcaster * cb, int send_goaway, int force_disconnect, grpc_closure_list * closure_list)
+channel_broadcaster_shutdown (grpc_exec_ctx * exec_ctx, channel_broadcaster * cb, int send_goaway, int force_disconnect)
 {
   size_t i;
 
@@ -337,13 +337,13 @@ request_matcher_destroy (request_matcher * request_matcher)
 }
 
 static void
-kill_zombie (void *elem, int success, grpc_closure_list * closure_list)
+kill_zombie (grpc_exec_ctx * exec_ctx, void *elem, int success)
 {
   grpc_call_destroy (grpc_call_from_top_element (elem));
 }
 
 static void
-request_matcher_zombify_all_pending_calls (request_matcher * request_matcher, grpc_closure_list * closure_list)
+request_matcher_zombify_all_pending_calls (grpc_exec_ctx * exec_ctx, request_matcher * request_matcher)
 {
   while (request_matcher->pending_head)
     {
@@ -358,7 +358,7 @@ request_matcher_zombify_all_pending_calls (request_matcher * request_matcher, gr
 }
 
 static void
-request_matcher_kill_requests (grpc_server * server, request_matcher * rm, grpc_closure_list * closure_list)
+request_matcher_kill_requests (grpc_exec_ctx * exec_ctx, grpc_server * server, request_matcher * rm)
 {
   int request_id;
   while ((request_id = gpr_stack_lockfree_pop (rm->requests)) != -1)
@@ -378,7 +378,7 @@ server_ref (grpc_server * server)
 }
 
 static void
-server_delete (grpc_server * server, grpc_closure_list * closure_list)
+server_delete (grpc_exec_ctx * exec_ctx, grpc_server * server)
 {
   registered_method *rm;
   size_t i;
@@ -408,7 +408,7 @@ server_delete (grpc_server * server, grpc_closure_list * closure_list)
 }
 
 static void
-server_unref (grpc_server * server, grpc_closure_list * closure_list)
+server_unref (grpc_exec_ctx * exec_ctx, grpc_server * server)
 {
   if (gpr_unref (&server->internal_refcount))
     {
@@ -431,7 +431,7 @@ orphan_channel (channel_data * chand)
 }
 
 static void
-finish_destroy_channel (void *cd, int success, grpc_closure_list * closure_list)
+finish_destroy_channel (grpc_exec_ctx * exec_ctx, void *cd, int success)
 {
   channel_data *chand = cd;
   grpc_server *server = chand->server;
@@ -441,7 +441,7 @@ finish_destroy_channel (void *cd, int success, grpc_closure_list * closure_list)
 }
 
 static void
-destroy_channel (channel_data * chand, grpc_closure_list * closure_list)
+destroy_channel (grpc_exec_ctx * exec_ctx, channel_data * chand)
 {
   if (is_channel_orphaned (chand))
     return;
@@ -455,7 +455,7 @@ destroy_channel (channel_data * chand, grpc_closure_list * closure_list)
 }
 
 static void
-finish_start_new_rpc (grpc_server * server, grpc_call_element * elem, request_matcher * request_matcher, grpc_closure_list * closure_list)
+finish_start_new_rpc (grpc_exec_ctx * exec_ctx, grpc_server * server, grpc_call_element * elem, request_matcher * request_matcher)
 {
   call_data *calld = elem->call_data;
   int request_id;
@@ -499,7 +499,7 @@ finish_start_new_rpc (grpc_server * server, grpc_call_element * elem, request_ma
 }
 
 static void
-start_new_rpc (grpc_call_element * elem, grpc_closure_list * closure_list)
+start_new_rpc (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
 {
   channel_data *chand = elem->channel_data;
   call_data *calld = elem->call_data;
@@ -556,7 +556,7 @@ num_listeners (grpc_server * server)
 }
 
 static void
-done_shutdown_event (void *server, grpc_cq_completion * completion, grpc_closure_list * closure_list)
+done_shutdown_event (grpc_exec_ctx * exec_ctx, void *server, grpc_cq_completion * completion)
 {
   server_unref (server, closure_list);
 }
@@ -574,7 +574,7 @@ num_channels (grpc_server * server)
 }
 
 static void
-kill_pending_work_locked (grpc_server * server, grpc_closure_list * closure_list)
+kill_pending_work_locked (grpc_exec_ctx * exec_ctx, grpc_server * server)
 {
   registered_method *rm;
   request_matcher_kill_requests (server, &server->unregistered_request_matcher, closure_list);
@@ -587,7 +587,7 @@ kill_pending_work_locked (grpc_server * server, grpc_closure_list * closure_list
 }
 
 static void
-maybe_finish_shutdown (grpc_server * server, grpc_closure_list * closure_list)
+maybe_finish_shutdown (grpc_exec_ctx * exec_ctx, grpc_server * server)
 {
   size_t i;
   if (!gpr_atm_acq_load (&server->shutdown_flag) || server->shutdown_published)
@@ -634,7 +634,7 @@ server_filter (void *user_data, grpc_mdelem * md)
 }
 
 static void
-server_on_recv (void *ptr, int success, grpc_closure_list * closure_list)
+server_on_recv (grpc_exec_ctx * exec_ctx, void *ptr, int success)
 {
   grpc_call_element *elem = ptr;
   call_data *calld = elem->call_data;
@@ -727,7 +727,7 @@ server_mutate_op (grpc_call_element * elem, grpc_transport_stream_op * op)
 }
 
 static void
-server_start_transport_stream_op (grpc_call_element * elem, grpc_transport_stream_op * op, grpc_closure_list * closure_list)
+server_start_transport_stream_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
 {
   GRPC_CALL_LOG_OP (GPR_INFO, elem, op);
   server_mutate_op (elem, op);
@@ -743,7 +743,7 @@ accept_stream (void *cd, grpc_transport * transport, const void *transport_serve
 }
 
 static void
-channel_connectivity_changed (void *cd, int iomgr_status_ignored, grpc_closure_list * closure_list)
+channel_connectivity_changed (grpc_exec_ctx * exec_ctx, void *cd, int iomgr_status_ignored)
 {
   channel_data *chand = cd;
   grpc_server *server = chand->server;
@@ -764,7 +764,7 @@ channel_connectivity_changed (void *cd, int iomgr_status_ignored, grpc_closure_l
 }
 
 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;
@@ -782,7 +782,7 @@ init_call_elem (grpc_call_element * elem, const void *server_transport_data, grp
 }
 
 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)
 {
   channel_data *chand = elem->channel_data;
   call_data *calld = elem->call_data;
@@ -804,7 +804,7 @@ destroy_call_elem (grpc_call_element * elem, grpc_closure_list * closure_list)
 }
 
 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;
   GPR_ASSERT (is_first);
@@ -820,7 +820,7 @@ init_channel_elem (grpc_channel_element * elem, grpc_channel * master, const grp
 }
 
 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)
 {
   size_t i;
   channel_data *chand = elem->channel_data;
@@ -998,7 +998,7 @@ grpc_server_start (grpc_server * server)
 }
 
 void
-grpc_server_setup_transport (grpc_server * s, grpc_transport * transport, grpc_channel_filter const **extra_filters, size_t num_extra_filters, grpc_mdctx * mdctx, const grpc_channel_args * args, grpc_closure_list * closure_list)
+grpc_server_setup_transport (grpc_exec_ctx * exec_ctx, grpc_server * s, grpc_transport * transport, grpc_channel_filter const **extra_filters, size_t num_extra_filters, grpc_mdctx * mdctx, const grpc_channel_args * args)
 {
   size_t num_filters = s->channel_filter_count + num_extra_filters + 1;
   grpc_channel_filter const **filters = gpr_malloc (sizeof (grpc_channel_filter *) * num_filters);
@@ -1093,14 +1093,14 @@ grpc_server_setup_transport (grpc_server * s, grpc_transport * transport, grpc_c
 }
 
 void
-done_published_shutdown (void *done_arg, grpc_cq_completion * storage, grpc_closure_list * closure_list)
+done_published_shutdown (grpc_exec_ctx * exec_ctx, void *done_arg, grpc_cq_completion * storage)
 {
   (void) done_arg;
   gpr_free (storage);
 }
 
 static void
-listener_destroy_done (void *s, int success, grpc_closure_list * closure_list)
+listener_destroy_done (grpc_exec_ctx * exec_ctx, void *s, int success)
 {
   grpc_server *server = s;
   gpr_mu_lock (&server->mu_global);
@@ -1202,7 +1202,7 @@ grpc_server_destroy (grpc_server * server)
 }
 
 void
-grpc_server_add_listener (grpc_server * server, void *arg, void (*start) (grpc_server * server, void *arg, grpc_pollset ** pollsets, size_t pollset_count, grpc_closure_list * closure_list), void (*destroy) (grpc_server * server, void *arg, grpc_closure * on_done, grpc_closure_list * closure_list), grpc_closure_list * closure_list)
+grpc_server_add_listener (grpc_server * server, void *arg, void (*start) (grpc_exec_ctx * exec_ctx, grpc_server * server, void *arg, grpc_pollset ** pollsets, size_t pollset_count), void (*destroy) (grpc_exec_ctx * exec_ctx, grpc_server * server, void *arg, grpc_closure * on_done, grpc_closure_list * closure_list))
 {
   listener *l = gpr_malloc (sizeof (listener));
   l->arg = arg;
@@ -1213,7 +1213,7 @@ grpc_server_add_listener (grpc_server * server, void *arg, void (*start) (grpc_s
 }
 
 static grpc_call_error
-queue_call_request (grpc_server * server, requested_call * rc, grpc_closure_list * closure_list)
+queue_call_request (grpc_exec_ctx * exec_ctx, grpc_server * server, requested_call * rc)
 {
   call_data *calld = NULL;
   request_matcher *request_matcher = NULL;
@@ -1333,9 +1333,9 @@ done:
   return error;
 }
 
-static void publish_registered_or_batch (grpc_call * call, int success, void *tag, grpc_closure_list * closure_list);
+static void publish_registered_or_batch (grpc_exec_ctx * exec_ctx, grpc_call * call, int success, void *tag);
 static void
-publish_was_not_set (grpc_call * call, int success, void *tag, grpc_closure_list * closure_list)
+publish_was_not_set (grpc_exec_ctx * exec_ctx, grpc_call * call, int success, void *tag)
 {
   abort ();
 }
@@ -1355,7 +1355,7 @@ cpstr (char **dest, size_t * capacity, grpc_mdstr * value)
 }
 
 static void
-begin_call (grpc_server * server, call_data * calld, requested_call * rc, grpc_closure_list * closure_list)
+begin_call (grpc_exec_ctx * exec_ctx, grpc_server * server, call_data * calld, requested_call * rc)
 {
   grpc_ioreq_completion_func publish = publish_was_not_set;
   grpc_ioreq req[2];
@@ -1406,7 +1406,7 @@ begin_call (grpc_server * server, call_data * calld, requested_call * rc, grpc_c
 }
 
 static void
-done_request_event (void *req, grpc_cq_completion * c, grpc_closure_list * closure_list)
+done_request_event (grpc_exec_ctx * exec_ctx, void *req, grpc_cq_completion * c)
 {
   requested_call *rc = req;
   grpc_server *server = rc->server;
@@ -1425,7 +1425,7 @@ done_request_event (void *req, grpc_cq_completion * c, grpc_closure_list * closu
 }
 
 static void
-fail_call (grpc_server * server, requested_call * rc, grpc_closure_list * closure_list)
+fail_call (grpc_exec_ctx * exec_ctx, grpc_server * server, requested_call * rc)
 {
   *rc->call = NULL;
   switch (rc->type)
@@ -1442,7 +1442,7 @@ fail_call (grpc_server * server, requested_call * rc, grpc_closure_list * closur
 }
 
 static void
-publish_registered_or_batch (grpc_call * call, int success, void *prc, grpc_closure_list * closure_list)
+publish_registered_or_batch (grpc_exec_ctx * exec_ctx, grpc_call * call, int success, void *prc)
 {
   grpc_call_element *elem = grpc_call_stack_element (grpc_call_get_call_stack (call), 0);
   requested_call *rc = prc;
diff --git a/src/core/surface/server.h b/src/core/surface/server.h
index 081377167a..8adaafd5e3 100644
--- a/src/core/surface/server.h
+++ b/src/core/surface/server.h
@@ -43,11 +43,11 @@ grpc_server *grpc_server_create_from_filters (const grpc_channel_filter ** filte
 
 /* Add a listener to the server: when the server starts, it will call start,
    and when it shuts down, it will call destroy */
-void grpc_server_add_listener (grpc_server * server, void *listener, void (*start) (grpc_server * server, void *arg, grpc_pollset ** pollsets, size_t npollsets, grpc_closure_list * closure_list), void (*destroy) (grpc_server * server, void *arg, grpc_closure * on_done, grpc_closure_list * closure_list), grpc_closure_list * closure_list);
+void grpc_server_add_listener (grpc_server * server, void *listener, void (*start) (grpc_exec_ctx * exec_ctx, grpc_server * server, void *arg, grpc_pollset ** pollsets, size_t npollsets), void (*destroy) (grpc_exec_ctx * exec_ctx, grpc_server * server, void *arg, grpc_closure * on_done, grpc_closure_list * closure_list));
 
 /* Setup a transport - creates a channel stack, binds the transport to the
    server */
-void grpc_server_setup_transport (grpc_server * server, grpc_transport * transport, grpc_channel_filter const **extra_filters, size_t num_extra_filters, grpc_mdctx * mdctx, const grpc_channel_args * args, grpc_closure_list * closure_list);
+void grpc_server_setup_transport (grpc_exec_ctx * exec_ctx, grpc_server * server, grpc_transport * transport, grpc_channel_filter const **extra_filters, size_t num_extra_filters, grpc_mdctx * mdctx, const grpc_channel_args * args);
 
 const grpc_channel_args *grpc_server_get_channel_args (grpc_server * server);
 
diff --git a/src/core/surface/server_chttp2.c b/src/core/surface/server_chttp2.c
index 47b96f8f1e..aa4eb9b05b 100644
--- a/src/core/surface/server_chttp2.c
+++ b/src/core/surface/server_chttp2.c
@@ -43,7 +43,7 @@
 #include <grpc/support/useful.h>
 
 static void
-setup_transport (void *server, grpc_transport * transport, grpc_mdctx * mdctx, grpc_closure_list * closure_list)
+setup_transport (grpc_exec_ctx * exec_ctx, void *server, grpc_transport * transport, grpc_mdctx * mdctx)
 {
   static grpc_channel_filter const *extra_filters[] = {
     &grpc_http_server_filter
@@ -52,7 +52,7 @@ setup_transport (void *server, grpc_transport * transport, grpc_mdctx * mdctx, g
 }
 
 static void
-new_transport (void *server, grpc_endpoint * tcp, grpc_closure_list * closure_list)
+new_transport (grpc_exec_ctx * exec_ctx, void *server, grpc_endpoint * tcp)
 {
   /*
    * Beware that the call to grpc_create_chttp2_transport() has to happen before
@@ -69,7 +69,7 @@ new_transport (void *server, grpc_endpoint * tcp, grpc_closure_list * closure_li
 
 /* Server callback: start listening on our ports */
 static void
-start (grpc_server * server, void *tcpp, grpc_pollset ** pollsets, size_t pollset_count, grpc_closure_list * closure_list)
+start (grpc_exec_ctx * exec_ctx, grpc_server * server, void *tcpp, grpc_pollset ** pollsets, size_t pollset_count)
 {
   grpc_tcp_server *tcp = tcpp;
   grpc_tcp_server_start (tcp, pollsets, pollset_count, new_transport, server, closure_list);
@@ -78,7 +78,7 @@ start (grpc_server * server, void *tcpp, grpc_pollset ** pollsets, size_t pollse
 /* Server callback: destroy the tcp listener (so we don't generate further
    callbacks) */
 static void
-destroy (grpc_server * server, void *tcpp, grpc_closure * destroy_done, grpc_closure_list * closure_list)
+destroy (grpc_exec_ctx * exec_ctx, grpc_server * server, void *tcpp, grpc_closure * destroy_done)
 {
   grpc_tcp_server *tcp = tcpp;
   grpc_tcp_server_destroy (tcp, destroy_done, closure_list);