grpc 1.8.7 → 1.9.0.pre1

data/src/core/lib/channel/channel_stack.h

@@ -40,15 +40,11 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gpr/arena.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/polling_entity.h"
-#include "src/core/lib/support/arena.h"
 #include "src/core/lib/transport/transport.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 typedef struct grpc_channel_element grpc_channel_element;
 typedef struct grpc_call_element grpc_call_element;
 
@@ -100,14 +96,12 @@ typedef struct {
 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_batch)(grpc_exec_ctx* exec_ctx,
-                                          grpc_call_element* elem,
+  void (*start_transport_stream_op_batch)(grpc_call_element* elem,
                                           grpc_transport_stream_op_batch* 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_exec_ctx* exec_ctx,
-                             grpc_channel_element* elem, grpc_transport_op* op);
+  void (*start_transport_op)(grpc_channel_element* elem, grpc_transport_op* op);
 
   /* sizeof(per call data) */
   size_t sizeof_call_data;
@@ -120,11 +114,9 @@ typedef struct {
      transport and is on the server. Most filters want to ignore this
      argument.
      Implementations may assume that elem->call_data is all zeros. */
-  grpc_error* (*init_call_elem)(grpc_exec_ctx* exec_ctx,
-                                grpc_call_element* elem,
+  grpc_error* (*init_call_elem)(grpc_call_element* elem,
                                 const grpc_call_element_args* args);
-  void (*set_pollset_or_pollset_set)(grpc_exec_ctx* exec_ctx,
-                                     grpc_call_element* elem,
+  void (*set_pollset_or_pollset_set)(grpc_call_element* elem,
                                      grpc_polling_entity* pollent);
   /* Destroy per call data.
      The filter does not need to do any chaining.
@@ -132,7 +124,7 @@ typedef struct {
      \a then_schedule_closure that should be passed to GRPC_CLOSURE_SCHED when
      destruction is complete. \a final_info contains data about the completed
      call, mainly for reporting purposes. */
-  void (*destroy_call_elem)(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+  void (*destroy_call_elem)(grpc_call_element* elem,
                             const grpc_call_final_info* final_info,
                             grpc_closure* then_schedule_closure);
 
@@ -145,16 +137,14 @@ typedef struct {
      useful for asserting correct configuration by upper layer code.
      The filter does not need to do any chaining.
      Implementations may assume that elem->call_data is all zeros. */
-  grpc_error* (*init_channel_elem)(grpc_exec_ctx* exec_ctx,
-                                   grpc_channel_element* elem,
+  grpc_error* (*init_channel_elem)(grpc_channel_element* elem,
                                    grpc_channel_element_args* args);
   /* Destroy per channel data.
      The filter does not need to do any chaining */
-  void (*destroy_channel_elem)(grpc_exec_ctx* exec_ctx,
-                               grpc_channel_element* elem);
+  void (*destroy_channel_elem)(grpc_channel_element* elem);
 
   /* Implement grpc_channel_get_info() */
-  void (*get_channel_info)(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+  void (*get_channel_info)(grpc_channel_element* elem,
                            const grpc_channel_info* channel_info);
 
   /* The name of this filter */
@@ -212,68 +202,62 @@ size_t grpc_channel_stack_size(const grpc_channel_filter** filters,
                                size_t filter_count);
 /* Initialize a channel stack given some filters */
 grpc_error* grpc_channel_stack_init(
-    grpc_exec_ctx* exec_ctx, int initial_refs, grpc_iomgr_cb_func destroy,
-    void* destroy_arg, const grpc_channel_filter** filters, size_t filter_count,
+    int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
+    const grpc_channel_filter** filters, size_t filter_count,
     const grpc_channel_args* args, grpc_transport* optional_transport,
     const char* name, grpc_channel_stack* stack);
 /* Destroy a channel stack */
-void grpc_channel_stack_destroy(grpc_exec_ctx* exec_ctx,
-                                grpc_channel_stack* stack);
+void grpc_channel_stack_destroy(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. */
-grpc_error* grpc_call_stack_init(grpc_exec_ctx* exec_ctx,
-                                 grpc_channel_stack* channel_stack,
+grpc_error* grpc_call_stack_init(grpc_channel_stack* channel_stack,
                                  int initial_refs, grpc_iomgr_cb_func destroy,
                                  void* destroy_arg,
                                  const grpc_call_element_args* elem_args);
 /* Set a pollset or a pollset_set for a call stack: must occur before the first
  * op is started */
-void grpc_call_stack_set_pollset_or_pollset_set(grpc_exec_ctx* exec_ctx,
-                                                grpc_call_stack* call_stack,
+void grpc_call_stack_set_pollset_or_pollset_set(grpc_call_stack* call_stack,
                                                 grpc_polling_entity* pollent);
 
 #ifndef NDEBUG
 #define GRPC_CALL_STACK_REF(call_stack, reason) \
   grpc_stream_ref(&(call_stack)->refcount, reason)
-#define GRPC_CALL_STACK_UNREF(exec_ctx, call_stack, reason) \
-  grpc_stream_unref(exec_ctx, &(call_stack)->refcount, reason)
+#define GRPC_CALL_STACK_UNREF(call_stack, reason) \
+  grpc_stream_unref(&(call_stack)->refcount, reason)
 #define GRPC_CHANNEL_STACK_REF(channel_stack, reason) \
   grpc_stream_ref(&(channel_stack)->refcount, reason)
-#define GRPC_CHANNEL_STACK_UNREF(exec_ctx, channel_stack, reason) \
-  grpc_stream_unref(exec_ctx, &(channel_stack)->refcount, reason)
+#define GRPC_CHANNEL_STACK_UNREF(channel_stack, reason) \
+  grpc_stream_unref(&(channel_stack)->refcount, reason)
 #else
 #define GRPC_CALL_STACK_REF(call_stack, reason) \
   grpc_stream_ref(&(call_stack)->refcount)
-#define GRPC_CALL_STACK_UNREF(exec_ctx, call_stack, reason) \
-  grpc_stream_unref(exec_ctx, &(call_stack)->refcount)
+#define GRPC_CALL_STACK_UNREF(call_stack, reason) \
+  grpc_stream_unref(&(call_stack)->refcount)
 #define GRPC_CHANNEL_STACK_REF(channel_stack, reason) \
   grpc_stream_ref(&(channel_stack)->refcount)
-#define GRPC_CHANNEL_STACK_UNREF(exec_ctx, channel_stack, reason) \
-  grpc_stream_unref(exec_ctx, &(channel_stack)->refcount)
+#define GRPC_CHANNEL_STACK_UNREF(channel_stack, reason) \
+  grpc_stream_unref(&(channel_stack)->refcount)
 #endif
 
 /* Destroy a call stack */
-void grpc_call_stack_destroy(grpc_exec_ctx* exec_ctx, grpc_call_stack* stack,
+void grpc_call_stack_destroy(grpc_call_stack* stack,
                              const grpc_call_final_info* final_info,
                              grpc_closure* then_schedule_closure);
 
 /* Ignore set pollset{_set} - used by filters if they don't care about pollsets
  * at all. Does nothing. */
 void grpc_call_stack_ignore_set_pollset_or_pollset_set(
-    grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
-    grpc_polling_entity* pollent);
+    grpc_call_element* elem, grpc_polling_entity* pollent);
 /* Call the next operation in a call stack */
-void grpc_call_next_op(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+void grpc_call_next_op(grpc_call_element* elem,
                        grpc_transport_stream_op_batch* op);
 /* Call the next operation (depending on call directionality) in a channel
    stack */
-void grpc_channel_next_op(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
-                          grpc_transport_op* op);
+void grpc_channel_next_op(grpc_channel_element* elem, grpc_transport_op* op);
 /* Pass through a request to get_channel_info() to the next child element */
-void grpc_channel_next_get_info(grpc_exec_ctx* exec_ctx,
-                                grpc_channel_element* elem,
+void grpc_channel_next_get_info(grpc_channel_element* elem,
                                 const grpc_channel_info* channel_info);
 
 /* Given the top element of a channel stack, get the channel stack itself */
@@ -291,8 +275,4 @@ extern grpc_core::TraceFlag grpc_trace_channel;
 #define GRPC_CALL_LOG_OP(sev, elem, op) \
   if (grpc_trace_channel.enabled()) grpc_call_log_op(sev, elem, op)
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_H */

data/src/core/lib/channel/channel_stack_builder.cc

@@ -150,10 +150,9 @@ void grpc_channel_stack_builder_set_name(grpc_channel_stack_builder* builder,
 }
 
 void grpc_channel_stack_builder_set_channel_arguments(
-    grpc_exec_ctx* exec_ctx, grpc_channel_stack_builder* builder,
-    const grpc_channel_args* args) {
+    grpc_channel_stack_builder* builder, const grpc_channel_args* args) {
   if (builder->args != nullptr) {
-    grpc_channel_args_destroy(exec_ctx, builder->args);
+    grpc_channel_args_destroy(builder->args);
   }
   builder->args = grpc_channel_args_copy(args);
 }
@@ -241,8 +240,7 @@ bool grpc_channel_stack_builder_add_filter_after(
   return true;
 }
 
-void grpc_channel_stack_builder_destroy(grpc_exec_ctx* exec_ctx,
-                                        grpc_channel_stack_builder* builder) {
+void grpc_channel_stack_builder_destroy(grpc_channel_stack_builder* builder) {
   filter_node* p = builder->begin.next;
   while (p != &builder->end) {
     filter_node* next = p->next;
@@ -250,16 +248,15 @@ void grpc_channel_stack_builder_destroy(grpc_exec_ctx* exec_ctx,
     p = next;
   }
   if (builder->args != nullptr) {
-    grpc_channel_args_destroy(exec_ctx, builder->args);
+    grpc_channel_args_destroy(builder->args);
   }
   gpr_free(builder->target);
   gpr_free(builder);
 }
 
 grpc_error* grpc_channel_stack_builder_finish(
-    grpc_exec_ctx* exec_ctx, grpc_channel_stack_builder* builder,
-    size_t prefix_bytes, int initial_refs, grpc_iomgr_cb_func destroy,
-    void* destroy_arg, void** result) {
+    grpc_channel_stack_builder* builder, size_t prefix_bytes, int initial_refs,
+    grpc_iomgr_cb_func destroy, void* destroy_arg, void** result) {
   // count the number of filters
   size_t num_filters = 0;
   for (filter_node* p = builder->begin.next; p != &builder->end; p = p->next) {
@@ -284,12 +281,12 @@ grpc_error* grpc_channel_stack_builder_finish(
       (grpc_channel_stack*)((char*)(*result) + prefix_bytes);
   // and initialize it
   grpc_error* error = grpc_channel_stack_init(
-      exec_ctx, initial_refs, destroy,
-      destroy_arg == nullptr ? *result : destroy_arg, filters, num_filters,
-      builder->args, builder->transport, builder->name, channel_stack);
+      initial_refs, destroy, destroy_arg == nullptr ? *result : destroy_arg,
+      filters, num_filters, builder->args, builder->transport, builder->name,
+      channel_stack);
 
   if (error != GRPC_ERROR_NONE) {
-    grpc_channel_stack_destroy(exec_ctx, channel_stack);
+    grpc_channel_stack_destroy(channel_stack);
     gpr_free(*result);
     *result = nullptr;
   } else {
@@ -305,7 +302,7 @@ grpc_error* grpc_channel_stack_builder_finish(
     }
   }
 
-  grpc_channel_stack_builder_destroy(exec_ctx, builder);
+  grpc_channel_stack_builder_destroy(builder);
   gpr_free((grpc_channel_filter**)filters);
 
   return error;

data/src/core/lib/channel/channel_stack_builder.h

@@ -24,10 +24,6 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /// grpc_channel_stack_builder offers a programmatic interface to selected
 /// and order channel filters
 typedef struct grpc_channel_stack_builder grpc_channel_stack_builder;
@@ -58,8 +54,7 @@ grpc_transport* grpc_channel_stack_builder_get_transport(
 
 /// Set channel arguments: copies args
 void grpc_channel_stack_builder_set_channel_arguments(
-    grpc_exec_ctx* exec_ctx, grpc_channel_stack_builder* builder,
-    const grpc_channel_args* args);
+    grpc_channel_stack_builder* builder, const grpc_channel_args* args);
 
 /// Return a borrowed pointer to the channel arguments
 const grpc_channel_args* grpc_channel_stack_builder_get_channel_arguments(
@@ -152,18 +147,12 @@ void grpc_channel_stack_builder_iterator_destroy(
 /// \a initial_refs, \a destroy, \a destroy_arg are as per
 /// grpc_channel_stack_init
 grpc_error* grpc_channel_stack_builder_finish(
-    grpc_exec_ctx* exec_ctx, grpc_channel_stack_builder* builder,
-    size_t prefix_bytes, int initial_refs, grpc_iomgr_cb_func destroy,
-    void* destroy_arg, void** result);
+    grpc_channel_stack_builder* builder, size_t prefix_bytes, int initial_refs,
+    grpc_iomgr_cb_func destroy, void* destroy_arg, void** result);
 
 /// Destroy the builder without creating a channel stack
-void grpc_channel_stack_builder_destroy(grpc_exec_ctx* exec_ctx,
-                                        grpc_channel_stack_builder* builder);
+void grpc_channel_stack_builder_destroy(grpc_channel_stack_builder* builder);
 
 extern grpc_core::TraceFlag grpc_trace_channel_stack_builder;
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_H */

data/src/core/lib/channel/connected_channel.cc

@@ -26,8 +26,8 @@
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/profiling/timers.h"
-#include "src/core/lib/support/string.h"
 #include "src/core/lib/transport/transport.h"
 
 #define MAX_BUFFER_LENGTH 8192
@@ -51,17 +51,14 @@ typedef struct connected_channel_call_data {
   callback_state recv_message_ready;
 } call_data;
 
-static void run_in_call_combiner(grpc_exec_ctx* exec_ctx, void* arg,
-                                 grpc_error* error) {
+static void run_in_call_combiner(void* arg, grpc_error* error) {
   callback_state* state = (callback_state*)arg;
-  GRPC_CALL_COMBINER_START(exec_ctx, state->call_combiner,
-                           state->original_closure, GRPC_ERROR_REF(error),
-                           state->reason);
+  GRPC_CALL_COMBINER_START(state->call_combiner, state->original_closure,
+                           GRPC_ERROR_REF(error), state->reason);
 }
 
-static void run_cancel_in_call_combiner(grpc_exec_ctx* exec_ctx, void* arg,
-                                        grpc_error* error) {
-  run_in_call_combiner(exec_ctx, arg, error);
+static void run_cancel_in_call_combiner(void* arg, grpc_error* error) {
+  run_in_call_combiner(arg, error);
   gpr_free(arg);
 }
 
@@ -98,8 +95,7 @@ static callback_state* get_state_for_batch(
 /* Intercept a call operation and either push it directly up or translate it
    into transport stream operations */
 static void con_start_transport_stream_op_batch(
-    grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
-    grpc_transport_stream_op_batch* batch) {
+    grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
   call_data* calld = (call_data*)elem->call_data;
   channel_data* chand = (channel_data*)elem->channel_data;
   if (batch->recv_initial_metadata) {
@@ -126,58 +122,52 @@ static void con_start_transport_stream_op_batch(
     callback_state* state = get_state_for_batch(calld, batch);
     intercept_callback(calld, state, false, "on_complete", &batch->on_complete);
   }
-  grpc_transport_perform_stream_op(exec_ctx, chand->transport,
-                                   TRANSPORT_STREAM_FROM_CALL_DATA(calld),
-                                   batch);
-  GRPC_CALL_COMBINER_STOP(exec_ctx, calld->call_combiner,
-                          "passed batch to transport");
+  grpc_transport_perform_stream_op(
+      chand->transport, TRANSPORT_STREAM_FROM_CALL_DATA(calld), batch);
+  GRPC_CALL_COMBINER_STOP(calld->call_combiner, "passed batch to transport");
 }
 
-static void con_start_transport_op(grpc_exec_ctx* exec_ctx,
-                                   grpc_channel_element* elem,
+static void con_start_transport_op(grpc_channel_element* elem,
                                    grpc_transport_op* op) {
   channel_data* chand = (channel_data*)elem->channel_data;
-  grpc_transport_perform_op(exec_ctx, chand->transport, op);
+  grpc_transport_perform_op(chand->transport, op);
 }
 
 /* Constructor for call_data */
-static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
-                                  grpc_call_element* elem,
+static grpc_error* init_call_elem(grpc_call_element* elem,
                                   const grpc_call_element_args* args) {
   call_data* calld = (call_data*)elem->call_data;
   channel_data* chand = (channel_data*)elem->channel_data;
   calld->call_combiner = args->call_combiner;
   int r = grpc_transport_init_stream(
-      exec_ctx, chand->transport, TRANSPORT_STREAM_FROM_CALL_DATA(calld),
+      chand->transport, TRANSPORT_STREAM_FROM_CALL_DATA(calld),
       &args->call_stack->refcount, args->server_transport_data, args->arena);
   return r == 0 ? GRPC_ERROR_NONE
                 : GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                       "transport stream initialization failed");
 }
 
-static void set_pollset_or_pollset_set(grpc_exec_ctx* exec_ctx,
-                                       grpc_call_element* elem,
+static void set_pollset_or_pollset_set(grpc_call_element* elem,
                                        grpc_polling_entity* pollent) {
   call_data* calld = (call_data*)elem->call_data;
   channel_data* chand = (channel_data*)elem->channel_data;
-  grpc_transport_set_pops(exec_ctx, chand->transport,
+  grpc_transport_set_pops(chand->transport,
                           TRANSPORT_STREAM_FROM_CALL_DATA(calld), pollent);
 }
 
 /* Destructor for call_data */
-static void destroy_call_elem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+static void destroy_call_elem(grpc_call_element* elem,
                               const grpc_call_final_info* final_info,
                               grpc_closure* then_schedule_closure) {
   call_data* calld = (call_data*)elem->call_data;
   channel_data* chand = (channel_data*)elem->channel_data;
-  grpc_transport_destroy_stream(exec_ctx, chand->transport,
+  grpc_transport_destroy_stream(chand->transport,
                                 TRANSPORT_STREAM_FROM_CALL_DATA(calld),
                                 then_schedule_closure);
 }
 
 /* Constructor for channel_data */
-static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
-                                     grpc_channel_element* elem,
+static grpc_error* init_channel_elem(grpc_channel_element* elem,
                                      grpc_channel_element_args* args) {
   channel_data* cd = (channel_data*)elem->channel_data;
   GPR_ASSERT(args->is_last);
@@ -186,17 +176,15 @@ static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
 }
 
 /* Destructor for channel_data */
-static void destroy_channel_elem(grpc_exec_ctx* exec_ctx,
-                                 grpc_channel_element* elem) {
+static void destroy_channel_elem(grpc_channel_element* elem) {
   channel_data* cd = (channel_data*)elem->channel_data;
   if (cd->transport) {
-    grpc_transport_destroy(exec_ctx, cd->transport);
+    grpc_transport_destroy(cd->transport);
   }
 }
 
 /* No-op. */
-static void con_get_channel_info(grpc_exec_ctx* exec_ctx,
-                                 grpc_channel_element* elem,
+static void con_get_channel_info(grpc_channel_element* elem,
                                  const grpc_channel_info* channel_info) {}
 
 const grpc_channel_filter grpc_connected_filter = {
@@ -230,8 +218,7 @@ static void bind_transport(grpc_channel_stack* channel_stack,
       grpc_transport_stream_size((grpc_transport*)t);
 }
 
-bool grpc_add_connected_filter(grpc_exec_ctx* exec_ctx,
-                               grpc_channel_stack_builder* builder,
+bool grpc_add_connected_filter(grpc_channel_stack_builder* builder,
                                void* arg_must_be_null) {
   GPR_ASSERT(arg_must_be_null == nullptr);
   grpc_transport* t = grpc_channel_stack_builder_get_transport(builder);

data/src/core/lib/channel/connected_channel.h

@@ -21,21 +21,12 @@
 
 #include "src/core/lib/channel/channel_stack_builder.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 extern const grpc_channel_filter grpc_connected_filter;
 
-bool grpc_add_connected_filter(grpc_exec_ctx* exec_ctx,
-                               grpc_channel_stack_builder* builder,
+bool grpc_add_connected_filter(grpc_channel_stack_builder* builder,
                                void* arg_must_be_null);
 
 /* Debug helper to dig the transport stream out of a call element */
 grpc_stream* grpc_connected_channel_get_stream(grpc_call_element* elem);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_CHANNEL_CONNECTED_CHANNEL_H */

data/src/core/lib/channel/handshaker.cc

@@ -34,23 +34,20 @@ void grpc_handshaker_init(const grpc_handshaker_vtable* vtable,
   handshaker->vtable = vtable;
 }
 
-void grpc_handshaker_destroy(grpc_exec_ctx* exec_ctx,
-                             grpc_handshaker* handshaker) {
-  handshaker->vtable->destroy(exec_ctx, handshaker);
+void grpc_handshaker_destroy(grpc_handshaker* handshaker) {
+  handshaker->vtable->destroy(handshaker);
 }
 
-void grpc_handshaker_shutdown(grpc_exec_ctx* exec_ctx,
-                              grpc_handshaker* handshaker, grpc_error* why) {
-  handshaker->vtable->shutdown(exec_ctx, handshaker, why);
+void grpc_handshaker_shutdown(grpc_handshaker* handshaker, grpc_error* why) {
+  handshaker->vtable->shutdown(handshaker, why);
 }
 
-void grpc_handshaker_do_handshake(grpc_exec_ctx* exec_ctx,
-                                  grpc_handshaker* handshaker,
+void grpc_handshaker_do_handshake(grpc_handshaker* handshaker,
                                   grpc_tcp_server_acceptor* acceptor,
                                   grpc_closure* on_handshake_done,
                                   grpc_handshaker_args* args) {
-  handshaker->vtable->do_handshake(exec_ctx, handshaker, acceptor,
-                                   on_handshake_done, args);
+  handshaker->vtable->do_handshake(handshaker, acceptor, on_handshake_done,
+                                   args);
 }
 
 //
@@ -116,9 +113,9 @@ void grpc_handshake_manager_pending_list_remove(grpc_handshake_manager** head,
 }
 
 void grpc_handshake_manager_pending_list_shutdown_all(
-    grpc_exec_ctx* exec_ctx, grpc_handshake_manager* head, grpc_error* why) {
+    grpc_handshake_manager* head, grpc_error* why) {
   while (head != nullptr) {
-    grpc_handshake_manager_shutdown(exec_ctx, head, GRPC_ERROR_REF(why));
+    grpc_handshake_manager_shutdown(head, GRPC_ERROR_REF(why));
     head = head->next;
   }
   GRPC_ERROR_UNREF(why);
@@ -145,11 +142,10 @@ void grpc_handshake_manager_add(grpc_handshake_manager* mgr,
   gpr_mu_unlock(&mgr->mu);
 }
 
-static void grpc_handshake_manager_unref(grpc_exec_ctx* exec_ctx,
-                                         grpc_handshake_manager* mgr) {
+static void grpc_handshake_manager_unref(grpc_handshake_manager* mgr) {
   if (gpr_unref(&mgr->refs)) {
     for (size_t i = 0; i < mgr->count; ++i) {
-      grpc_handshaker_destroy(exec_ctx, mgr->handshakers[i]);
+      grpc_handshaker_destroy(mgr->handshakers[i]);
     }
     gpr_free(mgr->handshakers);
     gpr_mu_destroy(&mgr->mu);
@@ -157,19 +153,17 @@ static void grpc_handshake_manager_unref(grpc_exec_ctx* exec_ctx,
   }
 }
 
-void grpc_handshake_manager_destroy(grpc_exec_ctx* exec_ctx,
-                                    grpc_handshake_manager* mgr) {
-  grpc_handshake_manager_unref(exec_ctx, mgr);
+void grpc_handshake_manager_destroy(grpc_handshake_manager* mgr) {
+  grpc_handshake_manager_unref(mgr);
 }
 
-void grpc_handshake_manager_shutdown(grpc_exec_ctx* exec_ctx,
-                                     grpc_handshake_manager* mgr,
+void grpc_handshake_manager_shutdown(grpc_handshake_manager* mgr,
                                      grpc_error* why) {
   gpr_mu_lock(&mgr->mu);
   // Shutdown the handshaker that's currently in progress, if any.
   if (!mgr->shutdown && mgr->index > 0) {
     mgr->shutdown = true;
-    grpc_handshaker_shutdown(exec_ctx, mgr->handshakers[mgr->index - 1],
+    grpc_handshaker_shutdown(mgr->handshakers[mgr->index - 1],
                              GRPC_ERROR_REF(why));
   }
   gpr_mu_unlock(&mgr->mu);
@@ -179,8 +173,7 @@ void grpc_handshake_manager_shutdown(grpc_exec_ctx* exec_ctx,
 // Helper function to call either the next handshaker or the
 // on_handshake_done callback.
 // Returns true if we've scheduled the on_handshake_done callback.
-static bool call_next_handshaker_locked(grpc_exec_ctx* exec_ctx,
-                                        grpc_handshake_manager* mgr,
+static bool call_next_handshaker_locked(grpc_handshake_manager* mgr,
                                         grpc_error* error) {
   GPR_ASSERT(mgr->index <= mgr->count);
   // If we got an error or we've been shut down or we're exiting early or
@@ -190,13 +183,12 @@ static bool call_next_handshaker_locked(grpc_exec_ctx* exec_ctx,
       mgr->index == mgr->count) {
     // Cancel deadline timer, since we're invoking the on_handshake_done
     // callback now.
-    grpc_timer_cancel(exec_ctx, &mgr->deadline_timer);
-    GRPC_CLOSURE_SCHED(exec_ctx, &mgr->on_handshake_done, error);
+    grpc_timer_cancel(&mgr->deadline_timer);
+    GRPC_CLOSURE_SCHED(&mgr->on_handshake_done, error);
     mgr->shutdown = true;
   } else {
-    grpc_handshaker_do_handshake(exec_ctx, mgr->handshakers[mgr->index],
-                                 mgr->acceptor, &mgr->call_next_handshaker,
-                                 &mgr->args);
+    grpc_handshaker_do_handshake(mgr->handshakers[mgr->index], mgr->acceptor,
+                                 &mgr->call_next_handshaker, &mgr->args);
   }
   ++mgr->index;
   return mgr->shutdown;
@@ -204,33 +196,31 @@ static bool call_next_handshaker_locked(grpc_exec_ctx* exec_ctx,
 
 // A function used as the handshaker-done callback when chaining
 // handshakers together.
-static void call_next_handshaker(grpc_exec_ctx* exec_ctx, void* arg,
-                                 grpc_error* error) {
+static void call_next_handshaker(void* arg, grpc_error* error) {
   grpc_handshake_manager* mgr = (grpc_handshake_manager*)arg;
   gpr_mu_lock(&mgr->mu);
-  bool done = call_next_handshaker_locked(exec_ctx, mgr, GRPC_ERROR_REF(error));
+  bool done = call_next_handshaker_locked(mgr, GRPC_ERROR_REF(error));
   gpr_mu_unlock(&mgr->mu);
   // If we're invoked the final callback, we won't be coming back
   // to this function, so we can release our reference to the
   // handshake manager.
   if (done) {
-    grpc_handshake_manager_unref(exec_ctx, mgr);
+    grpc_handshake_manager_unref(mgr);
   }
 }
 
 // Callback invoked when deadline is exceeded.
-static void on_timeout(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+static void on_timeout(void* arg, grpc_error* error) {
   grpc_handshake_manager* mgr = (grpc_handshake_manager*)arg;
   if (error == GRPC_ERROR_NONE) {  // Timer fired, rather than being cancelled.
     grpc_handshake_manager_shutdown(
-        exec_ctx, mgr,
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Handshake timed out"));
+        mgr, GRPC_ERROR_CREATE_FROM_STATIC_STRING("Handshake timed out"));
   }
-  grpc_handshake_manager_unref(exec_ctx, mgr);
+  grpc_handshake_manager_unref(mgr);
 }
 
 void grpc_handshake_manager_do_handshake(
-    grpc_exec_ctx* exec_ctx, grpc_handshake_manager* mgr,
+    grpc_handshake_manager* mgr, grpc_pollset_set* interested_parties,
     grpc_endpoint* endpoint, const grpc_channel_args* channel_args,
     grpc_millis deadline, grpc_tcp_server_acceptor* acceptor,
     grpc_iomgr_cb_func on_handshake_done, void* user_data) {
@@ -239,6 +229,7 @@ void grpc_handshake_manager_do_handshake(
   GPR_ASSERT(!mgr->shutdown);
   // Construct handshaker args.  These will be passed through all
   // handshakers and eventually be freed by the on_handshake_done callback.
+  mgr->args.interested_parties = interested_parties;
   mgr->args.endpoint = endpoint;
   mgr->args.args = grpc_channel_args_copy(channel_args);
   mgr->args.user_data = user_data;
@@ -255,12 +246,12 @@ void grpc_handshake_manager_do_handshake(
   gpr_ref(&mgr->refs);
   GRPC_CLOSURE_INIT(&mgr->on_timeout, on_timeout, mgr,
                     grpc_schedule_on_exec_ctx);
-  grpc_timer_init(exec_ctx, &mgr->deadline_timer, deadline, &mgr->on_timeout);
+  grpc_timer_init(&mgr->deadline_timer, deadline, &mgr->on_timeout);
   // Start first handshaker, which also owns a ref.
   gpr_ref(&mgr->refs);
-  bool done = call_next_handshaker_locked(exec_ctx, mgr, GRPC_ERROR_NONE);
+  bool done = call_next_handshaker_locked(mgr, GRPC_ERROR_NONE);
   gpr_mu_unlock(&mgr->mu);
   if (done) {
-    grpc_handshake_manager_unref(exec_ctx, mgr);
+    grpc_handshake_manager_unref(mgr);
   }
 }