grpc 1.7.3 → 1.8.0

data/src/core/lib/slice/{slice_buffer.c → slice_buffer.cc}

@@ -30,7 +30,7 @@
 /* grow a buffer; requires GRPC_SLICE_BUFFER_INLINE_ELEMENTS > 1 */
 #define GROW(x) (3 * (x) / 2)
 
-static void maybe_embiggen(grpc_slice_buffer *sb) {
+static void maybe_embiggen(grpc_slice_buffer* sb) {
   /* How far away from sb->base_slices is sb->slices pointer */
   size_t slice_offset = (size_t)(sb->slices - sb->base_slices);
   size_t slice_count = sb->count + slice_offset;
@@ -46,10 +46,10 @@ static void maybe_embiggen(grpc_slice_buffer *sb) {
       GPR_ASSERT(sb->capacity > slice_count);
       if (sb->base_slices == sb->inlined) {
         sb->base_slices =
-            (grpc_slice *)gpr_malloc(sb->capacity * sizeof(grpc_slice));
+            (grpc_slice*)gpr_malloc(sb->capacity * sizeof(grpc_slice));
         memcpy(sb->base_slices, sb->inlined, slice_count * sizeof(grpc_slice));
       } else {
-        sb->base_slices = (grpc_slice *)gpr_realloc(
+        sb->base_slices = (grpc_slice*)gpr_realloc(
             sb->base_slices, sb->capacity * sizeof(grpc_slice));
       }
 
@@ -58,30 +58,30 @@ static void maybe_embiggen(grpc_slice_buffer *sb) {
   }
 }
 
-void grpc_slice_buffer_init(grpc_slice_buffer *sb) {
+void grpc_slice_buffer_init(grpc_slice_buffer* sb) {
   sb->count = 0;
   sb->length = 0;
   sb->capacity = GRPC_SLICE_BUFFER_INLINE_ELEMENTS;
   sb->base_slices = sb->slices = sb->inlined;
 }
 
-void grpc_slice_buffer_destroy_internal(grpc_exec_ctx *exec_ctx,
-                                        grpc_slice_buffer *sb) {
+void grpc_slice_buffer_destroy_internal(grpc_exec_ctx* exec_ctx,
+                                        grpc_slice_buffer* sb) {
   grpc_slice_buffer_reset_and_unref_internal(exec_ctx, sb);
   if (sb->base_slices != sb->inlined) {
     gpr_free(sb->base_slices);
   }
 }
 
-void grpc_slice_buffer_destroy(grpc_slice_buffer *sb) {
+void grpc_slice_buffer_destroy(grpc_slice_buffer* sb) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_slice_buffer_destroy_internal(&exec_ctx, sb);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-uint8_t *grpc_slice_buffer_tiny_add(grpc_slice_buffer *sb, size_t n) {
-  grpc_slice *back;
-  uint8_t *out;
+uint8_t* grpc_slice_buffer_tiny_add(grpc_slice_buffer* sb, size_t n) {
+  grpc_slice* back;
+  uint8_t* out;
 
   sb->length += n;
 
@@ -98,12 +98,12 @@ add_new:
   maybe_embiggen(sb);
   back = &sb->slices[sb->count];
   sb->count++;
-  back->refcount = NULL;
+  back->refcount = nullptr;
   back->data.inlined.length = (uint8_t)n;
   return back->data.inlined.bytes;
 }
 
-size_t grpc_slice_buffer_add_indexed(grpc_slice_buffer *sb, grpc_slice s) {
+size_t grpc_slice_buffer_add_indexed(grpc_slice_buffer* sb, grpc_slice s) {
   size_t out = sb->count;
   maybe_embiggen(sb);
   sb->slices[out] = s;
@@ -112,7 +112,7 @@ size_t grpc_slice_buffer_add_indexed(grpc_slice_buffer *sb, grpc_slice s) {
   return out;
 }
 
-void grpc_slice_buffer_add(grpc_slice_buffer *sb, grpc_slice s) {
+void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice s) {
   size_t n = sb->count;
   /* if both the last slice in the slice buffer and the slice being added
      are inlined (that is, that they carry their data inside the slice data
@@ -120,7 +120,7 @@ void grpc_slice_buffer_add(grpc_slice_buffer *sb, grpc_slice s) {
      into the back slice, preventing many small slices being passed into
      writes */
   if (!s.refcount && n) {
-    grpc_slice *back = &sb->slices[n - 1];
+    grpc_slice* back = &sb->slices[n - 1];
     if (!back->refcount &&
         back->data.inlined.length < GRPC_SLICE_INLINED_SIZE) {
       if (s.data.inlined.length + back->data.inlined.length <=
@@ -137,7 +137,7 @@ void grpc_slice_buffer_add(grpc_slice_buffer *sb, grpc_slice s) {
         maybe_embiggen(sb);
         back = &sb->slices[n];
         sb->count = n + 1;
-        back->refcount = NULL;
+        back->refcount = nullptr;
         back->data.inlined.length = (uint8_t)(s.data.inlined.length - cp1);
         memcpy(back->data.inlined.bytes, s.data.inlined.bytes + cp1,
                s.data.inlined.length - cp1);
@@ -149,22 +149,22 @@ void grpc_slice_buffer_add(grpc_slice_buffer *sb, grpc_slice s) {
   grpc_slice_buffer_add_indexed(sb, s);
 }
 
-void grpc_slice_buffer_addn(grpc_slice_buffer *sb, grpc_slice *s, size_t n) {
+void grpc_slice_buffer_addn(grpc_slice_buffer* sb, grpc_slice* s, size_t n) {
   size_t i;
   for (i = 0; i < n; i++) {
     grpc_slice_buffer_add(sb, s[i]);
   }
 }
 
-void grpc_slice_buffer_pop(grpc_slice_buffer *sb) {
+void grpc_slice_buffer_pop(grpc_slice_buffer* sb) {
   if (sb->count != 0) {
     size_t count = --sb->count;
     sb->length -= GRPC_SLICE_LENGTH(sb->slices[count]);
   }
 }
 
-void grpc_slice_buffer_reset_and_unref_internal(grpc_exec_ctx *exec_ctx,
-                                                grpc_slice_buffer *sb) {
+void grpc_slice_buffer_reset_and_unref_internal(grpc_exec_ctx* exec_ctx,
+                                                grpc_slice_buffer* sb) {
   size_t i;
   for (i = 0; i < sb->count; i++) {
     grpc_slice_unref_internal(exec_ctx, sb->slices[i]);
@@ -174,13 +174,13 @@ void grpc_slice_buffer_reset_and_unref_internal(grpc_exec_ctx *exec_ctx,
   sb->length = 0;
 }
 
-void grpc_slice_buffer_reset_and_unref(grpc_slice_buffer *sb) {
+void grpc_slice_buffer_reset_and_unref(grpc_slice_buffer* sb) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_slice_buffer_reset_and_unref_internal(&exec_ctx, sb);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-void grpc_slice_buffer_swap(grpc_slice_buffer *a, grpc_slice_buffer *b) {
+void grpc_slice_buffer_swap(grpc_slice_buffer* a, grpc_slice_buffer* b) {
   size_t a_offset = (size_t)(a->slices - a->base_slices);
   size_t b_offset = (size_t)(b->slices - b->base_slices);
 
@@ -207,7 +207,7 @@ void grpc_slice_buffer_swap(grpc_slice_buffer *a, grpc_slice_buffer *b) {
     memcpy(a->base_slices, b->inlined, b_count * sizeof(grpc_slice));
   } else {
     /* no inlining: easy swap */
-    GPR_SWAP(grpc_slice *, a->base_slices, b->base_slices);
+    GPR_SWAP(grpc_slice*, a->base_slices, b->base_slices);
   }
 
   /* Update the slices pointers (cannot do a GPR_SWAP on slices fields here).
@@ -222,8 +222,8 @@ void grpc_slice_buffer_swap(grpc_slice_buffer *a, grpc_slice_buffer *b) {
   GPR_SWAP(size_t, a->length, b->length);
 }
 
-void grpc_slice_buffer_move_into(grpc_slice_buffer *src,
-                                 grpc_slice_buffer *dst) {
+void grpc_slice_buffer_move_into(grpc_slice_buffer* src,
+                                 grpc_slice_buffer* dst) {
   /* anything to move? */
   if (src->count == 0) {
     return;
@@ -239,8 +239,8 @@ void grpc_slice_buffer_move_into(grpc_slice_buffer *src,
   src->length = 0;
 }
 
-static void slice_buffer_move_first_maybe_ref(grpc_slice_buffer *src, size_t n,
-                                              grpc_slice_buffer *dst,
+static void slice_buffer_move_first_maybe_ref(grpc_slice_buffer* src, size_t n,
+                                              grpc_slice_buffer* dst,
                                               bool incref) {
   GPR_ASSERT(src->length >= n);
   if (src->length == n) {
@@ -279,20 +279,20 @@ static void slice_buffer_move_first_maybe_ref(grpc_slice_buffer *src, size_t n,
   GPR_ASSERT(src->count > 0);
 }
 
-void grpc_slice_buffer_move_first(grpc_slice_buffer *src, size_t n,
-                                  grpc_slice_buffer *dst) {
+void grpc_slice_buffer_move_first(grpc_slice_buffer* src, size_t n,
+                                  grpc_slice_buffer* dst) {
   slice_buffer_move_first_maybe_ref(src, n, dst, true);
 }
 
-void grpc_slice_buffer_move_first_no_ref(grpc_slice_buffer *src, size_t n,
-                                         grpc_slice_buffer *dst) {
+void grpc_slice_buffer_move_first_no_ref(grpc_slice_buffer* src, size_t n,
+                                         grpc_slice_buffer* dst) {
   slice_buffer_move_first_maybe_ref(src, n, dst, false);
 }
 
-void grpc_slice_buffer_move_first_into_buffer(grpc_exec_ctx *exec_ctx,
-                                              grpc_slice_buffer *src, size_t n,
-                                              void *dst) {
-  char *dstp = (char *)dst;
+void grpc_slice_buffer_move_first_into_buffer(grpc_exec_ctx* exec_ctx,
+                                              grpc_slice_buffer* src, size_t n,
+                                              void* dst) {
+  char* dstp = (char*)dst;
   GPR_ASSERT(src->length >= n);
 
   while (n > 0) {
@@ -316,8 +316,8 @@ void grpc_slice_buffer_move_first_into_buffer(grpc_exec_ctx *exec_ctx,
   }
 }
 
-void grpc_slice_buffer_trim_end(grpc_slice_buffer *sb, size_t n,
-                                grpc_slice_buffer *garbage) {
+void grpc_slice_buffer_trim_end(grpc_slice_buffer* sb, size_t n,
+                                grpc_slice_buffer* garbage) {
   GPR_ASSERT(n <= sb->length);
   sb->length -= n;
   for (;;) {
@@ -340,7 +340,7 @@ void grpc_slice_buffer_trim_end(grpc_slice_buffer *sb, size_t n,
   }
 }
 
-grpc_slice grpc_slice_buffer_take_first(grpc_slice_buffer *sb) {
+grpc_slice grpc_slice_buffer_take_first(grpc_slice_buffer* sb) {
   grpc_slice slice;
   GPR_ASSERT(sb->count > 0);
   slice = sb->slices[0];
@@ -351,7 +351,7 @@ grpc_slice grpc_slice_buffer_take_first(grpc_slice_buffer *sb) {
   return slice;
 }
 
-void grpc_slice_buffer_undo_take_first(grpc_slice_buffer *sb,
+void grpc_slice_buffer_undo_take_first(grpc_slice_buffer* sb,
                                        grpc_slice slice) {
   sb->slices--;
   sb->slices[0] = slice;

data/src/core/lib/slice/{slice_hash_table.c → slice_hash_table.cc}

@@ -35,12 +35,12 @@ struct grpc_slice_hash_table {
 };
 
 static bool is_empty(grpc_slice_hash_table_entry* entry) {
-  return entry->value == NULL;
+  return entry->value == nullptr;
 }
 
 static void grpc_slice_hash_table_add(grpc_slice_hash_table* table,
                                       grpc_slice key, void* value) {
-  GPR_ASSERT(value != NULL);
+  GPR_ASSERT(value != nullptr);
   const size_t hash = grpc_slice_hash(key);
   for (size_t offset = 0; offset < table->size; ++offset) {
     const size_t idx = (hash + offset) % table->size;
@@ -77,13 +77,13 @@ grpc_slice_hash_table* grpc_slice_hash_table_create(
 }
 
 grpc_slice_hash_table* grpc_slice_hash_table_ref(grpc_slice_hash_table* table) {
-  if (table != NULL) gpr_ref(&table->refs);
+  if (table != nullptr) gpr_ref(&table->refs);
   return table;
 }
 
 void grpc_slice_hash_table_unref(grpc_exec_ctx* exec_ctx,
                                  grpc_slice_hash_table* table) {
-  if (table != NULL && gpr_unref(&table->refs)) {
+  if (table != nullptr && gpr_unref(&table->refs)) {
     for (size_t i = 0; i < table->size; ++i) {
       grpc_slice_hash_table_entry* entry = &table->entries[i];
       if (!is_empty(entry)) {
@@ -108,16 +108,16 @@ void* grpc_slice_hash_table_get(const grpc_slice_hash_table* table,
       return table->entries[idx].value;
     }
   }
-  return NULL;  // Not found.
+  return nullptr;  // Not found.
 }
 
 static int pointer_cmp(void* a, void* b) { return GPR_ICMP(a, b); }
 int grpc_slice_hash_table_cmp(const grpc_slice_hash_table* a,
                               const grpc_slice_hash_table* b) {
   int (*const value_cmp_fn_a)(void* a, void* b) =
-      a->value_cmp != NULL ? a->value_cmp : pointer_cmp;
+      a->value_cmp != nullptr ? a->value_cmp : pointer_cmp;
   int (*const value_cmp_fn_b)(void* a, void* b) =
-      b->value_cmp != NULL ? b->value_cmp : pointer_cmp;
+      b->value_cmp != nullptr ? b->value_cmp : pointer_cmp;
   // Compare value_fns
   const int value_fns_cmp =
       GPR_ICMP((void*)value_cmp_fn_a, (void*)value_cmp_fn_b);

data/src/core/lib/slice/slice_hash_table.h

@@ -19,6 +19,10 @@
 
 #include "src/core/lib/transport/metadata.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /** Hash table implementation.
  *
  * This implementation uses open addressing
@@ -35,7 +39,7 @@ typedef struct grpc_slice_hash_table grpc_slice_hash_table;
 
 typedef struct grpc_slice_hash_table_entry {
   grpc_slice key;
-  void *value; /* Must not be NULL. */
+  void* value; /* Must not be NULL. */
 } grpc_slice_hash_table_entry;
 
 /** Creates a new hash table of containing \a entries, which is an array
@@ -44,18 +48,18 @@ typedef struct grpc_slice_hash_table_entry {
     value_cmp will be used to compare values in the context of \a
     grpc_slice_hash_table_cmp. If NULL, raw pointer (\a GPR_ICMP) comparison
     will be used. */
-grpc_slice_hash_table *grpc_slice_hash_table_create(
-    size_t num_entries, grpc_slice_hash_table_entry *entries,
-    void (*destroy_value)(grpc_exec_ctx *exec_ctx, void *value),
-    int (*value_cmp)(void *a, void *b));
+grpc_slice_hash_table* grpc_slice_hash_table_create(
+    size_t num_entries, grpc_slice_hash_table_entry* entries,
+    void (*destroy_value)(grpc_exec_ctx* exec_ctx, void* value),
+    int (*value_cmp)(void* a, void* b));
 
-grpc_slice_hash_table *grpc_slice_hash_table_ref(grpc_slice_hash_table *table);
-void grpc_slice_hash_table_unref(grpc_exec_ctx *exec_ctx,
-                                 grpc_slice_hash_table *table);
+grpc_slice_hash_table* grpc_slice_hash_table_ref(grpc_slice_hash_table* table);
+void grpc_slice_hash_table_unref(grpc_exec_ctx* exec_ctx,
+                                 grpc_slice_hash_table* table);
 
 /** Returns the value from \a table associated with \a key.
     Returns NULL if \a key is not found. */
-void *grpc_slice_hash_table_get(const grpc_slice_hash_table *table,
+void* grpc_slice_hash_table_get(const grpc_slice_hash_table* table,
                                 const grpc_slice key);
 
 /** Compares \a a vs. \a b.
@@ -64,7 +68,11 @@ void *grpc_slice_hash_table_get(const grpc_slice_hash_table *table,
  *  - else, it contains fewer (resp. more) entries,
  *  - else, if strcmp(a_key, b_key) < 1 (resp. > 1),
  *  - else, if value_cmp(a_value, b_value) < 1 (resp. > 1). */
-int grpc_slice_hash_table_cmp(const grpc_slice_hash_table *a,
-                              const grpc_slice_hash_table *b);
+int grpc_slice_hash_table_cmp(const grpc_slice_hash_table* a,
+                              const grpc_slice_hash_table* b);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_SLICE_SLICE_HASH_TABLE_H */

data/src/core/lib/slice/{slice_intern.c → slice_intern.cc}

@@ -18,6 +18,7 @@
 
 #include "src/core/lib/slice/slice_internal.h"
 
+#include <inttypes.h>
 #include <string.h>
 
 #include <grpc/support/alloc.h>
@@ -42,12 +43,12 @@ typedef struct interned_slice_refcount {
   size_t length;
   gpr_atm refcnt;
   uint32_t hash;
-  struct interned_slice_refcount *bucket_next;
+  struct interned_slice_refcount* bucket_next;
 } interned_slice_refcount;
 
 typedef struct slice_shard {
   gpr_mu mu;
-  interned_slice_refcount **strs;
+  interned_slice_refcount** strs;
   size_t count;
   size_t capacity;
 } slice_shard;
@@ -68,17 +69,17 @@ static static_metadata_hash_ent
 static uint32_t max_static_metadata_hash_probe;
 static uint32_t static_metadata_hash_values[GRPC_STATIC_MDSTR_COUNT];
 
-static void interned_slice_ref(void *p) {
-  interned_slice_refcount *s = (interned_slice_refcount *)p;
+static void interned_slice_ref(void* p) {
+  interned_slice_refcount* s = (interned_slice_refcount*)p;
   GPR_ASSERT(gpr_atm_no_barrier_fetch_add(&s->refcnt, 1) > 0);
 }
 
-static void interned_slice_destroy(interned_slice_refcount *s) {
-  slice_shard *shard = &g_shards[SHARD_IDX(s->hash)];
+static void interned_slice_destroy(interned_slice_refcount* s) {
+  slice_shard* shard = &g_shards[SHARD_IDX(s->hash)];
   gpr_mu_lock(&shard->mu);
   GPR_ASSERT(0 == gpr_atm_no_barrier_load(&s->refcnt));
-  interned_slice_refcount **prev_next;
-  interned_slice_refcount *cur;
+  interned_slice_refcount** prev_next;
+  interned_slice_refcount* cur;
   for (prev_next = &shard->strs[TABLE_IDX(s->hash, shard->capacity)],
       cur = *prev_next;
        cur != s; prev_next = &cur->bucket_next, cur = cur->bucket_next)
@@ -89,24 +90,24 @@ static void interned_slice_destroy(interned_slice_refcount *s) {
   gpr_mu_unlock(&shard->mu);
 }
 
-static void interned_slice_unref(grpc_exec_ctx *exec_ctx, void *p) {
-  interned_slice_refcount *s = (interned_slice_refcount *)p;
+static void interned_slice_unref(grpc_exec_ctx* exec_ctx, void* p) {
+  interned_slice_refcount* s = (interned_slice_refcount*)p;
   if (1 == gpr_atm_full_fetch_add(&s->refcnt, -1)) {
     interned_slice_destroy(s);
   }
 }
 
-static void interned_slice_sub_ref(void *p) {
-  interned_slice_ref(((char *)p) - offsetof(interned_slice_refcount, sub));
+static void interned_slice_sub_ref(void* p) {
+  interned_slice_ref(((char*)p) - offsetof(interned_slice_refcount, sub));
 }
 
-static void interned_slice_sub_unref(grpc_exec_ctx *exec_ctx, void *p) {
+static void interned_slice_sub_unref(grpc_exec_ctx* exec_ctx, void* p) {
   interned_slice_unref(exec_ctx,
-                       ((char *)p) - offsetof(interned_slice_refcount, sub));
+                       ((char*)p) - offsetof(interned_slice_refcount, sub));
 }
 
 static uint32_t interned_slice_hash(grpc_slice slice) {
-  interned_slice_refcount *s = (interned_slice_refcount *)slice.refcount;
+  interned_slice_refcount* s = (interned_slice_refcount*)slice.refcount;
   return s->hash;
 }
 
@@ -121,16 +122,16 @@ static const grpc_slice_refcount_vtable interned_slice_sub_vtable = {
     interned_slice_sub_ref, interned_slice_sub_unref,
     grpc_slice_default_eq_impl, grpc_slice_default_hash_impl};
 
-static void grow_shard(slice_shard *shard) {
+static void grow_shard(slice_shard* shard) {
   size_t capacity = shard->capacity * 2;
   size_t i;
-  interned_slice_refcount **strtab;
+  interned_slice_refcount** strtab;
   interned_slice_refcount *s, *next;
 
   GPR_TIMER_BEGIN("grow_strtab", 0);
 
-  strtab = (interned_slice_refcount **)gpr_zalloc(
-      sizeof(interned_slice_refcount *) * capacity);
+  strtab = (interned_slice_refcount**)gpr_zalloc(
+      sizeof(interned_slice_refcount*) * capacity);
 
   for (i = 0; i < shard->capacity; i++) {
     for (s = shard->strs[i]; s; s = next) {
@@ -148,10 +149,10 @@ static void grow_shard(slice_shard *shard) {
   GPR_TIMER_END("grow_strtab", 0);
 }
 
-static grpc_slice materialize(interned_slice_refcount *s) {
+static grpc_slice materialize(interned_slice_refcount* s) {
   grpc_slice slice;
   slice.refcount = &s->base;
-  slice.data.refcounted.bytes = (uint8_t *)(s + 1);
+  slice.data.refcounted.bytes = (uint8_t*)(s + 1);
   slice.data.refcounted.length = s->length;
   return slice;
 }
@@ -170,12 +171,12 @@ int grpc_static_slice_eq(grpc_slice a, grpc_slice b) {
 }
 
 uint32_t grpc_slice_hash(grpc_slice s) {
-  return s.refcount == NULL ? grpc_slice_default_hash_impl(s)
-                            : s.refcount->vtable->hash(s);
+  return s.refcount == nullptr ? grpc_slice_default_hash_impl(s)
+                               : s.refcount->vtable->hash(s);
 }
 
 grpc_slice grpc_slice_maybe_static_intern(grpc_slice slice,
-                                          bool *returned_slice_is_different) {
+                                          bool* returned_slice_is_different) {
   if (GRPC_IS_STATIC_METADATA_STRING(slice)) {
     return slice;
   }
@@ -217,8 +218,8 @@ grpc_slice grpc_slice_intern(grpc_slice slice) {
     }
   }
 
-  interned_slice_refcount *s;
-  slice_shard *shard = &g_shards[SHARD_IDX(hash)];
+  interned_slice_refcount* s;
+  slice_shard* shard = &g_shards[SHARD_IDX(hash)];
 
   gpr_mu_lock(&shard->mu);
 
@@ -243,8 +244,8 @@ grpc_slice grpc_slice_intern(grpc_slice slice) {
 
   /* not found: create a new string */
   /* string data goes after the internal_string header */
-  s = (interned_slice_refcount *)gpr_malloc(sizeof(*s) +
-                                            GRPC_SLICE_LENGTH(slice));
+  s = (interned_slice_refcount*)gpr_malloc(sizeof(*s) +
+                                           GRPC_SLICE_LENGTH(slice));
   gpr_atm_rel_store(&s->refcnt, 1);
   s->length = GRPC_SLICE_LENGTH(slice);
   s->hash = hash;
@@ -278,12 +279,12 @@ void grpc_slice_intern_init(void) {
     g_hash_seed = (uint32_t)gpr_now(GPR_CLOCK_REALTIME).tv_nsec;
   }
   for (size_t i = 0; i < SHARD_COUNT; i++) {
-    slice_shard *shard = &g_shards[i];
+    slice_shard* shard = &g_shards[i];
     gpr_mu_init(&shard->mu);
     shard->count = 0;
     shard->capacity = INITIAL_SHARD_CAPACITY;
-    shard->strs = (interned_slice_refcount **)gpr_zalloc(sizeof(*shard->strs) *
-                                                         shard->capacity);
+    shard->strs = (interned_slice_refcount**)gpr_zalloc(sizeof(*shard->strs) *
+                                                        shard->capacity);
   }
   for (size_t i = 0; i < GPR_ARRAY_SIZE(static_metadata_hash); i++) {
     static_metadata_hash[i].hash = 0;
@@ -310,16 +311,16 @@ void grpc_slice_intern_init(void) {
 
 void grpc_slice_intern_shutdown(void) {
   for (size_t i = 0; i < SHARD_COUNT; i++) {
-    slice_shard *shard = &g_shards[i];
+    slice_shard* shard = &g_shards[i];
     gpr_mu_destroy(&shard->mu);
     /* TODO(ctiller): GPR_ASSERT(shard->count == 0); */
     if (shard->count != 0) {
       gpr_log(GPR_DEBUG, "WARNING: %" PRIuPTR " metadata strings were leaked",
               shard->count);
       for (size_t j = 0; j < shard->capacity; j++) {
-        for (interned_slice_refcount *s = shard->strs[j]; s;
+        for (interned_slice_refcount* s = shard->strs[j]; s;
              s = s->bucket_next) {
-          char *text =
+          char* text =
               grpc_dump_slice(materialize(s), GPR_DUMP_HEX | GPR_DUMP_ASCII);
           gpr_log(GPR_DEBUG, "LEAKED: %s", text);
           gpr_free(text);