grpc 1.7.3 → 1.8.0

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

@@ -26,6 +26,10 @@
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/metadata.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 // Channel arg containing a grpc_resolved_address to connect to.
 #define GRPC_ARG_SUBCHANNEL_ADDRESS "grpc.subchannel_address"
 
@@ -75,117 +79,121 @@ typedef struct grpc_subchannel_key grpc_subchannel_key;
 #define GRPC_SUBCHANNEL_REF_EXTRA_ARGS
 #endif
 
-grpc_subchannel *grpc_subchannel_ref(
-    grpc_subchannel *channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-grpc_subchannel *grpc_subchannel_ref_from_weak_ref(
-    grpc_subchannel *channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-void grpc_subchannel_unref(grpc_exec_ctx *exec_ctx,
-                           grpc_subchannel *channel
+grpc_subchannel* grpc_subchannel_ref(
+    grpc_subchannel* channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
+grpc_subchannel* grpc_subchannel_ref_from_weak_ref(
+    grpc_subchannel* channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
+void grpc_subchannel_unref(grpc_exec_ctx* exec_ctx,
+                           grpc_subchannel* channel
                                GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-grpc_subchannel *grpc_subchannel_weak_ref(
-    grpc_subchannel *channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-void grpc_subchannel_weak_unref(grpc_exec_ctx *exec_ctx,
-                                grpc_subchannel *channel
+grpc_subchannel* grpc_subchannel_weak_ref(
+    grpc_subchannel* channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
+void grpc_subchannel_weak_unref(grpc_exec_ctx* exec_ctx,
+                                grpc_subchannel* channel
                                     GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-grpc_connected_subchannel *grpc_connected_subchannel_ref(
-    grpc_connected_subchannel *channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-void grpc_connected_subchannel_unref(grpc_exec_ctx *exec_ctx,
-                                     grpc_connected_subchannel *channel
+grpc_connected_subchannel* grpc_connected_subchannel_ref(
+    grpc_connected_subchannel* channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
+void grpc_connected_subchannel_unref(grpc_exec_ctx* exec_ctx,
+                                     grpc_connected_subchannel* channel
                                          GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
 void grpc_subchannel_call_ref(
-    grpc_subchannel_call *call GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-void grpc_subchannel_call_unref(grpc_exec_ctx *exec_ctx,
-                                grpc_subchannel_call *call
+    grpc_subchannel_call* call GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
+void grpc_subchannel_call_unref(grpc_exec_ctx* exec_ctx,
+                                grpc_subchannel_call* call
                                     GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
 
 /** construct a subchannel call */
 typedef struct {
-  grpc_polling_entity *pollent;
+  grpc_polling_entity* pollent;
   grpc_slice path;
   gpr_timespec start_time;
-  gpr_timespec deadline;
-  gpr_arena *arena;
-  grpc_call_context_element *context;
-  grpc_call_combiner *call_combiner;
+  grpc_millis deadline;
+  gpr_arena* arena;
+  grpc_call_context_element* context;
+  grpc_call_combiner* call_combiner;
 } grpc_connected_subchannel_call_args;
 
-grpc_error *grpc_connected_subchannel_create_call(
-    grpc_exec_ctx *exec_ctx, grpc_connected_subchannel *connected_subchannel,
-    const grpc_connected_subchannel_call_args *args,
-    grpc_subchannel_call **subchannel_call);
+grpc_error* grpc_connected_subchannel_create_call(
+    grpc_exec_ctx* exec_ctx, grpc_connected_subchannel* connected_subchannel,
+    const grpc_connected_subchannel_call_args* args,
+    grpc_subchannel_call** subchannel_call);
 
 /** process a transport level op */
 void grpc_connected_subchannel_process_transport_op(
-    grpc_exec_ctx *exec_ctx, grpc_connected_subchannel *subchannel,
-    grpc_transport_op *op);
+    grpc_exec_ctx* exec_ctx, grpc_connected_subchannel* subchannel,
+    grpc_transport_op* op);
 
 /** poll the current connectivity state of a channel */
 grpc_connectivity_state grpc_subchannel_check_connectivity(
-    grpc_subchannel *channel, grpc_error **error);
+    grpc_subchannel* channel, grpc_error** error);
 
-/** call notify when the connectivity state of a channel changes from *state.
-    Updates *state with the new state of the channel */
+/** Calls notify when the connectivity state of a channel becomes different
+    from *state.  Updates *state with the new state of the channel. */
 void grpc_subchannel_notify_on_state_change(
-    grpc_exec_ctx *exec_ctx, grpc_subchannel *channel,
-    grpc_pollset_set *interested_parties, grpc_connectivity_state *state,
-    grpc_closure *notify);
+    grpc_exec_ctx* exec_ctx, grpc_subchannel* channel,
+    grpc_pollset_set* interested_parties, grpc_connectivity_state* state,
+    grpc_closure* notify);
 void grpc_connected_subchannel_notify_on_state_change(
-    grpc_exec_ctx *exec_ctx, grpc_connected_subchannel *channel,
-    grpc_pollset_set *interested_parties, grpc_connectivity_state *state,
-    grpc_closure *notify);
-void grpc_connected_subchannel_ping(grpc_exec_ctx *exec_ctx,
-                                    grpc_connected_subchannel *channel,
-                                    grpc_closure *notify);
+    grpc_exec_ctx* exec_ctx, grpc_connected_subchannel* channel,
+    grpc_pollset_set* interested_parties, grpc_connectivity_state* state,
+    grpc_closure* notify);
+void grpc_connected_subchannel_ping(grpc_exec_ctx* exec_ctx,
+                                    grpc_connected_subchannel* channel,
+                                    grpc_closure* notify);
 
 /** retrieve the grpc_connected_subchannel - or NULL if called before
     the subchannel becomes connected */
-grpc_connected_subchannel *grpc_subchannel_get_connected_subchannel(
-    grpc_subchannel *subchannel);
+grpc_connected_subchannel* grpc_subchannel_get_connected_subchannel(
+    grpc_subchannel* subchannel);
 
 /** return the subchannel index key for \a subchannel */
-const grpc_subchannel_key *grpc_subchannel_get_key(
-    const grpc_subchannel *subchannel);
+const grpc_subchannel_key* grpc_subchannel_get_key(
+    const grpc_subchannel* subchannel);
 
 /** continue processing a transport op */
-void grpc_subchannel_call_process_op(grpc_exec_ctx *exec_ctx,
-                                     grpc_subchannel_call *subchannel_call,
-                                     grpc_transport_stream_op_batch *op);
+void grpc_subchannel_call_process_op(grpc_exec_ctx* exec_ctx,
+                                     grpc_subchannel_call* subchannel_call,
+                                     grpc_transport_stream_op_batch* op);
 
 /** Must be called once per call. Sets the 'then_schedule_closure' argument for
     call stack destruction. */
 void grpc_subchannel_call_set_cleanup_closure(
-    grpc_subchannel_call *subchannel_call, grpc_closure *closure);
+    grpc_subchannel_call* subchannel_call, grpc_closure* closure);
 
-grpc_call_stack *grpc_subchannel_call_get_call_stack(
-    grpc_subchannel_call *subchannel_call);
+grpc_call_stack* grpc_subchannel_call_get_call_stack(
+    grpc_subchannel_call* subchannel_call);
 
 struct grpc_subchannel_args {
   /* When updating this struct, also update subchannel_index.c */
 
   /** Channel filters for this channel - wrapped factories will likely
       want to mutate this */
-  const grpc_channel_filter **filters;
+  const grpc_channel_filter** filters;
   /** The number of filters in the above array */
   size_t filter_count;
   /** Channel arguments to be supplied to the newly created channel */
-  const grpc_channel_args *args;
+  const grpc_channel_args* args;
 };
 
 /** create a subchannel given a connector */
-grpc_subchannel *grpc_subchannel_create(grpc_exec_ctx *exec_ctx,
-                                        grpc_connector *connector,
-                                        const grpc_subchannel_args *args);
+grpc_subchannel* grpc_subchannel_create(grpc_exec_ctx* exec_ctx,
+                                        grpc_connector* connector,
+                                        const grpc_subchannel_args* args);
 
 /// Sets \a addr from \a args.
-void grpc_get_subchannel_address_arg(grpc_exec_ctx *exec_ctx,
-                                     const grpc_channel_args *args,
-                                     grpc_resolved_address *addr);
+void grpc_get_subchannel_address_arg(grpc_exec_ctx* exec_ctx,
+                                     const grpc_channel_args* args,
+                                     grpc_resolved_address* addr);
 
 /// Returns the URI string for the address to connect to.
-const char *grpc_get_subchannel_address_uri_arg(const grpc_channel_args *args);
+const char* grpc_get_subchannel_address_uri_arg(const grpc_channel_args* args);
 
 /// Returns a new channel arg encoding the subchannel address as a string.
 /// Caller is responsible for freeing the string.
-grpc_arg grpc_create_subchannel_address_arg(const grpc_resolved_address *addr);
+grpc_arg grpc_create_subchannel_address_arg(const grpc_resolved_address* addr);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_H */

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

@@ -42,34 +42,34 @@ struct grpc_subchannel_key {
 
 static bool g_force_creation = false;
 
-static grpc_subchannel_key *create_key(
-    const grpc_subchannel_args *args,
-    grpc_channel_args *(*copy_channel_args)(const grpc_channel_args *args)) {
-  grpc_subchannel_key *k = (grpc_subchannel_key *)gpr_malloc(sizeof(*k));
+static grpc_subchannel_key* create_key(
+    const grpc_subchannel_args* args,
+    grpc_channel_args* (*copy_channel_args)(const grpc_channel_args* args)) {
+  grpc_subchannel_key* k = (grpc_subchannel_key*)gpr_malloc(sizeof(*k));
   k->args.filter_count = args->filter_count;
   if (k->args.filter_count > 0) {
-    k->args.filters = (const grpc_channel_filter **)gpr_malloc(
+    k->args.filters = (const grpc_channel_filter**)gpr_malloc(
         sizeof(*k->args.filters) * k->args.filter_count);
-    memcpy((grpc_channel_filter *)k->args.filters, args->filters,
+    memcpy((grpc_channel_filter*)k->args.filters, args->filters,
            sizeof(*k->args.filters) * k->args.filter_count);
   } else {
-    k->args.filters = NULL;
+    k->args.filters = nullptr;
   }
   k->args.args = copy_channel_args(args->args);
   return k;
 }
 
-grpc_subchannel_key *grpc_subchannel_key_create(
-    const grpc_subchannel_args *args) {
+grpc_subchannel_key* grpc_subchannel_key_create(
+    const grpc_subchannel_args* args) {
   return create_key(args, grpc_channel_args_normalize);
 }
 
-static grpc_subchannel_key *subchannel_key_copy(grpc_subchannel_key *k) {
+static grpc_subchannel_key* subchannel_key_copy(grpc_subchannel_key* k) {
   return create_key(&k->args, grpc_channel_args_copy);
 }
 
-int grpc_subchannel_key_compare(const grpc_subchannel_key *a,
-                                const grpc_subchannel_key *b) {
+int grpc_subchannel_key_compare(const grpc_subchannel_key* a,
+                                const grpc_subchannel_key* b) {
   if (g_force_creation) return false;
   int c = GPR_ICMP(a->args.filter_count, b->args.filter_count);
   if (c != 0) return c;
@@ -81,44 +81,44 @@ int grpc_subchannel_key_compare(const grpc_subchannel_key *a,
   return grpc_channel_args_compare(a->args.args, b->args.args);
 }
 
-void grpc_subchannel_key_destroy(grpc_exec_ctx *exec_ctx,
-                                 grpc_subchannel_key *k) {
-  gpr_free((grpc_channel_args *)k->args.filters);
-  grpc_channel_args_destroy(exec_ctx, (grpc_channel_args *)k->args.args);
+void grpc_subchannel_key_destroy(grpc_exec_ctx* exec_ctx,
+                                 grpc_subchannel_key* k) {
+  gpr_free((grpc_channel_args*)k->args.filters);
+  grpc_channel_args_destroy(exec_ctx, (grpc_channel_args*)k->args.args);
   gpr_free(k);
 }
 
-static void sck_avl_destroy(void *p, void *user_data) {
-  grpc_exec_ctx *exec_ctx = (grpc_exec_ctx *)user_data;
-  grpc_subchannel_key_destroy(exec_ctx, (grpc_subchannel_key *)p);
+static void sck_avl_destroy(void* p, void* user_data) {
+  grpc_exec_ctx* exec_ctx = (grpc_exec_ctx*)user_data;
+  grpc_subchannel_key_destroy(exec_ctx, (grpc_subchannel_key*)p);
 }
 
-static void *sck_avl_copy(void *p, void *unused) {
-  return subchannel_key_copy((grpc_subchannel_key *)p);
+static void* sck_avl_copy(void* p, void* unused) {
+  return subchannel_key_copy((grpc_subchannel_key*)p);
 }
 
-static long sck_avl_compare(void *a, void *b, void *unused) {
-  return grpc_subchannel_key_compare((grpc_subchannel_key *)a,
-                                     (grpc_subchannel_key *)b);
+static long sck_avl_compare(void* a, void* b, void* unused) {
+  return grpc_subchannel_key_compare((grpc_subchannel_key*)a,
+                                     (grpc_subchannel_key*)b);
 }
 
-static void scv_avl_destroy(void *p, void *user_data) {
-  grpc_exec_ctx *exec_ctx = (grpc_exec_ctx *)user_data;
-  GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, (grpc_subchannel *)p,
-                             "subchannel_index");
+static void scv_avl_destroy(void* p, void* user_data) {
+  grpc_exec_ctx* exec_ctx = (grpc_exec_ctx*)user_data;
+  GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, (grpc_subchannel*)p, "subchannel_index");
 }
 
-static void *scv_avl_copy(void *p, void *unused) {
-  GRPC_SUBCHANNEL_WEAK_REF((grpc_subchannel *)p, "subchannel_index");
+static void* scv_avl_copy(void* p, void* unused) {
+  GRPC_SUBCHANNEL_WEAK_REF((grpc_subchannel*)p, "subchannel_index");
   return p;
 }
 
 static const gpr_avl_vtable subchannel_avl_vtable = {
-    .destroy_key = sck_avl_destroy,
-    .copy_key = sck_avl_copy,
-    .compare_keys = sck_avl_compare,
-    .destroy_value = scv_avl_destroy,
-    .copy_value = scv_avl_copy};
+    sck_avl_destroy,  // destroy_key
+    sck_avl_copy,     // copy_key
+    sck_avl_compare,  // compare_keys
+    scv_avl_destroy,  // destroy_value
+    scv_avl_copy      // copy_value
+};
 
 void grpc_subchannel_index_init(void) {
   g_subchannel_index = gpr_avl_create(&subchannel_avl_vtable);
@@ -144,28 +144,28 @@ void grpc_subchannel_index_unref(void) {
 
 void grpc_subchannel_index_ref(void) { gpr_ref_non_zero(&g_refcount); }
 
-grpc_subchannel *grpc_subchannel_index_find(grpc_exec_ctx *exec_ctx,
-                                            grpc_subchannel_key *key) {
+grpc_subchannel* grpc_subchannel_index_find(grpc_exec_ctx* exec_ctx,
+                                            grpc_subchannel_key* key) {
   // Lock, and take a reference to the subchannel index.
   // We don't need to do the search under a lock as avl's are immutable.
   gpr_mu_lock(&g_mu);
   gpr_avl index = gpr_avl_ref(g_subchannel_index, exec_ctx);
   gpr_mu_unlock(&g_mu);
 
-  grpc_subchannel *c = GRPC_SUBCHANNEL_REF_FROM_WEAK_REF(
-      (grpc_subchannel *)gpr_avl_get(index, key, exec_ctx), "index_find");
+  grpc_subchannel* c = GRPC_SUBCHANNEL_REF_FROM_WEAK_REF(
+      (grpc_subchannel*)gpr_avl_get(index, key, exec_ctx), "index_find");
   gpr_avl_unref(index, exec_ctx);
 
   return c;
 }
 
-grpc_subchannel *grpc_subchannel_index_register(grpc_exec_ctx *exec_ctx,
-                                                grpc_subchannel_key *key,
-                                                grpc_subchannel *constructed) {
-  grpc_subchannel *c = NULL;
-  bool need_to_unref_constructed;
+grpc_subchannel* grpc_subchannel_index_register(grpc_exec_ctx* exec_ctx,
+                                                grpc_subchannel_key* key,
+                                                grpc_subchannel* constructed) {
+  grpc_subchannel* c = nullptr;
+  bool need_to_unref_constructed = false;
 
-  while (c == NULL) {
+  while (c == nullptr) {
     need_to_unref_constructed = false;
 
     // Compare and swap loop:
@@ -175,11 +175,11 @@ grpc_subchannel *grpc_subchannel_index_register(grpc_exec_ctx *exec_ctx,
     gpr_mu_unlock(&g_mu);
 
     // - Check to see if a subchannel already exists
-    c = (grpc_subchannel *)gpr_avl_get(index, key, exec_ctx);
-    if (c != NULL) {
+    c = (grpc_subchannel*)gpr_avl_get(index, key, exec_ctx);
+    if (c != nullptr) {
       c = GRPC_SUBCHANNEL_REF_FROM_WEAK_REF(c, "index_register");
     }
-    if (c != NULL) {
+    if (c != nullptr) {
       // yes -> we're done
       need_to_unref_constructed = true;
     } else {
@@ -210,9 +210,9 @@ grpc_subchannel *grpc_subchannel_index_register(grpc_exec_ctx *exec_ctx,
   return c;
 }
 
-void grpc_subchannel_index_unregister(grpc_exec_ctx *exec_ctx,
-                                      grpc_subchannel_key *key,
-                                      grpc_subchannel *constructed) {
+void grpc_subchannel_index_unregister(grpc_exec_ctx* exec_ctx,
+                                      grpc_subchannel_key* key,
+                                      grpc_subchannel* constructed) {
   bool done = false;
   while (!done) {
     // Compare and swap loop:
@@ -223,7 +223,7 @@ void grpc_subchannel_index_unregister(grpc_exec_ctx *exec_ctx,
 
     // Check to see if this key still refers to the previously
     // registered subchannel
-    grpc_subchannel *c = (grpc_subchannel *)gpr_avl_get(index, key, exec_ctx);
+    grpc_subchannel* c = (grpc_subchannel*)gpr_avl_get(index, key, exec_ctx);
     if (c != constructed) {
       gpr_avl_unref(index, exec_ctx);
       break;

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

@@ -21,38 +21,42 @@
 
 #include "src/core/ext/filters/client_channel/subchannel.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /** \file Provides an index of active subchannels so that they can be
     shared amongst channels */
 
 /** Create a key that can be used to uniquely identify a subchannel */
-grpc_subchannel_key *grpc_subchannel_key_create(
-    const grpc_subchannel_args *args);
+grpc_subchannel_key* grpc_subchannel_key_create(
+    const grpc_subchannel_args* args);
 
 /** Destroy a subchannel key */
-void grpc_subchannel_key_destroy(grpc_exec_ctx *exec_ctx,
-                                 grpc_subchannel_key *key);
+void grpc_subchannel_key_destroy(grpc_exec_ctx* exec_ctx,
+                                 grpc_subchannel_key* key);
 
 /** Given a subchannel key, find the subchannel registered for it.
     Returns NULL if no such channel exists.
     Thread-safe. */
-grpc_subchannel *grpc_subchannel_index_find(grpc_exec_ctx *exec_ctx,
-                                            grpc_subchannel_key *key);
+grpc_subchannel* grpc_subchannel_index_find(grpc_exec_ctx* exec_ctx,
+                                            grpc_subchannel_key* key);
 
 /** Register a subchannel against a key.
     Takes ownership of \a constructed.
     Returns the registered subchannel. This may be different from
     \a constructed in the case of a registration race. */
-grpc_subchannel *grpc_subchannel_index_register(grpc_exec_ctx *exec_ctx,
-                                                grpc_subchannel_key *key,
-                                                grpc_subchannel *constructed);
+grpc_subchannel* grpc_subchannel_index_register(grpc_exec_ctx* exec_ctx,
+                                                grpc_subchannel_key* key,
+                                                grpc_subchannel* constructed);
 
 /** Remove \a constructed as the registered subchannel for \a key. */
-void grpc_subchannel_index_unregister(grpc_exec_ctx *exec_ctx,
-                                      grpc_subchannel_key *key,
-                                      grpc_subchannel *constructed);
+void grpc_subchannel_index_unregister(grpc_exec_ctx* exec_ctx,
+                                      grpc_subchannel_key* key,
+                                      grpc_subchannel* constructed);
 
-int grpc_subchannel_key_compare(const grpc_subchannel_key *a,
-                                const grpc_subchannel_key *b);
+int grpc_subchannel_key_compare(const grpc_subchannel_key* a,
+                                const grpc_subchannel_key* b);
 
 /** Initialize the subchannel index (global) */
 void grpc_subchannel_index_init(void);
@@ -78,4 +82,8 @@ void grpc_subchannel_index_unref(void);
  * force_creation set. */
 void grpc_subchannel_index_test_only_set_force_creation(bool force_creation);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_INDEX_H */

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

@@ -34,9 +34,9 @@
 /** a size_t default value... maps to all 1's */
 #define NOT_SET (~(size_t)0)
 
-static grpc_uri *bad_uri(const char *uri_text, size_t pos, const char *section,
+static grpc_uri* bad_uri(const char* uri_text, size_t pos, const char* section,
                          bool suppress_errors) {
-  char *line_prefix;
+  char* line_prefix;
   size_t pfx_len;
 
   if (!suppress_errors) {
@@ -45,24 +45,26 @@ static grpc_uri *bad_uri(const char *uri_text, size_t pos, const char *section,
     gpr_log(GPR_ERROR, "%s%s'", line_prefix, uri_text);
     gpr_free(line_prefix);
 
-    line_prefix = (char *)gpr_malloc(pfx_len + 1);
+    line_prefix = (char*)gpr_malloc(pfx_len + 1);
     memset(line_prefix, ' ', pfx_len);
     line_prefix[pfx_len] = 0;
     gpr_log(GPR_ERROR, "%s^ here", line_prefix);
     gpr_free(line_prefix);
   }
 
-  return NULL;
+  return nullptr;
 }
 
 /** Returns a copy of percent decoded \a src[begin, end) */
-static char *decode_and_copy_component(grpc_exec_ctx *exec_ctx, const char *src,
+static char* decode_and_copy_component(grpc_exec_ctx* exec_ctx, const char* src,
                                        size_t begin, size_t end) {
   grpc_slice component =
-      grpc_slice_from_copied_buffer(src + begin, end - begin);
+      (begin == NOT_SET || end == NOT_SET)
+          ? grpc_empty_slice()
+          : grpc_slice_from_copied_buffer(src + begin, end - begin);
   grpc_slice decoded_component =
       grpc_permissive_percent_decode_slice(component);
-  char *out = grpc_dump_slice(decoded_component, GPR_DUMP_ASCII);
+  char* out = grpc_dump_slice(decoded_component, GPR_DUMP_ASCII);
   grpc_slice_unref_internal(exec_ctx, component);
   grpc_slice_unref_internal(exec_ctx, decoded_component);
   return out;
@@ -76,7 +78,7 @@ static bool valid_hex(char c) {
 /** Returns how many chars to advance if \a uri_text[i] begins a valid \a pchar
  * production. If \a uri_text[i] introduces an invalid \a pchar (such as percent
  * sign not followed by two hex digits), NOT_SET is returned. */
-static size_t parse_pchar(const char *uri_text, size_t i) {
+static size_t parse_pchar(const char* uri_text, size_t i) {
   /* pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
    * unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
    * pct-encoded = "%" HEXDIG HEXDIG
@@ -118,7 +120,7 @@ static size_t parse_pchar(const char *uri_text, size_t i) {
 }
 
 /* *( pchar / "?" / "/" ) */
-static int parse_fragment_or_query(const char *uri_text, size_t *i) {
+static int parse_fragment_or_query(const char* uri_text, size_t* i) {
   char c;
   while ((c = uri_text[*i]) != 0) {
     const size_t advance = parse_pchar(uri_text, *i); /* pchar */
@@ -143,13 +145,13 @@ static int parse_fragment_or_query(const char *uri_text, size_t *i) {
   return 1;
 }
 
-static void parse_query_parts(grpc_uri *uri) {
-  static const char *QUERY_PARTS_SEPARATOR = "&";
-  static const char *QUERY_PARTS_VALUE_SEPARATOR = "=";
-  GPR_ASSERT(uri->query != NULL);
+static void parse_query_parts(grpc_uri* uri) {
+  static const char* QUERY_PARTS_SEPARATOR = "&";
+  static const char* QUERY_PARTS_VALUE_SEPARATOR = "=";
+  GPR_ASSERT(uri->query != nullptr);
   if (uri->query[0] == '\0') {
-    uri->query_parts = NULL;
-    uri->query_parts_values = NULL;
+    uri->query_parts = nullptr;
+    uri->query_parts_values = nullptr;
     uri->num_query_parts = 0;
     return;
   }
@@ -157,11 +159,11 @@ static void parse_query_parts(grpc_uri *uri) {
   gpr_string_split(uri->query, QUERY_PARTS_SEPARATOR, &uri->query_parts,
                    &uri->num_query_parts);
   uri->query_parts_values =
-      (char **)gpr_malloc(uri->num_query_parts * sizeof(char **));
+      (char**)gpr_malloc(uri->num_query_parts * sizeof(char**));
   for (size_t i = 0; i < uri->num_query_parts; i++) {
-    char **query_param_parts;
+    char** query_param_parts;
     size_t num_query_param_parts;
-    char *full = uri->query_parts[i];
+    char* full = uri->query_parts[i];
     gpr_string_split(full, QUERY_PARTS_VALUE_SEPARATOR, &query_param_parts,
                      &num_query_param_parts);
     GPR_ASSERT(num_query_param_parts > 0);
@@ -172,7 +174,7 @@ static void parse_query_parts(grpc_uri *uri) {
        * be included, even if they include the separator. */
       uri->query_parts_values[i] = query_param_parts[1];
     } else {
-      uri->query_parts_values[i] = NULL;
+      uri->query_parts_values[i] = nullptr;
     }
     for (size_t j = 2; j < num_query_param_parts; j++) {
       gpr_free(query_param_parts[j]);
@@ -182,9 +184,9 @@ static void parse_query_parts(grpc_uri *uri) {
   }
 }
 
-grpc_uri *grpc_uri_parse(grpc_exec_ctx *exec_ctx, const char *uri_text,
+grpc_uri* grpc_uri_parse(grpc_exec_ctx* exec_ctx, const char* uri_text,
                          bool suppress_errors) {
-  grpc_uri *uri;
+  grpc_uri* uri;
   size_t scheme_begin = 0;
   size_t scheme_end = NOT_SET;
   size_t authority_begin = NOT_SET;
@@ -270,7 +272,7 @@ grpc_uri *grpc_uri_parse(grpc_exec_ctx *exec_ctx, const char *uri_text,
     fragment_end = i;
   }
 
-  uri = (grpc_uri *)gpr_zalloc(sizeof(*uri));
+  uri = (grpc_uri*)gpr_zalloc(sizeof(*uri));
   uri->scheme =
       decode_and_copy_component(exec_ctx, uri_text, scheme_begin, scheme_end);
   uri->authority = decode_and_copy_component(exec_ctx, uri_text,
@@ -286,19 +288,19 @@ grpc_uri *grpc_uri_parse(grpc_exec_ctx *exec_ctx, const char *uri_text,
   return uri;
 }
 
-const char *grpc_uri_get_query_arg(const grpc_uri *uri, const char *key) {
-  GPR_ASSERT(key != NULL);
-  if (key[0] == '\0') return NULL;
+const char* grpc_uri_get_query_arg(const grpc_uri* uri, const char* key) {
+  GPR_ASSERT(key != nullptr);
+  if (key[0] == '\0') return nullptr;
 
   for (size_t i = 0; i < uri->num_query_parts; ++i) {
     if (0 == strcmp(key, uri->query_parts[i])) {
       return uri->query_parts_values[i];
     }
   }
-  return NULL;
+  return nullptr;
 }
 
-void grpc_uri_destroy(grpc_uri *uri) {
+void grpc_uri_destroy(grpc_uri* uri) {
   if (!uri) return;
   gpr_free(uri->scheme);
   gpr_free(uri->authority);