grpc 1.8.7 → 1.9.0.pre1

data/src/core/lib/surface/call.h

@@ -19,10 +19,6 @@
 #ifndef GRPC_CORE_LIB_SURFACE_CALL_H
 #define GRPC_CORE_LIB_SURFACE_CALL_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/surface/api_trace.h"
@@ -30,8 +26,7 @@ extern "C" {
 #include <grpc/grpc.h>
 #include <grpc/impl/codegen/compression_types.h>
 
-typedef void (*grpc_ioreq_completion_func)(grpc_exec_ctx* exec_ctx,
-                                           grpc_call* call, int success,
+typedef void (*grpc_ioreq_completion_func)(grpc_call* call, int success,
                                            void* user_data);
 
 typedef struct grpc_call_create_args {
@@ -55,33 +50,28 @@ typedef struct grpc_call_create_args {
 /* Create a new call based on \a args.
    Regardless of success or failure, always returns a valid new call into *call
    */
-grpc_error* grpc_call_create(grpc_exec_ctx* exec_ctx,
-                             const grpc_call_create_args* args,
+grpc_error* grpc_call_create(const grpc_call_create_args* args,
                              grpc_call** call);
 
-void grpc_call_set_completion_queue(grpc_exec_ctx* exec_ctx, grpc_call* call,
-                                    grpc_completion_queue* cq);
+void grpc_call_set_completion_queue(grpc_call* call, grpc_completion_queue* cq);
 
 #ifndef NDEBUG
 void grpc_call_internal_ref(grpc_call* call, const char* reason);
-void grpc_call_internal_unref(grpc_exec_ctx* exec_ctx, grpc_call* call,
-                              const char* reason);
+void grpc_call_internal_unref(grpc_call* call, const char* reason);
 #define GRPC_CALL_INTERNAL_REF(call, reason) \
   grpc_call_internal_ref(call, reason)
-#define GRPC_CALL_INTERNAL_UNREF(exec_ctx, call, reason) \
-  grpc_call_internal_unref(exec_ctx, call, reason)
+#define GRPC_CALL_INTERNAL_UNREF(call, reason) \
+  grpc_call_internal_unref(call, reason)
 #else
 void grpc_call_internal_ref(grpc_call* call);
-void grpc_call_internal_unref(grpc_exec_ctx* exec_ctx, grpc_call* call);
+void grpc_call_internal_unref(grpc_call* call);
 #define GRPC_CALL_INTERNAL_REF(call, reason) grpc_call_internal_ref(call)
-#define GRPC_CALL_INTERNAL_UNREF(exec_ctx, call, reason) \
-  grpc_call_internal_unref(exec_ctx, call)
+#define GRPC_CALL_INTERNAL_UNREF(call, reason) grpc_call_internal_unref(call)
 #endif
 
 grpc_call_stack* grpc_call_get_call_stack(grpc_call* call);
 
-grpc_call_error grpc_call_start_batch_and_execute(grpc_exec_ctx* exec_ctx,
-                                                  grpc_call* call,
+grpc_call_error grpc_call_start_batch_and_execute(grpc_call* call,
                                                   const grpc_op* ops,
                                                   size_t nops,
                                                   grpc_closure* closure);
@@ -114,8 +104,4 @@ grpc_compression_algorithm grpc_call_compression_for_level(
 extern grpc_core::TraceFlag grpc_call_error_trace;
 extern grpc_core::TraceFlag grpc_compression_trace;
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_SURFACE_CALL_H */

data/src/core/lib/surface/call_details.cc

@@ -34,8 +34,7 @@ void grpc_call_details_init(grpc_call_details* cd) {
 
 void grpc_call_details_destroy(grpc_call_details* cd) {
   GRPC_API_TRACE("grpc_call_details_destroy(cd=%p)", 1, (cd));
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_slice_unref_internal(&exec_ctx, cd->method);
-  grpc_slice_unref_internal(&exec_ctx, cd->host);
-  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_core::ExecCtx exec_ctx;
+  grpc_slice_unref_internal(cd->method);
+  grpc_slice_unref_internal(cd->host);
 }

data/src/core/lib/surface/call_log_batch.cc

@@ -22,8 +22,8 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
-#include "src/core/lib/support/string.h"
 
 static void add_metadata(gpr_strvec* b, const grpc_metadata* md, size_t count) {
   size_t i;

data/src/core/lib/surface/call_test_only.h

@@ -21,10 +21,6 @@
 
 #include <grpc/grpc.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /** Return the compression algorithm from \a call.
  *
  * \warning This function should \b only be used in test code. */
@@ -54,8 +50,4 @@ uint32_t grpc_call_test_only_get_stream_encodings_accepted_by_peer(
 grpc_stream_compression_algorithm
 grpc_call_test_only_get_incoming_stream_encodings(grpc_call* call);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_SURFACE_CALL_TEST_ONLY_H */

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

@@ -29,9 +29,9 @@
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/stats.h"
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/support/string.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel_init.h"
@@ -69,23 +69,22 @@ struct grpc_channel {
 #define CHANNEL_FROM_TOP_ELEM(top_elem) \
   CHANNEL_FROM_CHANNEL_STACK(grpc_channel_stack_from_top_element(top_elem))
 
-static void destroy_channel(grpc_exec_ctx* exec_ctx, void* arg,
-                            grpc_error* error);
+static void destroy_channel(void* arg, grpc_error* error);
 
 grpc_channel* grpc_channel_create_with_builder(
-    grpc_exec_ctx* exec_ctx, grpc_channel_stack_builder* builder,
+    grpc_channel_stack_builder* builder,
     grpc_channel_stack_type channel_stack_type) {
   char* target = gpr_strdup(grpc_channel_stack_builder_get_target(builder));
   grpc_channel_args* args = grpc_channel_args_copy(
       grpc_channel_stack_builder_get_channel_arguments(builder));
   grpc_channel* channel;
   if (channel_stack_type == GRPC_SERVER_CHANNEL) {
-    GRPC_STATS_INC_SERVER_CHANNELS_CREATED(exec_ctx);
+    GRPC_STATS_INC_SERVER_CHANNELS_CREATED();
   } else {
-    GRPC_STATS_INC_CLIENT_CHANNELS_CREATED(exec_ctx);
+    GRPC_STATS_INC_CLIENT_CHANNELS_CREATED();
   }
   grpc_error* error = grpc_channel_stack_builder_finish(
-      exec_ctx, builder, sizeof(grpc_channel), 1, destroy_channel, nullptr,
+      builder, sizeof(grpc_channel), 1, destroy_channel, nullptr,
       (void**)&channel);
   if (error != GRPC_ERROR_NONE) {
     gpr_log(GPR_ERROR, "channel stack builder failed: %s",
@@ -114,10 +113,10 @@ grpc_channel* grpc_channel_create_with_builder(
       } else {
         if (!GRPC_MDISNULL(channel->default_authority)) {
           /* setting this takes precedence over anything else */
-          GRPC_MDELEM_UNREF(exec_ctx, channel->default_authority);
+          GRPC_MDELEM_UNREF(channel->default_authority);
         }
         channel->default_authority = grpc_mdelem_from_slices(
-            exec_ctx, GRPC_MDSTR_AUTHORITY,
+            GRPC_MDSTR_AUTHORITY,
             grpc_slice_intern(
                 grpc_slice_from_static_string(args->args[i].value.string)));
       }
@@ -134,7 +133,7 @@ grpc_channel* grpc_channel_create_with_builder(
                   GRPC_SSL_TARGET_NAME_OVERRIDE_ARG);
         } else {
           channel->default_authority = grpc_mdelem_from_slices(
-              exec_ctx, GRPC_MDSTR_AUTHORITY,
+              GRPC_MDSTR_AUTHORITY,
               grpc_slice_intern(
                   grpc_slice_from_static_string(args->args[i].value.string)));
         }
@@ -191,25 +190,23 @@ grpc_channel* grpc_channel_create_with_builder(
   }
 
 done:
-  grpc_channel_args_destroy(exec_ctx, args);
+  grpc_channel_args_destroy(args);
   return channel;
 }
 
-grpc_channel* grpc_channel_create(grpc_exec_ctx* exec_ctx, const char* target,
+grpc_channel* grpc_channel_create(const char* target,
                                   const grpc_channel_args* input_args,
                                   grpc_channel_stack_type channel_stack_type,
                                   grpc_transport* optional_transport) {
   grpc_channel_stack_builder* builder = grpc_channel_stack_builder_create();
-  grpc_channel_stack_builder_set_channel_arguments(exec_ctx, builder,
-                                                   input_args);
+  grpc_channel_stack_builder_set_channel_arguments(builder, input_args);
   grpc_channel_stack_builder_set_target(builder, target);
   grpc_channel_stack_builder_set_transport(builder, optional_transport);
-  if (!grpc_channel_init_create_stack(exec_ctx, builder, channel_stack_type)) {
-    grpc_channel_stack_builder_destroy(exec_ctx, builder);
+  if (!grpc_channel_init_create_stack(builder, channel_stack_type)) {
+    grpc_channel_stack_builder_destroy(builder);
     return nullptr;
   }
-  return grpc_channel_create_with_builder(exec_ctx, builder,
-                                          channel_stack_type);
+  return grpc_channel_create_with_builder(builder, channel_stack_type);
 }
 
 size_t grpc_channel_get_call_size_estimate(grpc_channel* channel) {
@@ -251,18 +248,17 @@ char* grpc_channel_get_target(grpc_channel* channel) {
 
 void grpc_channel_get_info(grpc_channel* channel,
                            const grpc_channel_info* channel_info) {
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_core::ExecCtx exec_ctx;
   grpc_channel_element* elem =
       grpc_channel_stack_element(CHANNEL_STACK_FROM_CHANNEL(channel), 0);
-  elem->filter->get_channel_info(&exec_ctx, elem, channel_info);
-  grpc_exec_ctx_finish(&exec_ctx);
+  elem->filter->get_channel_info(elem, channel_info);
 }
 
 static grpc_call* grpc_channel_create_call_internal(
-    grpc_exec_ctx* exec_ctx, grpc_channel* channel, grpc_call* parent_call,
-    uint32_t propagation_mask, grpc_completion_queue* cq,
-    grpc_pollset_set* pollset_set_alternative, grpc_mdelem path_mdelem,
-    grpc_mdelem authority_mdelem, grpc_millis deadline) {
+    grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
+    grpc_completion_queue* cq, grpc_pollset_set* pollset_set_alternative,
+    grpc_mdelem path_mdelem, grpc_mdelem authority_mdelem,
+    grpc_millis deadline) {
   grpc_mdelem send_metadata[2];
   size_t num_metadata = 0;
 
@@ -289,7 +285,7 @@ static grpc_call* grpc_channel_create_call_internal(
   args.send_deadline = deadline;
 
   grpc_call* call;
-  GRPC_LOG_IF_ERROR("call_create", grpc_call_create(exec_ctx, &args, &call));
+  GRPC_LOG_IF_ERROR("call_create", grpc_call_create(&args, &call));
   return call;
 }
 
@@ -300,29 +296,27 @@ grpc_call* grpc_channel_create_call(grpc_channel* channel,
                                     grpc_slice method, const grpc_slice* host,
                                     gpr_timespec deadline, void* reserved) {
   GPR_ASSERT(!reserved);
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_core::ExecCtx exec_ctx;
   grpc_call* call = grpc_channel_create_call_internal(
-      &exec_ctx, channel, parent_call, propagation_mask, cq, nullptr,
-      grpc_mdelem_from_slices(&exec_ctx, GRPC_MDSTR_PATH,
-                              grpc_slice_ref_internal(method)),
-      host != nullptr ? grpc_mdelem_from_slices(&exec_ctx, GRPC_MDSTR_AUTHORITY,
+      channel, parent_call, propagation_mask, cq, nullptr,
+      grpc_mdelem_from_slices(GRPC_MDSTR_PATH, grpc_slice_ref_internal(method)),
+      host != nullptr ? grpc_mdelem_from_slices(GRPC_MDSTR_AUTHORITY,
                                                 grpc_slice_ref_internal(*host))
                       : GRPC_MDNULL,
       grpc_timespec_to_millis_round_up(deadline));
-  grpc_exec_ctx_finish(&exec_ctx);
+
   return call;
 }
 
 grpc_call* grpc_channel_create_pollset_set_call(
-    grpc_exec_ctx* exec_ctx, grpc_channel* channel, grpc_call* parent_call,
-    uint32_t propagation_mask, grpc_pollset_set* pollset_set, grpc_slice method,
-    const grpc_slice* host, grpc_millis deadline, void* reserved) {
+    grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
+    grpc_pollset_set* pollset_set, grpc_slice method, const grpc_slice* host,
+    grpc_millis deadline, void* reserved) {
   GPR_ASSERT(!reserved);
   return grpc_channel_create_call_internal(
-      exec_ctx, channel, parent_call, propagation_mask, nullptr, pollset_set,
-      grpc_mdelem_from_slices(exec_ctx, GRPC_MDSTR_PATH,
-                              grpc_slice_ref_internal(method)),
-      host != nullptr ? grpc_mdelem_from_slices(exec_ctx, GRPC_MDSTR_AUTHORITY,
+      channel, parent_call, propagation_mask, nullptr, pollset_set,
+      grpc_mdelem_from_slices(GRPC_MDSTR_PATH, grpc_slice_ref_internal(method)),
+      host != nullptr ? grpc_mdelem_from_slices(GRPC_MDSTR_AUTHORITY,
                                                 grpc_slice_ref_internal(*host))
                       : GRPC_MDNULL,
       deadline);
@@ -335,21 +329,21 @@ void* grpc_channel_register_call(grpc_channel* channel, const char* method,
       "grpc_channel_register_call(channel=%p, method=%s, host=%s, reserved=%p)",
       4, (channel, method, host, reserved));
   GPR_ASSERT(!reserved);
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_core::ExecCtx exec_ctx;
 
   rc->path = grpc_mdelem_from_slices(
-      &exec_ctx, GRPC_MDSTR_PATH,
+      GRPC_MDSTR_PATH,
       grpc_slice_intern(grpc_slice_from_static_string(method)));
   rc->authority =
       host ? grpc_mdelem_from_slices(
-                 &exec_ctx, GRPC_MDSTR_AUTHORITY,
+                 GRPC_MDSTR_AUTHORITY,
                  grpc_slice_intern(grpc_slice_from_static_string(host)))
            : GRPC_MDNULL;
   gpr_mu_lock(&channel->registered_call_mu);
   rc->next = channel->registered_calls;
   channel->registered_calls = rc;
   gpr_mu_unlock(&channel->registered_call_mu);
-  grpc_exec_ctx_finish(&exec_ctx);
+
   return rc;
 }
 
@@ -370,12 +364,12 @@ grpc_call* grpc_channel_create_registered_call(
        registered_call_handle, deadline.tv_sec, deadline.tv_nsec,
        (int)deadline.clock_type, reserved));
   GPR_ASSERT(!reserved);
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_core::ExecCtx exec_ctx;
   grpc_call* call = grpc_channel_create_call_internal(
-      &exec_ctx, channel, parent_call, propagation_mask, completion_queue,
-      nullptr, GRPC_MDELEM_REF(rc->path), GRPC_MDELEM_REF(rc->authority),
+      channel, parent_call, propagation_mask, completion_queue, nullptr,
+      GRPC_MDELEM_REF(rc->path), GRPC_MDELEM_REF(rc->authority),
       grpc_timespec_to_millis_round_up(deadline));
-  grpc_exec_ctx_finish(&exec_ctx);
+
   return call;
 }
 
@@ -390,23 +384,21 @@ void grpc_channel_internal_ref(grpc_channel* c REF_ARG) {
   GRPC_CHANNEL_STACK_REF(CHANNEL_STACK_FROM_CHANNEL(c), REF_REASON);
 }
 
-void grpc_channel_internal_unref(grpc_exec_ctx* exec_ctx,
-                                 grpc_channel* c REF_ARG) {
-  GRPC_CHANNEL_STACK_UNREF(exec_ctx, CHANNEL_STACK_FROM_CHANNEL(c), REF_REASON);
+void grpc_channel_internal_unref(grpc_channel* c REF_ARG) {
+  GRPC_CHANNEL_STACK_UNREF(CHANNEL_STACK_FROM_CHANNEL(c), REF_REASON);
 }
 
-static void destroy_channel(grpc_exec_ctx* exec_ctx, void* arg,
-                            grpc_error* error) {
+static void destroy_channel(void* arg, grpc_error* error) {
   grpc_channel* channel = (grpc_channel*)arg;
-  grpc_channel_stack_destroy(exec_ctx, CHANNEL_STACK_FROM_CHANNEL(channel));
+  grpc_channel_stack_destroy(CHANNEL_STACK_FROM_CHANNEL(channel));
   while (channel->registered_calls) {
     registered_call* rc = channel->registered_calls;
     channel->registered_calls = rc->next;
-    GRPC_MDELEM_UNREF(exec_ctx, rc->path);
-    GRPC_MDELEM_UNREF(exec_ctx, rc->authority);
+    GRPC_MDELEM_UNREF(rc->path);
+    GRPC_MDELEM_UNREF(rc->authority);
     gpr_free(rc);
   }
-  GRPC_MDELEM_UNREF(exec_ctx, channel->default_authority);
+  GRPC_MDELEM_UNREF(channel->default_authority);
   gpr_mu_destroy(&channel->registered_call_mu);
   gpr_free(channel->target);
   gpr_free(channel);
@@ -415,16 +407,14 @@ static void destroy_channel(grpc_exec_ctx* exec_ctx, void* arg,
 void grpc_channel_destroy(grpc_channel* channel) {
   grpc_transport_op* op = grpc_make_transport_op(nullptr);
   grpc_channel_element* elem;
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  grpc_core::ExecCtx exec_ctx;
   GRPC_API_TRACE("grpc_channel_destroy(channel=%p)", 1, (channel));
   op->disconnect_with_error =
       GRPC_ERROR_CREATE_FROM_STATIC_STRING("Channel Destroyed");
   elem = grpc_channel_stack_element(CHANNEL_STACK_FROM_CHANNEL(channel), 0);
-  elem->filter->start_transport_op(&exec_ctx, elem, op);
-
-  GRPC_CHANNEL_INTERNAL_UNREF(&exec_ctx, channel, "channel");
+  elem->filter->start_transport_op(elem, op);
 
-  grpc_exec_ctx_finish(&exec_ctx);
+  GRPC_CHANNEL_INTERNAL_UNREF(channel, "channel");
 }
 
 grpc_channel_stack* grpc_channel_get_channel_stack(grpc_channel* channel) {
@@ -436,8 +426,7 @@ grpc_compression_options grpc_channel_compression_options(
   return channel->compression_options;
 }
 
-grpc_mdelem grpc_channel_get_reffed_status_elem(grpc_exec_ctx* exec_ctx,
-                                                grpc_channel* channel, int i) {
+grpc_mdelem grpc_channel_get_reffed_status_elem(grpc_channel* channel, int i) {
   char tmp[GPR_LTOA_MIN_BUFSIZE];
   switch (i) {
     case 0:
@@ -448,6 +437,6 @@ grpc_mdelem grpc_channel_get_reffed_status_elem(grpc_exec_ctx* exec_ctx,
       return GRPC_MDELEM_GRPC_STATUS_2;
   }
   gpr_ltoa(i, tmp);
-  return grpc_mdelem_from_slices(exec_ctx, GRPC_MDSTR_GRPC_STATUS,
+  return grpc_mdelem_from_slices(GRPC_MDSTR_GRPC_STATUS,
                                  grpc_slice_from_copied_string(tmp));
 }

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

@@ -23,17 +23,13 @@
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-grpc_channel* grpc_channel_create(grpc_exec_ctx* exec_ctx, const char* target,
+grpc_channel* grpc_channel_create(const char* target,
                                   const grpc_channel_args* args,
                                   grpc_channel_stack_type channel_stack_type,
                                   grpc_transport* optional_transport);
 
 grpc_channel* grpc_channel_create_with_builder(
-    grpc_exec_ctx* exec_ctx, grpc_channel_stack_builder* builder,
+    grpc_channel_stack_builder* builder,
     grpc_channel_stack_type channel_stack_type);
 
 /** Create a call given a grpc_channel, in order to call \a method.
@@ -45,9 +41,9 @@ grpc_channel* grpc_channel_create_with_builder(
     properties from the server call to this new client call, depending on the
     value of \a propagation_mask (see propagation_bits.h for possible values) */
 grpc_call* grpc_channel_create_pollset_set_call(
-    grpc_exec_ctx* exec_ctx, grpc_channel* channel, grpc_call* parent_call,
-    uint32_t propagation_mask, grpc_pollset_set* pollset_set, grpc_slice method,
-    const grpc_slice* host, grpc_millis deadline, void* reserved);
+    grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
+    grpc_pollset_set* pollset_set, grpc_slice method, const grpc_slice* host,
+    grpc_millis deadline, void* reserved);
 
 /** Get a (borrowed) pointer to this channels underlying channel stack */
 grpc_channel_stack* grpc_channel_get_channel_stack(grpc_channel* channel);
@@ -56,8 +52,7 @@ grpc_channel_stack* grpc_channel_get_channel_stack(grpc_channel* channel);
     status_code.
 
     The returned elem is owned by the caller. */
-grpc_mdelem grpc_channel_get_reffed_status_elem(grpc_exec_ctx* exec_ctx,
-                                                grpc_channel* channel,
+grpc_mdelem grpc_channel_get_reffed_status_elem(grpc_channel* channel,
                                                 int status_code);
 
 size_t grpc_channel_get_call_size_estimate(grpc_channel* channel);
@@ -65,28 +60,22 @@ void grpc_channel_update_call_size_estimate(grpc_channel* channel, size_t size);
 
 #ifndef NDEBUG
 void grpc_channel_internal_ref(grpc_channel* channel, const char* reason);
-void grpc_channel_internal_unref(grpc_exec_ctx* exec_ctx, grpc_channel* channel,
-                                 const char* reason);
+void grpc_channel_internal_unref(grpc_channel* channel, const char* reason);
 #define GRPC_CHANNEL_INTERNAL_REF(channel, reason) \
   grpc_channel_internal_ref(channel, reason)
-#define GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, channel, reason) \
-  grpc_channel_internal_unref(exec_ctx, channel, reason)
+#define GRPC_CHANNEL_INTERNAL_UNREF(channel, reason) \
+  grpc_channel_internal_unref(channel, reason)
 #else
 void grpc_channel_internal_ref(grpc_channel* channel);
-void grpc_channel_internal_unref(grpc_exec_ctx* exec_ctx,
-                                 grpc_channel* channel);
+void grpc_channel_internal_unref(grpc_channel* channel);
 #define GRPC_CHANNEL_INTERNAL_REF(channel, reason) \
   grpc_channel_internal_ref(channel)
-#define GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, channel, reason) \
-  grpc_channel_internal_unref(exec_ctx, channel)
+#define GRPC_CHANNEL_INTERNAL_UNREF(channel, reason) \
+  grpc_channel_internal_unref(channel)
 #endif
 
 /** Return the channel's compression options. */
 grpc_compression_options grpc_channel_compression_options(
     const grpc_channel* channel);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_LIB_SURFACE_CHANNEL_H */