Update clang-format to 5.0

5 files changed, 122 insertions, 122 deletions

diff --git a/src/core/lib/json/json_reader.cc b/src/core/lib/json/json_reader.cc
index 094a35176c..30039419b1 100644
--- a/src/core/lib/json/json_reader.cc
+++ b/src/core/lib/json/json_reader.cc
@@ -24,60 +24,60 @@
 
 #include "src/core/lib/json/json_reader.h"
 
-static void json_reader_string_clear(grpc_json_reader *reader) {
+static void json_reader_string_clear(grpc_json_reader* reader) {
   reader->vtable->string_clear(reader->userdata);
 }
 
-static void json_reader_string_add_char(grpc_json_reader *reader, uint32_t c) {
+static void json_reader_string_add_char(grpc_json_reader* reader, uint32_t c) {
   reader->vtable->string_add_char(reader->userdata, c);
 }
 
-static void json_reader_string_add_utf32(grpc_json_reader *reader,
+static void json_reader_string_add_utf32(grpc_json_reader* reader,
                                          uint32_t utf32) {
   reader->vtable->string_add_utf32(reader->userdata, utf32);
 }
 
-static uint32_t grpc_json_reader_read_char(grpc_json_reader *reader) {
+static uint32_t grpc_json_reader_read_char(grpc_json_reader* reader) {
   return reader->vtable->read_char(reader->userdata);
 }
 
-static void json_reader_container_begins(grpc_json_reader *reader,
+static void json_reader_container_begins(grpc_json_reader* reader,
                                          grpc_json_type type) {
   reader->vtable->container_begins(reader->userdata, type);
 }
 
 static grpc_json_type grpc_json_reader_container_ends(
-    grpc_json_reader *reader) {
+    grpc_json_reader* reader) {
   return reader->vtable->container_ends(reader->userdata);
 }
 
-static void json_reader_set_key(grpc_json_reader *reader) {
+static void json_reader_set_key(grpc_json_reader* reader) {
   reader->vtable->set_key(reader->userdata);
 }
 
-static void json_reader_set_string(grpc_json_reader *reader) {
+static void json_reader_set_string(grpc_json_reader* reader) {
   reader->vtable->set_string(reader->userdata);
 }
 
-static int json_reader_set_number(grpc_json_reader *reader) {
+static int json_reader_set_number(grpc_json_reader* reader) {
   return reader->vtable->set_number(reader->userdata);
 }
 
-static void json_reader_set_true(grpc_json_reader *reader) {
+static void json_reader_set_true(grpc_json_reader* reader) {
   reader->vtable->set_true(reader->userdata);
 }
 
-static void json_reader_set_false(grpc_json_reader *reader) {
+static void json_reader_set_false(grpc_json_reader* reader) {
   reader->vtable->set_false(reader->userdata);
 }
 
-static void json_reader_set_null(grpc_json_reader *reader) {
+static void json_reader_set_null(grpc_json_reader* reader) {
   reader->vtable->set_null(reader->userdata);
 }
 
 /* Call this function to initialize the reader structure. */
-void grpc_json_reader_init(grpc_json_reader *reader,
-                           grpc_json_reader_vtable *vtable, void *userdata) {
+void grpc_json_reader_init(grpc_json_reader* reader,
+                           grpc_json_reader_vtable* vtable, void* userdata) {
   memset(reader, 0, sizeof(*reader));
   reader->vtable = vtable;
   reader->userdata = userdata;
@@ -85,13 +85,13 @@ void grpc_json_reader_init(grpc_json_reader *reader,
   reader->state = GRPC_JSON_STATE_VALUE_BEGIN;
 }
 
-int grpc_json_reader_is_complete(grpc_json_reader *reader) {
+int grpc_json_reader_is_complete(grpc_json_reader* reader) {
   return ((reader->depth == 0) &&
           ((reader->state == GRPC_JSON_STATE_END) ||
            (reader->state == GRPC_JSON_STATE_VALUE_END)));
 }
 
-grpc_json_reader_status grpc_json_reader_run(grpc_json_reader *reader) {
+grpc_json_reader_status grpc_json_reader_run(grpc_json_reader* reader) {
   uint32_t c, success;
 
   /* This state-machine is a strict implementation of ECMA-404 */
@@ -177,8 +177,8 @@ grpc_json_reader_status grpc_json_reader_run(grpc_json_reader *reader) {
             if (!success) return GRPC_JSON_PARSE_ERROR;
             json_reader_string_clear(reader);
             reader->state = GRPC_JSON_STATE_VALUE_END;
-          /* The missing break here is intentional. */
-          /* fallthrough */
+            /* The missing break here is intentional. */
+            /* fallthrough */
 
           case GRPC_JSON_STATE_VALUE_END:
           case GRPC_JSON_STATE_OBJECT_KEY_BEGIN:
diff --git a/src/core/lib/json/json_reader.h b/src/core/lib/json/json_reader.h
index 7f14a9a9c8..2636d2b1d9 100644
--- a/src/core/lib/json/json_reader.h
+++ b/src/core/lib/json/json_reader.h
@@ -71,27 +71,27 @@ struct grpc_json_reader;
 
 typedef struct grpc_json_reader_vtable {
   /* Clears your internal string scratchpad. */
-  void (*string_clear)(void *userdata);
+  void (*string_clear)(void* userdata);
   /* Adds a char to the string scratchpad. */
-  void (*string_add_char)(void *userdata, uint32_t c);
+  void (*string_add_char)(void* userdata, uint32_t c);
   /* Adds a utf32 char to the string scratchpad. */
-  void (*string_add_utf32)(void *userdata, uint32_t c);
+  void (*string_add_utf32)(void* userdata, uint32_t c);
   /* Reads a character from your input. May be utf-8, 16 or 32. */
-  uint32_t (*read_char)(void *userdata);
+  uint32_t (*read_char)(void* userdata);
   /* Starts a container of type GRPC_JSON_ARRAY or GRPC_JSON_OBJECT. */
-  void (*container_begins)(void *userdata, grpc_json_type type);
+  void (*container_begins)(void* userdata, grpc_json_type type);
   /* Ends the current container. Must return the type of its parent. */
-  grpc_json_type (*container_ends)(void *userdata);
+  grpc_json_type (*container_ends)(void* userdata);
   /* Your internal string scratchpad is an object's key. */
-  void (*set_key)(void *userdata);
+  void (*set_key)(void* userdata);
   /* Your internal string scratchpad is a string value. */
-  void (*set_string)(void *userdata);
+  void (*set_string)(void* userdata);
   /* Your internal string scratchpad is a numerical value. Return 1 if valid. */
-  int (*set_number)(void *userdata);
+  int (*set_number)(void* userdata);
   /* Sets the values true, false or null. */
-  void (*set_true)(void *userdata);
-  void (*set_false)(void *userdata);
-  void (*set_null)(void *userdata);
+  void (*set_true)(void* userdata);
+  void (*set_false)(void* userdata);
+  void (*set_null)(void* userdata);
 } grpc_json_reader_vtable;
 
 typedef struct grpc_json_reader {
@@ -99,8 +99,8 @@ typedef struct grpc_json_reader {
    * The definition is public so you can put it on your stack.
    */
 
-  void *userdata;
-  grpc_json_reader_vtable *vtable;
+  void* userdata;
+  grpc_json_reader_vtable* vtable;
   int depth;
   int in_object;
   int in_array;
@@ -133,18 +133,18 @@ typedef enum {
  *    . GRPC_JSON_INTERNAL_ERROR if the parser somehow ended into an invalid
  *      internal state.
  */
-grpc_json_reader_status grpc_json_reader_run(grpc_json_reader *reader);
+grpc_json_reader_status grpc_json_reader_run(grpc_json_reader* reader);
 
 /* Call this function to initialize the reader structure. */
-void grpc_json_reader_init(grpc_json_reader *reader,
-                           grpc_json_reader_vtable *vtable, void *userdata);
+void grpc_json_reader_init(grpc_json_reader* reader,
+                           grpc_json_reader_vtable* vtable, void* userdata);
 
 /* You may call this from the read_char callback if you don't know where is the
  * end of your input stream, and you'd like the json reader to hint you that it
  * has completed reading its input, so you can return an EOF to it. Note that
  * there might still be trailing whitespaces after that point.
  */
-int grpc_json_reader_is_complete(grpc_json_reader *reader);
+int grpc_json_reader_is_complete(grpc_json_reader* reader);
 
 #ifdef __cplusplus
 }
diff --git a/src/core/lib/json/json_string.cc b/src/core/lib/json/json_string.cc
index 3178d2d2b4..8674d72b7e 100644
--- a/src/core/lib/json/json_string.cc
+++ b/src/core/lib/json/json_string.cc
@@ -38,13 +38,13 @@
  * input size, and never expands it.
  */
 typedef struct {
-  grpc_json *top;
-  grpc_json *current_container;
-  grpc_json *current_value;
-  uint8_t *input;
-  uint8_t *key;
-  uint8_t *string;
-  uint8_t *string_ptr;
+  grpc_json* top;
+  grpc_json* current_container;
+  grpc_json* current_value;
+  uint8_t* input;
+  uint8_t* key;
+  uint8_t* string;
+  uint8_t* string_ptr;
   size_t remaining_input;
 } json_reader_userdata;
 
@@ -52,7 +52,7 @@ typedef struct {
  * The point is that we allocate that string in chunks of 256 bytes.
  */
 typedef struct {
-  char *output;
+  char* output;
   size_t free_space;
   size_t string_len;
   size_t allocated;
@@ -62,35 +62,35 @@ typedef struct {
  * and will enlarge it if necessary. We're only allocating chunks of 256
  * bytes at a time (or multiples thereof).
  */
-static void json_writer_output_check(void *userdata, size_t needed) {
-  json_writer_userdata *state = (json_writer_userdata *)userdata;
+static void json_writer_output_check(void* userdata, size_t needed) {
+  json_writer_userdata* state = (json_writer_userdata*)userdata;
   if (state->free_space >= needed) return;
   needed -= state->free_space;
   /* Round up by 256 bytes. */
   needed = (needed + 0xff) & ~0xffU;
-  state->output = (char *)gpr_realloc(state->output, state->allocated + needed);
+  state->output = (char*)gpr_realloc(state->output, state->allocated + needed);
   state->free_space += needed;
   state->allocated += needed;
 }
 
 /* These are needed by the writer's implementation. */
-static void json_writer_output_char(void *userdata, char c) {
-  json_writer_userdata *state = (json_writer_userdata *)userdata;
+static void json_writer_output_char(void* userdata, char c) {
+  json_writer_userdata* state = (json_writer_userdata*)userdata;
   json_writer_output_check(userdata, 1);
   state->output[state->string_len++] = c;
   state->free_space--;
 }
 
-static void json_writer_output_string_with_len(void *userdata, const char *str,
+static void json_writer_output_string_with_len(void* userdata, const char* str,
                                                size_t len) {
-  json_writer_userdata *state = (json_writer_userdata *)userdata;
+  json_writer_userdata* state = (json_writer_userdata*)userdata;
   json_writer_output_check(userdata, len);
   memcpy(state->output + state->string_len, str, len);
   state->string_len += len;
   state->free_space -= len;
 }
 
-static void json_writer_output_string(void *userdata, const char *str) {
+static void json_writer_output_string(void* userdata, const char* str) {
   size_t len = strlen(str);
   json_writer_output_string_with_len(userdata, str, len);
 }
@@ -98,8 +98,8 @@ static void json_writer_output_string(void *userdata, const char *str) {
 /* The reader asks us to clear our scratchpad. In our case, we'll simply mark
  * the end of the current string, and advance our output pointer.
  */
-static void json_reader_string_clear(void *userdata) {
-  json_reader_userdata *state = (json_reader_userdata *)userdata;
+static void json_reader_string_clear(void* userdata) {
+  json_reader_userdata* state = (json_reader_userdata*)userdata;
   if (state->string) {
     GPR_ASSERT(state->string_ptr < state->input);
     *state->string_ptr++ = 0;
@@ -107,8 +107,8 @@ static void json_reader_string_clear(void *userdata) {
   state->string = state->string_ptr;
 }
 
-static void json_reader_string_add_char(void *userdata, uint32_t c) {
-  json_reader_userdata *state = (json_reader_userdata *)userdata;
+static void json_reader_string_add_char(void* userdata, uint32_t c) {
+  json_reader_userdata* state = (json_reader_userdata*)userdata;
   GPR_ASSERT(state->string_ptr < state->input);
   GPR_ASSERT(c <= 0xff);
   *state->string_ptr++ = (uint8_t)c;
@@ -117,7 +117,7 @@ static void json_reader_string_add_char(void *userdata, uint32_t c) {
 /* We are converting a UTF-32 character into UTF-8 here,
  * as described by RFC3629.
  */
-static void json_reader_string_add_utf32(void *userdata, uint32_t c) {
+static void json_reader_string_add_utf32(void* userdata, uint32_t c) {
   if (c <= 0x7f) {
     json_reader_string_add_char(userdata, c);
   } else if (c <= 0x7ff) {
@@ -147,9 +147,9 @@ static void json_reader_string_add_utf32(void *userdata, uint32_t c) {
 /* We consider that the input may be a zero-terminated string. So we
  * can end up hitting eof before the end of the alleged string length.
  */
-static uint32_t json_reader_read_char(void *userdata) {
+static uint32_t json_reader_read_char(void* userdata) {
   uint32_t r;
-  json_reader_userdata *state = (json_reader_userdata *)userdata;
+  json_reader_userdata* state = (json_reader_userdata*)userdata;
 
   if (state->remaining_input == 0) return GRPC_JSON_READ_CHAR_EOF;
 
@@ -167,9 +167,9 @@ static uint32_t json_reader_read_char(void *userdata) {
 /* Helper function to create a new grpc_json object and link it into
  * our tree-in-progress inside our opaque structure.
  */
-static grpc_json *json_create_and_link(void *userdata, grpc_json_type type) {
-  json_reader_userdata *state = (json_reader_userdata *)userdata;
-  grpc_json *json = grpc_json_create(type);
+static grpc_json* json_create_and_link(void* userdata, grpc_json_type type) {
+  json_reader_userdata* state = (json_reader_userdata*)userdata;
+  grpc_json* json = grpc_json_create(type);
 
   json->parent = state->current_container;
   json->prev = state->current_value;
@@ -183,7 +183,7 @@ static grpc_json *json_create_and_link(void *userdata, grpc_json_type type) {
       json->parent->child = json;
     }
     if (json->parent->type == GRPC_JSON_OBJECT) {
-      json->key = (char *)state->key;
+      json->key = (char*)state->key;
     }
   }
   if (!state->top) {
@@ -193,9 +193,9 @@ static grpc_json *json_create_and_link(void *userdata, grpc_json_type type) {
   return json;
 }
 
-static void json_reader_container_begins(void *userdata, grpc_json_type type) {
-  json_reader_userdata *state = (json_reader_userdata *)userdata;
-  grpc_json *container;
+static void json_reader_container_begins(void* userdata, grpc_json_type type) {
+  json_reader_userdata* state = (json_reader_userdata*)userdata;
+  grpc_json* container;
 
   GPR_ASSERT(type == GRPC_JSON_ARRAY || type == GRPC_JSON_OBJECT);
 
@@ -213,9 +213,9 @@ static void json_reader_container_begins(void *userdata, grpc_json_type type) {
  * Also note that if we're at the top of the tree, and the last container
  * ends, we have to return GRPC_JSON_TOP_LEVEL.
  */
-static grpc_json_type json_reader_container_ends(void *userdata) {
+static grpc_json_type json_reader_container_ends(void* userdata) {
   grpc_json_type container_type = GRPC_JSON_TOP_LEVEL;
-  json_reader_userdata *state = (json_reader_userdata *)userdata;
+  json_reader_userdata* state = (json_reader_userdata*)userdata;
 
   GPR_ASSERT(state->current_container);
 
@@ -235,36 +235,36 @@ static grpc_json_type json_reader_container_ends(void *userdata) {
  * Note that in the set_number case, we're not going to try interpreting it.
  * We'll keep it as a string, and leave it to the caller to evaluate it.
  */
-static void json_reader_set_key(void *userdata) {
-  json_reader_userdata *state = (json_reader_userdata *)userdata;
+static void json_reader_set_key(void* userdata) {
+  json_reader_userdata* state = (json_reader_userdata*)userdata;
   state->key = state->string;
 }
 
-static void json_reader_set_string(void *userdata) {
-  json_reader_userdata *state = (json_reader_userdata *)userdata;
-  grpc_json *json = json_create_and_link(userdata, GRPC_JSON_STRING);
-  json->value = (char *)state->string;
+static void json_reader_set_string(void* userdata) {
+  json_reader_userdata* state = (json_reader_userdata*)userdata;
+  grpc_json* json = json_create_and_link(userdata, GRPC_JSON_STRING);
+  json->value = (char*)state->string;
 }
 
-static int json_reader_set_number(void *userdata) {
-  json_reader_userdata *state = (json_reader_userdata *)userdata;
-  grpc_json *json = json_create_and_link(userdata, GRPC_JSON_NUMBER);
-  json->value = (char *)state->string;
+static int json_reader_set_number(void* userdata) {
+  json_reader_userdata* state = (json_reader_userdata*)userdata;
+  grpc_json* json = json_create_and_link(userdata, GRPC_JSON_NUMBER);
+  json->value = (char*)state->string;
   return 1;
 }
 
 /* The object types true, false and null are self-sufficient, and don't need
  * any more information beside their type.
  */
-static void json_reader_set_true(void *userdata) {
+static void json_reader_set_true(void* userdata) {
   json_create_and_link(userdata, GRPC_JSON_TRUE);
 }
 
-static void json_reader_set_false(void *userdata) {
+static void json_reader_set_false(void* userdata) {
   json_create_and_link(userdata, GRPC_JSON_FALSE);
 }
 
-static void json_reader_set_null(void *userdata) {
+static void json_reader_set_null(void* userdata) {
   json_create_and_link(userdata, GRPC_JSON_NULL);
 }
 
@@ -277,17 +277,17 @@ static grpc_json_reader_vtable reader_vtable = {
     json_reader_set_false,        json_reader_set_null};
 
 /* And finally, let's define our public API. */
-grpc_json *grpc_json_parse_string_with_len(char *input, size_t size) {
+grpc_json* grpc_json_parse_string_with_len(char* input, size_t size) {
   grpc_json_reader reader;
   json_reader_userdata state;
-  grpc_json *json = NULL;
+  grpc_json* json = NULL;
   grpc_json_reader_status status;
 
   if (!input) return NULL;
 
   state.top = state.current_container = state.current_value = NULL;
   state.string = state.key = NULL;
-  state.string_ptr = state.input = (uint8_t *)input;
+  state.string_ptr = state.input = (uint8_t*)input;
   state.remaining_input = size;
   grpc_json_reader_init(&reader, &reader_vtable, &state);
 
@@ -304,11 +304,11 @@ grpc_json *grpc_json_parse_string_with_len(char *input, size_t size) {
 
 #define UNBOUND_JSON_STRING_LENGTH 0x7fffffff
 
-grpc_json *grpc_json_parse_string(char *input) {
+grpc_json* grpc_json_parse_string(char* input) {
   return grpc_json_parse_string_with_len(input, UNBOUND_JSON_STRING_LENGTH);
 }
 
-static void json_dump_recursive(grpc_json_writer *writer, grpc_json *json,
+static void json_dump_recursive(grpc_json_writer* writer, grpc_json* json,
                                 int in_object) {
   while (json) {
     if (in_object) grpc_json_writer_object_key(writer, json->key);
@@ -348,7 +348,7 @@ static grpc_json_writer_vtable writer_vtable = {
     json_writer_output_char, json_writer_output_string,
     json_writer_output_string_with_len};
 
-char *grpc_json_dump_to_string(grpc_json *json, int indent) {
+char* grpc_json_dump_to_string(grpc_json* json, int indent) {
   grpc_json_writer writer;
   json_writer_userdata state;
 
diff --git a/src/core/lib/json/json_writer.cc b/src/core/lib/json/json_writer.cc
index eab1bff7a6..0b9c7c30ea 100644
--- a/src/core/lib/json/json_writer.cc
+++ b/src/core/lib/json/json_writer.cc
@@ -22,22 +22,22 @@
 
 #include "src/core/lib/json/json_writer.h"
 
-static void json_writer_output_char(grpc_json_writer *writer, char c) {
+static void json_writer_output_char(grpc_json_writer* writer, char c) {
   writer->vtable->output_char(writer->userdata, c);
 }
 
-static void json_writer_output_string(grpc_json_writer *writer,
-                                      const char *str) {
+static void json_writer_output_string(grpc_json_writer* writer,
+                                      const char* str) {
   writer->vtable->output_string(writer->userdata, str);
 }
 
-static void json_writer_output_string_with_len(grpc_json_writer *writer,
-                                               const char *str, size_t len) {
+static void json_writer_output_string_with_len(grpc_json_writer* writer,
+                                               const char* str, size_t len) {
   writer->vtable->output_string_with_len(writer->userdata, str, len);
 }
 
-void grpc_json_writer_init(grpc_json_writer *writer, int indent,
-                           grpc_json_writer_vtable *vtable, void *userdata) {
+void grpc_json_writer_init(grpc_json_writer* writer, int indent,
+                           grpc_json_writer_vtable* vtable, void* userdata) {
   memset(writer, 0, sizeof(*writer));
   writer->container_empty = 1;
   writer->indent = indent;
@@ -45,7 +45,7 @@ void grpc_json_writer_init(grpc_json_writer *writer, int indent,
   writer->userdata = userdata;
 }
 
-static void json_writer_output_indent(grpc_json_writer *writer) {
+static void json_writer_output_indent(grpc_json_writer* writer) {
   static const char spacesstr[] =
       "                "
       "                "
@@ -73,7 +73,7 @@ static void json_writer_output_indent(grpc_json_writer *writer) {
       writer, spacesstr + sizeof(spacesstr) - 1 - spaces, spaces);
 }
 
-static void json_writer_value_end(grpc_json_writer *writer) {
+static void json_writer_value_end(grpc_json_writer* writer) {
   if (writer->container_empty) {
     writer->container_empty = 0;
     if ((writer->indent == 0) || (writer->depth == 0)) return;
@@ -85,7 +85,7 @@ static void json_writer_value_end(grpc_json_writer *writer) {
   }
 }
 
-static void json_writer_escape_utf16(grpc_json_writer *writer, uint16_t utf16) {
+static void json_writer_escape_utf16(grpc_json_writer* writer, uint16_t utf16) {
   static const char hex[] = "0123456789abcdef";
 
   json_writer_output_string_with_len(writer, "\\u", 2);
@@ -95,8 +95,8 @@ static void json_writer_escape_utf16(grpc_json_writer *writer, uint16_t utf16) {
   json_writer_output_char(writer, hex[(utf16)&0x0f]);
 }
 
-static void json_writer_escape_string(grpc_json_writer *writer,
-                                      const char *string) {
+static void json_writer_escape_string(grpc_json_writer* writer,
+                                      const char* string) {
   json_writer_output_char(writer, '"');
 
   for (;;) {
@@ -190,7 +190,7 @@ static void json_writer_escape_string(grpc_json_writer *writer,
   json_writer_output_char(writer, '"');
 }
 
-void grpc_json_writer_container_begins(grpc_json_writer *writer,
+void grpc_json_writer_container_begins(grpc_json_writer* writer,
                                        grpc_json_type type) {
   if (!writer->got_key) json_writer_value_end(writer);
   json_writer_output_indent(writer);
@@ -200,7 +200,7 @@ void grpc_json_writer_container_begins(grpc_json_writer *writer,
   writer->depth++;
 }
 
-void grpc_json_writer_container_ends(grpc_json_writer *writer,
+void grpc_json_writer_container_ends(grpc_json_writer* writer,
                                      grpc_json_type type) {
   if (writer->indent && !writer->container_empty)
     json_writer_output_char(writer, '\n');
@@ -211,7 +211,7 @@ void grpc_json_writer_container_ends(grpc_json_writer *writer,
   writer->got_key = 0;
 }
 
-void grpc_json_writer_object_key(grpc_json_writer *writer, const char *string) {
+void grpc_json_writer_object_key(grpc_json_writer* writer, const char* string) {
   json_writer_value_end(writer);
   json_writer_output_indent(writer);
   json_writer_escape_string(writer, string);
@@ -219,23 +219,23 @@ void grpc_json_writer_object_key(grpc_json_writer *writer, const char *string) {
   writer->got_key = 1;
 }
 
-void grpc_json_writer_value_raw(grpc_json_writer *writer, const char *string) {
+void grpc_json_writer_value_raw(grpc_json_writer* writer, const char* string) {
   if (!writer->got_key) json_writer_value_end(writer);
   json_writer_output_indent(writer);
   json_writer_output_string(writer, string);
   writer->got_key = 0;
 }
 
-void grpc_json_writer_value_raw_with_len(grpc_json_writer *writer,
-                                         const char *string, size_t len) {
+void grpc_json_writer_value_raw_with_len(grpc_json_writer* writer,
+                                         const char* string, size_t len) {
   if (!writer->got_key) json_writer_value_end(writer);
   json_writer_output_indent(writer);
   json_writer_output_string_with_len(writer, string, len);
   writer->got_key = 0;
 }
 
-void grpc_json_writer_value_string(grpc_json_writer *writer,
-                                   const char *string) {
+void grpc_json_writer_value_string(grpc_json_writer* writer,
+                                   const char* string) {
   if (!writer->got_key) json_writer_value_end(writer);
   json_writer_output_indent(writer);
   json_writer_escape_string(writer, string);
diff --git a/src/core/lib/json/json_writer.h b/src/core/lib/json/json_writer.h
index 132d1f24e8..93eeb2031b 100644
--- a/src/core/lib/json/json_writer.h
+++ b/src/core/lib/json/json_writer.h
@@ -41,17 +41,17 @@ extern "C" {
 
 typedef struct grpc_json_writer_vtable {
   /* Adds a character to the output stream. */
-  void (*output_char)(void *userdata, char);
+  void (*output_char)(void* userdata, char);
   /* Adds a zero-terminated string to the output stream. */
-  void (*output_string)(void *userdata, const char *str);
+  void (*output_string)(void* userdata, const char* str);
   /* Adds a fixed-length string to the output stream. */
-  void (*output_string_with_len)(void *userdata, const char *str, size_t len);
+  void (*output_string_with_len)(void* userdata, const char* str, size_t len);
 
 } grpc_json_writer_vtable;
 
 typedef struct grpc_json_writer {
-  void *userdata;
-  grpc_json_writer_vtable *vtable;
+  void* userdata;
+  grpc_json_writer_vtable* vtable;
   int indent;
   int depth;
   int container_empty;
@@ -63,25 +63,25 @@ typedef struct grpc_json_writer {
  * use indent=0, then the output will not have any newlines either, thus
  * emitting a condensed json output.
  */
-void grpc_json_writer_init(grpc_json_writer *writer, int indent,
-                           grpc_json_writer_vtable *vtable, void *userdata);
+void grpc_json_writer_init(grpc_json_writer* writer, int indent,
+                           grpc_json_writer_vtable* vtable, void* userdata);
 
 /* Signals the beginning of a container. */
-void grpc_json_writer_container_begins(grpc_json_writer *writer,
+void grpc_json_writer_container_begins(grpc_json_writer* writer,
                                        grpc_json_type type);
 /* Signals the end of a container. */
-void grpc_json_writer_container_ends(grpc_json_writer *writer,
+void grpc_json_writer_container_ends(grpc_json_writer* writer,
                                      grpc_json_type type);
 /* Writes down an object key for the next value. */
-void grpc_json_writer_object_key(grpc_json_writer *writer, const char *string);
+void grpc_json_writer_object_key(grpc_json_writer* writer, const char* string);
 /* Sets a raw value. Useful for numbers. */
-void grpc_json_writer_value_raw(grpc_json_writer *writer, const char *string);
+void grpc_json_writer_value_raw(grpc_json_writer* writer, const char* string);
 /* Sets a raw value with its length. Useful for values like true or false. */
-void grpc_json_writer_value_raw_with_len(grpc_json_writer *writer,
-                                         const char *string, size_t len);
+void grpc_json_writer_value_raw_with_len(grpc_json_writer* writer,
+                                         const char* string, size_t len);
 /* Sets a string value. It'll be escaped, and utf-8 validated. */
-void grpc_json_writer_value_string(grpc_json_writer *writer,
-                                   const char *string);
+void grpc_json_writer_value_string(grpc_json_writer* writer,
+                                   const char* string);
 
 #ifdef __cplusplus
 }