grpc 1.7.3 → 1.8.0

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

@@ -29,11 +29,15 @@
 // Channel arg key for grpc_lb_addresses.
 #define GRPC_ARG_LB_ADDRESSES "grpc.lb_addresses"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct grpc_lb_policy_factory grpc_lb_policy_factory;
 typedef struct grpc_lb_policy_factory_vtable grpc_lb_policy_factory_vtable;
 
 struct grpc_lb_policy_factory {
-  const grpc_lb_policy_factory_vtable *vtable;
+  const grpc_lb_policy_factory_vtable* vtable;
 };
 
 /** A resolved address alongside any LB related information associated with it.
@@ -44,90 +48,94 @@ struct grpc_lb_policy_factory {
 typedef struct grpc_lb_address {
   grpc_resolved_address address;
   bool is_balancer;
-  char *balancer_name; /* For secure naming. */
-  void *user_data;
+  char* balancer_name; /* For secure naming. */
+  void* user_data;
 } grpc_lb_address;
 
 typedef struct grpc_lb_user_data_vtable {
-  void *(*copy)(void *);
-  void (*destroy)(grpc_exec_ctx *exec_ctx, void *);
-  int (*cmp)(void *, void *);
+  void* (*copy)(void*);
+  void (*destroy)(grpc_exec_ctx* exec_ctx, void*);
+  int (*cmp)(void*, void*);
 } grpc_lb_user_data_vtable;
 
 typedef struct grpc_lb_addresses {
   size_t num_addresses;
-  grpc_lb_address *addresses;
-  const grpc_lb_user_data_vtable *user_data_vtable;
+  grpc_lb_address* addresses;
+  const grpc_lb_user_data_vtable* user_data_vtable;
 } grpc_lb_addresses;
 
 /** Returns a grpc_addresses struct with enough space for
     \a num_addresses addresses.  The \a user_data_vtable argument may be
     NULL if no user data will be added. */
-grpc_lb_addresses *grpc_lb_addresses_create(
-    size_t num_addresses, const grpc_lb_user_data_vtable *user_data_vtable);
+grpc_lb_addresses* grpc_lb_addresses_create(
+    size_t num_addresses, const grpc_lb_user_data_vtable* user_data_vtable);
 
 /** Creates a copy of \a addresses. */
-grpc_lb_addresses *grpc_lb_addresses_copy(const grpc_lb_addresses *addresses);
+grpc_lb_addresses* grpc_lb_addresses_copy(const grpc_lb_addresses* addresses);
 
 /** Sets the value of the address at index \a index of \a addresses.
  * \a address is a socket address of length \a address_len.
  * Takes ownership of \a balancer_name. */
-void grpc_lb_addresses_set_address(grpc_lb_addresses *addresses, size_t index,
-                                   const void *address, size_t address_len,
-                                   bool is_balancer, const char *balancer_name,
-                                   void *user_data);
+void grpc_lb_addresses_set_address(grpc_lb_addresses* addresses, size_t index,
+                                   const void* address, size_t address_len,
+                                   bool is_balancer, const char* balancer_name,
+                                   void* user_data);
 
 /** Sets the value of the address at index \a index of \a addresses from \a uri.
  * Returns true upon success, false otherwise. Takes ownership of \a
  * balancer_name. */
-bool grpc_lb_addresses_set_address_from_uri(grpc_lb_addresses *addresses,
-                                            size_t index, const grpc_uri *uri,
+bool grpc_lb_addresses_set_address_from_uri(grpc_lb_addresses* addresses,
+                                            size_t index, const grpc_uri* uri,
                                             bool is_balancer,
-                                            const char *balancer_name,
-                                            void *user_data);
+                                            const char* balancer_name,
+                                            void* user_data);
 
 /** Compares \a addresses1 and \a addresses2. */
-int grpc_lb_addresses_cmp(const grpc_lb_addresses *addresses1,
-                          const grpc_lb_addresses *addresses2);
+int grpc_lb_addresses_cmp(const grpc_lb_addresses* addresses1,
+                          const grpc_lb_addresses* addresses2);
 
 /** Destroys \a addresses. */
-void grpc_lb_addresses_destroy(grpc_exec_ctx *exec_ctx,
-                               grpc_lb_addresses *addresses);
+void grpc_lb_addresses_destroy(grpc_exec_ctx* exec_ctx,
+                               grpc_lb_addresses* addresses);
 
 /** Returns a channel arg containing \a addresses. */
 grpc_arg grpc_lb_addresses_create_channel_arg(
-    const grpc_lb_addresses *addresses);
+    const grpc_lb_addresses* addresses);
 
 /** Returns the \a grpc_lb_addresses instance in \a channel_args or NULL */
-grpc_lb_addresses *grpc_lb_addresses_find_channel_arg(
-    const grpc_channel_args *channel_args);
+grpc_lb_addresses* grpc_lb_addresses_find_channel_arg(
+    const grpc_channel_args* channel_args);
 
 /** Arguments passed to LB policies. */
 struct grpc_lb_policy_args {
-  grpc_client_channel_factory *client_channel_factory;
-  grpc_channel_args *args;
-  grpc_combiner *combiner;
+  grpc_client_channel_factory* client_channel_factory;
+  grpc_channel_args* args;
+  grpc_combiner* combiner;
 };
 
 struct grpc_lb_policy_factory_vtable {
-  void (*ref)(grpc_lb_policy_factory *factory);
-  void (*unref)(grpc_lb_policy_factory *factory);
+  void (*ref)(grpc_lb_policy_factory* factory);
+  void (*unref)(grpc_lb_policy_factory* factory);
 
   /** Implementation of grpc_lb_policy_factory_create_lb_policy */
-  grpc_lb_policy *(*create_lb_policy)(grpc_exec_ctx *exec_ctx,
-                                      grpc_lb_policy_factory *factory,
-                                      grpc_lb_policy_args *args);
+  grpc_lb_policy* (*create_lb_policy)(grpc_exec_ctx* exec_ctx,
+                                      grpc_lb_policy_factory* factory,
+                                      grpc_lb_policy_args* args);
 
   /** Name for the LB policy this factory implements */
-  const char *name;
+  const char* name;
 };
 
-void grpc_lb_policy_factory_ref(grpc_lb_policy_factory *factory);
-void grpc_lb_policy_factory_unref(grpc_lb_policy_factory *factory);
+void grpc_lb_policy_factory_ref(grpc_lb_policy_factory* factory);
+void grpc_lb_policy_factory_unref(grpc_lb_policy_factory* factory);
 
 /** Create a lb_policy instance. */
-grpc_lb_policy *grpc_lb_policy_factory_create_lb_policy(
-    grpc_exec_ctx *exec_ctx, grpc_lb_policy_factory *factory,
-    grpc_lb_policy_args *args);
+grpc_lb_policy* grpc_lb_policy_factory_create_lb_policy(
+    grpc_exec_ctx* exec_ctx, grpc_lb_policy_factory* factory,
+    grpc_lb_policy_args* args);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_FACTORY_H */

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

@@ -24,7 +24,7 @@
 
 #define MAX_POLICIES 10
 
-static grpc_lb_policy_factory *g_all_of_the_lb_policies[MAX_POLICIES];
+static grpc_lb_policy_factory* g_all_of_the_lb_policies[MAX_POLICIES];
 static int g_number_of_lb_policies = 0;
 
 void grpc_lb_policy_registry_init(void) { g_number_of_lb_policies = 0; }
@@ -36,7 +36,7 @@ void grpc_lb_policy_registry_shutdown(void) {
   }
 }
 
-void grpc_register_lb_policy(grpc_lb_policy_factory *factory) {
+void grpc_register_lb_policy(grpc_lb_policy_factory* factory) {
   int i;
   for (i = 0; i < g_number_of_lb_policies; i++) {
     GPR_ASSERT(0 != gpr_stricmp(factory->vtable->name,
@@ -47,10 +47,10 @@ void grpc_register_lb_policy(grpc_lb_policy_factory *factory) {
   g_all_of_the_lb_policies[g_number_of_lb_policies++] = factory;
 }
 
-static grpc_lb_policy_factory *lookup_factory(const char *name) {
+static grpc_lb_policy_factory* lookup_factory(const char* name) {
   int i;
 
-  if (name == NULL) return NULL;
+  if (name == nullptr) return nullptr;
 
   for (i = 0; i < g_number_of_lb_policies; i++) {
     if (0 == gpr_stricmp(name, g_all_of_the_lb_policies[i]->vtable->name)) {
@@ -58,13 +58,13 @@ static grpc_lb_policy_factory *lookup_factory(const char *name) {
     }
   }
 
-  return NULL;
+  return nullptr;
 }
 
-grpc_lb_policy *grpc_lb_policy_create(grpc_exec_ctx *exec_ctx, const char *name,
-                                      grpc_lb_policy_args *args) {
-  grpc_lb_policy_factory *factory = lookup_factory(name);
-  grpc_lb_policy *lb_policy =
+grpc_lb_policy* grpc_lb_policy_create(grpc_exec_ctx* exec_ctx, const char* name,
+                                      grpc_lb_policy_args* args) {
+  grpc_lb_policy_factory* factory = lookup_factory(name);
+  grpc_lb_policy* lb_policy =
       grpc_lb_policy_factory_create_lb_policy(exec_ctx, factory, args);
   return lb_policy;
 }

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

@@ -22,19 +22,27 @@
 #include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /** Initialize the registry and set \a default_factory as the factory to be
  * returned when no name is provided in a lookup */
 void grpc_lb_policy_registry_init(void);
 void grpc_lb_policy_registry_shutdown(void);
 
 /** Register a LB policy factory. */
-void grpc_register_lb_policy(grpc_lb_policy_factory *factory);
+void grpc_register_lb_policy(grpc_lb_policy_factory* factory);
 
 /** Create a \a grpc_lb_policy instance.
  *
  * If \a name is NULL, the default factory from \a grpc_lb_policy_registry_init
  * will be returned. */
-grpc_lb_policy *grpc_lb_policy_create(grpc_exec_ctx *exec_ctx, const char *name,
-                                      grpc_lb_policy_args *args);
+grpc_lb_policy* grpc_lb_policy_create(grpc_exec_ctx* exec_ctx, const char* name,
+                                      grpc_lb_policy_args* args);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_REGISTRY_H */

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

@@ -33,13 +33,13 @@
 
 #ifdef GRPC_HAVE_UNIX_SOCKET
 
-bool grpc_parse_unix(const grpc_uri *uri,
-                     grpc_resolved_address *resolved_addr) {
+bool grpc_parse_unix(const grpc_uri* uri,
+                     grpc_resolved_address* resolved_addr) {
   if (strcmp("unix", uri->scheme) != 0) {
     gpr_log(GPR_ERROR, "Expected 'unix' scheme, got '%s'", uri->scheme);
     return false;
   }
-  struct sockaddr_un *un = (struct sockaddr_un *)resolved_addr->addr;
+  struct sockaddr_un* un = (struct sockaddr_un*)resolved_addr->addr;
   const size_t maxlen = sizeof(un->sun_path);
   const size_t path_len = strnlen(uri->path, maxlen);
   if (path_len == maxlen) return false;
@@ -51,31 +51,31 @@ bool grpc_parse_unix(const grpc_uri *uri,
 
 #else /* GRPC_HAVE_UNIX_SOCKET */
 
-bool grpc_parse_unix(const grpc_uri *uri,
-                     grpc_resolved_address *resolved_addr) {
+bool grpc_parse_unix(const grpc_uri* uri,
+                     grpc_resolved_address* resolved_addr) {
   abort();
 }
 
 #endif /* GRPC_HAVE_UNIX_SOCKET */
 
-bool grpc_parse_ipv4_hostport(const char *hostport, grpc_resolved_address *addr,
+bool grpc_parse_ipv4_hostport(const char* hostport, grpc_resolved_address* addr,
                               bool log_errors) {
   bool success = false;
   // Split host and port.
-  char *host;
-  char *port;
+  char* host;
+  char* port;
   if (!gpr_split_host_port(hostport, &host, &port)) return false;
   // Parse IP address.
   memset(addr, 0, sizeof(*addr));
   addr->len = sizeof(struct sockaddr_in);
-  struct sockaddr_in *in = (struct sockaddr_in *)addr->addr;
+  struct sockaddr_in* in = (struct sockaddr_in*)addr->addr;
   in->sin_family = AF_INET;
   if (inet_pton(AF_INET, host, &in->sin_addr) == 0) {
     if (log_errors) gpr_log(GPR_ERROR, "invalid ipv4 address: '%s'", host);
     goto done;
   }
   // Parse port.
-  if (port == NULL) {
+  if (port == nullptr) {
     if (log_errors) gpr_log(GPR_ERROR, "no port given for ipv4 scheme");
     goto done;
   }
@@ -92,33 +92,33 @@ done:
   return success;
 }
 
-bool grpc_parse_ipv4(const grpc_uri *uri,
-                     grpc_resolved_address *resolved_addr) {
+bool grpc_parse_ipv4(const grpc_uri* uri,
+                     grpc_resolved_address* resolved_addr) {
   if (strcmp("ipv4", uri->scheme) != 0) {
     gpr_log(GPR_ERROR, "Expected 'ipv4' scheme, got '%s'", uri->scheme);
     return false;
   }
-  const char *host_port = uri->path;
+  const char* host_port = uri->path;
   if (*host_port == '/') ++host_port;
   return grpc_parse_ipv4_hostport(host_port, resolved_addr,
                                   true /* log_errors */);
 }
 
-bool grpc_parse_ipv6_hostport(const char *hostport, grpc_resolved_address *addr,
+bool grpc_parse_ipv6_hostport(const char* hostport, grpc_resolved_address* addr,
                               bool log_errors) {
   bool success = false;
   // Split host and port.
-  char *host;
-  char *port;
+  char* host;
+  char* port;
   if (!gpr_split_host_port(hostport, &host, &port)) return false;
   // Parse IP address.
   memset(addr, 0, sizeof(*addr));
   addr->len = sizeof(struct sockaddr_in6);
-  struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)addr->addr;
+  struct sockaddr_in6* in6 = (struct sockaddr_in6*)addr->addr;
   in6->sin6_family = AF_INET6;
   // Handle the RFC6874 syntax for IPv6 zone identifiers.
-  char *host_end = (char *)gpr_memrchr(host, '%', strlen(host));
-  if (host_end != NULL) {
+  char* host_end = (char*)gpr_memrchr(host, '%', strlen(host));
+  if (host_end != nullptr) {
     GPR_ASSERT(host_end >= host);
     char host_without_scope[INET6_ADDRSTRLEN];
     size_t host_without_scope_len = (size_t)(host_end - host);
@@ -144,7 +144,7 @@ bool grpc_parse_ipv6_hostport(const char *hostport, grpc_resolved_address *addr,
     }
   }
   // Parse port.
-  if (port == NULL) {
+  if (port == nullptr) {
     if (log_errors) gpr_log(GPR_ERROR, "no port given for ipv6 scheme");
     goto done;
   }
@@ -161,19 +161,19 @@ done:
   return success;
 }
 
-bool grpc_parse_ipv6(const grpc_uri *uri,
-                     grpc_resolved_address *resolved_addr) {
+bool grpc_parse_ipv6(const grpc_uri* uri,
+                     grpc_resolved_address* resolved_addr) {
   if (strcmp("ipv6", uri->scheme) != 0) {
     gpr_log(GPR_ERROR, "Expected 'ipv6' scheme, got '%s'", uri->scheme);
     return false;
   }
-  const char *host_port = uri->path;
+  const char* host_port = uri->path;
   if (*host_port == '/') ++host_port;
   return grpc_parse_ipv6_hostport(host_port, resolved_addr,
                                   true /* log_errors */);
 }
 
-bool grpc_parse_uri(const grpc_uri *uri, grpc_resolved_address *resolved_addr) {
+bool grpc_parse_uri(const grpc_uri* uri, grpc_resolved_address* resolved_addr) {
   if (strcmp("unix", uri->scheme) == 0) {
     return grpc_parse_unix(uri, resolved_addr);
   } else if (strcmp("ipv4", uri->scheme) == 0) {

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

@@ -24,25 +24,33 @@
 #include "src/core/ext/filters/client_channel/uri_parser.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /** Populate \a resolved_addr from \a uri, whose path is expected to contain a
  * unix socket path. Returns true upon success. */
-bool grpc_parse_unix(const grpc_uri *uri, grpc_resolved_address *resolved_addr);
+bool grpc_parse_unix(const grpc_uri* uri, grpc_resolved_address* resolved_addr);
 
 /** Populate \a resolved_addr from \a uri, whose path is expected to contain an
  * IPv4 host:port pair. Returns true upon success. */
-bool grpc_parse_ipv4(const grpc_uri *uri, grpc_resolved_address *resolved_addr);
+bool grpc_parse_ipv4(const grpc_uri* uri, grpc_resolved_address* resolved_addr);
 
 /** Populate \a resolved_addr from \a uri, whose path is expected to contain an
  * IPv6 host:port pair. Returns true upon success. */
-bool grpc_parse_ipv6(const grpc_uri *uri, grpc_resolved_address *resolved_addr);
+bool grpc_parse_ipv6(const grpc_uri* uri, grpc_resolved_address* resolved_addr);
 
 /** Populate \a resolved_addr from \a uri. Returns true upon success. */
-bool grpc_parse_uri(const grpc_uri *uri, grpc_resolved_address *resolved_addr);
+bool grpc_parse_uri(const grpc_uri* uri, grpc_resolved_address* resolved_addr);
 
 /** Parse bare IPv4 or IPv6 "IP:port" strings. */
-bool grpc_parse_ipv4_hostport(const char *hostport, grpc_resolved_address *addr,
+bool grpc_parse_ipv4_hostport(const char* hostport, grpc_resolved_address* addr,
                               bool log_errors);
-bool grpc_parse_ipv6_hostport(const char *hostport, grpc_resolved_address *addr,
+bool grpc_parse_ipv6_hostport(const char* hostport, grpc_resolved_address* addr,
                               bool log_errors);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_PARSE_ADDRESS_H */

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

@@ -25,6 +25,10 @@
 
 #include "src/core/lib/iomgr/resolve_address.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct grpc_proxy_mapper grpc_proxy_mapper;
 
 typedef struct {
@@ -71,4 +75,8 @@ bool grpc_proxy_mapper_map_address(grpc_exec_ctx* exec_ctx,
 
 void grpc_proxy_mapper_destroy(grpc_proxy_mapper* mapper);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_PROXY_MAPPER_H */

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

@@ -21,6 +21,10 @@
 
 #include "src/core/ext/filters/client_channel/proxy_mapper.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 void grpc_proxy_mapper_registry_init();
 void grpc_proxy_mapper_registry_shutdown();
 
@@ -41,4 +45,8 @@ bool grpc_proxy_mappers_map_address(grpc_exec_ctx* exec_ctx,
                                     grpc_resolved_address** new_address,
                                     grpc_channel_args** new_args);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_PROXY_MAPPER_REGISTRY_H */

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

@@ -19,65 +19,63 @@
 #include "src/core/ext/filters/client_channel/resolver.h"
 #include "src/core/lib/iomgr/combiner.h"
 
-#ifndef NDEBUG
-grpc_tracer_flag grpc_trace_resolver_refcount =
-    GRPC_TRACER_INITIALIZER(false, "resolver_refcount");
-#endif
+grpc_core::DebugOnlyTraceFlag grpc_trace_resolver_refcount(false,
+                                                           "resolver_refcount");
 
-void grpc_resolver_init(grpc_resolver *resolver,
-                        const grpc_resolver_vtable *vtable,
-                        grpc_combiner *combiner) {
+void grpc_resolver_init(grpc_resolver* resolver,
+                        const grpc_resolver_vtable* vtable,
+                        grpc_combiner* combiner) {
   resolver->vtable = vtable;
   resolver->combiner = GRPC_COMBINER_REF(combiner, "resolver");
   gpr_ref_init(&resolver->refs, 1);
 }
 
 #ifndef NDEBUG
-void grpc_resolver_ref(grpc_resolver *resolver, const char *file, int line,
-                       const char *reason) {
-  if (GRPC_TRACER_ON(grpc_trace_resolver_refcount)) {
+void grpc_resolver_ref(grpc_resolver* resolver, const char* file, int line,
+                       const char* reason) {
+  if (grpc_trace_resolver_refcount.enabled()) {
     gpr_atm old_refs = gpr_atm_no_barrier_load(&resolver->refs.count);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
             "RESOLVER:%p   ref %" PRIdPTR " -> %" PRIdPTR " %s", resolver,
             old_refs, old_refs + 1, reason);
   }
 #else
-void grpc_resolver_ref(grpc_resolver *resolver) {
+void grpc_resolver_ref(grpc_resolver* resolver) {
 #endif
   gpr_ref(&resolver->refs);
 }
 
 #ifndef NDEBUG
-void grpc_resolver_unref(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver,
-                         const char *file, int line, const char *reason) {
-  if (GRPC_TRACER_ON(grpc_trace_resolver_refcount)) {
+void grpc_resolver_unref(grpc_exec_ctx* exec_ctx, grpc_resolver* resolver,
+                         const char* file, int line, const char* reason) {
+  if (grpc_trace_resolver_refcount.enabled()) {
     gpr_atm old_refs = gpr_atm_no_barrier_load(&resolver->refs.count);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
             "RESOLVER:%p unref %" PRIdPTR " -> %" PRIdPTR " %s", resolver,
             old_refs, old_refs - 1, reason);
   }
 #else
-void grpc_resolver_unref(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver) {
+void grpc_resolver_unref(grpc_exec_ctx* exec_ctx, grpc_resolver* resolver) {
 #endif
   if (gpr_unref(&resolver->refs)) {
-    grpc_combiner *combiner = resolver->combiner;
+    grpc_combiner* combiner = resolver->combiner;
     resolver->vtable->destroy(exec_ctx, resolver);
     GRPC_COMBINER_UNREF(exec_ctx, combiner, "resolver");
   }
 }
 
-void grpc_resolver_shutdown_locked(grpc_exec_ctx *exec_ctx,
-                                   grpc_resolver *resolver) {
+void grpc_resolver_shutdown_locked(grpc_exec_ctx* exec_ctx,
+                                   grpc_resolver* resolver) {
   resolver->vtable->shutdown_locked(exec_ctx, resolver);
 }
 
-void grpc_resolver_channel_saw_error_locked(grpc_exec_ctx *exec_ctx,
-                                            grpc_resolver *resolver) {
+void grpc_resolver_channel_saw_error_locked(grpc_exec_ctx* exec_ctx,
+                                            grpc_resolver* resolver) {
   resolver->vtable->channel_saw_error_locked(exec_ctx, resolver);
 }
 
-void grpc_resolver_next_locked(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver,
-                               grpc_channel_args **result,
-                               grpc_closure *on_complete) {
+void grpc_resolver_next_locked(grpc_exec_ctx* exec_ctx, grpc_resolver* resolver,
+                               grpc_channel_args** result,
+                               grpc_closure* on_complete) {
   resolver->vtable->next_locked(exec_ctx, resolver, result, on_complete);
 }