grpc 1.8.7 → 1.9.0.pre1

data/src/core/ext/filters/load_reporting/server_load_reporting_filter.h

@@ -22,15 +22,7 @@
 #include "src/core/ext/filters/load_reporting/server_load_reporting_plugin.h"
 #include "src/core/lib/channel/channel_stack.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 extern const grpc_channel_filter grpc_server_load_reporting_filter;
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_EXT_FILTERS_LOAD_REPORTING_SERVER_LOAD_REPORTING_FILTER_H \
         */

data/src/core/ext/filters/load_reporting/server_load_reporting_plugin.cc

@@ -38,7 +38,7 @@ static bool is_load_reporting_enabled(const grpc_channel_args* a) {
 }
 
 static bool maybe_add_server_load_reporting_filter(
-    grpc_exec_ctx* exec_ctx, grpc_channel_stack_builder* builder, void* arg) {
+    grpc_channel_stack_builder* builder, void* arg) {
   const grpc_channel_args* args =
       grpc_channel_stack_builder_get_channel_arguments(builder);
   const grpc_channel_filter* filter = (const grpc_channel_filter*)arg;
@@ -61,10 +61,10 @@ grpc_arg grpc_load_reporting_enable_arg() {
 
 /* Plugin registration */
 
-extern "C" void grpc_server_load_reporting_plugin_init(void) {
+void grpc_server_load_reporting_plugin_init(void) {
   grpc_channel_init_register_stage(GRPC_SERVER_CHANNEL, INT_MAX,
                                    maybe_add_server_load_reporting_filter,
                                    (void*)&grpc_server_load_reporting_filter);
 }
 
-extern "C" void grpc_server_load_reporting_plugin_shutdown() {}
+void grpc_server_load_reporting_plugin_shutdown() {}

data/src/core/ext/filters/load_reporting/server_load_reporting_plugin.h

@@ -23,10 +23,6 @@
 
 #include "src/core/lib/channel/channel_stack.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /** Identifiers for the invocation point of the users LR callback */
 typedef enum grpc_load_reporting_source {
   GRPC_LR_POINT_UNKNOWN = 0,
@@ -59,9 +55,5 @@ typedef struct grpc_load_reporting_call_data {
 /** Return a \a grpc_arg enabling load reporting */
 grpc_arg grpc_load_reporting_enable_arg();
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_EXT_FILTERS_LOAD_REPORTING_SERVER_LOAD_REPORTING_PLUGIN_H \
         */

data/src/core/ext/filters/max_age/max_age_filter.cc

@@ -37,7 +37,8 @@
 #define MAX_CONNECTION_IDLE_INTEGER_OPTIONS \
   { DEFAULT_MAX_CONNECTION_IDLE_MS, 1, INT_MAX }
 
-typedef struct channel_data {
+namespace {
+struct channel_data {
   /* We take a reference to the channel stack for the timer callback */
   grpc_channel_stack* channel_stack;
   /* Guards access to max_age_timer, max_age_timer_pending, max_age_grace_timer
@@ -84,77 +85,74 @@ typedef struct channel_data {
   grpc_connectivity_state connectivity_state;
   /* Number of active calls */
   gpr_atm call_count;
-} channel_data;
+};
+}  // namespace
 
 /* Increase the nubmer of active calls. Before the increasement, if there are no
    calls, the max_idle_timer should be cancelled. */
-static void increase_call_count(grpc_exec_ctx* exec_ctx, channel_data* chand) {
+static void increase_call_count(channel_data* chand) {
   if (gpr_atm_full_fetch_add(&chand->call_count, 1) == 0) {
-    grpc_timer_cancel(exec_ctx, &chand->max_idle_timer);
+    grpc_timer_cancel(&chand->max_idle_timer);
   }
 }
 
 /* Decrease the nubmer of active calls. After the decrement, if there are no
    calls, the max_idle_timer should be started. */
-static void decrease_call_count(grpc_exec_ctx* exec_ctx, channel_data* chand) {
+static void decrease_call_count(channel_data* chand) {
   if (gpr_atm_full_fetch_add(&chand->call_count, -1) == 1) {
     GRPC_CHANNEL_STACK_REF(chand->channel_stack, "max_age max_idle_timer");
-    grpc_timer_init(exec_ctx, &chand->max_idle_timer,
-                    grpc_exec_ctx_now(exec_ctx) + chand->max_connection_idle,
-                    &chand->close_max_idle_channel);
+    grpc_timer_init(
+        &chand->max_idle_timer,
+        grpc_core::ExecCtx::Get()->Now() + chand->max_connection_idle,
+        &chand->close_max_idle_channel);
   }
 }
 
-static void start_max_idle_timer_after_init(grpc_exec_ctx* exec_ctx, void* arg,
-                                            grpc_error* error) {
+static void start_max_idle_timer_after_init(void* arg, grpc_error* error) {
   channel_data* chand = (channel_data*)arg;
   /* Decrease call_count. If there are no active calls at this time,
      max_idle_timer will start here. If the number of active calls is not 0,
      max_idle_timer will start after all the active calls end. */
-  decrease_call_count(exec_ctx, chand);
-  GRPC_CHANNEL_STACK_UNREF(exec_ctx, chand->channel_stack,
+  decrease_call_count(chand);
+  GRPC_CHANNEL_STACK_UNREF(chand->channel_stack,
                            "max_age start_max_idle_timer_after_init");
 }
 
-static void start_max_age_timer_after_init(grpc_exec_ctx* exec_ctx, void* arg,
-                                           grpc_error* error) {
+static void start_max_age_timer_after_init(void* arg, grpc_error* error) {
   channel_data* chand = (channel_data*)arg;
   gpr_mu_lock(&chand->max_age_timer_mu);
   chand->max_age_timer_pending = true;
   GRPC_CHANNEL_STACK_REF(chand->channel_stack, "max_age max_age_timer");
-  grpc_timer_init(exec_ctx, &chand->max_age_timer,
-                  grpc_exec_ctx_now(exec_ctx) + chand->max_connection_age,
+  grpc_timer_init(&chand->max_age_timer,
+                  grpc_core::ExecCtx::Get()->Now() + chand->max_connection_age,
                   &chand->close_max_age_channel);
   gpr_mu_unlock(&chand->max_age_timer_mu);
   grpc_transport_op* op = grpc_make_transport_op(nullptr);
   op->on_connectivity_state_change = &chand->channel_connectivity_changed;
   op->connectivity_state = &chand->connectivity_state;
-  grpc_channel_next_op(exec_ctx,
-                       grpc_channel_stack_element(chand->channel_stack, 0), op);
-  GRPC_CHANNEL_STACK_UNREF(exec_ctx, chand->channel_stack,
+  grpc_channel_next_op(grpc_channel_stack_element(chand->channel_stack, 0), op);
+  GRPC_CHANNEL_STACK_UNREF(chand->channel_stack,
                            "max_age start_max_age_timer_after_init");
 }
 
-static void start_max_age_grace_timer_after_goaway_op(grpc_exec_ctx* exec_ctx,
-                                                      void* arg,
+static void start_max_age_grace_timer_after_goaway_op(void* arg,
                                                       grpc_error* error) {
   channel_data* chand = (channel_data*)arg;
   gpr_mu_lock(&chand->max_age_timer_mu);
   chand->max_age_grace_timer_pending = true;
   GRPC_CHANNEL_STACK_REF(chand->channel_stack, "max_age max_age_grace_timer");
   grpc_timer_init(
-      exec_ctx, &chand->max_age_grace_timer,
+      &chand->max_age_grace_timer,
       chand->max_connection_age_grace == GRPC_MILLIS_INF_FUTURE
           ? GRPC_MILLIS_INF_FUTURE
-          : grpc_exec_ctx_now(exec_ctx) + chand->max_connection_age_grace,
+          : grpc_core::ExecCtx::Get()->Now() + chand->max_connection_age_grace,
       &chand->force_close_max_age_channel);
   gpr_mu_unlock(&chand->max_age_timer_mu);
-  GRPC_CHANNEL_STACK_UNREF(exec_ctx, chand->channel_stack,
+  GRPC_CHANNEL_STACK_UNREF(chand->channel_stack,
                            "max_age start_max_age_grace_timer_after_goaway_op");
 }
 
-static void close_max_idle_channel(grpc_exec_ctx* exec_ctx, void* arg,
-                                   grpc_error* error) {
+static void close_max_idle_channel(void* arg, grpc_error* error) {
   channel_data* chand = (channel_data*)arg;
   if (error == GRPC_ERROR_NONE) {
     /* Prevent the max idle timer from being set again */
@@ -165,16 +163,14 @@ static void close_max_idle_channel(grpc_exec_ctx* exec_ctx, void* arg,
                            GRPC_ERROR_INT_HTTP2_ERROR, GRPC_HTTP2_NO_ERROR);
     grpc_channel_element* elem =
         grpc_channel_stack_element(chand->channel_stack, 0);
-    elem->filter->start_transport_op(exec_ctx, elem, op);
+    elem->filter->start_transport_op(elem, op);
   } else if (error != GRPC_ERROR_CANCELLED) {
     GRPC_LOG_IF_ERROR("close_max_idle_channel", error);
   }
-  GRPC_CHANNEL_STACK_UNREF(exec_ctx, chand->channel_stack,
-                           "max_age max_idle_timer");
+  GRPC_CHANNEL_STACK_UNREF(chand->channel_stack, "max_age max_idle_timer");
 }
 
-static void close_max_age_channel(grpc_exec_ctx* exec_ctx, void* arg,
-                                  grpc_error* error) {
+static void close_max_age_channel(void* arg, grpc_error* error) {
   channel_data* chand = (channel_data*)arg;
   gpr_mu_lock(&chand->max_age_timer_mu);
   chand->max_age_timer_pending = false;
@@ -189,16 +185,14 @@ static void close_max_age_channel(grpc_exec_ctx* exec_ctx, void* arg,
                            GRPC_ERROR_INT_HTTP2_ERROR, GRPC_HTTP2_NO_ERROR);
     grpc_channel_element* elem =
         grpc_channel_stack_element(chand->channel_stack, 0);
-    elem->filter->start_transport_op(exec_ctx, elem, op);
+    elem->filter->start_transport_op(elem, op);
   } else if (error != GRPC_ERROR_CANCELLED) {
     GRPC_LOG_IF_ERROR("close_max_age_channel", error);
   }
-  GRPC_CHANNEL_STACK_UNREF(exec_ctx, chand->channel_stack,
-                           "max_age max_age_timer");
+  GRPC_CHANNEL_STACK_UNREF(chand->channel_stack, "max_age max_age_timer");
 }
 
-static void force_close_max_age_channel(grpc_exec_ctx* exec_ctx, void* arg,
-                                        grpc_error* error) {
+static void force_close_max_age_channel(void* arg, grpc_error* error) {
   channel_data* chand = (channel_data*)arg;
   gpr_mu_lock(&chand->max_age_timer_mu);
   chand->max_age_grace_timer_pending = false;
@@ -209,38 +203,36 @@ static void force_close_max_age_channel(grpc_exec_ctx* exec_ctx, void* arg,
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Channel reaches max age");
     grpc_channel_element* elem =
         grpc_channel_stack_element(chand->channel_stack, 0);
-    elem->filter->start_transport_op(exec_ctx, elem, op);
+    elem->filter->start_transport_op(elem, op);
   } else if (error != GRPC_ERROR_CANCELLED) {
     GRPC_LOG_IF_ERROR("force_close_max_age_channel", error);
   }
-  GRPC_CHANNEL_STACK_UNREF(exec_ctx, chand->channel_stack,
-                           "max_age max_age_grace_timer");
+  GRPC_CHANNEL_STACK_UNREF(chand->channel_stack, "max_age max_age_grace_timer");
 }
 
-static void channel_connectivity_changed(grpc_exec_ctx* exec_ctx, void* arg,
-                                         grpc_error* error) {
+static void channel_connectivity_changed(void* arg, grpc_error* error) {
   channel_data* chand = (channel_data*)arg;
   if (chand->connectivity_state != GRPC_CHANNEL_SHUTDOWN) {
     grpc_transport_op* op = grpc_make_transport_op(nullptr);
     op->on_connectivity_state_change = &chand->channel_connectivity_changed;
     op->connectivity_state = &chand->connectivity_state;
-    grpc_channel_next_op(
-        exec_ctx, grpc_channel_stack_element(chand->channel_stack, 0), op);
+    grpc_channel_next_op(grpc_channel_stack_element(chand->channel_stack, 0),
+                         op);
   } else {
     gpr_mu_lock(&chand->max_age_timer_mu);
     if (chand->max_age_timer_pending) {
-      grpc_timer_cancel(exec_ctx, &chand->max_age_timer);
+      grpc_timer_cancel(&chand->max_age_timer);
       chand->max_age_timer_pending = false;
     }
     if (chand->max_age_grace_timer_pending) {
-      grpc_timer_cancel(exec_ctx, &chand->max_age_grace_timer);
+      grpc_timer_cancel(&chand->max_age_grace_timer);
       chand->max_age_grace_timer_pending = false;
     }
     gpr_mu_unlock(&chand->max_age_timer_mu);
     /* If there are no active calls, this increasement will cancel
        max_idle_timer, and prevent max_idle_timer from being started in the
        future. */
-    increase_call_count(exec_ctx, chand);
+    increase_call_count(chand);
   }
 }
 
@@ -263,25 +255,23 @@ add_random_max_connection_age_jitter_and_convert_to_grpc_millis(int value) {
 }
 
 /* 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) {
   channel_data* chand = (channel_data*)elem->channel_data;
-  increase_call_count(exec_ctx, chand);
+  increase_call_count(chand);
   return GRPC_ERROR_NONE;
 }
 
 /* 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) {
   channel_data* chand = (channel_data*)elem->channel_data;
-  decrease_call_count(exec_ctx, chand);
+  decrease_call_count(chand);
 }
 
 /* Constructor for channel_data. */
-static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
-                                     grpc_channel_element* elem,
+static grpc_error* init_channel_elem(grpc_channel_element* elem,
                                      grpc_channel_element_args* args) {
   channel_data* chand = (channel_data*)elem->channel_data;
   gpr_mu_init(&chand->max_age_timer_mu);
@@ -351,8 +341,7 @@ static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
        initialization is done. */
     GRPC_CHANNEL_STACK_REF(chand->channel_stack,
                            "max_age start_max_age_timer_after_init");
-    GRPC_CLOSURE_SCHED(exec_ctx, &chand->start_max_age_timer_after_init,
-                       GRPC_ERROR_NONE);
+    GRPC_CLOSURE_SCHED(&chand->start_max_age_timer_after_init, GRPC_ERROR_NONE);
   }
 
   /* Initialize the number of calls as 1, so that the max_idle_timer will not
@@ -361,15 +350,14 @@ static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
   if (chand->max_connection_idle != GRPC_MILLIS_INF_FUTURE) {
     GRPC_CHANNEL_STACK_REF(chand->channel_stack,
                            "max_age start_max_idle_timer_after_init");
-    GRPC_CLOSURE_SCHED(exec_ctx, &chand->start_max_idle_timer_after_init,
+    GRPC_CLOSURE_SCHED(&chand->start_max_idle_timer_after_init,
                        GRPC_ERROR_NONE);
   }
   return GRPC_ERROR_NONE;
 }
 
 /* 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) {}
 
 const grpc_channel_filter grpc_max_age_filter = {
     grpc_call_next_op,
@@ -384,8 +372,7 @@ const grpc_channel_filter grpc_max_age_filter = {
     grpc_channel_next_get_info,
     "max_age"};
 
-static bool maybe_add_max_age_filter(grpc_exec_ctx* exec_ctx,
-                                     grpc_channel_stack_builder* builder,
+static bool maybe_add_max_age_filter(grpc_channel_stack_builder* builder,
                                      void* arg) {
   const grpc_channel_args* channel_args =
       grpc_channel_stack_builder_get_channel_arguments(builder);
@@ -404,10 +391,10 @@ static bool maybe_add_max_age_filter(grpc_exec_ctx* exec_ctx,
   }
 }
 
-extern "C" void grpc_max_age_filter_init(void) {
+void grpc_max_age_filter_init(void) {
   grpc_channel_init_register_stage(GRPC_SERVER_CHANNEL,
                                    GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
                                    maybe_add_max_age_filter, nullptr);
 }
 
-extern "C" void grpc_max_age_filter_shutdown(void) {}
+void grpc_max_age_filter_shutdown(void) {}

data/src/core/ext/filters/max_age/max_age_filter.h

@@ -19,14 +19,6 @@
 
 #include "src/core/lib/channel/channel_stack.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 extern const grpc_channel_filter grpc_max_age_filter;
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* GRPC_CORE_EXT_FILTERS_MAX_AGE_MAX_AGE_FILTER_H */

data/src/core/ext/filters/message_size/message_size_filter.cc

@@ -26,7 +26,7 @@
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
-#include "src/core/lib/support/string.h"
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/transport/service_config.h"
 
@@ -47,8 +47,7 @@ static void* refcounted_message_size_limits_ref(void* value) {
   return value;
 }
 
-static void refcounted_message_size_limits_unref(grpc_exec_ctx* exec_ctx,
-                                                 void* value) {
+static void refcounted_message_size_limits_unref(void* value) {
   refcounted_message_size_limits* limits =
       (refcounted_message_size_limits*)value;
   if (gpr_unref(&limits->refs)) {
@@ -87,7 +86,8 @@ static void* refcounted_message_size_limits_create_from_json(
   return value;
 }
 
-typedef struct call_data {
+namespace {
+struct call_data {
   grpc_call_combiner* call_combiner;
   message_size_limits limits;
   // Receive closures are chained: we inject this closure as the
@@ -98,18 +98,18 @@ typedef struct call_data {
   grpc_byte_stream** recv_message;
   // Original recv_message_ready callback, invoked after our own.
   grpc_closure* next_recv_message_ready;
-} call_data;
+};
 
-typedef struct channel_data {
+struct channel_data {
   message_size_limits limits;
   // Maps path names to refcounted_message_size_limits structs.
   grpc_slice_hash_table* method_limit_table;
-} channel_data;
+};
+}  // namespace
 
 // Callback invoked when we receive a message.  Here we check the max
 // receive message size.
-static void recv_message_ready(grpc_exec_ctx* exec_ctx, void* user_data,
-                               grpc_error* error) {
+static void recv_message_ready(void* user_data, grpc_error* error) {
   grpc_call_element* elem = (grpc_call_element*)user_data;
   call_data* calld = (call_data*)elem->call_data;
   if (*calld->recv_message != nullptr && calld->limits.max_recv_size >= 0 &&
@@ -132,13 +132,12 @@ static void recv_message_ready(grpc_exec_ctx* exec_ctx, void* user_data,
     GRPC_ERROR_REF(error);
   }
   // Invoke the next callback.
-  GRPC_CLOSURE_RUN(exec_ctx, calld->next_recv_message_ready, error);
+  GRPC_CLOSURE_RUN(calld->next_recv_message_ready, error);
 }
 
 // Start transport stream op.
 static void start_transport_stream_op_batch(
-    grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
-    grpc_transport_stream_op_batch* op) {
+    grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
   call_data* calld = (call_data*)elem->call_data;
   // Check max send message size.
   if (op->send_message && calld->limits.max_send_size >= 0 &&
@@ -149,7 +148,7 @@ static void start_transport_stream_op_batch(
                  op->payload->send_message.send_message->length,
                  calld->limits.max_send_size);
     grpc_transport_stream_op_batch_finish_with_failure(
-        exec_ctx, op,
+        op,
         grpc_error_set_int(GRPC_ERROR_CREATE_FROM_COPIED_STRING(message_string),
                            GRPC_ERROR_INT_GRPC_STATUS,
                            GRPC_STATUS_RESOURCE_EXHAUSTED),
@@ -165,12 +164,11 @@ static void start_transport_stream_op_batch(
     op->payload->recv_message.recv_message_ready = &calld->recv_message_ready;
   }
   // Chain to the next filter.
-  grpc_call_next_op(exec_ctx, elem, op);
+  grpc_call_next_op(elem, op);
 }
 
 // Constructor for call_data.
-static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
-                                  grpc_call_element* elem,
+static grpc_error* init_call_elem(grpc_call_element* elem,
                                   const grpc_call_element_args* args) {
   channel_data* chand = (channel_data*)elem->channel_data;
   call_data* calld = (call_data*)elem->call_data;
@@ -186,7 +184,7 @@ static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
   if (chand->method_limit_table != nullptr) {
     refcounted_message_size_limits* limits =
         (refcounted_message_size_limits*)grpc_method_config_table_get(
-            exec_ctx, chand->method_limit_table, args->path);
+            chand->method_limit_table, args->path);
     if (limits != nullptr) {
       if (limits->limits.max_send_size >= 0 &&
           (limits->limits.max_send_size < calld->limits.max_send_size ||
@@ -204,7 +202,7 @@ static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
 }
 
 // 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) {}
 
@@ -241,8 +239,7 @@ message_size_limits get_message_size_limits(
 }
 
 // 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) {
   GPR_ASSERT(!args->is_last);
   channel_data* chand = (channel_data*)elem->channel_data;
@@ -257,8 +254,7 @@ static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
     if (service_config != nullptr) {
       chand->method_limit_table =
           grpc_service_config_create_method_config_table(
-              exec_ctx, service_config,
-              refcounted_message_size_limits_create_from_json,
+              service_config, refcounted_message_size_limits_create_from_json,
               refcounted_message_size_limits_ref,
               refcounted_message_size_limits_unref);
       grpc_service_config_destroy(service_config);
@@ -268,10 +264,9 @@ static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
 }
 
 // Destructor for channel_data.
-static void destroy_channel_elem(grpc_exec_ctx* exec_ctx,
-                                 grpc_channel_element* elem) {
+static void destroy_channel_elem(grpc_channel_element* elem) {
   channel_data* chand = (channel_data*)elem->channel_data;
-  grpc_slice_hash_table_unref(exec_ctx, chand->method_limit_table);
+  grpc_slice_hash_table_unref(chand->method_limit_table);
 }
 
 const grpc_channel_filter grpc_message_size_filter = {
@@ -287,8 +282,7 @@ const grpc_channel_filter grpc_message_size_filter = {
     grpc_channel_next_get_info,
     "message_size"};
 
-static bool maybe_add_message_size_filter(grpc_exec_ctx* exec_ctx,
-                                          grpc_channel_stack_builder* builder,
+static bool maybe_add_message_size_filter(grpc_channel_stack_builder* builder,
                                           void* arg) {
   const grpc_channel_args* channel_args =
       grpc_channel_stack_builder_get_channel_arguments(builder);
@@ -310,7 +304,7 @@ static bool maybe_add_message_size_filter(grpc_exec_ctx* exec_ctx,
   }
 }
 
-extern "C" void grpc_message_size_filter_init(void) {
+void grpc_message_size_filter_init(void) {
   grpc_channel_init_register_stage(GRPC_CLIENT_SUBCHANNEL,
                                    GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
                                    maybe_add_message_size_filter, nullptr);
@@ -322,4 +316,4 @@ extern "C" void grpc_message_size_filter_init(void) {
                                    maybe_add_message_size_filter, nullptr);
 }
 
-extern "C" void grpc_message_size_filter_shutdown(void) {}
+void grpc_message_size_filter_shutdown(void) {}