grpc 1.7.3 → 1.8.0

data/src/core/ext/filters/client_channel/client_channel.h

@@ -23,11 +23,15 @@
 #include "src/core/ext/filters/client_channel/resolver.h"
 #include "src/core/lib/channel/channel_stack.h"
 
-extern grpc_tracer_flag grpc_client_channel_trace;
+extern grpc_core::TraceFlag grpc_client_channel_trace;
 
 // Channel arg key for server URI string.
 #define GRPC_ARG_SERVER_URI "grpc.server_uri"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* A client channel is a channel that begins disconnected, and can connect
    to some endpoint on demand. If that endpoint disconnects, it will be
    connected to again later.
@@ -38,18 +42,22 @@ extern grpc_tracer_flag grpc_client_channel_trace;
 extern const grpc_channel_filter grpc_client_channel_filter;
 
 grpc_connectivity_state grpc_client_channel_check_connectivity_state(
-    grpc_exec_ctx *exec_ctx, grpc_channel_element *elem, int try_to_connect);
+    grpc_exec_ctx* exec_ctx, grpc_channel_element* elem, int try_to_connect);
 
 int grpc_client_channel_num_external_connectivity_watchers(
-    grpc_channel_element *elem);
+    grpc_channel_element* elem);
 
 void grpc_client_channel_watch_connectivity_state(
-    grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
-    grpc_polling_entity pollent, grpc_connectivity_state *state,
-    grpc_closure *on_complete, grpc_closure *watcher_timer_init);
+    grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+    grpc_polling_entity pollent, grpc_connectivity_state* state,
+    grpc_closure* on_complete, grpc_closure* watcher_timer_init);
 
 /* Debug helper: pull the subchannel call from a call stack element */
-grpc_subchannel_call *grpc_client_channel_get_subchannel_call(
-    grpc_call_element *elem);
+grpc_subchannel_call* grpc_client_channel_get_subchannel_call(
+    grpc_call_element* elem);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CLIENT_CHANNEL_H */

data/src/core/ext/filters/client_channel/client_channel_factory.h

@@ -27,6 +27,10 @@
 // Channel arg key for client channel factory.
 #define GRPC_ARG_CLIENT_CHANNEL_FACTORY "grpc.client_channel_factory"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct grpc_client_channel_factory grpc_client_channel_factory;
 typedef struct grpc_client_channel_factory_vtable
     grpc_client_channel_factory_vtable;
@@ -40,38 +44,42 @@ typedef enum {
 /** Constructor for new configured channels.
     Creating decorators around this type is encouraged to adapt behavior. */
 struct grpc_client_channel_factory {
-  const grpc_client_channel_factory_vtable *vtable;
+  const grpc_client_channel_factory_vtable* vtable;
 };
 
 struct grpc_client_channel_factory_vtable {
-  void (*ref)(grpc_client_channel_factory *factory);
-  void (*unref)(grpc_exec_ctx *exec_ctx, grpc_client_channel_factory *factory);
-  grpc_subchannel *(*create_subchannel)(grpc_exec_ctx *exec_ctx,
-                                        grpc_client_channel_factory *factory,
-                                        const grpc_subchannel_args *args);
-  grpc_channel *(*create_client_channel)(grpc_exec_ctx *exec_ctx,
-                                         grpc_client_channel_factory *factory,
-                                         const char *target,
+  void (*ref)(grpc_client_channel_factory* factory);
+  void (*unref)(grpc_exec_ctx* exec_ctx, grpc_client_channel_factory* factory);
+  grpc_subchannel* (*create_subchannel)(grpc_exec_ctx* exec_ctx,
+                                        grpc_client_channel_factory* factory,
+                                        const grpc_subchannel_args* args);
+  grpc_channel* (*create_client_channel)(grpc_exec_ctx* exec_ctx,
+                                         grpc_client_channel_factory* factory,
+                                         const char* target,
                                          grpc_client_channel_type type,
-                                         const grpc_channel_args *args);
+                                         const grpc_channel_args* args);
 };
 
-void grpc_client_channel_factory_ref(grpc_client_channel_factory *factory);
-void grpc_client_channel_factory_unref(grpc_exec_ctx *exec_ctx,
-                                       grpc_client_channel_factory *factory);
+void grpc_client_channel_factory_ref(grpc_client_channel_factory* factory);
+void grpc_client_channel_factory_unref(grpc_exec_ctx* exec_ctx,
+                                       grpc_client_channel_factory* factory);
 
 /** Create a new grpc_subchannel */
-grpc_subchannel *grpc_client_channel_factory_create_subchannel(
-    grpc_exec_ctx *exec_ctx, grpc_client_channel_factory *factory,
-    const grpc_subchannel_args *args);
+grpc_subchannel* grpc_client_channel_factory_create_subchannel(
+    grpc_exec_ctx* exec_ctx, grpc_client_channel_factory* factory,
+    const grpc_subchannel_args* args);
 
 /** Create a new grpc_channel */
-grpc_channel *grpc_client_channel_factory_create_channel(
-    grpc_exec_ctx *exec_ctx, grpc_client_channel_factory *factory,
-    const char *target, grpc_client_channel_type type,
-    const grpc_channel_args *args);
+grpc_channel* grpc_client_channel_factory_create_channel(
+    grpc_exec_ctx* exec_ctx, grpc_client_channel_factory* factory,
+    const char* target, grpc_client_channel_type type,
+    const grpc_channel_args* args);
 
 grpc_arg grpc_client_channel_factory_create_channel_arg(
-    grpc_client_channel_factory *factory);
+    grpc_client_channel_factory* factory);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CLIENT_CHANNEL_FACTORY_H */

data/src/core/ext/filters/client_channel/{client_channel_plugin.c → client_channel_plugin.cc}

@@ -34,16 +34,16 @@
 #include "src/core/ext/filters/client_channel/subchannel_index.h"
 #include "src/core/lib/surface/channel_init.h"
 
-static bool append_filter(grpc_exec_ctx *exec_ctx,
-                          grpc_channel_stack_builder *builder, void *arg) {
+static bool append_filter(grpc_exec_ctx* exec_ctx,
+                          grpc_channel_stack_builder* builder, void* arg) {
   return grpc_channel_stack_builder_append_filter(
-      builder, (const grpc_channel_filter *)arg, NULL, NULL);
+      builder, (const grpc_channel_filter*)arg, nullptr, nullptr);
 }
 
-static bool set_default_host_if_unset(grpc_exec_ctx *exec_ctx,
-                                      grpc_channel_stack_builder *builder,
-                                      void *unused) {
-  const grpc_channel_args *args =
+static bool set_default_host_if_unset(grpc_exec_ctx* exec_ctx,
+                                      grpc_channel_stack_builder* builder,
+                                      void* unused) {
+  const grpc_channel_args* args =
       grpc_channel_stack_builder_get_channel_arguments(builder);
   for (size_t i = 0; i < args->num_args; i++) {
     if (0 == strcmp(args->args[i].key, GRPC_ARG_DEFAULT_AUTHORITY) ||
@@ -51,12 +51,12 @@ static bool set_default_host_if_unset(grpc_exec_ctx *exec_ctx,
       return true;
     }
   }
-  char *default_authority = grpc_get_default_authority(
+  char* default_authority = grpc_get_default_authority(
       exec_ctx, grpc_channel_stack_builder_get_target(builder));
-  if (default_authority != NULL) {
+  if (default_authority != nullptr) {
     grpc_arg arg = grpc_channel_arg_string_create(
-        (char *)GRPC_ARG_DEFAULT_AUTHORITY, default_authority);
-    grpc_channel_args *new_args = grpc_channel_args_copy_and_add(args, &arg, 1);
+        (char*)GRPC_ARG_DEFAULT_AUTHORITY, default_authority);
+    grpc_channel_args* new_args = grpc_channel_args_copy_and_add(args, &arg, 1);
     grpc_channel_stack_builder_set_channel_arguments(exec_ctx, builder,
                                                      new_args);
     gpr_free(default_authority);
@@ -65,7 +65,7 @@ static bool set_default_host_if_unset(grpc_exec_ctx *exec_ctx,
   return true;
 }
 
-void grpc_client_channel_init(void) {
+extern "C" void grpc_client_channel_init(void) {
   grpc_lb_policy_registry_init();
   grpc_resolver_registry_init();
   grpc_retry_throttle_map_init();
@@ -73,18 +73,14 @@ void grpc_client_channel_init(void) {
   grpc_register_http_proxy_mapper();
   grpc_subchannel_index_init();
   grpc_channel_init_register_stage(GRPC_CLIENT_CHANNEL, INT_MIN,
-                                   set_default_host_if_unset, NULL);
+                                   set_default_host_if_unset, nullptr);
   grpc_channel_init_register_stage(
       GRPC_CLIENT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY, append_filter,
-      (void *)&grpc_client_channel_filter);
+      (void*)&grpc_client_channel_filter);
   grpc_http_connect_register_handshaker_factory();
-  grpc_register_tracer(&grpc_client_channel_trace);
-#ifndef NDEBUG
-  grpc_register_tracer(&grpc_trace_resolver_refcount);
-#endif
 }
 
-void grpc_client_channel_shutdown(void) {
+extern "C" void grpc_client_channel_shutdown(void) {
   grpc_subchannel_index_shutdown();
   grpc_channel_init_shutdown();
   grpc_proxy_mapper_registry_shutdown();

data/src/core/ext/filters/client_channel/connector.h

@@ -23,51 +23,59 @@
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/transport/transport.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct grpc_connector grpc_connector;
 typedef struct grpc_connector_vtable grpc_connector_vtable;
 
 struct grpc_connector {
-  const grpc_connector_vtable *vtable;
+  const grpc_connector_vtable* vtable;
 };
 
 typedef struct {
   /** set of pollsets interested in this connection */
-  grpc_pollset_set *interested_parties;
+  grpc_pollset_set* interested_parties;
   /** deadline for connection */
-  gpr_timespec deadline;
+  grpc_millis deadline;
   /** channel arguments (to be passed to transport) */
-  const grpc_channel_args *channel_args;
+  const grpc_channel_args* channel_args;
 } grpc_connect_in_args;
 
 typedef struct {
   /** the connected transport */
-  grpc_transport *transport;
+  grpc_transport* transport;
 
   /** channel arguments (to be passed to the filters) */
-  grpc_channel_args *channel_args;
+  grpc_channel_args* channel_args;
 } grpc_connect_out_args;
 
 struct grpc_connector_vtable {
-  void (*ref)(grpc_connector *connector);
-  void (*unref)(grpc_exec_ctx *exec_ctx, grpc_connector *connector);
+  void (*ref)(grpc_connector* connector);
+  void (*unref)(grpc_exec_ctx* exec_ctx, grpc_connector* connector);
   /** Implementation of grpc_connector_shutdown */
-  void (*shutdown)(grpc_exec_ctx *exec_ctx, grpc_connector *connector,
-                   grpc_error *why);
+  void (*shutdown)(grpc_exec_ctx* exec_ctx, grpc_connector* connector,
+                   grpc_error* why);
   /** Implementation of grpc_connector_connect */
-  void (*connect)(grpc_exec_ctx *exec_ctx, grpc_connector *connector,
-                  const grpc_connect_in_args *in_args,
-                  grpc_connect_out_args *out_args, grpc_closure *notify);
+  void (*connect)(grpc_exec_ctx* exec_ctx, grpc_connector* connector,
+                  const grpc_connect_in_args* in_args,
+                  grpc_connect_out_args* out_args, grpc_closure* notify);
 };
 
-grpc_connector *grpc_connector_ref(grpc_connector *connector);
-void grpc_connector_unref(grpc_exec_ctx *exec_ctx, grpc_connector *connector);
+grpc_connector* grpc_connector_ref(grpc_connector* connector);
+void grpc_connector_unref(grpc_exec_ctx* exec_ctx, grpc_connector* connector);
 /** Connect using the connector: max one outstanding call at a time */
-void grpc_connector_connect(grpc_exec_ctx *exec_ctx, grpc_connector *connector,
-                            const grpc_connect_in_args *in_args,
-                            grpc_connect_out_args *out_args,
-                            grpc_closure *notify);
+void grpc_connector_connect(grpc_exec_ctx* exec_ctx, grpc_connector* connector,
+                            const grpc_connect_in_args* in_args,
+                            grpc_connect_out_args* out_args,
+                            grpc_closure* notify);
 /** Cancel any pending connection */
-void grpc_connector_shutdown(grpc_exec_ctx *exec_ctx, grpc_connector *connector,
-                             grpc_error *why);
+void grpc_connector_shutdown(grpc_exec_ctx* exec_ctx, grpc_connector* connector,
+                             grpc_error* why);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CONNECTOR_H */

data/src/core/ext/filters/client_channel/{http_connect_handshaker.c → http_connect_handshaker.cc}

@@ -65,10 +65,10 @@ static void http_connect_handshaker_unref(grpc_exec_ctx* exec_ctx,
                                           http_connect_handshaker* handshaker) {
   if (gpr_unref(&handshaker->refcount)) {
     gpr_mu_destroy(&handshaker->mu);
-    if (handshaker->endpoint_to_destroy != NULL) {
+    if (handshaker->endpoint_to_destroy != nullptr) {
       grpc_endpoint_destroy(exec_ctx, handshaker->endpoint_to_destroy);
     }
-    if (handshaker->read_buffer_to_destroy != NULL) {
+    if (handshaker->read_buffer_to_destroy != nullptr) {
       grpc_slice_buffer_destroy_internal(exec_ctx,
                                          handshaker->read_buffer_to_destroy);
       gpr_free(handshaker->read_buffer_to_destroy);
@@ -85,11 +85,11 @@ static void http_connect_handshaker_unref(grpc_exec_ctx* exec_ctx,
 static void cleanup_args_for_failure_locked(
     grpc_exec_ctx* exec_ctx, http_connect_handshaker* handshaker) {
   handshaker->endpoint_to_destroy = handshaker->args->endpoint;
-  handshaker->args->endpoint = NULL;
+  handshaker->args->endpoint = nullptr;
   handshaker->read_buffer_to_destroy = handshaker->args->read_buffer;
-  handshaker->args->read_buffer = NULL;
+  handshaker->args->read_buffer = nullptr;
   grpc_channel_args_destroy(exec_ctx, handshaker->args->args);
-  handshaker->args->args = NULL;
+  handshaker->args->args = nullptr;
 }
 
 // If the handshake failed or we're shutting down, clean up and invoke the
@@ -260,7 +260,7 @@ static void http_connect_handshaker_do_handshake(
   // If not found, invoke on_handshake_done without doing anything.
   const grpc_arg* arg =
       grpc_channel_args_find(args->args, GRPC_ARG_HTTP_CONNECT_SERVER);
-  if (arg == NULL) {
+  if (arg == nullptr) {
     // Set shutdown to true so that subsequent calls to
     // http_connect_handshaker_shutdown() do nothing.
     gpr_mu_lock(&handshaker->mu);
@@ -273,11 +273,11 @@ static void http_connect_handshaker_do_handshake(
   char* server_name = arg->value.string;
   // Get headers from channel args.
   arg = grpc_channel_args_find(args->args, GRPC_ARG_HTTP_CONNECT_HEADERS);
-  grpc_http_header* headers = NULL;
+  grpc_http_header* headers = nullptr;
   size_t num_headers = 0;
-  char** header_strings = NULL;
+  char** header_strings = nullptr;
   size_t num_header_strings = 0;
-  if (arg != NULL) {
+  if (arg != nullptr) {
     GPR_ASSERT(arg->type == GRPC_ARG_STRING);
     gpr_string_split(arg->value.string, "\n", &header_strings,
                      &num_header_strings);
@@ -285,7 +285,7 @@ static void http_connect_handshaker_do_handshake(
                                             num_header_strings);
     for (size_t i = 0; i < num_header_strings; ++i) {
       char* sep = strchr(header_strings[i], ':');
-      if (sep == NULL) {
+      if (sep == nullptr) {
         gpr_log(GPR_ERROR, "skipping unparseable HTTP CONNECT header: %s",
                 header_strings[i]);
         continue;

data/src/core/ext/filters/client_channel/http_connect_handshaker.h

@@ -28,7 +28,15 @@
 /// seperated by colons.
 #define GRPC_ARG_HTTP_CONNECT_HEADERS "grpc.http_connect_headers"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /// Registers handshaker factory.
 void grpc_http_connect_register_handshaker_factory();
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_CONNECT_HANDSHAKER_H */

data/src/core/ext/filters/client_channel/{http_proxy.c → http_proxy.cc}

@@ -41,15 +41,15 @@
  * responsibility to gpr_free user_cred.
  */
 static char* get_http_proxy_server(grpc_exec_ctx* exec_ctx, char** user_cred) {
-  GPR_ASSERT(user_cred != NULL);
-  char* proxy_name = NULL;
+  GPR_ASSERT(user_cred != nullptr);
+  char* proxy_name = nullptr;
   char* uri_str = gpr_getenv("http_proxy");
-  char** authority_strs = NULL;
+  char** authority_strs = nullptr;
   size_t authority_nstrs;
-  if (uri_str == NULL) return NULL;
+  if (uri_str == nullptr) return nullptr;
   grpc_uri* uri =
       grpc_uri_parse(exec_ctx, uri_str, false /* suppress_errors */);
-  if (uri == NULL || uri->authority == NULL) {
+  if (uri == nullptr || uri->authority == nullptr) {
     gpr_log(GPR_ERROR, "cannot parse value of 'http_proxy' env var");
     goto done;
   }
@@ -73,7 +73,7 @@ static char* get_http_proxy_server(grpc_exec_ctx* exec_ctx, char** user_cred) {
     for (size_t i = 0; i < authority_nstrs; i++) {
       gpr_free(authority_strs[i]);
     }
-    proxy_name = NULL;
+    proxy_name = nullptr;
   }
   gpr_free(authority_strs);
 done:
@@ -88,13 +88,13 @@ static bool proxy_mapper_map_name(grpc_exec_ctx* exec_ctx,
                                   const grpc_channel_args* args,
                                   char** name_to_resolve,
                                   grpc_channel_args** new_args) {
-  char* user_cred = NULL;
+  char* user_cred = nullptr;
   *name_to_resolve = get_http_proxy_server(exec_ctx, &user_cred);
-  if (*name_to_resolve == NULL) return false;
-  char* no_proxy_str = NULL;
+  if (*name_to_resolve == nullptr) return false;
+  char* no_proxy_str = nullptr;
   grpc_uri* uri =
       grpc_uri_parse(exec_ctx, server_uri, false /* suppress_errors */);
-  if (uri == NULL || uri->path[0] == '\0') {
+  if (uri == nullptr || uri->path[0] == '\0') {
     gpr_log(GPR_ERROR,
             "'http_proxy' environment variable set, but cannot "
             "parse server URI '%s' -- not using proxy",
@@ -107,7 +107,7 @@ static bool proxy_mapper_map_name(grpc_exec_ctx* exec_ctx,
     goto no_use_proxy;
   }
   no_proxy_str = gpr_getenv("no_proxy");
-  if (no_proxy_str != NULL) {
+  if (no_proxy_str != nullptr) {
     static const char* NO_PROXY_SEPARATOR = ",";
     bool use_proxy = true;
     char* server_host;
@@ -149,7 +149,7 @@ static bool proxy_mapper_map_name(grpc_exec_ctx* exec_ctx,
   args_to_add[0] = grpc_channel_arg_string_create(
       (char*)GRPC_ARG_HTTP_CONNECT_SERVER,
       uri->path[0] == '/' ? uri->path + 1 : uri->path);
-  if (user_cred != NULL) {
+  if (user_cred != nullptr) {
     /* Use base64 encoding for user credentials as stated in RFC 7617 */
     char* encoded_user_cred =
         grpc_base64_encode(user_cred, strlen(user_cred), 0, 0);
@@ -167,9 +167,9 @@ static bool proxy_mapper_map_name(grpc_exec_ctx* exec_ctx,
   gpr_free(user_cred);
   return true;
 no_use_proxy:
-  if (uri != NULL) grpc_uri_destroy(uri);
+  if (uri != nullptr) grpc_uri_destroy(uri);
   gpr_free(*name_to_resolve);
-  *name_to_resolve = NULL;
+  *name_to_resolve = nullptr;
   gpr_free(user_cred);
   return false;
 }

data/src/core/ext/filters/client_channel/http_proxy.h

@@ -19,6 +19,14 @@
 #ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_H
 #define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 void grpc_register_http_proxy_mapper();
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_H */

data/src/core/ext/filters/client_channel/{lb_policy.c → lb_policy.cc}

@@ -21,14 +21,12 @@
 
 #define WEAK_REF_BITS 16
 
-#ifndef NDEBUG
-grpc_tracer_flag grpc_trace_lb_policy_refcount =
-    GRPC_TRACER_INITIALIZER(false, "lb_policy_refcount");
-#endif
+grpc_core::DebugOnlyTraceFlag grpc_trace_lb_policy_refcount(
+    false, "lb_policy_refcount");
 
-void grpc_lb_policy_init(grpc_lb_policy *policy,
-                         const grpc_lb_policy_vtable *vtable,
-                         grpc_combiner *combiner) {
+void grpc_lb_policy_init(grpc_lb_policy* policy,
+                         const grpc_lb_policy_vtable* vtable,
+                         grpc_combiner* combiner) {
   policy->vtable = vtable;
   gpr_atm_no_barrier_store(&policy->ref_pair, 1 << WEAK_REF_BITS);
   policy->interested_parties = grpc_pollset_set_create();
@@ -37,7 +35,7 @@ void grpc_lb_policy_init(grpc_lb_policy *policy,
 
 #ifndef NDEBUG
 #define REF_FUNC_EXTRA_ARGS , const char *file, int line, const char *reason
-#define REF_MUTATE_EXTRA_ARGS REF_FUNC_EXTRA_ARGS, const char *purpose
+#define REF_MUTATE_EXTRA_ARGS REF_FUNC_EXTRA_ARGS, const char* purpose
 #define REF_FUNC_PASS_ARGS(new_reason) , file, line, new_reason
 #define REF_MUTATE_PASS_ARGS(purpose) , file, line, reason, purpose
 #else
@@ -47,12 +45,12 @@ void grpc_lb_policy_init(grpc_lb_policy *policy,
 #define REF_MUTATE_PASS_ARGS(x)
 #endif
 
-static gpr_atm ref_mutate(grpc_lb_policy *c, gpr_atm delta,
+static gpr_atm ref_mutate(grpc_lb_policy* c, gpr_atm delta,
                           int barrier REF_MUTATE_EXTRA_ARGS) {
   gpr_atm old_val = barrier ? gpr_atm_full_fetch_add(&c->ref_pair, delta)
                             : gpr_atm_no_barrier_fetch_add(&c->ref_pair, delta);
 #ifndef NDEBUG
-  if (GRPC_TRACER_ON(grpc_trace_lb_policy_refcount)) {
+  if (grpc_trace_lb_policy_refcount.enabled()) {
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
             "LB_POLICY: %p %12s 0x%" PRIxPTR " -> 0x%" PRIxPTR " [%s]", c,
             purpose, old_val, old_val + delta, reason);
@@ -61,104 +59,105 @@ static gpr_atm ref_mutate(grpc_lb_policy *c, gpr_atm delta,
   return old_val;
 }
 
-void grpc_lb_policy_ref(grpc_lb_policy *policy REF_FUNC_EXTRA_ARGS) {
+void grpc_lb_policy_ref(grpc_lb_policy* policy REF_FUNC_EXTRA_ARGS) {
   ref_mutate(policy, 1 << WEAK_REF_BITS, 0 REF_MUTATE_PASS_ARGS("STRONG_REF"));
 }
 
-static void shutdown_locked(grpc_exec_ctx *exec_ctx, void *arg,
-                            grpc_error *error) {
-  grpc_lb_policy *policy = (grpc_lb_policy *)arg;
+static void shutdown_locked(grpc_exec_ctx* exec_ctx, void* arg,
+                            grpc_error* error) {
+  grpc_lb_policy* policy = (grpc_lb_policy*)arg;
   policy->vtable->shutdown_locked(exec_ctx, policy);
   GRPC_LB_POLICY_WEAK_UNREF(exec_ctx, policy, "strong-unref");
 }
 
-void grpc_lb_policy_unref(grpc_exec_ctx *exec_ctx,
-                          grpc_lb_policy *policy REF_FUNC_EXTRA_ARGS) {
+void grpc_lb_policy_unref(grpc_exec_ctx* exec_ctx,
+                          grpc_lb_policy* policy REF_FUNC_EXTRA_ARGS) {
   gpr_atm old_val =
       ref_mutate(policy, (gpr_atm)1 - (gpr_atm)(1 << WEAK_REF_BITS),
                  1 REF_MUTATE_PASS_ARGS("STRONG_UNREF"));
   gpr_atm mask = ~(gpr_atm)((1 << WEAK_REF_BITS) - 1);
   gpr_atm check = 1 << WEAK_REF_BITS;
   if ((old_val & mask) == check) {
-    GRPC_CLOSURE_SCHED(exec_ctx, GRPC_CLOSURE_CREATE(
-                                     shutdown_locked, policy,
-                                     grpc_combiner_scheduler(policy->combiner)),
-                       GRPC_ERROR_NONE);
+    GRPC_CLOSURE_SCHED(
+        exec_ctx,
+        GRPC_CLOSURE_CREATE(shutdown_locked, policy,
+                            grpc_combiner_scheduler(policy->combiner)),
+        GRPC_ERROR_NONE);
   } else {
     grpc_lb_policy_weak_unref(exec_ctx,
                               policy REF_FUNC_PASS_ARGS("strong-unref"));
   }
 }
 
-void grpc_lb_policy_weak_ref(grpc_lb_policy *policy REF_FUNC_EXTRA_ARGS) {
+void grpc_lb_policy_weak_ref(grpc_lb_policy* policy REF_FUNC_EXTRA_ARGS) {
   ref_mutate(policy, 1, 0 REF_MUTATE_PASS_ARGS("WEAK_REF"));
 }
 
-void grpc_lb_policy_weak_unref(grpc_exec_ctx *exec_ctx,
-                               grpc_lb_policy *policy REF_FUNC_EXTRA_ARGS) {
+void grpc_lb_policy_weak_unref(grpc_exec_ctx* exec_ctx,
+                               grpc_lb_policy* policy REF_FUNC_EXTRA_ARGS) {
   gpr_atm old_val =
       ref_mutate(policy, -(gpr_atm)1, 1 REF_MUTATE_PASS_ARGS("WEAK_UNREF"));
   if (old_val == 1) {
     grpc_pollset_set_destroy(exec_ctx, policy->interested_parties);
-    grpc_combiner *combiner = policy->combiner;
+    grpc_combiner* combiner = policy->combiner;
     policy->vtable->destroy(exec_ctx, policy);
     GRPC_COMBINER_UNREF(exec_ctx, combiner, "lb_policy");
   }
 }
 
-int grpc_lb_policy_pick_locked(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy,
-                               const grpc_lb_policy_pick_args *pick_args,
-                               grpc_connected_subchannel **target,
-                               grpc_call_context_element *context,
-                               void **user_data, grpc_closure *on_complete) {
+int grpc_lb_policy_pick_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* policy,
+                               const grpc_lb_policy_pick_args* pick_args,
+                               grpc_connected_subchannel** target,
+                               grpc_call_context_element* context,
+                               void** user_data, grpc_closure* on_complete) {
   return policy->vtable->pick_locked(exec_ctx, policy, pick_args, target,
                                      context, user_data, on_complete);
 }
 
-void grpc_lb_policy_cancel_pick_locked(grpc_exec_ctx *exec_ctx,
-                                       grpc_lb_policy *policy,
-                                       grpc_connected_subchannel **target,
-                                       grpc_error *error) {
+void grpc_lb_policy_cancel_pick_locked(grpc_exec_ctx* exec_ctx,
+                                       grpc_lb_policy* policy,
+                                       grpc_connected_subchannel** target,
+                                       grpc_error* error) {
   policy->vtable->cancel_pick_locked(exec_ctx, policy, target, error);
 }
 
-void grpc_lb_policy_cancel_picks_locked(grpc_exec_ctx *exec_ctx,
-                                        grpc_lb_policy *policy,
+void grpc_lb_policy_cancel_picks_locked(grpc_exec_ctx* exec_ctx,
+                                        grpc_lb_policy* policy,
                                         uint32_t initial_metadata_flags_mask,
                                         uint32_t initial_metadata_flags_eq,
-                                        grpc_error *error) {
+                                        grpc_error* error) {
   policy->vtable->cancel_picks_locked(exec_ctx, policy,
                                       initial_metadata_flags_mask,
                                       initial_metadata_flags_eq, error);
 }
 
-void grpc_lb_policy_exit_idle_locked(grpc_exec_ctx *exec_ctx,
-                                     grpc_lb_policy *policy) {
+void grpc_lb_policy_exit_idle_locked(grpc_exec_ctx* exec_ctx,
+                                     grpc_lb_policy* policy) {
   policy->vtable->exit_idle_locked(exec_ctx, policy);
 }
 
-void grpc_lb_policy_ping_one_locked(grpc_exec_ctx *exec_ctx,
-                                    grpc_lb_policy *policy,
-                                    grpc_closure *closure) {
+void grpc_lb_policy_ping_one_locked(grpc_exec_ctx* exec_ctx,
+                                    grpc_lb_policy* policy,
+                                    grpc_closure* closure) {
   policy->vtable->ping_one_locked(exec_ctx, policy, closure);
 }
 
 void grpc_lb_policy_notify_on_state_change_locked(
-    grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy,
-    grpc_connectivity_state *state, grpc_closure *closure) {
+    grpc_exec_ctx* exec_ctx, grpc_lb_policy* policy,
+    grpc_connectivity_state* state, grpc_closure* closure) {
   policy->vtable->notify_on_state_change_locked(exec_ctx, policy, state,
                                                 closure);
 }
 
 grpc_connectivity_state grpc_lb_policy_check_connectivity_locked(
-    grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy,
-    grpc_error **connectivity_error) {
+    grpc_exec_ctx* exec_ctx, grpc_lb_policy* policy,
+    grpc_error** connectivity_error) {
   return policy->vtable->check_connectivity_locked(exec_ctx, policy,
                                                    connectivity_error);
 }
 
-void grpc_lb_policy_update_locked(grpc_exec_ctx *exec_ctx,
-                                  grpc_lb_policy *policy,
-                                  const grpc_lb_policy_args *lb_policy_args) {
+void grpc_lb_policy_update_locked(grpc_exec_ctx* exec_ctx,
+                                  grpc_lb_policy* policy,
+                                  const grpc_lb_policy_args* lb_policy_args) {
   policy->vtable->update_locked(exec_ctx, policy, lb_policy_args);
 }