grpc 1.7.3 → 1.8.0

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

@@ -78,31 +78,31 @@ static void fake_resolver_destroy(grpc_exec_ctx* exec_ctx, grpc_resolver* gr) {
 static void fake_resolver_shutdown_locked(grpc_exec_ctx* exec_ctx,
                                           grpc_resolver* resolver) {
   fake_resolver* r = (fake_resolver*)resolver;
-  if (r->next_completion != NULL) {
-    *r->target_result = NULL;
+  if (r->next_completion != nullptr) {
+    *r->target_result = nullptr;
     GRPC_CLOSURE_SCHED(
         exec_ctx, r->next_completion,
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Resolver Shutdown"));
-    r->next_completion = NULL;
+    r->next_completion = nullptr;
   }
 }
 
 static void fake_resolver_maybe_finish_next_locked(grpc_exec_ctx* exec_ctx,
                                                    fake_resolver* r) {
-  if (r->next_completion != NULL && r->next_results != NULL) {
+  if (r->next_completion != nullptr && r->next_results != nullptr) {
     *r->target_result =
         grpc_channel_args_union(r->next_results, r->channel_args);
     grpc_channel_args_destroy(exec_ctx, r->next_results);
-    r->next_results = NULL;
+    r->next_results = nullptr;
     GRPC_CLOSURE_SCHED(exec_ctx, r->next_completion, GRPC_ERROR_NONE);
-    r->next_completion = NULL;
+    r->next_completion = nullptr;
   }
 }
 
 static void fake_resolver_channel_saw_error_locked(grpc_exec_ctx* exec_ctx,
                                                    grpc_resolver* resolver) {
   fake_resolver* r = (fake_resolver*)resolver;
-  if (r->next_results == NULL && r->results_upon_error != NULL) {
+  if (r->next_results == nullptr && r->results_upon_error != nullptr) {
     // Pretend we re-resolved.
     r->next_results = grpc_channel_args_copy(r->results_upon_error);
   }
@@ -162,11 +162,11 @@ static void set_response_closure_fn(grpc_exec_ctx* exec_ctx, void* arg,
   set_response_closure_arg* closure_arg = (set_response_closure_arg*)arg;
   grpc_fake_resolver_response_generator* generator = closure_arg->generator;
   fake_resolver* r = generator->resolver;
-  if (r->next_results != NULL) {
+  if (r->next_results != nullptr) {
     grpc_channel_args_destroy(exec_ctx, r->next_results);
   }
   r->next_results = closure_arg->next_response;
-  if (r->results_upon_error != NULL) {
+  if (r->results_upon_error != nullptr) {
     grpc_channel_args_destroy(exec_ctx, r->results_upon_error);
   }
   r->results_upon_error = grpc_channel_args_copy(closure_arg->next_response);
@@ -177,7 +177,7 @@ static void set_response_closure_fn(grpc_exec_ctx* exec_ctx, void* arg,
 void grpc_fake_resolver_response_generator_set_response(
     grpc_exec_ctx* exec_ctx, grpc_fake_resolver_response_generator* generator,
     grpc_channel_args* next_response) {
-  GPR_ASSERT(generator->resolver != NULL);
+  GPR_ASSERT(generator->resolver != nullptr);
   set_response_closure_arg* closure_arg =
       (set_response_closure_arg*)gpr_zalloc(sizeof(*closure_arg));
   closure_arg->generator = generator;
@@ -220,7 +220,7 @@ grpc_fake_resolver_response_generator*
 grpc_fake_resolver_get_response_generator(const grpc_channel_args* args) {
   const grpc_arg* arg =
       grpc_channel_args_find(args, GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR);
-  if (arg == NULL || arg->type != GRPC_ARG_POINTER) return NULL;
+  if (arg == nullptr || arg->type != GRPC_ARG_POINTER) return nullptr;
   return (grpc_fake_resolver_response_generator*)arg->value.pointer.p;
 }
 
@@ -240,7 +240,7 @@ static grpc_resolver* fake_resolver_create(grpc_exec_ctx* exec_ctx,
   grpc_resolver_init(&r->base, &fake_resolver_vtable, args->combiner);
   grpc_fake_resolver_response_generator* response_generator =
       grpc_fake_resolver_get_response_generator(args->args);
-  if (response_generator != NULL) response_generator->resolver = r;
+  if (response_generator != nullptr) response_generator->resolver = r;
   return &r->base;
 }
 
@@ -258,8 +258,8 @@ static const grpc_resolver_factory_vtable fake_resolver_factory_vtable = {
 static grpc_resolver_factory fake_resolver_factory = {
     &fake_resolver_factory_vtable};
 
-void grpc_resolver_fake_init(void) {
+extern "C" void grpc_resolver_fake_init(void) {
   grpc_register_resolver_type(&fake_resolver_factory);
 }
 
-void grpc_resolver_fake_shutdown(void) {}
+extern "C" void grpc_resolver_fake_shutdown(void) {}

data/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h

@@ -21,6 +21,10 @@
 #include "src/core/ext/filters/client_channel/uri_parser.h"
 #include "src/core/lib/channel/channel_args.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #define GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR \
   "grpc.fake_resolver.response_generator"
 
@@ -56,5 +60,9 @@ grpc_fake_resolver_response_generator_ref(
 void grpc_fake_resolver_response_generator_unref(
     grpc_fake_resolver_response_generator* generator);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FAKE_FAKE_RESOLVER_H \
-          */
+        */

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

@@ -41,115 +41,115 @@ typedef struct {
   /** base class: must be first */
   grpc_resolver base;
   /** the addresses that we've 'resolved' */
-  grpc_lb_addresses *addresses;
+  grpc_lb_addresses* addresses;
   /** channel args */
-  grpc_channel_args *channel_args;
+  grpc_channel_args* channel_args;
   /** have we published? */
   bool published;
   /** pending next completion, or NULL */
-  grpc_closure *next_completion;
+  grpc_closure* next_completion;
   /** target result address for next completion */
-  grpc_channel_args **target_result;
+  grpc_channel_args** target_result;
 } sockaddr_resolver;
 
-static void sockaddr_destroy(grpc_exec_ctx *exec_ctx, grpc_resolver *r);
+static void sockaddr_destroy(grpc_exec_ctx* exec_ctx, grpc_resolver* r);
 
-static void sockaddr_maybe_finish_next_locked(grpc_exec_ctx *exec_ctx,
-                                              sockaddr_resolver *r);
+static void sockaddr_maybe_finish_next_locked(grpc_exec_ctx* exec_ctx,
+                                              sockaddr_resolver* r);
 
-static void sockaddr_shutdown_locked(grpc_exec_ctx *exec_ctx, grpc_resolver *r);
-static void sockaddr_channel_saw_error_locked(grpc_exec_ctx *exec_ctx,
-                                              grpc_resolver *r);
-static void sockaddr_next_locked(grpc_exec_ctx *exec_ctx, grpc_resolver *r,
-                                 grpc_channel_args **target_result,
-                                 grpc_closure *on_complete);
+static void sockaddr_shutdown_locked(grpc_exec_ctx* exec_ctx, grpc_resolver* r);
+static void sockaddr_channel_saw_error_locked(grpc_exec_ctx* exec_ctx,
+                                              grpc_resolver* r);
+static void sockaddr_next_locked(grpc_exec_ctx* exec_ctx, grpc_resolver* r,
+                                 grpc_channel_args** target_result,
+                                 grpc_closure* on_complete);
 
 static const grpc_resolver_vtable sockaddr_resolver_vtable = {
     sockaddr_destroy, sockaddr_shutdown_locked,
     sockaddr_channel_saw_error_locked, sockaddr_next_locked};
 
-static void sockaddr_shutdown_locked(grpc_exec_ctx *exec_ctx,
-                                     grpc_resolver *resolver) {
-  sockaddr_resolver *r = (sockaddr_resolver *)resolver;
-  if (r->next_completion != NULL) {
-    *r->target_result = NULL;
+static void sockaddr_shutdown_locked(grpc_exec_ctx* exec_ctx,
+                                     grpc_resolver* resolver) {
+  sockaddr_resolver* r = (sockaddr_resolver*)resolver;
+  if (r->next_completion != nullptr) {
+    *r->target_result = nullptr;
     GRPC_CLOSURE_SCHED(
         exec_ctx, r->next_completion,
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Resolver Shutdown"));
-    r->next_completion = NULL;
+    r->next_completion = nullptr;
   }
 }
 
-static void sockaddr_channel_saw_error_locked(grpc_exec_ctx *exec_ctx,
-                                              grpc_resolver *resolver) {
-  sockaddr_resolver *r = (sockaddr_resolver *)resolver;
+static void sockaddr_channel_saw_error_locked(grpc_exec_ctx* exec_ctx,
+                                              grpc_resolver* resolver) {
+  sockaddr_resolver* r = (sockaddr_resolver*)resolver;
   r->published = false;
   sockaddr_maybe_finish_next_locked(exec_ctx, r);
 }
 
-static void sockaddr_next_locked(grpc_exec_ctx *exec_ctx,
-                                 grpc_resolver *resolver,
-                                 grpc_channel_args **target_result,
-                                 grpc_closure *on_complete) {
-  sockaddr_resolver *r = (sockaddr_resolver *)resolver;
+static void sockaddr_next_locked(grpc_exec_ctx* exec_ctx,
+                                 grpc_resolver* resolver,
+                                 grpc_channel_args** target_result,
+                                 grpc_closure* on_complete) {
+  sockaddr_resolver* r = (sockaddr_resolver*)resolver;
   GPR_ASSERT(!r->next_completion);
   r->next_completion = on_complete;
   r->target_result = target_result;
   sockaddr_maybe_finish_next_locked(exec_ctx, r);
 }
 
-static void sockaddr_maybe_finish_next_locked(grpc_exec_ctx *exec_ctx,
-                                              sockaddr_resolver *r) {
-  if (r->next_completion != NULL && !r->published) {
+static void sockaddr_maybe_finish_next_locked(grpc_exec_ctx* exec_ctx,
+                                              sockaddr_resolver* r) {
+  if (r->next_completion != nullptr && !r->published) {
     r->published = true;
     grpc_arg arg = grpc_lb_addresses_create_channel_arg(r->addresses);
     *r->target_result =
         grpc_channel_args_copy_and_add(r->channel_args, &arg, 1);
     GRPC_CLOSURE_SCHED(exec_ctx, r->next_completion, GRPC_ERROR_NONE);
-    r->next_completion = NULL;
+    r->next_completion = nullptr;
   }
 }
 
-static void sockaddr_destroy(grpc_exec_ctx *exec_ctx, grpc_resolver *gr) {
-  sockaddr_resolver *r = (sockaddr_resolver *)gr;
+static void sockaddr_destroy(grpc_exec_ctx* exec_ctx, grpc_resolver* gr) {
+  sockaddr_resolver* r = (sockaddr_resolver*)gr;
   grpc_lb_addresses_destroy(exec_ctx, r->addresses);
   grpc_channel_args_destroy(exec_ctx, r->channel_args);
   gpr_free(r);
 }
 
-static char *ip_get_default_authority(grpc_uri *uri) {
-  const char *path = uri->path;
+static char* ip_get_default_authority(grpc_uri* uri) {
+  const char* path = uri->path;
   if (path[0] == '/') ++path;
   return gpr_strdup(path);
 }
 
-static char *ipv4_get_default_authority(grpc_resolver_factory *factory,
-                                        grpc_uri *uri) {
+static char* ipv4_get_default_authority(grpc_resolver_factory* factory,
+                                        grpc_uri* uri) {
   return ip_get_default_authority(uri);
 }
 
-static char *ipv6_get_default_authority(grpc_resolver_factory *factory,
-                                        grpc_uri *uri) {
+static char* ipv6_get_default_authority(grpc_resolver_factory* factory,
+                                        grpc_uri* uri) {
   return ip_get_default_authority(uri);
 }
 
 #ifdef GRPC_HAVE_UNIX_SOCKET
-char *unix_get_default_authority(grpc_resolver_factory *factory,
-                                 grpc_uri *uri) {
+char* unix_get_default_authority(grpc_resolver_factory* factory,
+                                 grpc_uri* uri) {
   return gpr_strdup("localhost");
 }
 #endif
 
-static void do_nothing(void *ignored) {}
+static void do_nothing(void* ignored) {}
 
-static grpc_resolver *sockaddr_create(grpc_exec_ctx *exec_ctx,
-                                      grpc_resolver_args *args,
-                                      bool parse(const grpc_uri *uri,
-                                                 grpc_resolved_address *dst)) {
+static grpc_resolver* sockaddr_create(grpc_exec_ctx* exec_ctx,
+                                      grpc_resolver_args* args,
+                                      bool parse(const grpc_uri* uri,
+                                                 grpc_resolved_address* dst)) {
   if (0 != strcmp(args->uri->authority, "")) {
     gpr_log(GPR_ERROR, "authority based uri's not supported by the %s scheme",
             args->uri->scheme);
-    return NULL;
+    return nullptr;
   }
   /* Construct addresses. */
   grpc_slice path_slice =
@@ -157,12 +157,12 @@ static grpc_resolver *sockaddr_create(grpc_exec_ctx *exec_ctx,
   grpc_slice_buffer path_parts;
   grpc_slice_buffer_init(&path_parts);
   grpc_slice_split(path_slice, ",", &path_parts);
-  grpc_lb_addresses *addresses =
-      grpc_lb_addresses_create(path_parts.count, NULL /* user_data_vtable */);
+  grpc_lb_addresses* addresses = grpc_lb_addresses_create(
+      path_parts.count, nullptr /* user_data_vtable */);
   bool errors_found = false;
   for (size_t i = 0; i < addresses->num_addresses; i++) {
     grpc_uri ith_uri = *args->uri;
-    char *part_str = grpc_slice_to_c_string(path_parts.slices[i]);
+    char* part_str = grpc_slice_to_c_string(path_parts.slices[i]);
     ith_uri.path = part_str;
     if (!parse(&ith_uri, &addresses->addresses[i].address)) {
       errors_found = true; /* GPR_TRUE */
@@ -174,11 +174,11 @@ static grpc_resolver *sockaddr_create(grpc_exec_ctx *exec_ctx,
   grpc_slice_unref_internal(exec_ctx, path_slice);
   if (errors_found) {
     grpc_lb_addresses_destroy(exec_ctx, addresses);
-    return NULL;
+    return nullptr;
   }
   /* Instantiate resolver. */
-  sockaddr_resolver *r =
-      (sockaddr_resolver *)gpr_zalloc(sizeof(sockaddr_resolver));
+  sockaddr_resolver* r =
+      (sockaddr_resolver*)gpr_zalloc(sizeof(sockaddr_resolver));
   r->addresses = addresses;
   r->channel_args = grpc_channel_args_copy(args->args);
   grpc_resolver_init(&r->base, &sockaddr_resolver_vtable, args->combiner);
@@ -189,14 +189,14 @@ static grpc_resolver *sockaddr_create(grpc_exec_ctx *exec_ctx,
  * FACTORY
  */
 
-static void sockaddr_factory_ref(grpc_resolver_factory *factory) {}
+static void sockaddr_factory_ref(grpc_resolver_factory* factory) {}
 
-static void sockaddr_factory_unref(grpc_resolver_factory *factory) {}
+static void sockaddr_factory_unref(grpc_resolver_factory* factory) {}
 
 #define DECL_FACTORY(name)                                                  \
-  static grpc_resolver *name##_factory_create_resolver(                     \
-      grpc_exec_ctx *exec_ctx, grpc_resolver_factory *factory,              \
-      grpc_resolver_args *args) {                                           \
+  static grpc_resolver* name##_factory_create_resolver(                     \
+      grpc_exec_ctx* exec_ctx, grpc_resolver_factory* factory,              \
+      grpc_resolver_args* args) {                                           \
     return sockaddr_create(exec_ctx, args, grpc_parse_##name);              \
   }                                                                         \
   static const grpc_resolver_factory_vtable name##_factory_vtable = {       \
@@ -211,7 +211,7 @@ DECL_FACTORY(unix);
 DECL_FACTORY(ipv4);
 DECL_FACTORY(ipv6);
 
-void grpc_resolver_sockaddr_init(void) {
+extern "C" void grpc_resolver_sockaddr_init(void) {
   grpc_register_resolver_type(&ipv4_resolver_factory);
   grpc_register_resolver_type(&ipv6_resolver_factory);
 #ifdef GRPC_HAVE_UNIX_SOCKET
@@ -219,4 +219,4 @@ void grpc_resolver_sockaddr_init(void) {
 #endif
 }
 
-void grpc_resolver_sockaddr_shutdown(void) {}
+extern "C" void grpc_resolver_sockaddr_shutdown(void) {}

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

@@ -30,12 +30,12 @@ void grpc_resolver_factory_unref(grpc_resolver_factory* factory) {
 grpc_resolver* grpc_resolver_factory_create_resolver(
     grpc_exec_ctx* exec_ctx, grpc_resolver_factory* factory,
     grpc_resolver_args* args) {
-  if (factory == NULL) return NULL;
+  if (factory == nullptr) return nullptr;
   return factory->vtable->create_resolver(exec_ctx, factory, args);
 }
 
 char* grpc_resolver_factory_get_default_authority(
     grpc_resolver_factory* factory, grpc_uri* uri) {
-  if (factory == NULL) return NULL;
+  if (factory == nullptr) return nullptr;
   return factory->vtable->get_default_authority(factory, uri);
 }

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

@@ -24,47 +24,55 @@
 #include "src/core/ext/filters/client_channel/uri_parser.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct grpc_resolver_factory grpc_resolver_factory;
 typedef struct grpc_resolver_factory_vtable grpc_resolver_factory_vtable;
 
 struct grpc_resolver_factory {
-  const grpc_resolver_factory_vtable *vtable;
+  const grpc_resolver_factory_vtable* vtable;
 };
 
 typedef struct grpc_resolver_args {
-  grpc_uri *uri;
-  const grpc_channel_args *args;
-  grpc_pollset_set *pollset_set;
-  grpc_combiner *combiner;
+  grpc_uri* uri;
+  const grpc_channel_args* args;
+  grpc_pollset_set* pollset_set;
+  grpc_combiner* combiner;
 } grpc_resolver_args;
 
 struct grpc_resolver_factory_vtable {
-  void (*ref)(grpc_resolver_factory *factory);
-  void (*unref)(grpc_resolver_factory *factory);
+  void (*ref)(grpc_resolver_factory* factory);
+  void (*unref)(grpc_resolver_factory* factory);
 
   /** Implementation of grpc_resolver_factory_create_resolver */
-  grpc_resolver *(*create_resolver)(grpc_exec_ctx *exec_ctx,
-                                    grpc_resolver_factory *factory,
-                                    grpc_resolver_args *args);
+  grpc_resolver* (*create_resolver)(grpc_exec_ctx* exec_ctx,
+                                    grpc_resolver_factory* factory,
+                                    grpc_resolver_args* args);
 
   /** Implementation of grpc_resolver_factory_get_default_authority */
-  char *(*get_default_authority)(grpc_resolver_factory *factory, grpc_uri *uri);
+  char* (*get_default_authority)(grpc_resolver_factory* factory, grpc_uri* uri);
 
   /** URI scheme that this factory implements */
-  const char *scheme;
+  const char* scheme;
 };
 
-void grpc_resolver_factory_ref(grpc_resolver_factory *resolver);
-void grpc_resolver_factory_unref(grpc_resolver_factory *resolver);
+void grpc_resolver_factory_ref(grpc_resolver_factory* resolver);
+void grpc_resolver_factory_unref(grpc_resolver_factory* resolver);
 
 /** Create a resolver instance for a name */
-grpc_resolver *grpc_resolver_factory_create_resolver(
-    grpc_exec_ctx *exec_ctx, grpc_resolver_factory *factory,
-    grpc_resolver_args *args);
+grpc_resolver* grpc_resolver_factory_create_resolver(
+    grpc_exec_ctx* exec_ctx, grpc_resolver_factory* factory,
+    grpc_resolver_args* args);
 
 /** Return a (freshly allocated with gpr_malloc) string representing
     the default authority to use for this scheme. */
-char *grpc_resolver_factory_get_default_authority(
-    grpc_resolver_factory *factory, grpc_uri *uri);
+char* grpc_resolver_factory_get_default_authority(
+    grpc_resolver_factory* factory, grpc_uri* uri);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_FACTORY_H */

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

@@ -27,7 +27,7 @@
 #define MAX_RESOLVERS 10
 #define DEFAULT_RESOLVER_PREFIX_MAX_LENGTH 32
 
-static grpc_resolver_factory *g_all_of_the_resolvers[MAX_RESOLVERS];
+static grpc_resolver_factory* g_all_of_the_resolvers[MAX_RESOLVERS];
 static int g_number_of_resolvers = 0;
 
 static char g_default_resolver_prefix[DEFAULT_RESOLVER_PREFIX_MAX_LENGTH] =
@@ -49,7 +49,7 @@ void grpc_resolver_registry_shutdown(void) {
 }
 
 void grpc_resolver_registry_set_default_prefix(
-    const char *default_resolver_prefix) {
+    const char* default_resolver_prefix) {
   const size_t len = strlen(default_resolver_prefix);
   GPR_ASSERT(len < DEFAULT_RESOLVER_PREFIX_MAX_LENGTH &&
              "default resolver prefix too long");
@@ -59,7 +59,7 @@ void grpc_resolver_registry_set_default_prefix(
   strcpy(g_default_resolver_prefix, default_resolver_prefix);
 }
 
-void grpc_register_resolver_type(grpc_resolver_factory *factory) {
+void grpc_register_resolver_type(grpc_resolver_factory* factory) {
   int i;
   for (i = 0; i < g_number_of_resolvers; i++) {
     GPR_ASSERT(0 != strcmp(factory->vtable->scheme,
@@ -70,7 +70,7 @@ void grpc_register_resolver_type(grpc_resolver_factory *factory) {
   g_all_of_the_resolvers[g_number_of_resolvers++] = factory;
 }
 
-static grpc_resolver_factory *lookup_factory(const char *name) {
+static grpc_resolver_factory* lookup_factory(const char* name) {
   int i;
 
   for (i = 0; i < g_number_of_resolvers; i++) {
@@ -78,35 +78,35 @@ static grpc_resolver_factory *lookup_factory(const char *name) {
       return g_all_of_the_resolvers[i];
     }
   }
-  return NULL;
+  return nullptr;
 }
 
-grpc_resolver_factory *grpc_resolver_factory_lookup(const char *name) {
-  grpc_resolver_factory *f = lookup_factory(name);
+grpc_resolver_factory* grpc_resolver_factory_lookup(const char* name) {
+  grpc_resolver_factory* f = lookup_factory(name);
   if (f) grpc_resolver_factory_ref(f);
   return f;
 }
 
-static grpc_resolver_factory *lookup_factory_by_uri(grpc_uri *uri) {
-  if (!uri) return NULL;
+static grpc_resolver_factory* lookup_factory_by_uri(grpc_uri* uri) {
+  if (!uri) return nullptr;
   return lookup_factory(uri->scheme);
 }
 
-static grpc_resolver_factory *resolve_factory(grpc_exec_ctx *exec_ctx,
-                                              const char *target,
-                                              grpc_uri **uri,
-                                              char **canonical_target) {
-  grpc_resolver_factory *factory = NULL;
+static grpc_resolver_factory* resolve_factory(grpc_exec_ctx* exec_ctx,
+                                              const char* target,
+                                              grpc_uri** uri,
+                                              char** canonical_target) {
+  grpc_resolver_factory* factory = nullptr;
 
-  GPR_ASSERT(uri != NULL);
+  GPR_ASSERT(uri != nullptr);
   *uri = grpc_uri_parse(exec_ctx, target, 1);
   factory = lookup_factory_by_uri(*uri);
-  if (factory == NULL) {
+  if (factory == nullptr) {
     grpc_uri_destroy(*uri);
     gpr_asprintf(canonical_target, "%s%s", g_default_resolver_prefix, target);
     *uri = grpc_uri_parse(exec_ctx, *canonical_target, 1);
     factory = lookup_factory_by_uri(*uri);
-    if (factory == NULL) {
+    if (factory == nullptr) {
       grpc_uri_destroy(grpc_uri_parse(exec_ctx, target, 0));
       grpc_uri_destroy(grpc_uri_parse(exec_ctx, *canonical_target, 0));
       gpr_log(GPR_ERROR, "don't know how to resolve '%s' or '%s'", target,
@@ -116,15 +116,15 @@ static grpc_resolver_factory *resolve_factory(grpc_exec_ctx *exec_ctx,
   return factory;
 }
 
-grpc_resolver *grpc_resolver_create(grpc_exec_ctx *exec_ctx, const char *target,
-                                    const grpc_channel_args *args,
-                                    grpc_pollset_set *pollset_set,
-                                    grpc_combiner *combiner) {
-  grpc_uri *uri = NULL;
-  char *canonical_target = NULL;
-  grpc_resolver_factory *factory =
+grpc_resolver* grpc_resolver_create(grpc_exec_ctx* exec_ctx, const char* target,
+                                    const grpc_channel_args* args,
+                                    grpc_pollset_set* pollset_set,
+                                    grpc_combiner* combiner) {
+  grpc_uri* uri = nullptr;
+  char* canonical_target = nullptr;
+  grpc_resolver_factory* factory =
       resolve_factory(exec_ctx, target, &uri, &canonical_target);
-  grpc_resolver *resolver;
+  grpc_resolver* resolver;
   grpc_resolver_args resolver_args;
   memset(&resolver_args, 0, sizeof(resolver_args));
   resolver_args.uri = uri;
@@ -138,22 +138,22 @@ grpc_resolver *grpc_resolver_create(grpc_exec_ctx *exec_ctx, const char *target,
   return resolver;
 }
 
-char *grpc_get_default_authority(grpc_exec_ctx *exec_ctx, const char *target) {
-  grpc_uri *uri = NULL;
-  char *canonical_target = NULL;
-  grpc_resolver_factory *factory =
+char* grpc_get_default_authority(grpc_exec_ctx* exec_ctx, const char* target) {
+  grpc_uri* uri = nullptr;
+  char* canonical_target = nullptr;
+  grpc_resolver_factory* factory =
       resolve_factory(exec_ctx, target, &uri, &canonical_target);
-  char *authority = grpc_resolver_factory_get_default_authority(factory, uri);
+  char* authority = grpc_resolver_factory_get_default_authority(factory, uri);
   grpc_uri_destroy(uri);
   gpr_free(canonical_target);
   return authority;
 }
 
-char *grpc_resolver_factory_add_default_prefix_if_needed(
-    grpc_exec_ctx *exec_ctx, const char *target) {
-  grpc_uri *uri = NULL;
-  char *canonical_target = NULL;
+char* grpc_resolver_factory_add_default_prefix_if_needed(
+    grpc_exec_ctx* exec_ctx, const char* target) {
+  grpc_uri* uri = nullptr;
+  char* canonical_target = nullptr;
   resolve_factory(exec_ctx, target, &uri, &canonical_target);
   grpc_uri_destroy(uri);
-  return canonical_target == NULL ? gpr_strdup(target) : canonical_target;
+  return canonical_target == nullptr ? gpr_strdup(target) : canonical_target;
 }