Update clang-format to 5.0
diff --git a/src/core/lib/transport/metadata.cc b/src/core/lib/transport/metadata.cc
index 2392f26..ff11dde 100644
--- a/src/core/lib/transport/metadata.cc
+++ b/src/core/lib/transport/metadata.cc
@@ -67,7 +67,7 @@
 #define TABLE_IDX(hash, capacity) (((hash) >> (LOG2_SHARD_COUNT)) % (capacity))
 #define SHARD_IDX(hash) ((hash) & ((1 << (LOG2_SHARD_COUNT)) - 1))
 
-typedef void (*destroy_user_data_func)(void *user_data);
+typedef void (*destroy_user_data_func)(void* user_data);
 
 /* Shadow structure for grpc_mdelem_data for interned elements */
 typedef struct interned_metadata {
@@ -82,7 +82,7 @@
   gpr_atm destroy_user_data;
   gpr_atm user_data;
 
-  struct interned_metadata *bucket_next;
+  struct interned_metadata* bucket_next;
 } interned_metadata;
 
 /* Shadow structure for grpc_mdelem_data for allocated elements */
@@ -97,7 +97,7 @@
 
 typedef struct mdtab_shard {
   gpr_mu mu;
-  interned_metadata **elems;
+  interned_metadata** elems;
   size_t count;
   size_t capacity;
   /** Estimate of the number of unreferenced mdelems in the hash table.
@@ -108,24 +108,24 @@
 
 static mdtab_shard g_shards[SHARD_COUNT];
 
-static void gc_mdtab(grpc_exec_ctx *exec_ctx, mdtab_shard *shard);
+static void gc_mdtab(grpc_exec_ctx* exec_ctx, mdtab_shard* shard);
 
 void grpc_mdctx_global_init(void) {
   /* initialize shards */
   for (size_t i = 0; i < SHARD_COUNT; i++) {
-    mdtab_shard *shard = &g_shards[i];
+    mdtab_shard* shard = &g_shards[i];
     gpr_mu_init(&shard->mu);
     shard->count = 0;
     gpr_atm_no_barrier_store(&shard->free_estimate, 0);
     shard->capacity = INITIAL_SHARD_CAPACITY;
-    shard->elems = (interned_metadata **)gpr_zalloc(sizeof(*shard->elems) *
-                                                    shard->capacity);
+    shard->elems = (interned_metadata**)gpr_zalloc(sizeof(*shard->elems) *
+                                                   shard->capacity);
   }
 }
 
-void grpc_mdctx_global_shutdown(grpc_exec_ctx *exec_ctx) {
+void grpc_mdctx_global_shutdown(grpc_exec_ctx* exec_ctx) {
   for (size_t i = 0; i < SHARD_COUNT; i++) {
-    mdtab_shard *shard = &g_shards[i];
+    mdtab_shard* shard = &g_shards[i];
     gpr_mu_destroy(&shard->mu);
     gc_mdtab(exec_ctx, shard);
     /* TODO(ctiller): GPR_ASSERT(shard->count == 0); */
@@ -146,14 +146,14 @@
              &grpc_static_mdelem_table[GRPC_STATIC_MDELEM_COUNT];
 }
 
-static void ref_md_locked(mdtab_shard *shard,
-                          interned_metadata *md DEBUG_ARGS) {
+static void ref_md_locked(mdtab_shard* shard,
+                          interned_metadata* md DEBUG_ARGS) {
 #ifndef NDEBUG
   if (GRPC_TRACER_ON(grpc_trace_metadata)) {
-    char *key_str = grpc_slice_to_c_string(md->key);
-    char *value_str = grpc_slice_to_c_string(md->value);
+    char* key_str = grpc_slice_to_c_string(md->key);
+    char* value_str = grpc_slice_to_c_string(md->value);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
-            "ELM   REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'", (void *)md,
+            "ELM   REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'", (void*)md,
             gpr_atm_no_barrier_load(&md->refcnt),
             gpr_atm_no_barrier_load(&md->refcnt) + 1, key_str, value_str);
     gpr_free(key_str);
@@ -165,9 +165,9 @@
   }
 }
 
-static void gc_mdtab(grpc_exec_ctx *exec_ctx, mdtab_shard *shard) {
+static void gc_mdtab(grpc_exec_ctx* exec_ctx, mdtab_shard* shard) {
   size_t i;
-  interned_metadata **prev_next;
+  interned_metadata** prev_next;
   interned_metadata *md, *next;
   gpr_atm num_freed = 0;
 
@@ -175,7 +175,7 @@
   for (i = 0; i < shard->capacity; i++) {
     prev_next = &shard->elems[i];
     for (md = shard->elems[i]; md; md = next) {
-      void *user_data = (void *)gpr_atm_no_barrier_load(&md->user_data);
+      void* user_data = (void*)gpr_atm_no_barrier_load(&md->user_data);
       next = md->bucket_next;
       if (gpr_atm_acq_load(&md->refcnt) == 0) {
         grpc_slice_unref_internal(exec_ctx, md->key);
@@ -197,17 +197,17 @@
   GPR_TIMER_END("gc_mdtab", 0);
 }
 
-static void grow_mdtab(mdtab_shard *shard) {
+static void grow_mdtab(mdtab_shard* shard) {
   size_t capacity = shard->capacity * 2;
   size_t i;
-  interned_metadata **mdtab;
+  interned_metadata** mdtab;
   interned_metadata *md, *next;
   uint32_t hash;
 
   GPR_TIMER_BEGIN("grow_mdtab", 0);
 
   mdtab =
-      (interned_metadata **)gpr_zalloc(sizeof(interned_metadata *) * capacity);
+      (interned_metadata**)gpr_zalloc(sizeof(interned_metadata*) * capacity);
 
   for (i = 0; i < shard->capacity; i++) {
     for (md = shard->elems[i]; md; md = next) {
@@ -228,7 +228,7 @@
   GPR_TIMER_END("grow_mdtab", 0);
 }
 
-static void rehash_mdtab(grpc_exec_ctx *exec_ctx, mdtab_shard *shard) {
+static void rehash_mdtab(grpc_exec_ctx* exec_ctx, mdtab_shard* shard) {
   if (gpr_atm_no_barrier_load(&shard->free_estimate) >
       (gpr_atm)(shard->capacity / 4)) {
     gc_mdtab(exec_ctx, shard);
@@ -238,25 +238,25 @@
 }
 
 grpc_mdelem grpc_mdelem_create(
-    grpc_exec_ctx *exec_ctx, grpc_slice key, grpc_slice value,
-    grpc_mdelem_data *compatible_external_backing_store) {
+    grpc_exec_ctx* exec_ctx, grpc_slice key, grpc_slice value,
+    grpc_mdelem_data* compatible_external_backing_store) {
   if (!grpc_slice_is_interned(key) || !grpc_slice_is_interned(value)) {
     if (compatible_external_backing_store != NULL) {
       return GRPC_MAKE_MDELEM(compatible_external_backing_store,
                               GRPC_MDELEM_STORAGE_EXTERNAL);
     }
 
-    allocated_metadata *allocated =
-        (allocated_metadata *)gpr_malloc(sizeof(*allocated));
+    allocated_metadata* allocated =
+        (allocated_metadata*)gpr_malloc(sizeof(*allocated));
     allocated->key = grpc_slice_ref_internal(key);
     allocated->value = grpc_slice_ref_internal(value);
     gpr_atm_rel_store(&allocated->refcnt, 1);
 #ifndef NDEBUG
     if (GRPC_TRACER_ON(grpc_trace_metadata)) {
-      char *key_str = grpc_slice_to_c_string(allocated->key);
-      char *value_str = grpc_slice_to_c_string(allocated->value);
+      char* key_str = grpc_slice_to_c_string(allocated->key);
+      char* value_str = grpc_slice_to_c_string(allocated->value);
       gpr_log(GPR_DEBUG, "ELM ALLOC:%p:%" PRIdPTR ": '%s' = '%s'",
-              (void *)allocated, gpr_atm_no_barrier_load(&allocated->refcnt),
+              (void*)allocated, gpr_atm_no_barrier_load(&allocated->refcnt),
               key_str, value_str);
       gpr_free(key_str);
       gpr_free(value_str);
@@ -276,8 +276,8 @@
 
   uint32_t hash =
       GRPC_MDSTR_KV_HASH(grpc_slice_hash(key), grpc_slice_hash(value));
-  interned_metadata *md;
-  mdtab_shard *shard = &g_shards[SHARD_IDX(hash)];
+  interned_metadata* md;
+  mdtab_shard* shard = &g_shards[SHARD_IDX(hash)];
   size_t idx;
 
   GPR_TIMER_BEGIN("grpc_mdelem_from_metadata_strings", 0);
@@ -296,7 +296,7 @@
   }
 
   /* not found: create a new pair */
-  md = (interned_metadata *)gpr_malloc(sizeof(interned_metadata));
+  md = (interned_metadata*)gpr_malloc(sizeof(interned_metadata));
   gpr_atm_rel_store(&md->refcnt, 1);
   md->key = grpc_slice_ref_internal(key);
   md->value = grpc_slice_ref_internal(value);
@@ -307,9 +307,9 @@
   gpr_mu_init(&md->mu_user_data);
 #ifndef NDEBUG
   if (GRPC_TRACER_ON(grpc_trace_metadata)) {
-    char *key_str = grpc_slice_to_c_string(md->key);
-    char *value_str = grpc_slice_to_c_string(md->value);
-    gpr_log(GPR_DEBUG, "ELM   NEW:%p:%" PRIdPTR ": '%s' = '%s'", (void *)md,
+    char* key_str = grpc_slice_to_c_string(md->key);
+    char* value_str = grpc_slice_to_c_string(md->value);
+    gpr_log(GPR_DEBUG, "ELM   NEW:%p:%" PRIdPTR ": '%s' = '%s'", (void*)md,
             gpr_atm_no_barrier_load(&md->refcnt), key_str, value_str);
     gpr_free(key_str);
     gpr_free(value_str);
@@ -328,7 +328,7 @@
   return GRPC_MAKE_MDELEM(md, GRPC_MDELEM_STORAGE_INTERNED);
 }
 
-grpc_mdelem grpc_mdelem_from_slices(grpc_exec_ctx *exec_ctx, grpc_slice key,
+grpc_mdelem grpc_mdelem_from_slices(grpc_exec_ctx* exec_ctx, grpc_slice key,
                                     grpc_slice value) {
   grpc_mdelem out = grpc_mdelem_create(exec_ctx, key, value, NULL);
   grpc_slice_unref_internal(exec_ctx, key);
@@ -336,15 +336,15 @@
   return out;
 }
 
-grpc_mdelem grpc_mdelem_from_grpc_metadata(grpc_exec_ctx *exec_ctx,
-                                           grpc_metadata *metadata) {
+grpc_mdelem grpc_mdelem_from_grpc_metadata(grpc_exec_ctx* exec_ctx,
+                                           grpc_metadata* metadata) {
   bool changed = false;
   grpc_slice key_slice =
       grpc_slice_maybe_static_intern(metadata->key, &changed);
   grpc_slice value_slice =
       grpc_slice_maybe_static_intern(metadata->value, &changed);
   return grpc_mdelem_create(exec_ctx, key_slice, value_slice,
-                            changed ? NULL : (grpc_mdelem_data *)metadata);
+                            changed ? NULL : (grpc_mdelem_data*)metadata);
 }
 
 static size_t get_base64_encoded_size(size_t raw_length) {
@@ -371,14 +371,14 @@
     case GRPC_MDELEM_STORAGE_STATIC:
       break;
     case GRPC_MDELEM_STORAGE_INTERNED: {
-      interned_metadata *md = (interned_metadata *)GRPC_MDELEM_DATA(gmd);
+      interned_metadata* md = (interned_metadata*)GRPC_MDELEM_DATA(gmd);
 #ifndef NDEBUG
       if (GRPC_TRACER_ON(grpc_trace_metadata)) {
-        char *key_str = grpc_slice_to_c_string(md->key);
-        char *value_str = grpc_slice_to_c_string(md->value);
+        char* key_str = grpc_slice_to_c_string(md->key);
+        char* value_str = grpc_slice_to_c_string(md->value);
         gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
                 "ELM   REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'",
-                (void *)md, gpr_atm_no_barrier_load(&md->refcnt),
+                (void*)md, gpr_atm_no_barrier_load(&md->refcnt),
                 gpr_atm_no_barrier_load(&md->refcnt) + 1, key_str, value_str);
         gpr_free(key_str);
         gpr_free(value_str);
@@ -393,14 +393,14 @@
       break;
     }
     case GRPC_MDELEM_STORAGE_ALLOCATED: {
-      allocated_metadata *md = (allocated_metadata *)GRPC_MDELEM_DATA(gmd);
+      allocated_metadata* md = (allocated_metadata*)GRPC_MDELEM_DATA(gmd);
 #ifndef NDEBUG
       if (GRPC_TRACER_ON(grpc_trace_metadata)) {
-        char *key_str = grpc_slice_to_c_string(md->key);
-        char *value_str = grpc_slice_to_c_string(md->value);
+        char* key_str = grpc_slice_to_c_string(md->key);
+        char* value_str = grpc_slice_to_c_string(md->value);
         gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
                 "ELM   REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'",
-                (void *)md, gpr_atm_no_barrier_load(&md->refcnt),
+                (void*)md, gpr_atm_no_barrier_load(&md->refcnt),
                 gpr_atm_no_barrier_load(&md->refcnt) + 1, key_str, value_str);
         gpr_free(key_str);
         gpr_free(value_str);
@@ -417,20 +417,20 @@
   return gmd;
 }
 
-void grpc_mdelem_unref(grpc_exec_ctx *exec_ctx, grpc_mdelem gmd DEBUG_ARGS) {
+void grpc_mdelem_unref(grpc_exec_ctx* exec_ctx, grpc_mdelem gmd DEBUG_ARGS) {
   switch (GRPC_MDELEM_STORAGE(gmd)) {
     case GRPC_MDELEM_STORAGE_EXTERNAL:
     case GRPC_MDELEM_STORAGE_STATIC:
       break;
     case GRPC_MDELEM_STORAGE_INTERNED: {
-      interned_metadata *md = (interned_metadata *)GRPC_MDELEM_DATA(gmd);
+      interned_metadata* md = (interned_metadata*)GRPC_MDELEM_DATA(gmd);
 #ifndef NDEBUG
       if (GRPC_TRACER_ON(grpc_trace_metadata)) {
-        char *key_str = grpc_slice_to_c_string(md->key);
-        char *value_str = grpc_slice_to_c_string(md->value);
+        char* key_str = grpc_slice_to_c_string(md->key);
+        char* value_str = grpc_slice_to_c_string(md->value);
         gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
                 "ELM UNREF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'",
-                (void *)md, gpr_atm_no_barrier_load(&md->refcnt),
+                (void*)md, gpr_atm_no_barrier_load(&md->refcnt),
                 gpr_atm_no_barrier_load(&md->refcnt) - 1, key_str, value_str);
         gpr_free(key_str);
         gpr_free(value_str);
@@ -443,20 +443,20 @@
       if (1 == prev_refcount) {
         /* once the refcount hits zero, some other thread can come along and
            free md at any time: it's unsafe from this point on to access it */
-        mdtab_shard *shard = &g_shards[SHARD_IDX(hash)];
+        mdtab_shard* shard = &g_shards[SHARD_IDX(hash)];
         gpr_atm_no_barrier_fetch_add(&shard->free_estimate, 1);
       }
       break;
     }
     case GRPC_MDELEM_STORAGE_ALLOCATED: {
-      allocated_metadata *md = (allocated_metadata *)GRPC_MDELEM_DATA(gmd);
+      allocated_metadata* md = (allocated_metadata*)GRPC_MDELEM_DATA(gmd);
 #ifndef NDEBUG
       if (GRPC_TRACER_ON(grpc_trace_metadata)) {
-        char *key_str = grpc_slice_to_c_string(md->key);
-        char *value_str = grpc_slice_to_c_string(md->value);
+        char* key_str = grpc_slice_to_c_string(md->key);
+        char* value_str = grpc_slice_to_c_string(md->value);
         gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
                 "ELM UNREF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'",
-                (void *)md, gpr_atm_no_barrier_load(&md->refcnt),
+                (void*)md, gpr_atm_no_barrier_load(&md->refcnt),
                 gpr_atm_no_barrier_load(&md->refcnt) - 1, key_str, value_str);
         gpr_free(key_str);
         gpr_free(value_str);
@@ -474,19 +474,19 @@
   }
 }
 
-void *grpc_mdelem_get_user_data(grpc_mdelem md, void (*destroy_func)(void *)) {
+void* grpc_mdelem_get_user_data(grpc_mdelem md, void (*destroy_func)(void*)) {
   switch (GRPC_MDELEM_STORAGE(md)) {
     case GRPC_MDELEM_STORAGE_EXTERNAL:
     case GRPC_MDELEM_STORAGE_ALLOCATED:
       return NULL;
     case GRPC_MDELEM_STORAGE_STATIC:
-      return (void *)grpc_static_mdelem_user_data[GRPC_MDELEM_DATA(md) -
-                                                  grpc_static_mdelem_table];
+      return (void*)grpc_static_mdelem_user_data[GRPC_MDELEM_DATA(md) -
+                                                 grpc_static_mdelem_table];
     case GRPC_MDELEM_STORAGE_INTERNED: {
-      interned_metadata *im = (interned_metadata *)GRPC_MDELEM_DATA(md);
-      void *result;
+      interned_metadata* im = (interned_metadata*)GRPC_MDELEM_DATA(md);
+      void* result;
       if (gpr_atm_acq_load(&im->destroy_user_data) == (gpr_atm)destroy_func) {
-        return (void *)gpr_atm_no_barrier_load(&im->user_data);
+        return (void*)gpr_atm_no_barrier_load(&im->user_data);
       } else {
         return NULL;
       }
@@ -496,8 +496,8 @@
   GPR_UNREACHABLE_CODE(return NULL);
 }
 
-void *grpc_mdelem_set_user_data(grpc_mdelem md, void (*destroy_func)(void *),
-                                void *user_data) {
+void* grpc_mdelem_set_user_data(grpc_mdelem md, void (*destroy_func)(void*),
+                                void* user_data) {
   switch (GRPC_MDELEM_STORAGE(md)) {
     case GRPC_MDELEM_STORAGE_EXTERNAL:
     case GRPC_MDELEM_STORAGE_ALLOCATED:
@@ -505,10 +505,10 @@
       return NULL;
     case GRPC_MDELEM_STORAGE_STATIC:
       destroy_func(user_data);
-      return (void *)grpc_static_mdelem_user_data[GRPC_MDELEM_DATA(md) -
-                                                  grpc_static_mdelem_table];
+      return (void*)grpc_static_mdelem_user_data[GRPC_MDELEM_DATA(md) -
+                                                 grpc_static_mdelem_table];
     case GRPC_MDELEM_STORAGE_INTERNED: {
-      interned_metadata *im = (interned_metadata *)GRPC_MDELEM_DATA(md);
+      interned_metadata* im = (interned_metadata*)GRPC_MDELEM_DATA(md);
       GPR_ASSERT(!is_mdelem_static(md));
       GPR_ASSERT((user_data == NULL) == (destroy_func == NULL));
       gpr_mu_lock(&im->mu_user_data);
@@ -518,7 +518,7 @@
         if (destroy_func != NULL) {
           destroy_func(user_data);
         }
-        return (void *)gpr_atm_no_barrier_load(&im->user_data);
+        return (void*)gpr_atm_no_barrier_load(&im->user_data);
       }
       gpr_atm_no_barrier_store(&im->user_data, (gpr_atm)user_data);
       gpr_atm_rel_store(&im->destroy_user_data, (gpr_atm)destroy_func);