grpc 1.8.7 → 1.9.0.pre1

data/src/core/lib/security/credentials/oauth2/oauth2_credentials.h

@@ -22,10 +22,6 @@
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/security/credentials/credentials.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 // auth_refresh_token parsing.
 typedef struct {
   const char* type;
@@ -56,8 +52,7 @@ void grpc_auth_refresh_token_destruct(grpc_auth_refresh_token* refresh_token);
 //  This object is a base for credentials that need to acquire an oauth2 token
 //  from an http service.
 
-typedef void (*grpc_fetch_oauth2_func)(grpc_exec_ctx* exec_ctx,
-                                       grpc_credentials_metadata_request* req,
+typedef void (*grpc_fetch_oauth2_func)(grpc_credentials_metadata_request* req,
                                        grpc_httpcli_context* http_context,
                                        grpc_polling_entity* pollent,
                                        grpc_iomgr_cb_func cb,
@@ -103,11 +98,7 @@ grpc_refresh_token_credentials_create_from_auth_refresh_token(
 // Exposed for testing only.
 grpc_credentials_status
 grpc_oauth2_token_fetcher_credentials_parse_server_response(
-    grpc_exec_ctx* exec_ctx, const struct grpc_http_response* response,
-    grpc_mdelem* token_md, grpc_millis* token_lifetime);
-
-#ifdef __cplusplus
-}
-#endif
+    const struct grpc_http_response* response, grpc_mdelem* token_md,
+    grpc_millis* token_lifetime);
 
 #endif /* GRPC_CORE_LIB_SECURITY_CREDENTIALS_OAUTH2_OAUTH2_CREDENTIALS_H */

data/src/core/lib/security/credentials/plugin/plugin_credentials.cc

@@ -33,8 +33,7 @@
 
 grpc_core::TraceFlag grpc_plugin_credentials_trace(false, "plugin_credentials");
 
-static void plugin_destruct(grpc_exec_ctx* exec_ctx,
-                            grpc_call_credentials* creds) {
+static void plugin_destruct(grpc_call_credentials* creds) {
   grpc_plugin_credentials* c = (grpc_plugin_credentials*)creds;
   gpr_mu_destroy(&c->mu);
   if (c->plugin.state != nullptr && c->plugin.destroy != nullptr) {
@@ -61,18 +60,17 @@ static void pending_request_remove_locked(
 // When this returns, r->cancelled indicates whether the request was
 // cancelled before completion.
 static void pending_request_complete(
-    grpc_exec_ctx* exec_ctx, grpc_plugin_credentials_pending_request* r) {
+    grpc_plugin_credentials_pending_request* r) {
   gpr_mu_lock(&r->creds->mu);
   if (!r->cancelled) pending_request_remove_locked(r->creds, r);
   gpr_mu_unlock(&r->creds->mu);
   // Ref to credentials not needed anymore.
-  grpc_call_credentials_unref(exec_ctx, &r->creds->base);
+  grpc_call_credentials_unref(&r->creds->base);
 }
 
 static grpc_error* process_plugin_result(
-    grpc_exec_ctx* exec_ctx, grpc_plugin_credentials_pending_request* r,
-    const grpc_metadata* md, size_t num_md, grpc_status_code status,
-    const char* error_details) {
+    grpc_plugin_credentials_pending_request* r, const grpc_metadata* md,
+    size_t num_md, grpc_status_code status, const char* error_details) {
   grpc_error* error = GRPC_ERROR_NONE;
   if (status != GRPC_STATUS_OK) {
     char* msg;
@@ -100,11 +98,11 @@ static grpc_error* process_plugin_result(
       error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Illegal metadata");
     } else {
       for (size_t i = 0; i < num_md; ++i) {
-        grpc_mdelem mdelem = grpc_mdelem_from_slices(
-            exec_ctx, grpc_slice_ref_internal(md[i].key),
-            grpc_slice_ref_internal(md[i].value));
+        grpc_mdelem mdelem =
+            grpc_mdelem_from_slices(grpc_slice_ref_internal(md[i].key),
+                                    grpc_slice_ref_internal(md[i].value));
         grpc_credentials_mdelem_array_add(r->md_array, mdelem);
-        GRPC_MDELEM_UNREF(exec_ctx, mdelem);
+        GRPC_MDELEM_UNREF(mdelem);
       }
     }
   }
@@ -117,9 +115,8 @@ static void plugin_md_request_metadata_ready(void* request,
                                              grpc_status_code status,
                                              const char* error_details) {
   /* called from application code */
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INITIALIZER(
-      GRPC_EXEC_CTX_FLAG_IS_FINISHED | GRPC_EXEC_CTX_FLAG_THREAD_RESOURCE_LOOP,
-      nullptr, nullptr);
+  grpc_core::ExecCtx exec_ctx(GRPC_EXEC_CTX_FLAG_IS_FINISHED |
+                              GRPC_EXEC_CTX_FLAG_THREAD_RESOURCE_LOOP);
   grpc_plugin_credentials_pending_request* r =
       (grpc_plugin_credentials_pending_request*)request;
   if (grpc_plugin_credentials_trace.enabled()) {
@@ -129,12 +126,12 @@ static void plugin_md_request_metadata_ready(void* request,
             r->creds, r);
   }
   // Remove request from pending list if not previously cancelled.
-  pending_request_complete(&exec_ctx, r);
+  pending_request_complete(r);
   // If it has not been cancelled, process it.
   if (!r->cancelled) {
     grpc_error* error =
-        process_plugin_result(&exec_ctx, r, md, num_md, status, error_details);
-    GRPC_CLOSURE_SCHED(&exec_ctx, r->on_request_metadata, error);
+        process_plugin_result(r, md, num_md, status, error_details);
+    GRPC_CLOSURE_SCHED(r->on_request_metadata, error);
   } else if (grpc_plugin_credentials_trace.enabled()) {
     gpr_log(GPR_INFO,
             "plugin_credentials[%p]: request %p: plugin was previously "
@@ -142,11 +139,9 @@ static void plugin_md_request_metadata_ready(void* request,
             r->creds, r);
   }
   gpr_free(r);
-  grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static bool plugin_get_request_metadata(grpc_exec_ctx* exec_ctx,
-                                        grpc_call_credentials* creds,
+static bool plugin_get_request_metadata(grpc_call_credentials* creds,
                                         grpc_polling_entity* pollent,
                                         grpc_auth_metadata_context context,
                                         grpc_credentials_mdelem_array* md_array,
@@ -194,7 +189,7 @@ static bool plugin_get_request_metadata(grpc_exec_ctx* exec_ctx,
     }
     // Returned synchronously.
     // Remove request from pending list if not previously cancelled.
-    pending_request_complete(exec_ctx, pending_request);
+    pending_request_complete(pending_request);
     // If the request was cancelled, the error will have been returned
     // asynchronously by plugin_cancel_get_request_metadata(), so return
     // false.  Otherwise, process the result.
@@ -213,13 +208,13 @@ static bool plugin_get_request_metadata(grpc_exec_ctx* exec_ctx,
                 "synchronously",
                 c, pending_request);
       }
-      *error = process_plugin_result(exec_ctx, pending_request, creds_md,
-                                     num_creds_md, status, error_details);
+      *error = process_plugin_result(pending_request, creds_md, num_creds_md,
+                                     status, error_details);
     }
     // Clean up.
     for (size_t i = 0; i < num_creds_md; ++i) {
-      grpc_slice_unref_internal(exec_ctx, creds_md[i].key);
-      grpc_slice_unref_internal(exec_ctx, creds_md[i].value);
+      grpc_slice_unref_internal(creds_md[i].key);
+      grpc_slice_unref_internal(creds_md[i].value);
     }
     gpr_free((void*)error_details);
     gpr_free(pending_request);
@@ -228,8 +223,8 @@ static bool plugin_get_request_metadata(grpc_exec_ctx* exec_ctx,
 }
 
 static void plugin_cancel_get_request_metadata(
-    grpc_exec_ctx* exec_ctx, grpc_call_credentials* creds,
-    grpc_credentials_mdelem_array* md_array, grpc_error* error) {
+    grpc_call_credentials* creds, grpc_credentials_mdelem_array* md_array,
+    grpc_error* error) {
   grpc_plugin_credentials* c = (grpc_plugin_credentials*)creds;
   gpr_mu_lock(&c->mu);
   for (grpc_plugin_credentials_pending_request* pending_request =
@@ -241,7 +236,7 @@ static void plugin_cancel_get_request_metadata(
                 pending_request);
       }
       pending_request->cancelled = true;
-      GRPC_CLOSURE_SCHED(exec_ctx, pending_request->on_request_metadata,
+      GRPC_CLOSURE_SCHED(pending_request->on_request_metadata,
                          GRPC_ERROR_REF(error));
       pending_request_remove_locked(c, pending_request);
       break;

data/src/core/lib/security/credentials/ssl/ssl_credentials.cc

@@ -41,18 +41,16 @@ void grpc_tsi_ssl_pem_key_cert_pairs_destroy(tsi_ssl_pem_key_cert_pair* kp,
   gpr_free(kp);
 }
 
-static void ssl_destruct(grpc_exec_ctx* exec_ctx,
-                         grpc_channel_credentials* creds) {
+static void ssl_destruct(grpc_channel_credentials* creds) {
   grpc_ssl_credentials* c = (grpc_ssl_credentials*)creds;
   gpr_free(c->config.pem_root_certs);
   grpc_tsi_ssl_pem_key_cert_pairs_destroy(c->config.pem_key_cert_pair, 1);
 }
 
 static grpc_security_status ssl_create_security_connector(
-    grpc_exec_ctx* exec_ctx, grpc_channel_credentials* creds,
-    grpc_call_credentials* call_creds, const char* target,
-    const grpc_channel_args* args, grpc_channel_security_connector** sc,
-    grpc_channel_args** new_args) {
+    grpc_channel_credentials* creds, grpc_call_credentials* call_creds,
+    const char* target, const grpc_channel_args* args,
+    grpc_channel_security_connector** sc, grpc_channel_args** new_args) {
   grpc_ssl_credentials* c = (grpc_ssl_credentials*)creds;
   grpc_security_status status = GRPC_SECURITY_OK;
   const char* overridden_target_name = nullptr;
@@ -65,8 +63,7 @@ static grpc_security_status ssl_create_security_connector(
     }
   }
   status = grpc_ssl_channel_security_connector_create(
-      exec_ctx, creds, call_creds, &c->config, target, overridden_target_name,
-      sc);
+      creds, call_creds, &c->config, target, overridden_target_name, sc);
   if (status != GRPC_SECURITY_OK) {
     return status;
   }
@@ -125,8 +122,7 @@ struct grpc_ssl_server_credentials_options {
   grpc_ssl_server_certificate_config_fetcher* certificate_config_fetcher;
 };
 
-static void ssl_server_destruct(grpc_exec_ctx* exec_ctx,
-                                grpc_server_credentials* creds) {
+static void ssl_server_destruct(grpc_server_credentials* creds) {
   grpc_ssl_server_credentials* c = (grpc_ssl_server_credentials*)creds;
   grpc_tsi_ssl_pem_key_cert_pairs_destroy(c->config.pem_key_cert_pairs,
                                           c->config.num_key_cert_pairs);
@@ -134,9 +130,8 @@ static void ssl_server_destruct(grpc_exec_ctx* exec_ctx,
 }
 
 static grpc_security_status ssl_server_create_security_connector(
-    grpc_exec_ctx* exec_ctx, grpc_server_credentials* creds,
-    grpc_server_security_connector** sc) {
-  return grpc_ssl_server_security_connector_create(exec_ctx, creds, sc);
+    grpc_server_credentials* creds, grpc_server_security_connector** sc) {
+  return grpc_ssl_server_security_connector_create(creds, sc);
 }
 
 static grpc_server_credentials_vtable ssl_server_vtable = {

data/src/core/lib/security/credentials/ssl/ssl_credentials.h

@@ -20,10 +20,6 @@
 
 #include "src/core/lib/security/credentials/credentials.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 typedef struct {
   grpc_channel_credentials base;
   grpc_ssl_config config;
@@ -53,8 +49,4 @@ tsi_ssl_pem_key_cert_pair* grpc_convert_grpc_to_tsi_cert_pairs(
 void grpc_tsi_ssl_pem_key_cert_pairs_destroy(tsi_ssl_pem_key_cert_pair* kp,
                                              size_t num_key_cert_pairs);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_SECURITY_CREDENTIALS_SSL_SSL_CREDENTIALS_H */

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

@@ -22,10 +22,6 @@
 #include <grpc/grpc_security.h>
 #include "src/core/lib/channel/channel_stack.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 extern const grpc_channel_filter grpc_client_auth_filter;
 extern const grpc_channel_filter grpc_server_auth_filter;
 
@@ -36,8 +32,4 @@ void grpc_auth_metadata_context_build(
 
 void grpc_auth_metadata_context_reset(grpc_auth_metadata_context* context);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_SECURITY_TRANSPORT_AUTH_FILTERS_H */

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

@@ -25,20 +25,21 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/security/context/security_context.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/transport/security_connector.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/lib/surface/call.h"
 #include "src/core/lib/transport/static_metadata.h"
 
 #define MAX_CREDENTIALS_METADATA_COUNT 4
 
+namespace {
 /* We can have a per-call credentials. */
-typedef struct {
+struct call_data {
   grpc_call_stack* owning_call;
   grpc_call_combiner* call_combiner;
   grpc_call_credentials* creds;
@@ -57,13 +58,14 @@ typedef struct {
   grpc_closure async_result_closure;
   grpc_closure check_call_host_cancel_closure;
   grpc_closure get_request_metadata_cancel_closure;
-} call_data;
+};
 
 /* We can have a per-channel credentials. */
-typedef struct {
+struct channel_data {
   grpc_channel_security_connector* security_connector;
   grpc_auth_context* auth_context;
-} channel_data;
+};
+}  // namespace
 
 void grpc_auth_metadata_context_reset(
     grpc_auth_metadata_context* auth_md_context) {
@@ -90,8 +92,7 @@ static void add_error(grpc_error** combined, grpc_error* error) {
   *combined = grpc_error_add_child(*combined, error);
 }
 
-static void on_credentials_metadata(grpc_exec_ctx* exec_ctx, void* arg,
-                                    grpc_error* input_error) {
+static void on_credentials_metadata(void* arg, grpc_error* input_error) {
   grpc_transport_stream_op_batch* batch = (grpc_transport_stream_op_batch*)arg;
   grpc_call_element* elem =
       (grpc_call_element*)batch->handler_private.extra_arg;
@@ -105,16 +106,16 @@ static void on_credentials_metadata(grpc_exec_ctx* exec_ctx, void* arg,
         batch->payload->send_initial_metadata.send_initial_metadata;
     for (size_t i = 0; i < calld->md_array.size; ++i) {
       add_error(&error, grpc_metadata_batch_add_tail(
-                            exec_ctx, mdb, &calld->md_links[i],
+                            mdb, &calld->md_links[i],
                             GRPC_MDELEM_REF(calld->md_array.md[i])));
     }
   }
   if (error == GRPC_ERROR_NONE) {
-    grpc_call_next_op(exec_ctx, elem, batch);
+    grpc_call_next_op(elem, batch);
   } else {
     error = grpc_error_set_int(error, GRPC_ERROR_INT_GRPC_STATUS,
-                               GRPC_STATUS_UNAUTHENTICATED);
-    grpc_transport_stream_op_batch_finish_with_failure(exec_ctx, batch, error,
+                               GRPC_STATUS_UNAVAILABLE);
+    grpc_transport_stream_op_batch_finish_with_failure(batch, error,
                                                        calld->call_combiner);
   }
 }
@@ -156,20 +157,17 @@ void grpc_auth_metadata_context_build(
   gpr_free(host_and_port);
 }
 
-static void cancel_get_request_metadata(grpc_exec_ctx* exec_ctx, void* arg,
-                                        grpc_error* error) {
+static void cancel_get_request_metadata(void* arg, grpc_error* error) {
   grpc_call_element* elem = (grpc_call_element*)arg;
   call_data* calld = (call_data*)elem->call_data;
   if (error != GRPC_ERROR_NONE) {
     grpc_call_credentials_cancel_get_request_metadata(
-        exec_ctx, calld->creds, &calld->md_array, GRPC_ERROR_REF(error));
+        calld->creds, &calld->md_array, GRPC_ERROR_REF(error));
   }
-  GRPC_CALL_STACK_UNREF(exec_ctx, calld->owning_call,
-                        "cancel_get_request_metadata");
+  GRPC_CALL_STACK_UNREF(calld->owning_call, "cancel_get_request_metadata");
 }
 
-static void send_security_metadata(grpc_exec_ctx* exec_ctx,
-                                   grpc_call_element* elem,
+static void send_security_metadata(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;
@@ -183,7 +181,7 @@ static void send_security_metadata(grpc_exec_ctx* exec_ctx,
 
   if (channel_call_creds == nullptr && !call_creds_has_md) {
     /* Skip sending metadata altogether. */
-    grpc_call_next_op(exec_ctx, elem, batch);
+    grpc_call_next_op(elem, batch);
     return;
   }
 
@@ -192,7 +190,7 @@ static void send_security_metadata(grpc_exec_ctx* exec_ctx,
                                                           ctx->creds, nullptr);
     if (calld->creds == nullptr) {
       grpc_transport_stream_op_batch_finish_with_failure(
-          exec_ctx, batch,
+          batch,
           grpc_error_set_int(
               GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                   "Incompatible credentials set on channel and call."),
@@ -215,30 +213,29 @@ static void send_security_metadata(grpc_exec_ctx* exec_ctx,
                     batch, grpc_schedule_on_exec_ctx);
   grpc_error* error = GRPC_ERROR_NONE;
   if (grpc_call_credentials_get_request_metadata(
-          exec_ctx, calld->creds, calld->pollent, calld->auth_md_context,
+          calld->creds, calld->pollent, calld->auth_md_context,
           &calld->md_array, &calld->async_result_closure, &error)) {
     // Synchronous return; invoke on_credentials_metadata() directly.
-    on_credentials_metadata(exec_ctx, batch, error);
+    on_credentials_metadata(batch, error);
     GRPC_ERROR_UNREF(error);
   } else {
     // Async return; register cancellation closure with call combiner.
     GRPC_CALL_STACK_REF(calld->owning_call, "cancel_get_request_metadata");
     grpc_call_combiner_set_notify_on_cancel(
-        exec_ctx, calld->call_combiner,
+        calld->call_combiner,
         GRPC_CLOSURE_INIT(&calld->get_request_metadata_cancel_closure,
                           cancel_get_request_metadata, elem,
                           grpc_schedule_on_exec_ctx));
   }
 }
 
-static void on_host_checked(grpc_exec_ctx* exec_ctx, void* arg,
-                            grpc_error* error) {
+static void on_host_checked(void* arg, grpc_error* error) {
   grpc_transport_stream_op_batch* batch = (grpc_transport_stream_op_batch*)arg;
   grpc_call_element* elem =
       (grpc_call_element*)batch->handler_private.extra_arg;
   call_data* calld = (call_data*)elem->call_data;
   if (error == GRPC_ERROR_NONE) {
-    send_security_metadata(exec_ctx, elem, batch);
+    send_security_metadata(elem, batch);
   } else {
     char* error_msg;
     char* host = grpc_slice_to_c_string(calld->host);
@@ -246,7 +243,7 @@ static void on_host_checked(grpc_exec_ctx* exec_ctx, void* arg,
                  host);
     gpr_free(host);
     grpc_transport_stream_op_batch_finish_with_failure(
-        exec_ctx, batch,
+        batch,
         grpc_error_set_int(GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg),
                            GRPC_ERROR_INT_GRPC_STATUS,
                            GRPC_STATUS_UNAUTHENTICATED),
@@ -255,22 +252,20 @@ static void on_host_checked(grpc_exec_ctx* exec_ctx, void* arg,
   }
 }
 
-static void cancel_check_call_host(grpc_exec_ctx* exec_ctx, void* arg,
-                                   grpc_error* error) {
+static void cancel_check_call_host(void* arg, grpc_error* error) {
   grpc_call_element* elem = (grpc_call_element*)arg;
   call_data* calld = (call_data*)elem->call_data;
   channel_data* chand = (channel_data*)elem->channel_data;
   if (error != GRPC_ERROR_NONE) {
     grpc_channel_security_connector_cancel_check_call_host(
-        exec_ctx, chand->security_connector, &calld->async_result_closure,
+        chand->security_connector, &calld->async_result_closure,
         GRPC_ERROR_REF(error));
   }
-  GRPC_CALL_STACK_UNREF(exec_ctx, calld->owning_call, "cancel_check_call_host");
+  GRPC_CALL_STACK_UNREF(calld->owning_call, "cancel_check_call_host");
 }
 
 static void auth_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) {
   GPR_TIMER_BEGIN("auth_start_transport_stream_op_batch", 0);
 
   /* grab pointers to our data from the call element */
@@ -303,13 +298,13 @@ static void auth_start_transport_stream_op_batch(
        */
       if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_AUTHORITY)) {
         if (calld->have_host) {
-          grpc_slice_unref_internal(exec_ctx, calld->host);
+          grpc_slice_unref_internal(calld->host);
         }
         calld->host = grpc_slice_ref_internal(GRPC_MDVALUE(md));
         calld->have_host = true;
       } else if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_PATH)) {
         if (calld->have_method) {
-          grpc_slice_unref_internal(exec_ctx, calld->method);
+          grpc_slice_unref_internal(calld->method);
         }
         calld->method = grpc_slice_ref_internal(GRPC_MDVALUE(md));
         calld->have_method = true;
@@ -322,16 +317,16 @@ static void auth_start_transport_stream_op_batch(
       char* call_host = grpc_slice_to_c_string(calld->host);
       grpc_error* error = GRPC_ERROR_NONE;
       if (grpc_channel_security_connector_check_call_host(
-              exec_ctx, chand->security_connector, call_host,
-              chand->auth_context, &calld->async_result_closure, &error)) {
+              chand->security_connector, call_host, chand->auth_context,
+              &calld->async_result_closure, &error)) {
         // Synchronous return; invoke on_host_checked() directly.
-        on_host_checked(exec_ctx, batch, error);
+        on_host_checked(batch, error);
         GRPC_ERROR_UNREF(error);
       } else {
         // Async return; register cancellation closure with call combiner.
         GRPC_CALL_STACK_REF(calld->owning_call, "cancel_check_call_host");
         grpc_call_combiner_set_notify_on_cancel(
-            exec_ctx, calld->call_combiner,
+            calld->call_combiner,
             GRPC_CLOSURE_INIT(&calld->check_call_host_cancel_closure,
                               cancel_check_call_host, elem,
                               grpc_schedule_on_exec_ctx));
@@ -343,13 +338,12 @@ static void auth_start_transport_stream_op_batch(
   }
 
   /* pass control down the stack */
-  grpc_call_next_op(exec_ctx, elem, batch);
+  grpc_call_next_op(elem, batch);
   GPR_TIMER_END("auth_start_transport_stream_op_batch", 0);
 }
 
 /* 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;
   calld->owning_call = args->call_stack;
@@ -357,32 +351,30 @@ static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
   return GRPC_ERROR_NONE;
 }
 
-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;
   calld->pollent = 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* ignored) {
   call_data* calld = (call_data*)elem->call_data;
-  grpc_credentials_mdelem_array_destroy(exec_ctx, &calld->md_array);
-  grpc_call_credentials_unref(exec_ctx, calld->creds);
+  grpc_credentials_mdelem_array_destroy(&calld->md_array);
+  grpc_call_credentials_unref(calld->creds);
   if (calld->have_host) {
-    grpc_slice_unref_internal(exec_ctx, calld->host);
+    grpc_slice_unref_internal(calld->host);
   }
   if (calld->have_method) {
-    grpc_slice_unref_internal(exec_ctx, calld->method);
+    grpc_slice_unref_internal(calld->method);
   }
   grpc_auth_metadata_context_reset(&calld->auth_md_context);
 }
 
 /* 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) {
   grpc_security_connector* sc =
       grpc_security_connector_find_in_args(args->channel_args);
@@ -415,13 +407,12 @@ 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) {
   /* grab pointers to our data from the channel element */
   channel_data* chand = (channel_data*)elem->channel_data;
   grpc_channel_security_connector* sc = chand->security_connector;
   if (sc != nullptr) {
-    GRPC_SECURITY_CONNECTOR_UNREF(exec_ctx, &sc->base, "client_auth_filter");
+    GRPC_SECURITY_CONNECTOR_UNREF(&sc->base, "client_auth_filter");
   }
   GRPC_AUTH_CONTEXT_UNREF(chand->auth_context, "client_auth_filter");
 }