grpc 1.8.7 → 1.9.0.pre1

data/src/core/lib/http/httpcli_security_connector.cc

@@ -26,9 +26,9 @@
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/handshaker_registry.h"
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/security/transport/security_handshaker.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/support/string.h"
 #include "src/core/tsi/ssl_transport_security.h"
 #include "src/core/tsi/transport_security_adapter.h"
 
@@ -38,8 +38,7 @@ typedef struct {
   char* secure_peer_name;
 } grpc_httpcli_ssl_channel_security_connector;
 
-static void httpcli_ssl_destroy(grpc_exec_ctx* exec_ctx,
-                                grpc_security_connector* sc) {
+static void httpcli_ssl_destroy(grpc_security_connector* sc) {
   grpc_httpcli_ssl_channel_security_connector* c =
       (grpc_httpcli_ssl_channel_security_connector*)sc;
   if (c->handshaker_factory != nullptr) {
@@ -50,8 +49,7 @@ static void httpcli_ssl_destroy(grpc_exec_ctx* exec_ctx,
   gpr_free(sc);
 }
 
-static void httpcli_ssl_add_handshakers(grpc_exec_ctx* exec_ctx,
-                                        grpc_channel_security_connector* sc,
+static void httpcli_ssl_add_handshakers(grpc_channel_security_connector* sc,
                                         grpc_handshake_manager* handshake_mgr) {
   grpc_httpcli_ssl_channel_security_connector* c =
       (grpc_httpcli_ssl_channel_security_connector*)sc;
@@ -65,13 +63,11 @@ static void httpcli_ssl_add_handshakers(grpc_exec_ctx* exec_ctx,
     }
   }
   grpc_handshake_manager_add(
-      handshake_mgr,
-      grpc_security_handshaker_create(
-          exec_ctx, tsi_create_adapter_handshaker(handshaker), &sc->base));
+      handshake_mgr, grpc_security_handshaker_create(
+                         tsi_create_adapter_handshaker(handshaker), &sc->base));
 }
 
-static void httpcli_ssl_check_peer(grpc_exec_ctx* exec_ctx,
-                                   grpc_security_connector* sc, tsi_peer peer,
+static void httpcli_ssl_check_peer(grpc_security_connector* sc, tsi_peer peer,
                                    grpc_auth_context** auth_context,
                                    grpc_closure* on_peer_checked) {
   grpc_httpcli_ssl_channel_security_connector* c =
@@ -87,7 +83,7 @@ static void httpcli_ssl_check_peer(grpc_exec_ctx* exec_ctx,
     error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
     gpr_free(msg);
   }
-  GRPC_CLOSURE_SCHED(exec_ctx, on_peer_checked, error);
+  GRPC_CLOSURE_SCHED(on_peer_checked, error);
   tsi_peer_destruct(&peer);
 }
 
@@ -104,8 +100,8 @@ static grpc_security_connector_vtable httpcli_ssl_vtable = {
     httpcli_ssl_destroy, httpcli_ssl_check_peer, httpcli_ssl_cmp};
 
 static grpc_security_status httpcli_ssl_channel_security_connector_create(
-    grpc_exec_ctx* exec_ctx, const char* pem_root_certs,
-    const char* secure_peer_name, grpc_channel_security_connector** sc) {
+    const char* pem_root_certs, const char* secure_peer_name,
+    grpc_channel_security_connector** sc) {
   tsi_result result = TSI_OK;
   grpc_httpcli_ssl_channel_security_connector* c;
 
@@ -128,12 +124,12 @@ static grpc_security_status httpcli_ssl_channel_security_connector_create(
   if (result != TSI_OK) {
     gpr_log(GPR_ERROR, "Handshaker factory creation failed with %s.",
             tsi_result_to_string(result));
-    httpcli_ssl_destroy(exec_ctx, &c->base.base);
+    httpcli_ssl_destroy(&c->base.base);
     *sc = nullptr;
     return GRPC_SECURITY_ERROR;
   }
   // We don't actually need a channel credentials object in this case,
-  // but we set it to a non-NULL address so that we don't trigger
+  // but we set it to a non-nullptr address so that we don't trigger
   // assertions in grpc_channel_security_connector_cmp().
   c->base.channel_creds = (grpc_channel_credentials*)1;
   c->base.add_handshakers = httpcli_ssl_add_handshakers;
@@ -144,40 +140,37 @@ static grpc_security_status httpcli_ssl_channel_security_connector_create(
 /* handshaker */
 
 typedef struct {
-  void (*func)(grpc_exec_ctx* exec_ctx, void* arg, grpc_endpoint* endpoint);
+  void (*func)(void* arg, grpc_endpoint* endpoint);
   void* arg;
   grpc_handshake_manager* handshake_mgr;
 } on_done_closure;
 
-static void on_handshake_done(grpc_exec_ctx* exec_ctx, void* arg,
-                              grpc_error* error) {
+static void on_handshake_done(void* arg, grpc_error* error) {
   grpc_handshaker_args* args = (grpc_handshaker_args*)arg;
   on_done_closure* c = (on_done_closure*)args->user_data;
   if (error != GRPC_ERROR_NONE) {
     const char* msg = grpc_error_string(error);
     gpr_log(GPR_ERROR, "Secure transport setup failed: %s", msg);
 
-    c->func(exec_ctx, c->arg, nullptr);
+    c->func(c->arg, nullptr);
   } else {
-    grpc_channel_args_destroy(exec_ctx, args->args);
-    grpc_slice_buffer_destroy_internal(exec_ctx, args->read_buffer);
+    grpc_channel_args_destroy(args->args);
+    grpc_slice_buffer_destroy_internal(args->read_buffer);
     gpr_free(args->read_buffer);
-    c->func(exec_ctx, c->arg, args->endpoint);
+    c->func(c->arg, args->endpoint);
   }
-  grpc_handshake_manager_destroy(exec_ctx, c->handshake_mgr);
+  grpc_handshake_manager_destroy(c->handshake_mgr);
   gpr_free(c);
 }
 
-static void ssl_handshake(grpc_exec_ctx* exec_ctx, void* arg,
-                          grpc_endpoint* tcp, const char* host,
+static void ssl_handshake(void* arg, grpc_endpoint* tcp, const char* host,
                           grpc_millis deadline,
-                          void (*on_done)(grpc_exec_ctx* exec_ctx, void* arg,
-                                          grpc_endpoint* endpoint)) {
+                          void (*on_done)(void* arg, grpc_endpoint* endpoint)) {
   on_done_closure* c = (on_done_closure*)gpr_malloc(sizeof(*c));
   const char* pem_root_certs = grpc_get_default_ssl_roots();
   if (pem_root_certs == nullptr) {
     gpr_log(GPR_ERROR, "Could not get default pem root certs.");
-    on_done(exec_ctx, arg, nullptr);
+    on_done(arg, nullptr);
     gpr_free(c);
     return;
   }
@@ -185,15 +178,16 @@ static void ssl_handshake(grpc_exec_ctx* exec_ctx, void* arg,
   c->arg = arg;
   grpc_channel_security_connector* sc = nullptr;
   GPR_ASSERT(httpcli_ssl_channel_security_connector_create(
-                 exec_ctx, pem_root_certs, host, &sc) == GRPC_SECURITY_OK);
+                 pem_root_certs, host, &sc) == GRPC_SECURITY_OK);
   grpc_arg channel_arg = grpc_security_connector_to_arg(&sc->base);
   grpc_channel_args args = {1, &channel_arg};
   c->handshake_mgr = grpc_handshake_manager_create();
-  grpc_handshakers_add(exec_ctx, HANDSHAKER_CLIENT, &args, c->handshake_mgr);
+  grpc_handshakers_add(HANDSHAKER_CLIENT, &args, c->handshake_mgr);
   grpc_handshake_manager_do_handshake(
-      exec_ctx, c->handshake_mgr, tcp, nullptr /* channel_args */, deadline,
-      nullptr /* acceptor */, on_handshake_done, c /* user_data */);
-  GRPC_SECURITY_CONNECTOR_UNREF(exec_ctx, &sc->base, "httpcli");
+      c->handshake_mgr, nullptr /* interested_parties */, tcp,
+      nullptr /* channel_args */, deadline, nullptr /* acceptor */,
+      on_handshake_done, c /* user_data */);
+  GRPC_SECURITY_CONNECTOR_UNREF(&sc->base, "httpcli");
 }
 
 const grpc_httpcli_handshaker grpc_httpcli_ssl = {"https", ssl_handshake};

data/src/core/lib/http/parser.h

@@ -27,10 +27,6 @@
 /* Maximum length of a header string of the form 'Key: Value\r\n' */
 #define GRPC_HTTP_PARSER_MAX_HEADER_LENGTH 4096
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /* A single header to be passed in a request */
 typedef struct grpc_http_header {
   char* key;
@@ -113,8 +109,4 @@ void grpc_http_response_destroy(grpc_http_response* response);
 
 extern grpc_core::TraceFlag grpc_http1_trace;
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_HTTP_PARSER_H */

data/src/core/lib/iomgr/block_annotate.h

@@ -19,17 +19,9 @@
 #ifndef GRPC_CORE_LIB_IOMGR_BLOCK_ANNOTATE_H
 #define GRPC_CORE_LIB_IOMGR_BLOCK_ANNOTATE_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 void gpr_thd_start_blocking_region();
 void gpr_thd_end_blocking_region();
 
-#ifdef __cplusplus
-}
-#endif
-
 /* These annotations identify the beginning and end of regions where
    the code may block for reasons other than synchronization functions.
    These include poll, epoll, and getaddrinfo. */
@@ -39,26 +31,27 @@ void gpr_thd_end_blocking_region();
   do {                                        \
     gpr_thd_start_blocking_region();          \
   } while (0)
+#define GRPC_SCHEDULING_END_BLOCKING_REGION     \
+  do {                                          \
+    gpr_thd_end_blocking_region();              \
+    grpc_core::ExecCtx::Get()->InvalidateNow(); \
+  } while (0)
 #define GRPC_SCHEDULING_END_BLOCKING_REGION_NO_EXEC_CTX \
   do {                                                  \
     gpr_thd_end_blocking_region();                      \
   } while (0)
-#define GRPC_SCHEDULING_END_BLOCKING_REGION_WITH_EXEC_CTX(ec) \
-  do {                                                        \
-    gpr_thd_end_blocking_region();                            \
-    grpc_exec_ctx_invalidate_now((ec));                       \
-  } while (0)
+
 #else
 #define GRPC_SCHEDULING_START_BLOCKING_REGION \
   do {                                        \
   } while (0)
+#define GRPC_SCHEDULING_END_BLOCKING_REGION     \
+  do {                                          \
+    grpc_core::ExecCtx::Get()->InvalidateNow(); \
+  } while (0)
 #define GRPC_SCHEDULING_END_BLOCKING_REGION_NO_EXEC_CTX \
   do {                                                  \
   } while (0)
-#define GRPC_SCHEDULING_END_BLOCKING_REGION_WITH_EXEC_CTX(ec) \
-  do {                                                        \
-    grpc_exec_ctx_invalidate_now((ec));                       \
-  } while (0)
 #endif
 
 #endif /* GRPC_CORE_LIB_IOMGR_BLOCK_ANNOTATE_H */

data/src/core/lib/iomgr/call_combiner.cc

@@ -56,8 +56,7 @@ void grpc_call_combiner_destroy(grpc_call_combiner* call_combiner) {
 #define DEBUG_FMT_ARGS
 #endif
 
-void grpc_call_combiner_start(grpc_exec_ctx* exec_ctx,
-                              grpc_call_combiner* call_combiner,
+void grpc_call_combiner_start(grpc_call_combiner* call_combiner,
                               grpc_closure* closure,
                               grpc_error* error DEBUG_ARGS,
                               const char* reason) {
@@ -75,15 +74,16 @@ void grpc_call_combiner_start(grpc_exec_ctx* exec_ctx,
     gpr_log(GPR_DEBUG, "  size: %" PRIdPTR " -> %" PRIdPTR, prev_size,
             prev_size + 1);
   }
-  GRPC_STATS_INC_CALL_COMBINER_LOCKS_SCHEDULED_ITEMS(exec_ctx);
+  GRPC_STATS_INC_CALL_COMBINER_LOCKS_SCHEDULED_ITEMS();
   if (prev_size == 0) {
-    GRPC_STATS_INC_CALL_COMBINER_LOCKS_INITIATED(exec_ctx);
+    GRPC_STATS_INC_CALL_COMBINER_LOCKS_INITIATED();
+
     GPR_TIMER_MARK("call_combiner_initiate", 0);
     if (grpc_call_combiner_trace.enabled()) {
       gpr_log(GPR_DEBUG, "  EXECUTING IMMEDIATELY");
     }
     // Queue was empty, so execute this closure immediately.
-    GRPC_CLOSURE_SCHED(exec_ctx, closure, error);
+    GRPC_CLOSURE_SCHED(closure, error);
   } else {
     if (grpc_call_combiner_trace.enabled()) {
       gpr_log(GPR_INFO, "  QUEUING");
@@ -95,8 +95,7 @@ void grpc_call_combiner_start(grpc_exec_ctx* exec_ctx,
   GPR_TIMER_END("call_combiner_start", 0);
 }
 
-void grpc_call_combiner_stop(grpc_exec_ctx* exec_ctx,
-                             grpc_call_combiner* call_combiner DEBUG_ARGS,
+void grpc_call_combiner_stop(grpc_call_combiner* call_combiner DEBUG_ARGS,
                              const char* reason) {
   GPR_TIMER_BEGIN("call_combiner_stop", 0);
   if (grpc_call_combiner_trace.enabled()) {
@@ -131,7 +130,7 @@ void grpc_call_combiner_stop(grpc_exec_ctx* exec_ctx,
         gpr_log(GPR_DEBUG, "  EXECUTING FROM QUEUE: closure=%p error=%s",
                 closure, grpc_error_string(closure->error_data.error));
       }
-      GRPC_CLOSURE_SCHED(exec_ctx, closure, closure->error_data.error);
+      GRPC_CLOSURE_SCHED(closure, closure->error_data.error);
       break;
     }
   } else if (grpc_call_combiner_trace.enabled()) {
@@ -140,10 +139,9 @@ void grpc_call_combiner_stop(grpc_exec_ctx* exec_ctx,
   GPR_TIMER_END("call_combiner_stop", 0);
 }
 
-void grpc_call_combiner_set_notify_on_cancel(grpc_exec_ctx* exec_ctx,
-                                             grpc_call_combiner* call_combiner,
+void grpc_call_combiner_set_notify_on_cancel(grpc_call_combiner* call_combiner,
                                              grpc_closure* closure) {
-  GRPC_STATS_INC_CALL_COMBINER_SET_NOTIFY_ON_CANCEL(exec_ctx);
+  GRPC_STATS_INC_CALL_COMBINER_SET_NOTIFY_ON_CANCEL();
   while (true) {
     // Decode original state.
     gpr_atm original_state = gpr_atm_acq_load(&call_combiner->cancel_state);
@@ -157,7 +155,7 @@ void grpc_call_combiner_set_notify_on_cancel(grpc_exec_ctx* exec_ctx,
                 "for pre-existing cancellation",
                 call_combiner, closure);
       }
-      GRPC_CLOSURE_SCHED(exec_ctx, closure, GRPC_ERROR_REF(original_error));
+      GRPC_CLOSURE_SCHED(closure, GRPC_ERROR_REF(original_error));
       break;
     } else {
       if (gpr_atm_full_cas(&call_combiner->cancel_state, original_state,
@@ -176,7 +174,7 @@ void grpc_call_combiner_set_notify_on_cancel(grpc_exec_ctx* exec_ctx,
                     "call_combiner=%p: scheduling old cancel callback=%p",
                     call_combiner, closure);
           }
-          GRPC_CLOSURE_SCHED(exec_ctx, closure, GRPC_ERROR_NONE);
+          GRPC_CLOSURE_SCHED(closure, GRPC_ERROR_NONE);
         }
         break;
       }
@@ -185,10 +183,9 @@ void grpc_call_combiner_set_notify_on_cancel(grpc_exec_ctx* exec_ctx,
   }
 }
 
-void grpc_call_combiner_cancel(grpc_exec_ctx* exec_ctx,
-                               grpc_call_combiner* call_combiner,
+void grpc_call_combiner_cancel(grpc_call_combiner* call_combiner,
                                grpc_error* error) {
-  GRPC_STATS_INC_CALL_COMBINER_CANCELLED(exec_ctx);
+  GRPC_STATS_INC_CALL_COMBINER_CANCELLED();
   while (true) {
     gpr_atm original_state = gpr_atm_acq_load(&call_combiner->cancel_state);
     grpc_error* original_error = decode_cancel_state_error(original_state);
@@ -205,7 +202,7 @@ void grpc_call_combiner_cancel(grpc_exec_ctx* exec_ctx,
                   "call_combiner=%p: scheduling notify_on_cancel callback=%p",
                   call_combiner, notify_on_cancel);
         }
-        GRPC_CLOSURE_SCHED(exec_ctx, notify_on_cancel, GRPC_ERROR_REF(error));
+        GRPC_CLOSURE_SCHED(notify_on_cancel, GRPC_ERROR_REF(error));
       }
       break;
     }

data/src/core/lib/iomgr/call_combiner.h

@@ -23,13 +23,9 @@
 
 #include <grpc/support/atm.h>
 
+#include "src/core/lib/gpr/mpscq.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/support/mpscq.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
 
 // A simple, lock-free mechanism for serializing activity related to a
 // single call.  This is similar to a combiner but is more lightweight.
@@ -57,37 +53,29 @@ void grpc_call_combiner_init(grpc_call_combiner* call_combiner);
 void grpc_call_combiner_destroy(grpc_call_combiner* call_combiner);
 
 #ifndef NDEBUG
-#define GRPC_CALL_COMBINER_START(exec_ctx, call_combiner, closure, error,   \
-                                 reason)                                    \
-  grpc_call_combiner_start((exec_ctx), (call_combiner), (closure), (error), \
-                           __FILE__, __LINE__, (reason))
-#define GRPC_CALL_COMBINER_STOP(exec_ctx, call_combiner, reason)           \
-  grpc_call_combiner_stop((exec_ctx), (call_combiner), __FILE__, __LINE__, \
-                          (reason))
+#define GRPC_CALL_COMBINER_START(call_combiner, closure, error, reason)   \
+  grpc_call_combiner_start((call_combiner), (closure), (error), __FILE__, \
+                           __LINE__, (reason))
+#define GRPC_CALL_COMBINER_STOP(call_combiner, reason) \
+  grpc_call_combiner_stop((call_combiner), __FILE__, __LINE__, (reason))
 /// Starts processing \a closure on \a call_combiner.
-void grpc_call_combiner_start(grpc_exec_ctx* exec_ctx,
-                              grpc_call_combiner* call_combiner,
+void grpc_call_combiner_start(grpc_call_combiner* call_combiner,
                               grpc_closure* closure, grpc_error* error,
                               const char* file, int line, const char* reason);
 /// Yields the call combiner to the next closure in the queue, if any.
-void grpc_call_combiner_stop(grpc_exec_ctx* exec_ctx,
-                             grpc_call_combiner* call_combiner,
+void grpc_call_combiner_stop(grpc_call_combiner* call_combiner,
                              const char* file, int line, const char* reason);
 #else
-#define GRPC_CALL_COMBINER_START(exec_ctx, call_combiner, closure, error,   \
-                                 reason)                                    \
-  grpc_call_combiner_start((exec_ctx), (call_combiner), (closure), (error), \
-                           (reason))
-#define GRPC_CALL_COMBINER_STOP(exec_ctx, call_combiner, reason) \
-  grpc_call_combiner_stop((exec_ctx), (call_combiner), (reason))
+#define GRPC_CALL_COMBINER_START(call_combiner, closure, error, reason) \
+  grpc_call_combiner_start((call_combiner), (closure), (error), (reason))
+#define GRPC_CALL_COMBINER_STOP(call_combiner, reason) \
+  grpc_call_combiner_stop((call_combiner), (reason))
 /// Starts processing \a closure on \a call_combiner.
-void grpc_call_combiner_start(grpc_exec_ctx* exec_ctx,
-                              grpc_call_combiner* call_combiner,
+void grpc_call_combiner_start(grpc_call_combiner* call_combiner,
                               grpc_closure* closure, grpc_error* error,
                               const char* reason);
 /// Yields the call combiner to the next closure in the queue, if any.
-void grpc_call_combiner_stop(grpc_exec_ctx* exec_ctx,
-                             grpc_call_combiner* call_combiner,
+void grpc_call_combiner_stop(grpc_call_combiner* call_combiner,
                              const char* reason);
 #endif
 
@@ -113,17 +101,11 @@ void grpc_call_combiner_stop(grpc_exec_ctx* exec_ctx,
 /// cancellation; this effectively unregisters the previously set closure.
 /// However, most filters will not need to explicitly unregister their
 /// callbacks, as this is done automatically when the call is destroyed.
-void grpc_call_combiner_set_notify_on_cancel(grpc_exec_ctx* exec_ctx,
-                                             grpc_call_combiner* call_combiner,
+void grpc_call_combiner_set_notify_on_cancel(grpc_call_combiner* call_combiner,
                                              grpc_closure* closure);
 
 /// Indicates that the call has been cancelled.
-void grpc_call_combiner_cancel(grpc_exec_ctx* exec_ctx,
-                               grpc_call_combiner* call_combiner,
+void grpc_call_combiner_cancel(grpc_call_combiner* call_combiner,
                                grpc_error* error);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_IOMGR_CALL_COMBINER_H */

data/src/core/lib/iomgr/closure.h

@@ -22,13 +22,12 @@
 #include <grpc/support/port_platform.h>
 
 #include <assert.h>
-#include <grpc/impl/codegen/exec_ctx_fwd.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <stdbool.h>
+#include "src/core/lib/gpr/mpscq.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/profiling/timers.h"
-#include "src/core/lib/support/mpscq.h"
 
 struct grpc_closure;
 typedef struct grpc_closure grpc_closure;
@@ -47,18 +46,15 @@ typedef struct grpc_closure_list {
  *              describing what went wrong.
  *              Error contract: it is not the cb's job to unref this error;
  *              the closure scheduler will do that after the cb returns */
-typedef void (*grpc_iomgr_cb_func)(grpc_exec_ctx* exec_ctx, void* arg,
-                                   grpc_error* error);
+typedef void (*grpc_iomgr_cb_func)(void* arg, grpc_error* error);
 
 typedef struct grpc_closure_scheduler grpc_closure_scheduler;
 
 typedef struct grpc_closure_scheduler_vtable {
   /* NOTE: for all these functions, closure->scheduler == the scheduler that was
            used to find this vtable */
-  void (*run)(grpc_exec_ctx* exec_ctx, grpc_closure* closure,
-              grpc_error* error);
-  void (*sched)(grpc_exec_ctx* exec_ctx, grpc_closure* closure,
-                grpc_error* error);
+  void (*run)(grpc_closure* closure, grpc_error* error);
+  void (*sched)(grpc_closure* closure, grpc_error* error);
   const char* name;
 } grpc_closure_scheduler_vtable;
 
@@ -146,13 +142,12 @@ typedef struct {
   grpc_closure wrapper;
 } wrapped_closure;
 
-inline void closure_wrapper(grpc_exec_ctx* exec_ctx, void* arg,
-                            grpc_error* error) {
+inline void closure_wrapper(void* arg, grpc_error* error) {
   wrapped_closure* wc = (wrapped_closure*)arg;
   grpc_iomgr_cb_func cb = wc->cb;
   void* cb_arg = wc->cb_arg;
   gpr_free(wc);
-  cb(exec_ctx, cb_arg, error);
+  cb(cb_arg, error);
 }
 
 }  // namespace closure_impl
@@ -247,12 +242,10 @@ inline bool grpc_closure_list_empty(grpc_closure_list closure_list) {
 }
 
 #ifndef NDEBUG
-inline void grpc_closure_run(const char* file, int line,
-                             grpc_exec_ctx* exec_ctx, grpc_closure* c,
+inline void grpc_closure_run(const char* file, int line, grpc_closure* c,
                              grpc_error* error) {
 #else
-inline void grpc_closure_run(grpc_exec_ctx* exec_ctx, grpc_closure* c,
-                             grpc_error* error) {
+inline void grpc_closure_run(grpc_closure* c, grpc_error* error) {
 #endif
   GPR_TIMER_BEGIN("grpc_closure_run", 0);
   if (c != nullptr) {
@@ -262,7 +255,7 @@ inline void grpc_closure_run(grpc_exec_ctx* exec_ctx, grpc_closure* c,
     c->run = true;
 #endif
     assert(c->cb);
-    c->scheduler->vtable->run(exec_ctx, c, error);
+    c->scheduler->vtable->run(c, error);
   } else {
     GRPC_ERROR_UNREF(error);
   }
@@ -273,20 +266,17 @@ inline void grpc_closure_run(grpc_exec_ctx* exec_ctx, grpc_closure* c,
  *  Note that calling this at the end of a closure callback function itself is
  *  by definition safe. */
 #ifndef NDEBUG
-#define GRPC_CLOSURE_RUN(exec_ctx, closure, error) \
-  grpc_closure_run(__FILE__, __LINE__, exec_ctx, closure, error)
+#define GRPC_CLOSURE_RUN(closure, error) \
+  grpc_closure_run(__FILE__, __LINE__, closure, error)
 #else
-#define GRPC_CLOSURE_RUN(exec_ctx, closure, error) \
-  grpc_closure_run(exec_ctx, closure, error)
+#define GRPC_CLOSURE_RUN(closure, error) grpc_closure_run(closure, error)
 #endif
 
 #ifndef NDEBUG
-inline void grpc_closure_sched(const char* file, int line,
-                               grpc_exec_ctx* exec_ctx, grpc_closure* c,
+inline void grpc_closure_sched(const char* file, int line, grpc_closure* c,
                                grpc_error* error) {
 #else
-inline void grpc_closure_sched(grpc_exec_ctx* exec_ctx, grpc_closure* c,
-                               grpc_error* error) {
+inline void grpc_closure_sched(grpc_closure* c, grpc_error* error) {
 #endif
   GPR_TIMER_BEGIN("grpc_closure_sched", 0);
   if (c != nullptr) {
@@ -305,7 +295,7 @@ inline void grpc_closure_sched(grpc_exec_ctx* exec_ctx, grpc_closure* c,
     c->run = false;
 #endif
     assert(c->cb);
-    c->scheduler->vtable->sched(exec_ctx, c, error);
+    c->scheduler->vtable->sched(c, error);
   } else {
     GRPC_ERROR_UNREF(error);
   }
@@ -314,20 +304,17 @@ inline void grpc_closure_sched(grpc_exec_ctx* exec_ctx, grpc_closure* c,
 
 /** Schedule a closure to be run. Does not need to be run from a safe point. */
 #ifndef NDEBUG
-#define GRPC_CLOSURE_SCHED(exec_ctx, closure, error) \
-  grpc_closure_sched(__FILE__, __LINE__, exec_ctx, closure, error)
+#define GRPC_CLOSURE_SCHED(closure, error) \
+  grpc_closure_sched(__FILE__, __LINE__, closure, error)
 #else
-#define GRPC_CLOSURE_SCHED(exec_ctx, closure, error) \
-  grpc_closure_sched(exec_ctx, closure, error)
+#define GRPC_CLOSURE_SCHED(closure, error) grpc_closure_sched(closure, error)
 #endif
 
 #ifndef NDEBUG
 inline void grpc_closure_list_sched(const char* file, int line,
-                                    grpc_exec_ctx* exec_ctx,
                                     grpc_closure_list* list) {
 #else
-inline void grpc_closure_list_sched(grpc_exec_ctx* exec_ctx,
-                                    grpc_closure_list* list) {
+inline void grpc_closure_list_sched(grpc_closure_list* list) {
 #endif
   grpc_closure* c = list->head;
   while (c != nullptr) {
@@ -347,7 +334,7 @@ inline void grpc_closure_list_sched(grpc_exec_ctx* exec_ctx,
     c->run = false;
 #endif
     assert(c->cb);
-    c->scheduler->vtable->sched(exec_ctx, c, c->error_data.error);
+    c->scheduler->vtable->sched(c, c->error_data.error);
     c = next;
   }
   list->head = list->tail = nullptr;
@@ -356,11 +343,11 @@ inline void grpc_closure_list_sched(grpc_exec_ctx* exec_ctx,
 /** Schedule all closures in a list to be run. Does not need to be run from a
  * safe point. */
 #ifndef NDEBUG
-#define GRPC_CLOSURE_LIST_SCHED(exec_ctx, closure_list) \
-  grpc_closure_list_sched(__FILE__, __LINE__, exec_ctx, closure_list)
+#define GRPC_CLOSURE_LIST_SCHED(closure_list) \
+  grpc_closure_list_sched(__FILE__, __LINE__, closure_list)
 #else
-#define GRPC_CLOSURE_LIST_SCHED(exec_ctx, closure_list) \
-  grpc_closure_list_sched(exec_ctx, closure_list)
+#define GRPC_CLOSURE_LIST_SCHED(closure_list) \
+  grpc_closure_list_sched(closure_list)
 #endif
 
 #endif /* GRPC_CORE_LIB_IOMGR_CLOSURE_H */