grpc 1.8.7 → 1.9.0.pre1

data/src/core/lib/security/transport/lb_targets_info.cc

@@ -28,8 +28,8 @@
 static void* targets_info_copy(void* p) {
   return grpc_slice_hash_table_ref((grpc_slice_hash_table*)p);
 }
-static void targets_info_destroy(grpc_exec_ctx* exec_ctx, void* p) {
-  grpc_slice_hash_table_unref(exec_ctx, (grpc_slice_hash_table*)p);
+static void targets_info_destroy(void* p) {
+  grpc_slice_hash_table_unref((grpc_slice_hash_table*)p);
 }
 static int targets_info_cmp(void* a, void* b) {
   return grpc_slice_hash_table_cmp((const grpc_slice_hash_table*)a,

data/src/core/lib/security/transport/lb_targets_info.h

@@ -21,10 +21,6 @@
 
 #include "src/core/lib/slice/slice_hash_table.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /** Return a channel argument containing \a targets_info. */
 grpc_arg grpc_lb_targets_info_create_channel_arg(
     grpc_slice_hash_table* targets_info);
@@ -33,8 +29,4 @@ grpc_arg grpc_lb_targets_info_create_channel_arg(
 grpc_slice_hash_table* grpc_lb_targets_info_find_in_args(
     const grpc_channel_args* args);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_SECURITY_TRANSPORT_LB_TARGETS_INFO_H */

data/src/core/lib/security/transport/secure_endpoint.cc

@@ -28,12 +28,12 @@
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/security/transport/secure_endpoint.h"
 #include "src/core/lib/security/transport/tsi_error.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
-#include "src/core/lib/support/string.h"
 #include "src/core/tsi/transport_security_grpc.h"
 
 #define STAGING_BUFFER_SIZE 8192
@@ -63,28 +63,27 @@ typedef struct {
 
 grpc_core::TraceFlag grpc_trace_secure_endpoint(false, "secure_endpoint");
 
-static void destroy(grpc_exec_ctx* exec_ctx, secure_endpoint* secure_ep) {
+static void destroy(secure_endpoint* secure_ep) {
   secure_endpoint* ep = secure_ep;
-  grpc_endpoint_destroy(exec_ctx, ep->wrapped_ep);
+  grpc_endpoint_destroy(ep->wrapped_ep);
   tsi_frame_protector_destroy(ep->protector);
-  tsi_zero_copy_grpc_protector_destroy(exec_ctx, ep->zero_copy_protector);
-  grpc_slice_buffer_destroy_internal(exec_ctx, &ep->leftover_bytes);
-  grpc_slice_unref_internal(exec_ctx, ep->read_staging_buffer);
-  grpc_slice_unref_internal(exec_ctx, ep->write_staging_buffer);
-  grpc_slice_buffer_destroy_internal(exec_ctx, &ep->output_buffer);
-  grpc_slice_buffer_destroy_internal(exec_ctx, &ep->source_buffer);
+  tsi_zero_copy_grpc_protector_destroy(ep->zero_copy_protector);
+  grpc_slice_buffer_destroy_internal(&ep->leftover_bytes);
+  grpc_slice_unref_internal(ep->read_staging_buffer);
+  grpc_slice_unref_internal(ep->write_staging_buffer);
+  grpc_slice_buffer_destroy_internal(&ep->output_buffer);
+  grpc_slice_buffer_destroy_internal(&ep->source_buffer);
   gpr_mu_destroy(&ep->protector_mu);
   gpr_free(ep);
 }
 
 #ifndef NDEBUG
-#define SECURE_ENDPOINT_UNREF(exec_ctx, ep, reason) \
-  secure_endpoint_unref((exec_ctx), (ep), (reason), __FILE__, __LINE__)
+#define SECURE_ENDPOINT_UNREF(ep, reason) \
+  secure_endpoint_unref((ep), (reason), __FILE__, __LINE__)
 #define SECURE_ENDPOINT_REF(ep, reason) \
   secure_endpoint_ref((ep), (reason), __FILE__, __LINE__)
-static void secure_endpoint_unref(grpc_exec_ctx* exec_ctx, secure_endpoint* ep,
-                                  const char* reason, const char* file,
-                                  int line) {
+static void secure_endpoint_unref(secure_endpoint* ep, const char* reason,
+                                  const char* file, int line) {
   if (grpc_trace_secure_endpoint.enabled()) {
     gpr_atm val = gpr_atm_no_barrier_load(&ep->ref.count);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
@@ -92,7 +91,7 @@ static void secure_endpoint_unref(grpc_exec_ctx* exec_ctx, secure_endpoint* ep,
             val - 1);
   }
   if (gpr_unref(&ep->ref)) {
-    destroy(exec_ctx, ep);
+    destroy(ep);
   }
 }
 
@@ -107,13 +106,11 @@ static void secure_endpoint_ref(secure_endpoint* ep, const char* reason,
   gpr_ref(&ep->ref);
 }
 #else
-#define SECURE_ENDPOINT_UNREF(exec_ctx, ep, reason) \
-  secure_endpoint_unref((exec_ctx), (ep))
+#define SECURE_ENDPOINT_UNREF(ep, reason) secure_endpoint_unref((ep))
 #define SECURE_ENDPOINT_REF(ep, reason) secure_endpoint_ref((ep))
-static void secure_endpoint_unref(grpc_exec_ctx* exec_ctx,
-                                  secure_endpoint* ep) {
+static void secure_endpoint_unref(secure_endpoint* ep) {
   if (gpr_unref(&ep->ref)) {
-    destroy(exec_ctx, ep);
+    destroy(ep);
   }
 }
 
@@ -128,8 +125,7 @@ static void flush_read_staging_buffer(secure_endpoint* ep, uint8_t** cur,
   *end = GRPC_SLICE_END_PTR(ep->read_staging_buffer);
 }
 
-static void call_read_cb(grpc_exec_ctx* exec_ctx, secure_endpoint* ep,
-                         grpc_error* error) {
+static void call_read_cb(secure_endpoint* ep, grpc_error* error) {
   if (grpc_trace_secure_endpoint.enabled()) {
     size_t i;
     for (i = 0; i < ep->read_buffer->count; i++) {
@@ -140,12 +136,11 @@ static void call_read_cb(grpc_exec_ctx* exec_ctx, secure_endpoint* ep,
     }
   }
   ep->read_buffer = nullptr;
-  GRPC_CLOSURE_SCHED(exec_ctx, ep->read_cb, error);
-  SECURE_ENDPOINT_UNREF(exec_ctx, ep, "read");
+  GRPC_CLOSURE_SCHED(ep->read_cb, error);
+  SECURE_ENDPOINT_UNREF(ep, "read");
 }
 
-static void on_read(grpc_exec_ctx* exec_ctx, void* user_data,
-                    grpc_error* error) {
+static void on_read(void* user_data, grpc_error* error) {
   unsigned i;
   uint8_t keep_looping = 0;
   tsi_result result = TSI_OK;
@@ -154,17 +149,16 @@ static void on_read(grpc_exec_ctx* exec_ctx, void* user_data,
   uint8_t* end = GRPC_SLICE_END_PTR(ep->read_staging_buffer);
 
   if (error != GRPC_ERROR_NONE) {
-    grpc_slice_buffer_reset_and_unref_internal(exec_ctx, ep->read_buffer);
-    call_read_cb(exec_ctx, ep,
-                 GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                     "Secure read failed", &error, 1));
+    grpc_slice_buffer_reset_and_unref_internal(ep->read_buffer);
+    call_read_cb(ep, GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+                         "Secure read failed", &error, 1));
     return;
   }
 
   if (ep->zero_copy_protector != nullptr) {
     // Use zero-copy grpc protector to unprotect.
     result = tsi_zero_copy_grpc_protector_unprotect(
-        exec_ctx, ep->zero_copy_protector, &ep->source_buffer, ep->read_buffer);
+        ep->zero_copy_protector, &ep->source_buffer, ep->read_buffer);
   } else {
     // Use frame protector to unprotect.
     /* TODO(yangg) check error, maybe bail out early */
@@ -217,37 +211,35 @@ static void on_read(grpc_exec_ctx* exec_ctx, void* user_data,
 
   /* TODO(yangg) experiment with moving this block after read_cb to see if it
      helps latency */
-  grpc_slice_buffer_reset_and_unref_internal(exec_ctx, &ep->source_buffer);
+  grpc_slice_buffer_reset_and_unref_internal(&ep->source_buffer);
 
   if (result != TSI_OK) {
-    grpc_slice_buffer_reset_and_unref_internal(exec_ctx, ep->read_buffer);
+    grpc_slice_buffer_reset_and_unref_internal(ep->read_buffer);
     call_read_cb(
-        exec_ctx, ep,
-        grpc_set_tsi_error_result(
-            GRPC_ERROR_CREATE_FROM_STATIC_STRING("Unwrap failed"), result));
+        ep, grpc_set_tsi_error_result(
+                GRPC_ERROR_CREATE_FROM_STATIC_STRING("Unwrap failed"), result));
     return;
   }
 
-  call_read_cb(exec_ctx, ep, GRPC_ERROR_NONE);
+  call_read_cb(ep, GRPC_ERROR_NONE);
 }
 
-static void endpoint_read(grpc_exec_ctx* exec_ctx, grpc_endpoint* secure_ep,
-                          grpc_slice_buffer* slices, grpc_closure* cb) {
+static void endpoint_read(grpc_endpoint* secure_ep, grpc_slice_buffer* slices,
+                          grpc_closure* cb) {
   secure_endpoint* ep = (secure_endpoint*)secure_ep;
   ep->read_cb = cb;
   ep->read_buffer = slices;
-  grpc_slice_buffer_reset_and_unref_internal(exec_ctx, ep->read_buffer);
+  grpc_slice_buffer_reset_and_unref_internal(ep->read_buffer);
 
   SECURE_ENDPOINT_REF(ep, "read");
   if (ep->leftover_bytes.count) {
     grpc_slice_buffer_swap(&ep->leftover_bytes, &ep->source_buffer);
     GPR_ASSERT(ep->leftover_bytes.count == 0);
-    on_read(exec_ctx, ep, GRPC_ERROR_NONE);
+    on_read(ep, GRPC_ERROR_NONE);
     return;
   }
 
-  grpc_endpoint_read(exec_ctx, ep->wrapped_ep, &ep->source_buffer,
-                     &ep->on_read);
+  grpc_endpoint_read(ep->wrapped_ep, &ep->source_buffer, &ep->on_read);
 }
 
 static void flush_write_staging_buffer(secure_endpoint* ep, uint8_t** cur,
@@ -258,8 +250,8 @@ static void flush_write_staging_buffer(secure_endpoint* ep, uint8_t** cur,
   *end = GRPC_SLICE_END_PTR(ep->write_staging_buffer);
 }
 
-static void endpoint_write(grpc_exec_ctx* exec_ctx, grpc_endpoint* secure_ep,
-                           grpc_slice_buffer* slices, grpc_closure* cb) {
+static void endpoint_write(grpc_endpoint* secure_ep, grpc_slice_buffer* slices,
+                           grpc_closure* cb) {
   GPR_TIMER_BEGIN("secure_endpoint.endpoint_write", 0);
 
   unsigned i;
@@ -268,7 +260,7 @@ static void endpoint_write(grpc_exec_ctx* exec_ctx, grpc_endpoint* secure_ep,
   uint8_t* cur = GRPC_SLICE_START_PTR(ep->write_staging_buffer);
   uint8_t* end = GRPC_SLICE_END_PTR(ep->write_staging_buffer);
 
-  grpc_slice_buffer_reset_and_unref_internal(exec_ctx, &ep->output_buffer);
+  grpc_slice_buffer_reset_and_unref_internal(&ep->output_buffer);
 
   if (grpc_trace_secure_endpoint.enabled()) {
     for (i = 0; i < slices->count; i++) {
@@ -281,8 +273,8 @@ static void endpoint_write(grpc_exec_ctx* exec_ctx, grpc_endpoint* secure_ep,
 
   if (ep->zero_copy_protector != nullptr) {
     // Use zero-copy grpc protector to protect.
-    result = tsi_zero_copy_grpc_protector_protect(
-        exec_ctx, ep->zero_copy_protector, slices, &ep->output_buffer);
+    result = tsi_zero_copy_grpc_protector_protect(ep->zero_copy_protector,
+                                                  slices, &ep->output_buffer);
   } else {
     // Use frame protector to protect.
     for (i = 0; i < slices->count; i++) {
@@ -340,50 +332,44 @@ static void endpoint_write(grpc_exec_ctx* exec_ctx, grpc_endpoint* secure_ep,
 
   if (result != TSI_OK) {
     /* TODO(yangg) do different things according to the error type? */
-    grpc_slice_buffer_reset_and_unref_internal(exec_ctx, &ep->output_buffer);
+    grpc_slice_buffer_reset_and_unref_internal(&ep->output_buffer);
     GRPC_CLOSURE_SCHED(
-        exec_ctx, cb,
-        grpc_set_tsi_error_result(
-            GRPC_ERROR_CREATE_FROM_STATIC_STRING("Wrap failed"), result));
+        cb, grpc_set_tsi_error_result(
+                GRPC_ERROR_CREATE_FROM_STATIC_STRING("Wrap failed"), result));
     GPR_TIMER_END("secure_endpoint.endpoint_write", 0);
     return;
   }
 
-  grpc_endpoint_write(exec_ctx, ep->wrapped_ep, &ep->output_buffer, cb);
+  grpc_endpoint_write(ep->wrapped_ep, &ep->output_buffer, cb);
   GPR_TIMER_END("secure_endpoint.endpoint_write", 0);
 }
 
-static void endpoint_shutdown(grpc_exec_ctx* exec_ctx, grpc_endpoint* secure_ep,
-                              grpc_error* why) {
+static void endpoint_shutdown(grpc_endpoint* secure_ep, grpc_error* why) {
   secure_endpoint* ep = (secure_endpoint*)secure_ep;
-  grpc_endpoint_shutdown(exec_ctx, ep->wrapped_ep, why);
+  grpc_endpoint_shutdown(ep->wrapped_ep, why);
 }
 
-static void endpoint_destroy(grpc_exec_ctx* exec_ctx,
-                             grpc_endpoint* secure_ep) {
+static void endpoint_destroy(grpc_endpoint* secure_ep) {
   secure_endpoint* ep = (secure_endpoint*)secure_ep;
-  SECURE_ENDPOINT_UNREF(exec_ctx, ep, "destroy");
+  SECURE_ENDPOINT_UNREF(ep, "destroy");
 }
 
-static void endpoint_add_to_pollset(grpc_exec_ctx* exec_ctx,
-                                    grpc_endpoint* secure_ep,
+static void endpoint_add_to_pollset(grpc_endpoint* secure_ep,
                                     grpc_pollset* pollset) {
   secure_endpoint* ep = (secure_endpoint*)secure_ep;
-  grpc_endpoint_add_to_pollset(exec_ctx, ep->wrapped_ep, pollset);
+  grpc_endpoint_add_to_pollset(ep->wrapped_ep, pollset);
 }
 
-static void endpoint_add_to_pollset_set(grpc_exec_ctx* exec_ctx,
-                                        grpc_endpoint* secure_ep,
+static void endpoint_add_to_pollset_set(grpc_endpoint* secure_ep,
                                         grpc_pollset_set* pollset_set) {
   secure_endpoint* ep = (secure_endpoint*)secure_ep;
-  grpc_endpoint_add_to_pollset_set(exec_ctx, ep->wrapped_ep, pollset_set);
+  grpc_endpoint_add_to_pollset_set(ep->wrapped_ep, pollset_set);
 }
 
-static void endpoint_delete_from_pollset_set(grpc_exec_ctx* exec_ctx,
-                                             grpc_endpoint* secure_ep,
+static void endpoint_delete_from_pollset_set(grpc_endpoint* secure_ep,
                                              grpc_pollset_set* pollset_set) {
   secure_endpoint* ep = (secure_endpoint*)secure_ep;
-  grpc_endpoint_delete_from_pollset_set(exec_ctx, ep->wrapped_ep, pollset_set);
+  grpc_endpoint_delete_from_pollset_set(ep->wrapped_ep, pollset_set);
 }
 
 static char* endpoint_get_peer(grpc_endpoint* secure_ep) {

data/src/core/lib/security/transport/secure_endpoint.h

@@ -22,10 +22,6 @@
 #include <grpc/slice.h>
 #include "src/core/lib/iomgr/endpoint.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 struct tsi_frame_protector;
 struct tsi_zero_copy_grpc_protector;
 
@@ -40,8 +36,4 @@ grpc_endpoint* grpc_secure_endpoint_create(
     grpc_endpoint* to_wrap, grpc_slice* leftover_slices,
     size_t leftover_nslices);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_SECURITY_TRANSPORT_SECURE_ENDPOINT_H */

data/src/core/lib/security/transport/security_connector.cc

@@ -30,6 +30,8 @@
 #include "src/core/ext/transport/chttp2/alpn/alpn.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/handshaker.h"
+#include "src/core/lib/gpr/env.h"
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/load_file.h"
 #include "src/core/lib/security/context/security_context.h"
 #include "src/core/lib/security/credentials/credentials.h"
@@ -38,8 +40,6 @@
 #include "src/core/lib/security/transport/lb_targets_info.h"
 #include "src/core/lib/security/transport/secure_endpoint.h"
 #include "src/core/lib/security/transport/security_handshaker.h"
-#include "src/core/lib/support/env.h"
-#include "src/core/lib/support/string.h"
 #include "src/core/tsi/fake_transport_security.h"
 #include "src/core/tsi/ssl_transport_security.h"
 #include "src/core/tsi/transport_security_adapter.h"
@@ -105,33 +105,32 @@ const tsi_peer_property* tsi_peer_get_property_by_name(const tsi_peer* peer,
 }
 
 void grpc_channel_security_connector_add_handshakers(
-    grpc_exec_ctx* exec_ctx, grpc_channel_security_connector* connector,
+    grpc_channel_security_connector* connector,
     grpc_handshake_manager* handshake_mgr) {
   if (connector != nullptr) {
-    connector->add_handshakers(exec_ctx, connector, handshake_mgr);
+    connector->add_handshakers(connector, handshake_mgr);
   }
 }
 
 void grpc_server_security_connector_add_handshakers(
-    grpc_exec_ctx* exec_ctx, grpc_server_security_connector* connector,
+    grpc_server_security_connector* connector,
     grpc_handshake_manager* handshake_mgr) {
   if (connector != nullptr) {
-    connector->add_handshakers(exec_ctx, connector, handshake_mgr);
+    connector->add_handshakers(connector, handshake_mgr);
   }
 }
 
-void grpc_security_connector_check_peer(grpc_exec_ctx* exec_ctx,
-                                        grpc_security_connector* sc,
+void grpc_security_connector_check_peer(grpc_security_connector* sc,
                                         tsi_peer peer,
                                         grpc_auth_context** auth_context,
                                         grpc_closure* on_peer_checked) {
   if (sc == nullptr) {
-    GRPC_CLOSURE_SCHED(exec_ctx, on_peer_checked,
+    GRPC_CLOSURE_SCHED(on_peer_checked,
                        GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                            "cannot check peer -- no security connector"));
     tsi_peer_destruct(&peer);
   } else {
-    sc->vtable->check_peer(exec_ctx, sc, peer, auth_context, on_peer_checked);
+    sc->vtable->check_peer(sc, peer, auth_context, on_peer_checked);
   }
 }
 
@@ -169,26 +168,26 @@ int grpc_server_security_connector_cmp(grpc_server_security_connector* sc1,
 }
 
 bool grpc_channel_security_connector_check_call_host(
-    grpc_exec_ctx* exec_ctx, grpc_channel_security_connector* sc,
-    const char* host, grpc_auth_context* auth_context,
-    grpc_closure* on_call_host_checked, grpc_error** error) {
+    grpc_channel_security_connector* sc, const char* host,
+    grpc_auth_context* auth_context, grpc_closure* on_call_host_checked,
+    grpc_error** error) {
   if (sc == nullptr || sc->check_call_host == nullptr) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "cannot check call host -- no security connector");
     return true;
   }
-  return sc->check_call_host(exec_ctx, sc, host, auth_context,
-                             on_call_host_checked, error);
+  return sc->check_call_host(sc, host, auth_context, on_call_host_checked,
+                             error);
 }
 
 void grpc_channel_security_connector_cancel_check_call_host(
-    grpc_exec_ctx* exec_ctx, grpc_channel_security_connector* sc,
-    grpc_closure* on_call_host_checked, grpc_error* error) {
+    grpc_channel_security_connector* sc, grpc_closure* on_call_host_checked,
+    grpc_error* error) {
   if (sc == nullptr || sc->cancel_check_call_host == nullptr) {
     GRPC_ERROR_UNREF(error);
     return;
   }
-  sc->cancel_check_call_host(exec_ctx, sc, on_call_host_checked, error);
+  sc->cancel_check_call_host(sc, on_call_host_checked, error);
 }
 
 #ifndef NDEBUG
@@ -205,15 +204,14 @@ grpc_security_connector* grpc_security_connector_ref(
 #else
 grpc_security_connector* grpc_security_connector_ref(
     grpc_security_connector* sc) {
-  if (sc == NULL) return NULL;
+  if (sc == nullptr) return nullptr;
 #endif
   gpr_ref(&sc->refcount);
   return sc;
 }
 
 #ifndef NDEBUG
-void grpc_security_connector_unref(grpc_exec_ctx* exec_ctx,
-                                   grpc_security_connector* sc,
+void grpc_security_connector_unref(grpc_security_connector* sc,
                                    const char* file, int line,
                                    const char* reason) {
   if (sc == nullptr) return;
@@ -224,15 +222,14 @@ void grpc_security_connector_unref(grpc_exec_ctx* exec_ctx,
             val, val - 1, reason);
   }
 #else
-void grpc_security_connector_unref(grpc_exec_ctx* exec_ctx,
-                                   grpc_security_connector* sc) {
-  if (sc == NULL) return;
+void grpc_security_connector_unref(grpc_security_connector* sc) {
+  if (sc == nullptr) return;
 #endif
-  if (gpr_unref(&sc->refcount)) sc->vtable->destroy(exec_ctx, sc);
+  if (gpr_unref(&sc->refcount)) sc->vtable->destroy(sc);
 }
 
-static void connector_arg_destroy(grpc_exec_ctx* exec_ctx, void* p) {
-  GRPC_SECURITY_CONNECTOR_UNREF(exec_ctx, (grpc_security_connector*)p,
+static void connector_arg_destroy(void* p) {
+  GRPC_SECURITY_CONNECTOR_UNREF((grpc_security_connector*)p,
                                 "connector_arg_destroy");
 }
 
@@ -309,20 +306,16 @@ typedef struct {
   bool is_lb_channel;
 } grpc_fake_channel_security_connector;
 
-static void fake_channel_destroy(grpc_exec_ctx* exec_ctx,
-                                 grpc_security_connector* sc) {
+static void fake_channel_destroy(grpc_security_connector* sc) {
   grpc_fake_channel_security_connector* c =
       (grpc_fake_channel_security_connector*)sc;
-  grpc_call_credentials_unref(exec_ctx, c->base.request_metadata_creds);
+  grpc_call_credentials_unref(c->base.request_metadata_creds);
   gpr_free(c->target);
   gpr_free(c->expected_targets);
   gpr_free(c);
 }
 
-static void fake_server_destroy(grpc_exec_ctx* exec_ctx,
-                                grpc_security_connector* sc) {
-  gpr_free(sc);
-}
+static void fake_server_destroy(grpc_security_connector* sc) { gpr_free(sc); }
 
 static bool fake_check_target(const char* target_type, const char* target,
                               const char* set_str) {
@@ -386,8 +379,7 @@ done:
   if (!success) abort();
 }
 
-static void fake_check_peer(grpc_exec_ctx* exec_ctx,
-                            grpc_security_connector* sc, tsi_peer peer,
+static void fake_check_peer(grpc_security_connector* sc, tsi_peer peer,
                             grpc_auth_context** auth_context,
                             grpc_closure* on_peer_checked) {
   const char* prop_name;
@@ -419,25 +411,23 @@ static void fake_check_peer(grpc_exec_ctx* exec_ctx,
       *auth_context, GRPC_TRANSPORT_SECURITY_TYPE_PROPERTY_NAME,
       GRPC_FAKE_TRANSPORT_SECURITY_TYPE);
 end:
-  GRPC_CLOSURE_SCHED(exec_ctx, on_peer_checked, error);
+  GRPC_CLOSURE_SCHED(on_peer_checked, error);
   tsi_peer_destruct(&peer);
 }
 
-static void fake_channel_check_peer(grpc_exec_ctx* exec_ctx,
-                                    grpc_security_connector* sc, tsi_peer peer,
+static void fake_channel_check_peer(grpc_security_connector* sc, tsi_peer peer,
                                     grpc_auth_context** auth_context,
                                     grpc_closure* on_peer_checked) {
-  fake_check_peer(exec_ctx, sc, peer, auth_context, on_peer_checked);
+  fake_check_peer(sc, peer, auth_context, on_peer_checked);
   grpc_fake_channel_security_connector* c =
       (grpc_fake_channel_security_connector*)sc;
   fake_secure_name_check(c->target, c->expected_targets, c->is_lb_channel);
 }
 
-static void fake_server_check_peer(grpc_exec_ctx* exec_ctx,
-                                   grpc_security_connector* sc, tsi_peer peer,
+static void fake_server_check_peer(grpc_security_connector* sc, tsi_peer peer,
                                    grpc_auth_context** auth_context,
                                    grpc_closure* on_peer_checked) {
-  fake_check_peer(exec_ctx, sc, peer, auth_context, on_peer_checked);
+  fake_check_peer(sc, peer, auth_context, on_peer_checked);
 }
 
 static int fake_channel_cmp(grpc_security_connector* sc1,
@@ -466,8 +456,7 @@ static int fake_server_cmp(grpc_security_connector* sc1,
       (grpc_server_security_connector*)sc2);
 }
 
-static bool fake_channel_check_call_host(grpc_exec_ctx* exec_ctx,
-                                         grpc_channel_security_connector* sc,
+static bool fake_channel_check_call_host(grpc_channel_security_connector* sc,
                                          const char* host,
                                          grpc_auth_context* auth_context,
                                          grpc_closure* on_call_host_checked,
@@ -476,29 +465,26 @@ static bool fake_channel_check_call_host(grpc_exec_ctx* exec_ctx,
 }
 
 static void fake_channel_cancel_check_call_host(
-    grpc_exec_ctx* exec_ctx, grpc_channel_security_connector* sc,
-    grpc_closure* on_call_host_checked, grpc_error* error) {
+    grpc_channel_security_connector* sc, grpc_closure* on_call_host_checked,
+    grpc_error* error) {
   GRPC_ERROR_UNREF(error);
 }
 
 static void fake_channel_add_handshakers(
-    grpc_exec_ctx* exec_ctx, grpc_channel_security_connector* sc,
+    grpc_channel_security_connector* sc,
     grpc_handshake_manager* handshake_mgr) {
   grpc_handshake_manager_add(
       handshake_mgr,
       grpc_security_handshaker_create(
-          exec_ctx, tsi_create_fake_handshaker(true /* is_client */),
-          &sc->base));
+          tsi_create_fake_handshaker(true /* is_client */), &sc->base));
 }
 
-static void fake_server_add_handshakers(grpc_exec_ctx* exec_ctx,
-                                        grpc_server_security_connector* sc,
+static void fake_server_add_handshakers(grpc_server_security_connector* sc,
                                         grpc_handshake_manager* handshake_mgr) {
   grpc_handshake_manager_add(
       handshake_mgr,
       grpc_security_handshaker_create(
-          exec_ctx, tsi_create_fake_handshaker(false /* is_client */),
-          &sc->base));
+          tsi_create_fake_handshaker(false /* is_client */), &sc->base));
 }
 
 static grpc_security_connector_vtable fake_channel_vtable = {
@@ -565,12 +551,11 @@ static bool server_connector_has_cert_config_fetcher(
   return server_creds->certificate_config_fetcher.cb != nullptr;
 }
 
-static void ssl_channel_destroy(grpc_exec_ctx* exec_ctx,
-                                grpc_security_connector* sc) {
+static void ssl_channel_destroy(grpc_security_connector* sc) {
   grpc_ssl_channel_security_connector* c =
       (grpc_ssl_channel_security_connector*)sc;
-  grpc_channel_credentials_unref(exec_ctx, c->base.channel_creds);
-  grpc_call_credentials_unref(exec_ctx, c->base.request_metadata_creds);
+  grpc_channel_credentials_unref(c->base.channel_creds);
+  grpc_call_credentials_unref(c->base.request_metadata_creds);
   tsi_ssl_client_handshaker_factory_unref(c->client_handshaker_factory);
   c->client_handshaker_factory = nullptr;
   if (c->target_name != nullptr) gpr_free(c->target_name);
@@ -578,18 +563,16 @@ static void ssl_channel_destroy(grpc_exec_ctx* exec_ctx,
   gpr_free(sc);
 }
 
-static void ssl_server_destroy(grpc_exec_ctx* exec_ctx,
-                               grpc_security_connector* sc) {
+static void ssl_server_destroy(grpc_security_connector* sc) {
   grpc_ssl_server_security_connector* c =
       (grpc_ssl_server_security_connector*)sc;
-  grpc_server_credentials_unref(exec_ctx, c->base.server_creds);
+  grpc_server_credentials_unref(c->base.server_creds);
   tsi_ssl_server_handshaker_factory_unref(c->server_handshaker_factory);
   c->server_handshaker_factory = nullptr;
   gpr_free(sc);
 }
 
-static void ssl_channel_add_handshakers(grpc_exec_ctx* exec_ctx,
-                                        grpc_channel_security_connector* sc,
+static void ssl_channel_add_handshakers(grpc_channel_security_connector* sc,
                                         grpc_handshake_manager* handshake_mgr) {
   grpc_ssl_channel_security_connector* c =
       (grpc_ssl_channel_security_connector*)sc;
@@ -607,9 +590,8 @@ static void ssl_channel_add_handshakers(grpc_exec_ctx* exec_ctx,
   }
   // Create handshakers.
   grpc_handshake_manager_add(
-      handshake_mgr,
-      grpc_security_handshaker_create(
-          exec_ctx, tsi_create_adapter_handshaker(tsi_hs), &sc->base));
+      handshake_mgr, grpc_security_handshaker_create(
+                         tsi_create_adapter_handshaker(tsi_hs), &sc->base));
 }
 
 static const char** fill_alpn_protocol_strings(size_t* num_alpn_protocols) {
@@ -701,8 +683,7 @@ static bool try_fetch_ssl_server_credentials(
   return status;
 }
 
-static void ssl_server_add_handshakers(grpc_exec_ctx* exec_ctx,
-                                       grpc_server_security_connector* sc,
+static void ssl_server_add_handshakers(grpc_server_security_connector* sc,
                                        grpc_handshake_manager* handshake_mgr) {
   grpc_ssl_server_security_connector* c =
       (grpc_ssl_server_security_connector*)sc;
@@ -718,9 +699,8 @@ static void ssl_server_add_handshakers(grpc_exec_ctx* exec_ctx,
   }
   // Create handshakers.
   grpc_handshake_manager_add(
-      handshake_mgr,
-      grpc_security_handshaker_create(
-          exec_ctx, tsi_create_adapter_handshaker(tsi_hs), &sc->base));
+      handshake_mgr, grpc_security_handshaker_create(
+                         tsi_create_adapter_handshaker(tsi_hs), &sc->base));
 }
 
 static int ssl_host_matches_name(const tsi_peer* peer, const char* peer_name) {
@@ -804,8 +784,7 @@ static grpc_error* ssl_check_peer(grpc_security_connector* sc,
   return GRPC_ERROR_NONE;
 }
 
-static void ssl_channel_check_peer(grpc_exec_ctx* exec_ctx,
-                                   grpc_security_connector* sc, tsi_peer peer,
+static void ssl_channel_check_peer(grpc_security_connector* sc, tsi_peer peer,
                                    grpc_auth_context** auth_context,
                                    grpc_closure* on_peer_checked) {
   grpc_ssl_channel_security_connector* c =
@@ -815,17 +794,16 @@ static void ssl_channel_check_peer(grpc_exec_ctx* exec_ctx,
                                          ? c->overridden_target_name
                                          : c->target_name,
                                      &peer, auth_context);
-  GRPC_CLOSURE_SCHED(exec_ctx, on_peer_checked, error);
+  GRPC_CLOSURE_SCHED(on_peer_checked, error);
   tsi_peer_destruct(&peer);
 }
 
-static void ssl_server_check_peer(grpc_exec_ctx* exec_ctx,
-                                  grpc_security_connector* sc, tsi_peer peer,
+static void ssl_server_check_peer(grpc_security_connector* sc, tsi_peer peer,
                                   grpc_auth_context** auth_context,
                                   grpc_closure* on_peer_checked) {
   grpc_error* error = ssl_check_peer(sc, nullptr, &peer, auth_context);
   tsi_peer_destruct(&peer);
-  GRPC_CLOSURE_SCHED(exec_ctx, on_peer_checked, error);
+  GRPC_CLOSURE_SCHED(on_peer_checked, error);
 }
 
 static int ssl_channel_cmp(grpc_security_connector* sc1,
@@ -895,8 +873,7 @@ void tsi_shallow_peer_destruct(tsi_peer* peer) {
   if (peer->properties != nullptr) gpr_free(peer->properties);
 }
 
-static bool ssl_channel_check_call_host(grpc_exec_ctx* exec_ctx,
-                                        grpc_channel_security_connector* sc,
+static bool ssl_channel_check_call_host(grpc_channel_security_connector* sc,
                                         const char* host,
                                         grpc_auth_context* auth_context,
                                         grpc_closure* on_call_host_checked,
@@ -922,8 +899,8 @@ static bool ssl_channel_check_call_host(grpc_exec_ctx* exec_ctx,
 }
 
 static void ssl_channel_cancel_check_call_host(
-    grpc_exec_ctx* exec_ctx, grpc_channel_security_connector* sc,
-    grpc_closure* on_call_host_checked, grpc_error* error) {
+    grpc_channel_security_connector* sc, grpc_closure* on_call_host_checked,
+    grpc_error* error) {
   GRPC_ERROR_UNREF(error);
 }
 
@@ -990,7 +967,7 @@ const char* grpc_get_default_ssl_roots(void) {
 }
 
 grpc_security_status grpc_ssl_channel_security_connector_create(
-    grpc_exec_ctx* exec_ctx, grpc_channel_credentials* channel_creds,
+    grpc_channel_credentials* channel_creds,
     grpc_call_credentials* request_metadata_creds,
     const grpc_ssl_config* config, const char* target_name,
     const char* overridden_target_name, grpc_channel_security_connector** sc) {
@@ -1045,7 +1022,7 @@ grpc_security_status grpc_ssl_channel_security_connector_create(
   if (result != TSI_OK) {
     gpr_log(GPR_ERROR, "Handshaker factory creation failed with %s.",
             tsi_result_to_string(result));
-    ssl_channel_destroy(exec_ctx, &c->base.base);
+    ssl_channel_destroy(&c->base.base);
     *sc = nullptr;
     goto error;
   }
@@ -1073,8 +1050,7 @@ grpc_ssl_server_security_connector_initialize(
 }
 
 grpc_security_status grpc_ssl_server_security_connector_create(
-    grpc_exec_ctx* exec_ctx, grpc_server_credentials* gsc,
-    grpc_server_security_connector** sc) {
+    grpc_server_credentials* gsc, grpc_server_security_connector** sc) {
   tsi_result result = TSI_OK;
   grpc_ssl_server_credentials* server_credentials =
       (grpc_ssl_server_credentials*)gsc;
@@ -1114,7 +1090,7 @@ grpc_security_status grpc_ssl_server_security_connector_create(
   if (retval == GRPC_SECURITY_OK) {
     *sc = &c->base;
   } else {
-    if (c != nullptr) ssl_server_destroy(exec_ctx, &c->base.base);
+    if (c != nullptr) ssl_server_destroy(&c->base.base);
     if (sc != nullptr) *sc = nullptr;
   }
   return retval;