run clang-format

include/grpc++/server_credentials.h

@@ -61,7 +61,7 @@ class ServerCredentials final {
 
 // Options to create ServerCredentials with SSL
 struct SslServerCredentialsOptions {
-  struct PemKeyCertPair{
+  struct PemKeyCertPair {
     grpc::string private_key;
     grpc::string cert_chain;
   };

include/grpc/grpc.h

@@ -183,17 +183,17 @@ typedef struct grpc_metadata {
 } grpc_metadata;
 
 typedef enum grpc_completion_type {
-  GRPC_QUEUE_SHUTDOWN,       /* Shutting down */
-  GRPC_READ,                 /* A read has completed */
-  GRPC_INVOKE_ACCEPTED,      /* An invoke call has been accepted by flow
-                                control */
-  GRPC_WRITE_ACCEPTED,       /* A write has been accepted by
-                                flow control */
+  GRPC_QUEUE_SHUTDOWN,  /* Shutting down */
+  GRPC_READ,            /* A read has completed */
+  GRPC_INVOKE_ACCEPTED, /* An invoke call has been accepted by flow
+                           control */
+  GRPC_WRITE_ACCEPTED, /* A write has been accepted by
+                          flow control */
   GRPC_FINISH_ACCEPTED,      /* writes_done or write_status has been accepted */
   GRPC_CLIENT_METADATA_READ, /* The metadata array sent by server received at
                                 client */
-  GRPC_FINISHED,             /* An RPC has finished. The event contains status.
-                                On the server this will be OK or Cancelled. */
+  GRPC_FINISHED, /* An RPC has finished. The event contains status.
+                    On the server this will be OK or Cancelled. */
   GRPC_SERVER_RPC_NEW,       /* A new RPC has arrived at the server */
   GRPC_SERVER_SHUTDOWN,      /* The server has finished shutting down */
   GRPC_COMPLETION_DO_NOT_USE /* must be last, forces users to include

include/grpc/support/sync_generic.h

@@ -38,16 +38,22 @@
 #include <grpc/support/atm.h>
 
 /* gpr_event */
-typedef struct { gpr_atm state; } gpr_event;
+typedef struct {
+  gpr_atm state;
+} gpr_event;
 
 #define GPR_EVENT_INIT \
   { 0 }
 
 /* gpr_refcount */
-typedef struct { gpr_atm count; } gpr_refcount;
+typedef struct {
+  gpr_atm count;
+} gpr_refcount;
 
 /* gpr_stats_counter */
-typedef struct { gpr_atm value; } gpr_stats_counter;
+typedef struct {
+  gpr_atm value;
+} gpr_stats_counter;
 
 #define GPR_STATS_INIT \
   { 0 }

src/compiler/ruby_generator.cc

@@ -67,10 +67,9 @@ void PrintMethod(const MethodDescriptor *method, const std::string &package,
   if (method->server_streaming()) {
     output_type = "stream(" + output_type + ")";
   }
-  std::map<std::string, std::string> method_vars = ListToDict({
-      "mth.name", method->name(), "input.type", input_type, "output.type",
-      output_type,
-  });
+  std::map<std::string, std::string> method_vars =
+      ListToDict({"mth.name", method->name(), "input.type", input_type,
+                  "output.type", output_type, });
   out->Print(method_vars, "rpc :$mth.name$, $input.type$, $output.type$\n");
 }
 
@@ -82,17 +81,15 @@ void PrintService(const ServiceDescriptor *service, const std::string &package,
   }
 
   // Begin the service module
-  std::map<std::string, std::string> module_vars = ListToDict({
-      "module.name", CapitalizeFirst(service->name()),
-  });
+  std::map<std::string, std::string> module_vars =
+      ListToDict({"module.name", CapitalizeFirst(service->name()), });
   out->Print(module_vars, "module $module.name$\n");
   out->Indent();
 
   // TODO(temiola): add documentation
   std::string doc = "TODO: add proto service documentation here";
-  std::map<std::string, std::string> template_vars = ListToDict({
-      "Documentation", doc,
-  });
+  std::map<std::string, std::string> template_vars =
+      ListToDict({"Documentation", doc, });
   out->Print("\n");
   out->Print(template_vars, "# $Documentation$\n");
   out->Print("class Service\n");
@@ -104,9 +101,8 @@ void PrintService(const ServiceDescriptor *service, const std::string &package,
   out->Print("\n");
   out->Print("self.marshal_class_method = :encode\n");
   out->Print("self.unmarshal_class_method = :decode\n");
-  std::map<std::string, std::string> pkg_vars = ListToDict({
-      "service.name", service->name(), "pkg.name", package,
-  });
+  std::map<std::string, std::string> pkg_vars =
+      ListToDict({"service.name", service->name(), "pkg.name", package, });
   out->Print(pkg_vars, "self.service_name = '$pkg.name$.$service.name$'\n");
   out->Print("\n");
   for (int i = 0; i < service->method_count(); ++i) {
@@ -137,9 +133,8 @@ std::string GetServices(const FileDescriptor *file) {
   }
 
   // Write out a file header.
-  std::map<std::string, std::string> header_comment_vars = ListToDict({
-      "file.name", file->name(), "file.package", file->package(),
-  });
+  std::map<std::string, std::string> header_comment_vars = ListToDict(
+      {"file.name", file->name(), "file.package", file->package(), });
   out.Print("# Generated by the protocol buffer compiler.  DO NOT EDIT!\n");
   out.Print(header_comment_vars,
             "# Source: $file.name$ for package '$file.package$'\n");
@@ -149,18 +144,16 @@ std::string GetServices(const FileDescriptor *file) {
   // Write out require statemment to import the separately generated file
   // that defines the messages used by the service. This is generated by the
   // main ruby plugin.
-  std::map<std::string, std::string> dep_vars = ListToDict({
-      "dep.name", MessagesRequireName(file),
-  });
+  std::map<std::string, std::string> dep_vars =
+      ListToDict({"dep.name", MessagesRequireName(file), });
   out.Print(dep_vars, "require '$dep.name$'\n");
 
   // Write out services within the modules
   out.Print("\n");
   std::vector<std::string> modules = Split(file->package(), '.');
   for (size_t i = 0; i < modules.size(); ++i) {
-    std::map<std::string, std::string> module_vars = ListToDict({
-        "module.name", CapitalizeFirst(modules[i]),
-    });
+    std::map<std::string, std::string> module_vars =
+        ListToDict({"module.name", CapitalizeFirst(modules[i]), });
     out.Print(module_vars, "module $module.name$\n");
     out.Indent();
   }

src/core/channel/census_filter.c

@@ -178,19 +178,11 @@ static void destroy_channel_elem(grpc_channel_element* elem) {
 }
 
 const grpc_channel_filter grpc_client_census_filter = {
-    client_call_op,       channel_op,
-
-    sizeof(call_data),    client_init_call_elem, client_destroy_call_elem,
-
-    sizeof(channel_data), init_channel_elem,     destroy_channel_elem,
-
-    "census-client"};
+    client_call_op,        channel_op,               sizeof(call_data),
+    client_init_call_elem, client_destroy_call_elem, sizeof(channel_data),
+    init_channel_elem,     destroy_channel_elem,     "census-client"};
 
 const grpc_channel_filter grpc_server_census_filter = {
-    server_call_op,       channel_op,
-
-    sizeof(call_data),    server_init_call_elem, server_destroy_call_elem,
-
-    sizeof(channel_data), init_channel_elem,     destroy_channel_elem,
-
-    "census-server"};
+    server_call_op,        channel_op,               sizeof(call_data),
+    server_init_call_elem, server_destroy_call_elem, sizeof(channel_data),
+    init_channel_elem,     destroy_channel_elem,     "census-server"};

src/core/channel/channel_stack.c

@@ -54,7 +54,7 @@
 
 /* Given a size, round up to the next multiple of sizeof(void*) */
 #define ROUND_UP_TO_ALIGNMENT_SIZE(x) \
-  (((x)+GPR_MAX_ALIGNMENT - 1) & ~(GPR_MAX_ALIGNMENT - 1))
+  (((x) + GPR_MAX_ALIGNMENT - 1) & ~(GPR_MAX_ALIGNMENT - 1))
 
 size_t grpc_channel_stack_size(const grpc_channel_filter **filters,
                                size_t filter_count) {
@@ -75,9 +75,9 @@ size_t grpc_channel_stack_size(const grpc_channel_filter **filters,
   return size;
 }
 
-#define CHANNEL_ELEMS_FROM_STACK(stk)                                   \
-  ((grpc_channel_element *)((char *)(stk) + ROUND_UP_TO_ALIGNMENT_SIZE( \
-                                                sizeof(grpc_channel_stack))))
+#define CHANNEL_ELEMS_FROM_STACK(stk) \
+  ((grpc_channel_element *)(          \
+      (char *)(stk) + ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_channel_stack))))
 
 #define CALL_ELEMS_FROM_STACK(stk)       \
   ((grpc_call_element *)((char *)(stk) + \

src/core/channel/channel_stack.h

@@ -244,7 +244,9 @@ typedef struct {
 
 /* A call stack tracks a set of related filters for one call, and guarantees
    they live within a single malloc() allocation */
-typedef struct { size_t count; } grpc_call_stack;
+typedef struct {
+  size_t count;
+} grpc_call_stack;
 
 /* Get a channel element given a channel stack and its index */
 grpc_channel_element *grpc_channel_stack_element(grpc_channel_stack *stack,

src/core/channel/child_channel.c

@@ -165,14 +165,9 @@ static void lb_destroy_channel_elem(grpc_channel_element *elem) {
 }
 
 const grpc_channel_filter grpc_child_channel_top_filter = {
-    lb_call_op,              lb_channel_op,
-
-    sizeof(lb_call_data),    lb_init_call_elem,    lb_destroy_call_elem,
-
-    sizeof(lb_channel_data), lb_init_channel_elem, lb_destroy_channel_elem,
-
-    "child-channel",
-};
+    lb_call_op,           lb_channel_op,           sizeof(lb_call_data),
+    lb_init_call_elem,    lb_destroy_call_elem,    sizeof(lb_channel_data),
+    lb_init_channel_elem, lb_destroy_channel_elem, "child-channel", };
 
 /* grpc_child_channel proper */
 

src/core/channel/client_channel.c

@@ -450,14 +450,9 @@ static void destroy_channel_elem(grpc_channel_element *elem) {
 }
 
 const grpc_channel_filter grpc_client_channel_filter = {
-    call_op,              channel_op,
-
-    sizeof(call_data),    init_call_elem,    destroy_call_elem,
-
-    sizeof(channel_data), init_channel_elem, destroy_channel_elem,
-
-    "client-channel",
-};
+    call_op,           channel_op,           sizeof(call_data),
+    init_call_elem,    destroy_call_elem,    sizeof(channel_data),
+    init_channel_elem, destroy_channel_elem, "client-channel", };
 
 grpc_transport_setup_result grpc_client_channel_transport_setup_complete(
     grpc_channel_stack *channel_stack, grpc_transport *transport,

src/core/channel/connected_channel.c

@@ -69,7 +69,7 @@ typedef struct {
 /* We perform a small hack to locate transport data alongside the connected
    channel data in call allocations, to allow everything to be pulled in minimal
    cache line requests */
-#define TRANSPORT_STREAM_FROM_CALL_DATA(calld) ((grpc_stream *)((calld)+1))
+#define TRANSPORT_STREAM_FROM_CALL_DATA(calld) ((grpc_stream *)((calld) + 1))
 #define CALL_DATA_FROM_TRANSPORT_STREAM(transport_stream) \
   (((call_data *)(transport_stream)) - 1)
 
@@ -257,14 +257,9 @@ static void destroy_channel_elem(grpc_channel_element *elem) {
 }
 
 const grpc_channel_filter grpc_connected_channel_filter = {
-    call_op,              channel_op,
-
-    sizeof(call_data),    init_call_elem,    destroy_call_elem,
-
-    sizeof(channel_data), init_channel_elem, destroy_channel_elem,
-
-    "connected",
-};
+    call_op,           channel_op,           sizeof(call_data),
+    init_call_elem,    destroy_call_elem,    sizeof(channel_data),
+    init_channel_elem, destroy_channel_elem, "connected", };
 
 static gpr_slice alloc_recv_buffer(void *user_data, grpc_transport *transport,
                                    grpc_stream *stream, size_t size_hint) {
@@ -507,8 +502,7 @@ static void transport_closed(void *user_data, grpc_transport *transport) {
 
 const grpc_transport_callbacks connected_channel_transport_callbacks = {
     alloc_recv_buffer, accept_stream,    recv_batch,
-    transport_goaway,  transport_closed,
-};
+    transport_goaway,  transport_closed, };
 
 grpc_transport_setup_result grpc_connected_channel_bind_transport(
     grpc_channel_stack *channel_stack, grpc_transport *transport) {

src/core/channel/http_client_filter.c

@@ -35,7 +35,9 @@
 #include <string.h>
 #include <grpc/support/log.h>
 
-typedef struct call_data { int sent_headers; } call_data;
+typedef struct call_data {
+  int sent_headers;
+} call_data;
 
 typedef struct channel_data {
   grpc_mdelem *te_trailers;
@@ -178,10 +180,6 @@ static void destroy_channel_elem(grpc_channel_element *elem) {
 }
 
 const grpc_channel_filter grpc_http_client_filter = {
-    call_op,              channel_op,
-
-    sizeof(call_data),    init_call_elem,    destroy_call_elem,
-
-    sizeof(channel_data), init_channel_elem, destroy_channel_elem,
-
-    "http-client"};
+    call_op,           channel_op,           sizeof(call_data),
+    init_call_elem,    destroy_call_elem,    sizeof(channel_data),
+    init_channel_elem, destroy_channel_elem, "http-client"};

src/core/channel/http_filter.c

@@ -132,10 +132,6 @@ static void destroy_channel_elem(grpc_channel_element *elem) {
 }
 
 const grpc_channel_filter grpc_http_filter = {
-    call_op,              channel_op,
-
-    sizeof(call_data),    init_call_elem,    destroy_call_elem,
-
-    sizeof(channel_data), init_channel_elem, destroy_channel_elem,
-
-    "http"};
+    call_op,           channel_op,           sizeof(call_data),
+    init_call_elem,    destroy_call_elem,    sizeof(channel_data),
+    init_channel_elem, destroy_channel_elem, "http"};

src/core/channel/http_server_filter.c

@@ -244,10 +244,6 @@ static void destroy_channel_elem(grpc_channel_element *elem) {
 }
 
 const grpc_channel_filter grpc_http_server_filter = {
-    call_op,              channel_op,
-
-    sizeof(call_data),    init_call_elem,    destroy_call_elem,
-
-    sizeof(channel_data), init_channel_elem, destroy_channel_elem,
-
-    "http-server"};
+    call_op,           channel_op,           sizeof(call_data),
+    init_call_elem,    destroy_call_elem,    sizeof(channel_data),
+    init_channel_elem, destroy_channel_elem, "http-server"};

src/core/channel/metadata_buffer.c

@@ -61,7 +61,7 @@ struct grpc_metadata_buffer_impl {
   size_t elem_cap;
 };
 
-#define ELEMS(buffer) ((qelem *)((buffer)+1))
+#define ELEMS(buffer) ((qelem *)((buffer) + 1))
 
 void grpc_metadata_buffer_init(grpc_metadata_buffer *buffer) {
   /* start buffer as NULL, indicating no elements */
@@ -152,7 +152,9 @@ size_t grpc_metadata_buffer_count(const grpc_metadata_buffer *buffer) {
   return *buffer ? (*buffer)->elems : 0;
 }
 
-typedef struct { grpc_metadata_buffer_impl *impl; } elems_hdr;
+typedef struct {
+  grpc_metadata_buffer_impl *impl;
+} elems_hdr;
 
 grpc_metadata *grpc_metadata_buffer_extract_elements(
     grpc_metadata_buffer *buffer) {

src/core/channel/noop_filter.c

@@ -131,10 +131,6 @@ static void destroy_channel_elem(grpc_channel_element *elem) {
 }
 
 const grpc_channel_filter grpc_no_op_filter = {
-    call_op,              channel_op,
-
-    sizeof(call_data),    init_call_elem,    destroy_call_elem,
-
-    sizeof(channel_data), init_channel_elem, destroy_channel_elem,
-
-    "no-op"};
+    call_op,           channel_op,           sizeof(call_data),
+    init_call_elem,    destroy_call_elem,    sizeof(channel_data),
+    init_channel_elem, destroy_channel_elem, "no-op"};

src/core/iomgr/alarm_heap.c

@@ -66,11 +66,11 @@ static void adjust_downwards(grpc_alarm **first, int i, int length,
     int next_i;
     if (left_child >= length) break;
     right_child = left_child + 1;
-    next_i = right_child < length &&
-                     gpr_time_cmp(first[left_child]->deadline,
-                                  first[right_child]->deadline) < 0
-                 ? right_child
-                 : left_child;
+    next_i =
+        right_child < length && gpr_time_cmp(first[left_child]->deadline,
+                                             first[right_child]->deadline) < 0
+            ? right_child
+            : left_child;
     if (gpr_time_cmp(t->deadline, first[next_i]->deadline) >= 0) break;
     first[i] = first[next_i];
     first[i]->heap_index = i;

src/core/iomgr/pollset_windows.h

@@ -44,8 +44,8 @@
 struct grpc_fd;
 
 typedef struct grpc_pollset {
-	gpr_mu mu;
-	gpr_cv cv;
+  gpr_mu mu;
+  gpr_cv cv;
 } grpc_pollset;
 
 #define GRPC_POLLSET_MU(pollset) (&(pollset)->mu)

src/core/iomgr/tcp_server_posix.c

@@ -255,8 +255,7 @@ static int add_socket_to_server(grpc_tcp_server *s, int fd,
     /* append it to the list under a lock */
     if (s->nports == s->port_capacity) {
       s->port_capacity *= 2;
-      s->ports =
-          gpr_realloc(s->ports, sizeof(server_port) * s->port_capacity);
+      s->ports = gpr_realloc(s->ports, sizeof(server_port) * s->port_capacity);
     }
     sp = &s->ports[s->nports++];
     sp->server = s;

src/core/security/credentials.h

@@ -118,9 +118,9 @@ grpc_credentials *grpc_credentials_contains_type(
 
 /* Exposed for testing only. */
 grpc_credentials_status
-grpc_oauth2_token_fetcher_credentials_parse_server_response(
-    const struct grpc_httpcli_response *response, grpc_mdctx *ctx,
-    grpc_mdelem **token_elem, gpr_timespec *token_lifetime);
+    grpc_oauth2_token_fetcher_credentials_parse_server_response(
+        const struct grpc_httpcli_response *response, grpc_mdctx *ctx,
+        grpc_mdelem **token_elem, gpr_timespec *token_lifetime);
 
 /* Simulates an oauth2 token fetch with the specified value for testing. */
 grpc_credentials *grpc_fake_oauth2_credentials_create(

src/core/support/histogram.c

@@ -186,10 +186,9 @@ static double threshold_for_count_below(gpr_histogram *h, double count_below) {
        should lie */
     lower_bound = bucket_start(h, lower_idx);
     upper_bound = bucket_start(h, lower_idx + 1);
-    return GPR_CLAMP(upper_bound -
-                         (upper_bound - lower_bound) *
-                             (count_so_far - count_below) /
-                             h->buckets[lower_idx],
+    return GPR_CLAMP(upper_bound - (upper_bound - lower_bound) *
+                                       (count_so_far - count_below) /
+                                       h->buckets[lower_idx],
                      h->min_seen, h->max_seen);
   }
 }

src/core/surface/call.c

@@ -203,7 +203,7 @@ struct grpc_call {
   gpr_refcount internal_refcount;
 };
 
-#define CALL_STACK_FROM_CALL(call) ((grpc_call_stack *)((call)+1))
+#define CALL_STACK_FROM_CALL(call) ((grpc_call_stack *)((call) + 1))
 #define CALL_FROM_CALL_STACK(call_stack) (((grpc_call *)(call_stack)) - 1)
 #define CALL_ELEM_FROM_CALL(call, idx) \
   grpc_call_stack_element(CALL_STACK_FROM_CALL(call), idx)
@@ -863,7 +863,7 @@ static gpr_uint32 decode_status(grpc_mdelem *md) {
   gpr_uint32 status;
   void *user_data = grpc_mdelem_get_user_data(md, destroy_status);
   if (user_data) {
-    status = ((gpr_uint32)(gpr_intptr) user_data) - STATUS_OFFSET;
+    status = ((gpr_uint32)(gpr_intptr)user_data) - STATUS_OFFSET;
   } else {
     if (!gpr_parse_bytes_to_uint32(grpc_mdstr_as_c_string(md->value),
                                    GPR_SLICE_LENGTH(md->value->slice),

src/core/surface/channel.c

@@ -51,7 +51,7 @@ struct grpc_channel {
   grpc_mdstr *authority_string;
 };
 
-#define CHANNEL_STACK_FROM_CHANNEL(c) ((grpc_channel_stack *)((c)+1))
+#define CHANNEL_STACK_FROM_CHANNEL(c) ((grpc_channel_stack *)((c) + 1))
 
 grpc_channel *grpc_channel_create_from_filters(
     const grpc_channel_filter **filters, size_t num_filters,

src/core/surface/client.c

@@ -38,9 +38,13 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-typedef struct { void *unused; } call_data;
+typedef struct {
+  void *unused;
+} call_data;
 
-typedef struct { void *unused; } channel_data;
+typedef struct {
+  void *unused;
+} channel_data;
 
 static void call_op(grpc_call_element *elem, grpc_call_element *from_elem,
                     grpc_call_op *op) {
@@ -109,11 +113,6 @@ static void init_channel_elem(grpc_channel_element *elem,
 static void destroy_channel_elem(grpc_channel_element *elem) {}
 
 const grpc_channel_filter grpc_client_surface_filter = {
-    call_op,              channel_op,
-
-    sizeof(call_data),    init_call_elem,    destroy_call_elem,
-
-    sizeof(channel_data), init_channel_elem, destroy_channel_elem,
-
-    "client",
-};
+    call_op,           channel_op,           sizeof(call_data),
+    init_call_elem,    destroy_call_elem,    sizeof(channel_data),
+    init_channel_elem, destroy_channel_elem, "client", };

src/core/surface/lame_client.c

@@ -42,9 +42,13 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-typedef struct { void *unused; } call_data;
+typedef struct {
+  void *unused;
+} call_data;
 
-typedef struct { grpc_mdelem *message; } channel_data;
+typedef struct {
+  grpc_mdelem *message;
+} channel_data;
 
 static void do_nothing(void *data, grpc_op_error error) {}
 
@@ -111,14 +115,9 @@ static void destroy_channel_elem(grpc_channel_element *elem) {
 }
 
 static const grpc_channel_filter lame_filter = {
-    call_op,              channel_op,
-
-    sizeof(call_data),    init_call_elem,    destroy_call_elem,
-
-    sizeof(channel_data), init_channel_elem, destroy_channel_elem,
-
-    "lame-client",
-};
+    call_op,           channel_op,           sizeof(call_data),
+    init_call_elem,    destroy_call_elem,    sizeof(channel_data),
+    init_channel_elem, destroy_channel_elem, "lame-client", };
 
 grpc_channel *grpc_lame_client_channel_create(void) {
   static const grpc_channel_filter *filters[] = {&lame_filter};

src/core/surface/server.c

@@ -411,14 +411,9 @@ static void destroy_channel_elem(grpc_channel_element *elem) {
 }
 
 static const grpc_channel_filter server_surface_filter = {
-    call_op,              channel_op,
-
-    sizeof(call_data),    init_call_elem,    destroy_call_elem,
-
-    sizeof(channel_data), init_channel_elem, destroy_channel_elem,
-
-    "server",
-};
+    call_op,           channel_op,           sizeof(call_data),
+    init_call_elem,    destroy_call_elem,    sizeof(channel_data),
+    init_channel_elem, destroy_channel_elem, "server", };
 
 static void early_terminate_requested_calls(grpc_completion_queue *cq,
                                             void **tags, size_t ntags) {

src/core/transport/chttp2/frame_data.c

@@ -105,28 +105,28 @@ grpc_chttp2_parse_error grpc_chttp2_data_parser_parse(
       }
     /* fallthrough */
     case GRPC_CHTTP2_DATA_FH_1:
-      p->frame_size = ((gpr_uint32)*cur) << 24;
+      p->frame_size = ((gpr_uint32) * cur) << 24;
       if (++cur == end) {
         p->state = GRPC_CHTTP2_DATA_FH_2;
         return GRPC_CHTTP2_PARSE_OK;
       }
     /* fallthrough */
     case GRPC_CHTTP2_DATA_FH_2:
-      p->frame_size |= ((gpr_uint32)*cur) << 16;
+      p->frame_size |= ((gpr_uint32) * cur) << 16;
       if (++cur == end) {
         p->state = GRPC_CHTTP2_DATA_FH_3;
         return GRPC_CHTTP2_PARSE_OK;
       }
     /* fallthrough */
     case GRPC_CHTTP2_DATA_FH_3:
-      p->frame_size |= ((gpr_uint32)*cur) << 8;
+      p->frame_size |= ((gpr_uint32) * cur) << 8;
       if (++cur == end) {
         p->state = GRPC_CHTTP2_DATA_FH_4;
         return GRPC_CHTTP2_PARSE_OK;
       }
     /* fallthrough */
     case GRPC_CHTTP2_DATA_FH_4:
-      p->frame_size |= ((gpr_uint32)*cur);
+      p->frame_size |= ((gpr_uint32) * cur);
       p->state = GRPC_CHTTP2_DATA_FRAME;
       ++cur;
       state->need_flush_reads = 1;

src/core/transport/chttp2/frame_goaway.c

@@ -75,7 +75,7 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
         p->state = GRPC_CHTTP2_GOAWAY_LSI0;
         return GRPC_CHTTP2_PARSE_OK;
       }
-      p->last_stream_id = ((gpr_uint32)*cur) << 24;
+      p->last_stream_id = ((gpr_uint32) * cur) << 24;
       ++cur;
     /* fallthrough */
     case GRPC_CHTTP2_GOAWAY_LSI1:
@@ -83,7 +83,7 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
         p->state = GRPC_CHTTP2_GOAWAY_LSI1;
         return GRPC_CHTTP2_PARSE_OK;
       }
-      p->last_stream_id |= ((gpr_uint32)*cur) << 16;
+      p->last_stream_id |= ((gpr_uint32) * cur) << 16;
       ++cur;
     /* fallthrough */
     case GRPC_CHTTP2_GOAWAY_LSI2:
@@ -91,7 +91,7 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
         p->state = GRPC_CHTTP2_GOAWAY_LSI2;
         return GRPC_CHTTP2_PARSE_OK;
       }
-      p->last_stream_id |= ((gpr_uint32)*cur) << 8;
+      p->last_stream_id |= ((gpr_uint32) * cur) << 8;
       ++cur;
     /* fallthrough */
     case GRPC_CHTTP2_GOAWAY_LSI3:
@@ -99,7 +99,7 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
         p->state = GRPC_CHTTP2_GOAWAY_LSI3;
         return GRPC_CHTTP2_PARSE_OK;
       }
-      p->last_stream_id |= ((gpr_uint32)*cur);
+      p->last_stream_id |= ((gpr_uint32) * cur);
       ++cur;
     /* fallthrough */
     case GRPC_CHTTP2_GOAWAY_ERR0:
@@ -107,7 +107,7 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
         p->state = GRPC_CHTTP2_GOAWAY_ERR0;
         return GRPC_CHTTP2_PARSE_OK;
       }
-      p->error_code = ((gpr_uint32)*cur) << 24;
+      p->error_code = ((gpr_uint32) * cur) << 24;
       ++cur;
     /* fallthrough */
     case GRPC_CHTTP2_GOAWAY_ERR1:
@@ -115,7 +115,7 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
         p->state = GRPC_CHTTP2_GOAWAY_ERR1;
         return GRPC_CHTTP2_PARSE_OK;
       }
-      p->error_code |= ((gpr_uint32)*cur) << 16;
+      p->error_code |= ((gpr_uint32) * cur) << 16;
       ++cur;
     /* fallthrough */
     case GRPC_CHTTP2_GOAWAY_ERR2:
@@ -123,7 +123,7 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
         p->state = GRPC_CHTTP2_GOAWAY_ERR2;
         return GRPC_CHTTP2_PARSE_OK;
       }
-      p->error_code |= ((gpr_uint32)*cur) << 8;
+      p->error_code |= ((gpr_uint32) * cur) << 8;
       ++cur;
     /* fallthrough */
     case GRPC_CHTTP2_GOAWAY_ERR3:
@@ -131,7 +131,7 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
         p->state = GRPC_CHTTP2_GOAWAY_ERR3;
         return GRPC_CHTTP2_PARSE_OK;
       }
-      p->error_code |= ((gpr_uint32)*cur);
+      p->error_code |= ((gpr_uint32) * cur);
       ++cur;
     /* fallthrough */
     case GRPC_CHTTP2_GOAWAY_DEBUG:

src/core/transport/chttp2/frame_settings.c

@@ -53,8 +53,7 @@ const grpc_chttp2_setting_parameters
         {"MAX_FRAME_SIZE", 16384, 16384, 16777215,
          GRPC_CHTTP2_DISCONNECT_ON_INVALID_VALUE},
         {"MAX_HEADER_LIST_SIZE", 0xffffffffu, 0, 0xffffffffu,
-         GRPC_CHTTP2_CLAMP_INVALID_VALUE},
-};
+         GRPC_CHTTP2_CLAMP_INVALID_VALUE}, };
 
 static gpr_uint8 *fill_header(gpr_uint8 *out, gpr_uint32 length,
                               gpr_uint8 flags) {
@@ -156,7 +155,7 @@ grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse(
           }
           return GRPC_CHTTP2_PARSE_OK;
         }
-        parser->id = ((gpr_uint16)*cur) << 8;
+        parser->id = ((gpr_uint16) * cur) << 8;
         cur++;
       /* fallthrough */
       case GRPC_CHTTP2_SPS_ID1:
@@ -172,7 +171,7 @@ grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse(
           parser->state = GRPC_CHTTP2_SPS_VAL0;
           return GRPC_CHTTP2_PARSE_OK;
         }
-        parser->value = ((gpr_uint32)*cur) << 24;
+        parser->value = ((gpr_uint32) * cur) << 24;
         cur++;
       /* fallthrough */
       case GRPC_CHTTP2_SPS_VAL1:
@@ -180,7 +179,7 @@ grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse(
           parser->state = GRPC_CHTTP2_SPS_VAL1;
           return GRPC_CHTTP2_PARSE_OK;
         }
-        parser->value |= ((gpr_uint32)*cur) << 16;
+        parser->value |= ((gpr_uint32) * cur) << 16;
         cur++;
       /* fallthrough */
       case GRPC_CHTTP2_SPS_VAL2:
@@ -188,7 +187,7 @@ grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse(
           parser->state = GRPC_CHTTP2_SPS_VAL2;
           return GRPC_CHTTP2_PARSE_OK;
         }
-        parser->value |= ((gpr_uint32)*cur) << 8;
+        parser->value |= ((gpr_uint32) * cur) << 8;
         cur++;
       /* fallthrough */
       case GRPC_CHTTP2_SPS_VAL3:

src/core/transport/chttp2/frame_window_update.c

@@ -81,7 +81,7 @@ grpc_chttp2_parse_error grpc_chttp2_window_update_parser_parse(
   grpc_chttp2_window_update_parser *p = parser;
 
   while (p->byte != 4 && cur != end) {
-    p->amount |= ((gpr_uint32)*cur) << (8 * (3 - p->byte));
+    p->amount |= ((gpr_uint32) * cur) << (8 * (3 - p->byte));
     cur++;
     p->byte++;
   }

src/core/transport/chttp2/gen_hpack_tables.c

@@ -55,21 +55,19 @@ typedef struct {
   unsigned char index;
 } spec;
 
-static const spec fields[] = {
-    {"INDEXED_FIELD", 0X80, 1, 1},
-    {"INDEXED_FIELD_X", 0X80, 1, 2},
-    {"LITHDR_INCIDX", 0X40, 2, 1},
-    {"LITHDR_INCIDX_X", 0X40, 2, 2},
-    {"LITHDR_INCIDX_V", 0X40, 2, 0},
-    {"LITHDR_NOTIDX", 0X00, 4, 1},
-    {"LITHDR_NOTIDX_X", 0X00, 4, 2},
-    {"LITHDR_NOTIDX_V", 0X00, 4, 0},
-    {"LITHDR_NVRIDX", 0X10, 4, 1},
-    {"LITHDR_NVRIDX_X", 0X10, 4, 2},
-    {"LITHDR_NVRIDX_V", 0X10, 4, 0},
-    {"MAX_TBL_SIZE", 0X20, 3, 1},
-    {"MAX_TBL_SIZE_X", 0X20, 3, 2},
-};
+static const spec fields[] = {{"INDEXED_FIELD", 0X80, 1, 1},
+                              {"INDEXED_FIELD_X", 0X80, 1, 2},
+                              {"LITHDR_INCIDX", 0X40, 2, 1},
+                              {"LITHDR_INCIDX_X", 0X40, 2, 2},
+                              {"LITHDR_INCIDX_V", 0X40, 2, 0},
+                              {"LITHDR_NOTIDX", 0X00, 4, 1},
+                              {"LITHDR_NOTIDX_X", 0X00, 4, 2},
+                              {"LITHDR_NOTIDX_V", 0X00, 4, 0},
+                              {"LITHDR_NVRIDX", 0X10, 4, 1},
+                              {"LITHDR_NVRIDX_X", 0X10, 4, 2},
+                              {"LITHDR_NVRIDX_V", 0X10, 4, 0},
+                              {"MAX_TBL_SIZE", 0X20, 3, 1},
+                              {"MAX_TBL_SIZE_X", 0X20, 3, 2}, };
 
 static const int num_fields = sizeof(fields) / sizeof(*fields);
 
@@ -131,9 +129,13 @@ static void generate_first_byte_lut(void) {
 #define MAXHUFFSTATES 1024
 
 /* represents a set of symbols as an array of booleans indicating inclusion */
-typedef struct { char included[GRPC_CHTTP2_NUM_HUFFSYMS]; } symset;
+typedef struct {
+  char included[GRPC_CHTTP2_NUM_HUFFSYMS];
+} symset;
 /* represents a lookup table indexed by a nibble */
-typedef struct { int values[16]; } nibblelut;
+typedef struct {
+  int values[16];
+} nibblelut;
 
 /* returns a symset that includes all possible symbols */
 static symset symset_all(void) {

src/core/transport/chttp2/hpack_parser.c

@@ -221,8 +221,7 @@ static const gpr_uint8 first_byte_lut[256] = {
     INDEXED_FIELD,   INDEXED_FIELD, INDEXED_FIELD, INDEXED_FIELD,
     INDEXED_FIELD,   INDEXED_FIELD, INDEXED_FIELD, INDEXED_FIELD,
     INDEXED_FIELD,   INDEXED_FIELD, INDEXED_FIELD, INDEXED_FIELD,
-    INDEXED_FIELD,   INDEXED_FIELD, INDEXED_FIELD, INDEXED_FIELD_X,
-};
+    INDEXED_FIELD,   INDEXED_FIELD, INDEXED_FIELD, INDEXED_FIELD_X, };
 
 /* state table for huffman decoding: given a state, gives an index/16 into
    next_sub_tbl. Taking that index and adding the value of the nibble being
@@ -242,8 +241,7 @@ static const gpr_uint8 next_tbl[256] = {
     38, 1,  1,  1,  1,  1,  1, 1,  15, 2, 2,  2,  2,  26, 3,  3,  39, 1,  1,  1,
     1,  1,  1,  1,  1,  1,  1, 1,  2,  2, 2,  2,  2,  2,  7,  3,  3,  3,  40, 2,
     41, 1,  1,  1,  42, 43, 1, 1,  44, 1, 1,  1,  1,  15, 2,  2,  2,  2,  2,  2,
-    3,  3,  3,  45, 46, 1,  1, 2,  2,  2, 35, 3,  3,  18, 47, 2,
-};
+    3,  3,  3,  45, 46, 1,  1, 2,  2,  2, 35, 3,  3,  18, 47, 2, };
 /* next state, based upon current state and the current nibble: see above.
    generated by gen_hpack_tables.c */
 static const gpr_int16 next_sub_tbl[48 * 16] = {
@@ -298,8 +296,7 @@ static const gpr_int16 next_sub_tbl[48 * 16] = {
     4,   8,   4,   8,   4,   8,   4,   8,   4,   8,   0,   0,   0,   0,   0,
     0,   0,   0,   0,   0,   0,   0,   245, 246, 247, 248, 249, 250, 251, 252,
     253, 254, 0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-    0,   0,   255,
-};
+    0,   0,   255, };
 /* emission table: indexed like next_tbl, ultimately gives the byte to be
    emitted, or -1 for no byte, or 256 for end of stream
 
@@ -322,8 +319,7 @@ static const gpr_uint16 emit_tbl[256] = {
     204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218,
     219, 220, 221, 0,   222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232,
     233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247,
-    248,
-};
+    248, };
 /* generated by gen_hpack_tables.c */
 static const gpr_int16 emit_sub_tbl[249 * 16] = {
     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
@@ -591,8 +587,7 @@ static const gpr_int16 emit_sub_tbl[249 * 16] = {
     251, 251, 252, 252, 253, 253, 254, 254, 2,   3,   4,   5,   6,   7,   8,
     11,  12,  14,  15,  16,  17,  18,  19,  20,  21,  23,  24,  25,  26,  27,
     28,  29,  30,  31,  127, 220, 249, -1,  10,  10,  10,  10,  13,  13,  13,
-    13,  22,  22,  22,  22,  256, 256, 256, 256,
-};
+    13,  22,  22,  22,  22,  256, 256, 256, 256, };
 
 static const gpr_uint8 inverse_base64[256] = {
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
@@ -612,8 +607,7 @@ static const gpr_uint8 inverse_base64[256] = {
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255,
-};
+    255, };
 
 /* emission helpers */
 static void on_hdr(grpc_chttp2_hpack_parser *p, grpc_mdelem *md,
@@ -951,7 +945,7 @@ static int parse_value1(grpc_chttp2_hpack_parser *p, const gpr_uint8 *cur,
     return 1;
   }
 
-  *p->parsing.value += (((gpr_uint32)*cur) & 0x7f) << 7;
+  *p->parsing.value += (((gpr_uint32) * cur) & 0x7f) << 7;
 
   if ((*cur) & 0x80) {
     return parse_value2(p, cur + 1, end);
@@ -969,7 +963,7 @@ static int parse_value2(grpc_chttp2_hpack_parser *p, const gpr_uint8 *cur,
     return 1;
   }
 
-  *p->parsing.value += (((gpr_uint32)*cur) & 0x7f) << 14;
+  *p->parsing.value += (((gpr_uint32) * cur) & 0x7f) << 14;
 
   if ((*cur) & 0x80) {
     return parse_value3(p, cur + 1, end);
@@ -987,7 +981,7 @@ static int parse_value3(grpc_chttp2_hpack_parser *p, const gpr_uint8 *cur,
     return 1;
   }
 
-  *p->parsing.value += (((gpr_uint32)*cur) & 0x7f) << 21;
+  *p->parsing.value += (((gpr_uint32) * cur) & 0x7f) << 21;
 
   if ((*cur) & 0x80) {
     return parse_value4(p, cur + 1, end);
@@ -1212,7 +1206,7 @@ static int huff_nibble(grpc_chttp2_hpack_parser *p, gpr_uint8 nibble) {
   gpr_int16 next = next_sub_tbl[16 * next_tbl[p->huff_state] + nibble];
   if (emit != -1) {
     if (emit >= 0 && emit < 256) {
-      gpr_uint8 c = (gpr_uint8) emit;
+      gpr_uint8 c = (gpr_uint8)emit;
       if (!append_string(p, &c, (&c) + 1)) return 0;
     } else {
       assert(emit == 256);

src/core/transport/chttp2/hpack_table.c

@@ -104,8 +104,7 @@ static struct {
       /* 58: */ {"user-agent", ""},
       /* 59: */ {"vary", ""},
       /* 60: */ {"via", ""},
-      /* 61: */ {"www-authenticate", ""},
-};
+      /* 61: */ {"www-authenticate", ""}, };
 
 void grpc_chttp2_hptbl_init(grpc_chttp2_hptbl *tbl, grpc_mdctx *mdctx) {
   size_t i;

src/core/transport/chttp2/huffsyms.c

@@ -293,5 +293,4 @@ const grpc_chttp2_huffsym grpc_chttp2_huffsyms[GRPC_CHTTP2_NUM_HUFFSYMS] = {
     {0x7ffffef, 27},
     {0x7fffff0, 27},
     {0x3ffffee, 26},
-    {0x3fffffff, 30},
-};
+    {0x3fffffff, 30}, };

src/core/transport/chttp2/stream_encoder.c

@@ -43,7 +43,7 @@
 #include "src/core/transport/chttp2/timeout_encoding.h"
 #include "src/core/transport/chttp2/varint.h"
 
-#define HASH_FRAGMENT_1(x) ((x)&255)
+#define HASH_FRAGMENT_1(x) ((x) & 255)
 #define HASH_FRAGMENT_2(x) ((x >> 8) & 255)
 #define HASH_FRAGMENT_3(x) ((x >> 16) & 255)
 #define HASH_FRAGMENT_4(x) ((x >> 24) & 255)

src/core/transport/chttp2/timeout_encoding.c

@@ -60,7 +60,7 @@ static void enc_tiny(char *buffer) { memcpy(buffer, "1n", 3); }
 static void enc_ext(char *buffer, long value, char ext) {
   int n = gpr_ltoa(value, buffer);
   buffer[n] = ext;
-  buffer[n+1] = 0;
+  buffer[n + 1] = 0;
 }
 
 static void enc_seconds(char *buffer, long sec) {

src/core/transport/chttp2/varint.h

@@ -56,7 +56,7 @@ void grpc_chttp2_hpack_write_varint_tail(gpr_uint32 tail_value,
   ((n) < GRPC_CHTTP2_MAX_IN_PREFIX(prefix_bits)   \
        ? 1                                        \
        : grpc_chttp2_hpack_varint_length(         \
-             (n)-GRPC_CHTTP2_MAX_IN_PREFIX(prefix_bits)))
+             (n) - GRPC_CHTTP2_MAX_IN_PREFIX(prefix_bits)))
 
 #define GRPC_CHTTP2_WRITE_VARINT(n, prefix_bits, prefix_or, target, length) \
   do {                                                                      \
@@ -66,7 +66,8 @@ void grpc_chttp2_hpack_write_varint_tail(gpr_uint32 tail_value,
     } else {                                                                \
       (tgt)[0] = (prefix_or) | GRPC_CHTTP2_MAX_IN_PREFIX(prefix_bits);      \
       grpc_chttp2_hpack_write_varint_tail(                                  \
-          (n)-GRPC_CHTTP2_MAX_IN_PREFIX(prefix_bits), (tgt)+1, (length)-1); \
+          (n) - GRPC_CHTTP2_MAX_IN_PREFIX(prefix_bits), (tgt) + 1,          \
+          (length) - 1);                                                    \
     }                                                                       \
   } while (0)
 

src/core/transport/chttp2_transport.c

@@ -525,7 +525,7 @@ static int init_stream(grpc_transport *gt, grpc_stream *gs,
     lock(t);
     s->id = 0;
   } else {
-    s->id = (gpr_uint32)(gpr_uintptr) server_data;
+    s->id = (gpr_uint32)(gpr_uintptr)server_data;
     t->incoming_stream = s;
     grpc_chttp2_stream_map_add(&t->stream_map, s->id, s);
   }
@@ -1238,7 +1238,7 @@ static int init_header_frame_parser(transport *t, int is_continuation) {
     t->incoming_stream = NULL;
     /* if stream is accepted, we set incoming_stream in init_stream */
     t->cb->accept_stream(t->cb_user_data, &t->base,
-                         (void *)(gpr_uintptr) t->incoming_stream_id);
+                         (void *)(gpr_uintptr)t->incoming_stream_id);
     s = t->incoming_stream;
     if (!s) {
       gpr_log(GPR_ERROR, "stream not accepted");
@@ -1503,8 +1503,8 @@ static int process_read(transport *t, gpr_slice slice) {
                   "Connect string mismatch: expected '%c' (%d) got '%c' (%d) "
                   "at byte %d",
                   CLIENT_CONNECT_STRING[t->deframe_state],
-                  (int)(gpr_uint8) CLIENT_CONNECT_STRING[t->deframe_state],
-                  *cur, (int)*cur, t->deframe_state);
+                  (int)(gpr_uint8)CLIENT_CONNECT_STRING[t->deframe_state], *cur,
+                  (int)*cur, t->deframe_state);
           drop_connection(t);
           return 0;
         }
@@ -1518,7 +1518,7 @@ static int process_read(transport *t, gpr_slice slice) {
     dts_fh_0:
     case DTS_FH_0:
       GPR_ASSERT(cur < end);
-      t->incoming_frame_size = ((gpr_uint32)*cur) << 16;
+      t->incoming_frame_size = ((gpr_uint32) * cur) << 16;
       if (++cur == end) {
         t->deframe_state = DTS_FH_1;
         return 1;
@@ -1526,7 +1526,7 @@ static int process_read(transport *t, gpr_slice slice) {
     /* fallthrough */
     case DTS_FH_1:
       GPR_ASSERT(cur < end);
-      t->incoming_frame_size |= ((gpr_uint32)*cur) << 8;
+      t->incoming_frame_size |= ((gpr_uint32) * cur) << 8;
       if (++cur == end) {
         t->deframe_state = DTS_FH_2;
         return 1;
@@ -1558,7 +1558,7 @@ static int process_read(transport *t, gpr_slice slice) {
     /* fallthrough */
     case DTS_FH_5:
       GPR_ASSERT(cur < end);
-      t->incoming_stream_id = (((gpr_uint32)*cur) << 24) & 0x7f;
+      t->incoming_stream_id = (((gpr_uint32) * cur) << 24) & 0x7f;
       if (++cur == end) {
         t->deframe_state = DTS_FH_6;
         return 1;
@@ -1566,7 +1566,7 @@ static int process_read(transport *t, gpr_slice slice) {
     /* fallthrough */
     case DTS_FH_6:
       GPR_ASSERT(cur < end);
-      t->incoming_stream_id |= ((gpr_uint32)*cur) << 16;
+      t->incoming_stream_id |= ((gpr_uint32) * cur) << 16;
       if (++cur == end) {
         t->deframe_state = DTS_FH_7;
         return 1;
@@ -1574,7 +1574,7 @@ static int process_read(transport *t, gpr_slice slice) {
     /* fallthrough */
     case DTS_FH_7:
       GPR_ASSERT(cur < end);
-      t->incoming_stream_id |= ((gpr_uint32)*cur) << 8;
+      t->incoming_stream_id |= ((gpr_uint32) * cur) << 8;
       if (++cur == end) {
         t->deframe_state = DTS_FH_8;
         return 1;
@@ -1582,7 +1582,7 @@ static int process_read(transport *t, gpr_slice slice) {
     /* fallthrough */
     case DTS_FH_8:
       GPR_ASSERT(cur < end);
-      t->incoming_stream_id |= ((gpr_uint32)*cur);
+      t->incoming_stream_id |= ((gpr_uint32) * cur);
       t->deframe_state = DTS_FRAME;
       if (!init_frame_parser(t)) {
         return 0;

src/core/tsi/fake_transport_security.c

@@ -369,8 +369,7 @@ static void fake_protector_destroy(tsi_frame_protector* self) {
 
 static const tsi_frame_protector_vtable frame_protector_vtable = {
     fake_protector_protect, fake_protector_protect_flush,
-    fake_protector_unprotect, fake_protector_destroy,
-};
+    fake_protector_unprotect, fake_protector_destroy, };
 
 /* --- tsi_handshaker methods implementation. ---*/
 
@@ -485,8 +484,7 @@ static const tsi_handshaker_vtable handshaker_vtable = {
     fake_handshaker_get_result,
     fake_handshaker_extract_peer,
     fake_handshaker_create_frame_protector,
-    fake_handshaker_destroy,
-};
+    fake_handshaker_destroy, };
 
 tsi_handshaker* tsi_create_fake_handshaker(int is_client) {
   tsi_fake_handshaker* impl = calloc(1, sizeof(tsi_fake_handshaker));

src/core/tsi/ssl_transport_security.c

@@ -703,8 +703,7 @@ static void ssl_protector_destroy(tsi_frame_protector* self) {
 
 static const tsi_frame_protector_vtable frame_protector_vtable = {
     ssl_protector_protect, ssl_protector_protect_flush, ssl_protector_unprotect,
-    ssl_protector_destroy,
-};
+    ssl_protector_destroy, };
 
 /* --- tsi_handshaker methods implementation. ---*/
 
@@ -877,8 +876,7 @@ static const tsi_handshaker_vtable handshaker_vtable = {
     ssl_handshaker_get_result,
     ssl_handshaker_extract_peer,
     ssl_handshaker_create_frame_protector,
-    ssl_handshaker_destroy,
-};
+    ssl_handshaker_destroy, };
 
 /* --- tsi_ssl_handshaker_factory common methods. --- */
 

src/node/credentials.cc

@@ -157,8 +157,7 @@ NAN_METHOD(Credentials::CreateSsl) {
   }
 
   NanReturnValue(WrapStruct(grpc_ssl_credentials_create(
-      root_certs,
-      key_cert_pair.private_key == NULL ? NULL : &key_cert_pair)));
+      root_certs, key_cert_pair.private_key == NULL ? NULL : &key_cert_pair)));
 }
 
 NAN_METHOD(Credentials::CreateComposite) {

src/ruby/ext/grpc/rb_channel_args.c

@@ -143,7 +143,7 @@ void grpc_rb_hash_convert_to_channel_args(VALUE src_hash,
   /* Make a protected call to grpc_rb_hash_convert_channel_args */
   params.src_hash = src_hash;
   params.dst = dst;
-  rb_protect(grpc_rb_hash_convert_to_channel_args0, (VALUE)&params, &status);
+  rb_protect(grpc_rb_hash_convert_to_channel_args0, (VALUE) & params, &status);
   if (status != 0) {
     if (dst->args != NULL) {
       /* Free any allocated memory before propagating the error */

src/ruby/ext/grpc/rb_credentials.c

@@ -230,8 +230,8 @@ static VALUE grpc_rb_credentials_init(int argc, VALUE *argv, VALUE self) {
   } else {
     grpc_ssl_pem_key_cert_pair key_cert_pair = {RSTRING_PTR(pem_private_key),
                                                 RSTRING_PTR(pem_cert_chain)};
-    creds = grpc_ssl_credentials_create(
-        RSTRING_PTR(pem_root_certs), &key_cert_pair);
+    creds = grpc_ssl_credentials_create(RSTRING_PTR(pem_root_certs),
+                                        &key_cert_pair);
   }
   if (creds == NULL) {
     rb_raise(rb_eRuntimeError, "could not create a credentials, not sure why");

test/core/channel/channel_stack_test.c

@@ -77,13 +77,10 @@ static void channel_func(grpc_channel_element *elem,
 }
 
 static void test_create_channel_stack(void) {
-  const grpc_channel_filter filter = {
-      call_func,   channel_func,
-
-      sizeof(int), call_init_func,    call_destroy_func,
-
-      sizeof(int), channel_init_func, channel_destroy_func,
-  };
+  const grpc_channel_filter
+      filter = {call_func,         channel_func,         sizeof(int),
+                call_init_func,    call_destroy_func,    sizeof(int),
+                channel_init_func, channel_destroy_func, };
   const grpc_channel_filter *filters = &filter;
   grpc_channel_stack *channel_stack;
   grpc_call_stack *call_stack;

test/core/channel/metadata_buffer_test.c

@@ -148,7 +148,7 @@ static void test_case(size_t key_prefix_len, size_t value_prefix_len,
     op.flags = i;
     op.data.metadata = grpc_mdelem_from_slices(mdctx, key, value);
     op.done_cb = do_nothing;
-    op.user_data = (void *)(gpr_uintptr) i;
+    op.user_data = (void *)(gpr_uintptr)i;
 
     grpc_metadata_buffer_queue(&buffer, &op);
   }

test/core/end2end/fixtures/chttp2_fake_security.c

@@ -117,8 +117,7 @@ static grpc_end2end_test_config configs[] = {
      chttp2_create_fixture_secure_fullstack,
      chttp2_init_client_fake_secure_fullstack,
      chttp2_init_server_fake_secure_fullstack,
-     chttp2_tear_down_secure_fullstack},
-};
+     chttp2_tear_down_secure_fullstack}, };
 
 int main(int argc, char **argv) {
   size_t i;

test/core/end2end/fixtures/chttp2_fullstack.c

@@ -99,8 +99,7 @@ void chttp2_tear_down_fullstack(grpc_end2end_test_fixture *f) {
 static grpc_end2end_test_config configs[] = {
     {"chttp2/fullstack", FEATURE_MASK_SUPPORTS_DELAYED_CONNECTION,
      chttp2_create_fixture_fullstack, chttp2_init_client_fullstack,
-     chttp2_init_server_fullstack, chttp2_tear_down_fullstack},
-};
+     chttp2_init_server_fullstack, chttp2_tear_down_fullstack}, };
 
 int main(int argc, char **argv) {
   size_t i;

test/core/end2end/fixtures/chttp2_simple_ssl_fullstack.c

@@ -125,8 +125,7 @@ static grpc_end2end_test_config configs[] = {
      chttp2_create_fixture_secure_fullstack,
      chttp2_init_client_simple_ssl_secure_fullstack,
      chttp2_init_server_simple_ssl_secure_fullstack,
-     chttp2_tear_down_secure_fullstack},
-};
+     chttp2_tear_down_secure_fullstack}, };
 
 int main(int argc, char **argv) {
   size_t i;

test/core/end2end/fixtures/chttp2_simple_ssl_with_oauth2_fullstack.c

@@ -99,7 +99,8 @@ void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture *f) {
 
 static void chttp2_init_client_simple_ssl_with_oauth2_secure_fullstack(
     grpc_end2end_test_fixture *f, grpc_channel_args *client_args) {
-  grpc_credentials *ssl_creds = grpc_ssl_credentials_create(test_root_cert, NULL);
+  grpc_credentials *ssl_creds =
+      grpc_ssl_credentials_create(test_root_cert, NULL);
   grpc_credentials *oauth2_creds =
       grpc_fake_oauth2_credentials_create("Bearer aaslkfjs424535asdf", 1);
   grpc_credentials *ssl_oauth2_creds =
@@ -132,8 +133,7 @@ static grpc_end2end_test_config configs[] = {
      chttp2_create_fixture_secure_fullstack,
      chttp2_init_client_simple_ssl_with_oauth2_secure_fullstack,
      chttp2_init_server_simple_ssl_secure_fullstack,
-     chttp2_tear_down_secure_fullstack},
-};
+     chttp2_tear_down_secure_fullstack}, };
 
 int main(int argc, char **argv) {
   size_t i;

test/core/end2end/fixtures/chttp2_socket_pair.c

@@ -133,8 +133,7 @@ static void chttp2_tear_down_socketpair(grpc_end2end_test_fixture *f) {
 static grpc_end2end_test_config configs[] = {
     {"chttp2/socketpair", 0, chttp2_create_fixture_socketpair,
      chttp2_init_client_socketpair, chttp2_init_server_socketpair,
-     chttp2_tear_down_socketpair},
-};
+     chttp2_tear_down_socketpair}, };
 
 int main(int argc, char **argv) {
   size_t i;

test/core/end2end/fixtures/chttp2_socket_pair_one_byte_at_a_time.c

@@ -133,8 +133,7 @@ static void chttp2_tear_down_socketpair(grpc_end2end_test_fixture *f) {
 static grpc_end2end_test_config configs[] = {
     {"chttp2/socketpair_one_byte_at_a_time", 0,
      chttp2_create_fixture_socketpair, chttp2_init_client_socketpair,
-     chttp2_init_server_socketpair, chttp2_tear_down_socketpair},
-};
+     chttp2_init_server_socketpair, chttp2_tear_down_socketpair}, };
 
 int main(int argc, char **argv) {
   size_t i;

test/core/end2end/tests/cancel_test_helpers.h

@@ -46,7 +46,6 @@ static grpc_call_error wait_for_deadline(grpc_call *call) {
 
 static const cancellation_mode cancellation_modes[] = {
     {grpc_call_cancel, GRPC_STATUS_CANCELLED, NULL},
-    {wait_for_deadline, GRPC_STATUS_DEADLINE_EXCEEDED, "Deadline Exceeded"},
-};
+    {wait_for_deadline, GRPC_STATUS_DEADLINE_EXCEEDED, "Deadline Exceeded"}, };
 
 #endif

test/core/end2end/tests/max_concurrent_streams.c

@@ -204,7 +204,7 @@ static void test_max_concurrent_streams(grpc_end2end_test_config config) {
   /* The /alpha or /beta calls started above could be invoked (but NOT both);
    * check this here */
   /* We'll get tag 303 or 403, we want 300, 400 */
-  live_call = ((int)(gpr_intptr) ev->tag) - 3;
+  live_call = ((int)(gpr_intptr)ev->tag) - 3;
   grpc_event_finish(ev);
 
   cq_expect_server_rpc_new(v_server, &s1, tag(100),

test/core/end2end/tests/thread_stress.c

@@ -278,11 +278,11 @@ static void run_test(grpc_end2end_test_config config, int requests_in_flight) {
   /* kick off threads */
   for (i = 0; i < CLIENT_THREADS; i++) {
     gpr_event_init(&g_client_done[i]);
-    gpr_thd_new(&thd_id, client_thread, (void *)(gpr_intptr) i, NULL);
+    gpr_thd_new(&thd_id, client_thread, (void *)(gpr_intptr)i, NULL);
   }
   for (i = 0; i < SERVER_THREADS; i++) {
     gpr_event_init(&g_server_done[i]);
-    gpr_thd_new(&thd_id, server_thread, (void *)(gpr_intptr) i, NULL);
+    gpr_thd_new(&thd_id, server_thread, (void *)(gpr_intptr)i, NULL);
   }
 
   /* start requests */

test/core/fling/client.c

@@ -98,8 +98,7 @@ typedef struct {
 
 static const scenario scenarios[] = {
     {"ping-pong-request", init_ping_pong_request, step_ping_pong_request},
-    {"ping-pong-stream", init_ping_pong_stream, step_ping_pong_stream},
-};
+    {"ping-pong-stream", init_ping_pong_stream, step_ping_pong_stream}, };
 
 int main(int argc, char **argv) {
   gpr_slice slice = gpr_slice_from_copied_string("x");

test/core/iomgr/alarm_list_test.c

@@ -61,13 +61,13 @@ static void add_test(void) {
   /* 10 ms alarms.  will expire in the current epoch */
   for (i = 0; i < 10; i++) {
     grpc_alarm_init(&alarms[i], gpr_time_add(start, gpr_time_from_millis(10)),
-                    cb, (void *)(gpr_intptr) i, start);
+                    cb, (void *)(gpr_intptr)i, start);
   }
 
   /* 1010 ms alarms.  will expire in the next epoch */
   for (i = 10; i < 20; i++) {
     grpc_alarm_init(&alarms[i], gpr_time_add(start, gpr_time_from_millis(1010)),
-                    cb, (void *)(gpr_intptr) i, start);
+                    cb, (void *)(gpr_intptr)i, start);
   }
 
   /* collect alarms.  Only the first batch should be ready. */
@@ -115,15 +115,15 @@ void destruction_test(void) {
   memset(cb_called, 0, sizeof(cb_called));
 
   grpc_alarm_init(&alarms[0], gpr_time_from_millis(100), cb,
-                  (void *)(gpr_intptr) 0, gpr_time_0);
+                  (void *)(gpr_intptr)0, gpr_time_0);
   grpc_alarm_init(&alarms[1], gpr_time_from_millis(3), cb,
-                  (void *)(gpr_intptr) 1, gpr_time_0);
+                  (void *)(gpr_intptr)1, gpr_time_0);
   grpc_alarm_init(&alarms[2], gpr_time_from_millis(100), cb,
-                  (void *)(gpr_intptr) 2, gpr_time_0);
+                  (void *)(gpr_intptr)2, gpr_time_0);
   grpc_alarm_init(&alarms[3], gpr_time_from_millis(3), cb,
-                  (void *)(gpr_intptr) 3, gpr_time_0);
+                  (void *)(gpr_intptr)3, gpr_time_0);
   grpc_alarm_init(&alarms[4], gpr_time_from_millis(1), cb,
-                  (void *)(gpr_intptr) 4, gpr_time_0);
+                  (void *)(gpr_intptr)4, gpr_time_0);
   GPR_ASSERT(1 == grpc_alarm_check(NULL, gpr_time_from_millis(2), NULL));
   GPR_ASSERT(1 == cb_called[4][1]);
   grpc_alarm_cancel(&alarms[0]);

test/core/iomgr/endpoint_tests.c

@@ -290,7 +290,7 @@ static void shutdown_during_write_test_read_handler(
 
   if (error != GRPC_ENDPOINT_CB_OK) {
     grpc_endpoint_destroy(st->ep);
-    gpr_event_set(&st->ev, (void *)(gpr_intptr) error);
+    gpr_event_set(&st->ev, (void *)(gpr_intptr)error);
   } else {
     grpc_endpoint_notify_on_read(
         st->ep, shutdown_during_write_test_read_handler, user_data);
@@ -309,7 +309,7 @@ static void shutdown_during_write_test_write_handler(
     gpr_log(GPR_ERROR,
             "shutdown_during_write_test_write_handler completed unexpectedly");
   }
-  gpr_event_set(&st->ev, (void *)(gpr_intptr) 1);
+  gpr_event_set(&st->ev, (void *)(gpr_intptr)1);
 }
 
 static void shutdown_during_write_test(grpc_endpoint_test_config config,

test/core/iomgr/resolve_address_test.c

@@ -83,9 +83,8 @@ static void test_ipv6_with_port(void) {
 }
 
 static void test_ipv6_without_port(void) {
-  const char* const kCases[] = {
-      "2001:db8::1", "2001:db8::1.2.3.4", "[2001:db8::1]",
-  };
+  const char* const kCases[] = {"2001:db8::1", "2001:db8::1.2.3.4",
+                                "[2001:db8::1]", };
   int i;
   for (i = 0; i < sizeof(kCases) / sizeof(*kCases); i++) {
     gpr_event ev;
@@ -96,9 +95,7 @@ static void test_ipv6_without_port(void) {
 }
 
 static void test_invalid_ip_addresses(void) {
-  const char* const kCases[] = {
-      "293.283.1238.3:1", "[2001:db8::11111]:1",
-  };
+  const char* const kCases[] = {"293.283.1238.3:1", "[2001:db8::11111]:1", };
   int i;
   for (i = 0; i < sizeof(kCases) / sizeof(*kCases); i++) {
     gpr_event ev;
@@ -109,9 +106,8 @@ static void test_invalid_ip_addresses(void) {
 }
 
 static void test_unparseable_hostports(void) {
-  const char* const kCases[] = {
-      "[", "[::1", "[::1]bad", "[1.2.3.4]", "[localhost]", "[localhost]:1",
-  };
+  const char* const kCases[] = {"[",         "[::1",        "[::1]bad",
+                                "[1.2.3.4]", "[localhost]", "[localhost]:1", };
   int i;
   for (i = 0; i < sizeof(kCases) / sizeof(*kCases); i++) {
     gpr_event ev;

test/core/iomgr/tcp_client_posix_test.c

@@ -140,7 +140,7 @@ void test_times_out(void) {
   /* tie up the listen buffer, which is somewhat arbitrarily sized. */
   for (i = 0; i < NUM_CLIENT_CONNECTS; ++i) {
     client_fd[i] = socket(AF_INET, SOCK_STREAM, 0);
-    grpc_set_socket_nonblocking(client_fd[i], 1);  
+    grpc_set_socket_nonblocking(client_fd[i], 1);
     do {
       r = connect(client_fd[i], (struct sockaddr *)&addr, addr_len);
     } while (r == -1 && errno == EINTR);

test/core/iomgr/tcp_posix_test.c

@@ -484,8 +484,7 @@ static grpc_endpoint_test_fixture create_fixture_tcp_socketpair(
 }
 
 static grpc_endpoint_test_config configs[] = {
-    {"tcp/tcp_socketpair", create_fixture_tcp_socketpair, clean_up},
-};
+    {"tcp/tcp_socketpair", create_fixture_tcp_socketpair, clean_up}, };
 
 int main(int argc, char **argv) {
   grpc_test_init(argc, argv);

test/core/security/secure_endpoint_test.c

@@ -131,8 +131,7 @@ static grpc_endpoint_test_config configs[] = {
     {"secure_ep/tcp_socketpair",
      secure_endpoint_create_fixture_tcp_socketpair_noleftover, clean_up},
     {"secure_ep/tcp_socketpair_leftover",
-     secure_endpoint_create_fixture_tcp_socketpair_leftover, clean_up},
-};
+     secure_endpoint_create_fixture_tcp_socketpair_leftover, clean_up}, };
 
 static void verify_leftover(void *user_data, gpr_slice *slices, size_t nslices,
                             grpc_endpoint_cb_status error) {

test/core/support/sync_test.c

@@ -53,12 +53,12 @@ typedef struct queue {
   gpr_cv non_empty; /* Signalled when length becomes non-zero. */
   gpr_cv non_full;  /* Signalled when length becomes non-N. */
   gpr_mu mu;        /* Protects all fields below.
-                        (That is, except during initialization or
-                        destruction, the fields below should be accessed
-                        only by a thread that holds mu.) */
-  int head;         /* Index of head of queue 0..N-1. */
-  int length;       /* Number of valid elements in queue 0..N. */
-  int elem[N];      /* elem[head .. head+length-1] are queue elements. */
+                 (That is, except during initialization or
+                 destruction, the fields below should be accessed
+                 only by a thread that holds mu.) */
+  int head;    /* Index of head of queue 0..N-1. */
+  int length;  /* Number of valid elements in queue 0..N. */
+  int elem[N]; /* elem[head .. head+length-1] are queue elements. */
 } queue;
 
 /* Initialize *q. */

test/core/surface/completion_queue_benchmark.c

@@ -53,23 +53,23 @@ static void producer_thread(void *arg) {
   test_thread_options *opt = arg;
   int i;
 
-  gpr_event_set(&opt->on_started, (void *)(gpr_intptr) 1);
+  gpr_event_set(&opt->on_started, (void *)(gpr_intptr)1);
   GPR_ASSERT(gpr_event_wait(opt->start, gpr_inf_future));
 
   for (i = 0; i < opt->iterations; i++) {
     grpc_cq_begin_op(opt->cc, NULL, GRPC_WRITE_ACCEPTED);
-    grpc_cq_end_write_accepted(opt->cc, (void *)(gpr_intptr) 1, NULL, NULL,
-                               NULL, GRPC_OP_OK);
+    grpc_cq_end_write_accepted(opt->cc, (void *)(gpr_intptr)1, NULL, NULL, NULL,
+                               GRPC_OP_OK);
   }
 
-  gpr_event_set(&opt->on_finished, (void *)(gpr_intptr) 1);
+  gpr_event_set(&opt->on_finished, (void *)(gpr_intptr)1);
 }
 
 static void consumer_thread(void *arg) {
   test_thread_options *opt = arg;
   grpc_event *ev;
 
-  gpr_event_set(&opt->on_started, (void *)(gpr_intptr) 1);
+  gpr_event_set(&opt->on_started, (void *)(gpr_intptr)1);
   GPR_ASSERT(gpr_event_wait(opt->start, gpr_inf_future));
 
   for (;;) {
@@ -78,7 +78,7 @@ static void consumer_thread(void *arg) {
       case GRPC_WRITE_ACCEPTED:
         break;
       case GRPC_QUEUE_SHUTDOWN:
-        gpr_event_set(&opt->on_finished, (void *)(gpr_intptr) 1);
+        gpr_event_set(&opt->on_finished, (void *)(gpr_intptr)1);
         return;
       default:
         gpr_log(GPR_ERROR, "Invalid event received: %d", ev->type);
@@ -112,7 +112,7 @@ double ops_per_second(int consumers, int producers, int iterations) {
 
   /* start the benchmark */
   t_start = gpr_now();
-  gpr_event_set(&start, (void *)(gpr_intptr) 1);
+  gpr_event_set(&start, (void *)(gpr_intptr)1);
 
   /* wait for producers to finish */
   for (i = 0; i < producers; i++) {

test/core/surface/completion_queue_test.c

@@ -282,7 +282,7 @@ static void producer_thread(void *arg) {
   int i;
 
   gpr_log(GPR_INFO, "producer %d started", opt->id);
-  gpr_event_set(&opt->on_started, (void *)(gpr_intptr) 1);
+  gpr_event_set(&opt->on_started, (void *)(gpr_intptr)1);
   GPR_ASSERT(gpr_event_wait(opt->phase1, ten_seconds_time()));
 
   gpr_log(GPR_INFO, "producer %d phase 1", opt->id);
@@ -291,18 +291,18 @@ static void producer_thread(void *arg) {
   }
 
   gpr_log(GPR_INFO, "producer %d phase 1 done", opt->id);
-  gpr_event_set(&opt->on_phase1_done, (void *)(gpr_intptr) 1);
+  gpr_event_set(&opt->on_phase1_done, (void *)(gpr_intptr)1);
   GPR_ASSERT(gpr_event_wait(opt->phase2, ten_seconds_time()));
 
   gpr_log(GPR_INFO, "producer %d phase 2", opt->id);
   for (i = 0; i < TEST_THREAD_EVENTS; i++) {
-    grpc_cq_end_write_accepted(opt->cc, (void *)(gpr_intptr) 1, NULL, NULL,
-                               NULL, GRPC_OP_OK);
+    grpc_cq_end_write_accepted(opt->cc, (void *)(gpr_intptr)1, NULL, NULL, NULL,
+                               GRPC_OP_OK);
     opt->events_triggered++;
   }
 
   gpr_log(GPR_INFO, "producer %d phase 2 done", opt->id);
-  gpr_event_set(&opt->on_finished, (void *)(gpr_intptr) 1);
+  gpr_event_set(&opt->on_finished, (void *)(gpr_intptr)1);
 }
 
 static void consumer_thread(void *arg) {
@@ -310,13 +310,13 @@ static void consumer_thread(void *arg) {
   grpc_event *ev;
 
   gpr_log(GPR_INFO, "consumer %d started", opt->id);
-  gpr_event_set(&opt->on_started, (void *)(gpr_intptr) 1);
+  gpr_event_set(&opt->on_started, (void *)(gpr_intptr)1);
   GPR_ASSERT(gpr_event_wait(opt->phase1, ten_seconds_time()));
 
   gpr_log(GPR_INFO, "consumer %d phase 1", opt->id);
 
   gpr_log(GPR_INFO, "consumer %d phase 1 done", opt->id);
-  gpr_event_set(&opt->on_phase1_done, (void *)(gpr_intptr) 1);
+  gpr_event_set(&opt->on_phase1_done, (void *)(gpr_intptr)1);
   GPR_ASSERT(gpr_event_wait(opt->phase2, ten_seconds_time()));
 
   gpr_log(GPR_INFO, "consumer %d phase 2", opt->id);
@@ -331,7 +331,7 @@ static void consumer_thread(void *arg) {
         break;
       case GRPC_QUEUE_SHUTDOWN:
         gpr_log(GPR_INFO, "consumer %d phase 2 done", opt->id);
-        gpr_event_set(&opt->on_finished, (void *)(gpr_intptr) 1);
+        gpr_event_set(&opt->on_finished, (void *)(gpr_intptr)1);
         grpc_event_finish(ev);
         return;
       default:
@@ -376,7 +376,7 @@ static void test_threading(int producers, int consumers) {
   /* start phase1: producers will pre-declare all operations they will
      complete */
   gpr_log(GPR_INFO, "start phase 1");
-  gpr_event_set(&phase1, (void *)(gpr_intptr) 1);
+  gpr_event_set(&phase1, (void *)(gpr_intptr)1);
 
   gpr_log(GPR_INFO, "wait phase 1");
   for (i = 0; i < producers + consumers; i++) {
@@ -386,7 +386,7 @@ static void test_threading(int producers, int consumers) {
 
   /* start phase2: operations will complete, and consumers will consume them */
   gpr_log(GPR_INFO, "start phase 2");
-  gpr_event_set(&phase2, (void *)(gpr_intptr) 1);
+  gpr_event_set(&phase2, (void *)(gpr_intptr)1);
 
   /* in parallel, we shutdown the completion channel - all events should still
      be consumed */

test/core/transport/chttp2/hpack_parser_test.c

@@ -42,7 +42,9 @@
 #include "test/core/util/slice_splitter.h"
 #include "test/core/util/test_config.h"
 
-typedef struct { va_list args; } test_checker;
+typedef struct {
+  va_list args;
+} test_checker;
 
 static void onhdr(void *ud, grpc_mdelem *md) {
   const char *ekey, *evalue;

test/core/transport/chttp2/stream_map_test.c

@@ -93,7 +93,7 @@ static void test_basic_add_find(size_t n) {
   grpc_chttp2_stream_map_init(&map, 8);
   GPR_ASSERT(0 == grpc_chttp2_stream_map_size(&map));
   for (i = 1; i <= n; i++) {
-    grpc_chttp2_stream_map_add(&map, i, (void *)(gpr_uintptr) i);
+    grpc_chttp2_stream_map_add(&map, i, (void *)(gpr_uintptr)i);
   }
   GPR_ASSERT(n == grpc_chttp2_stream_map_size(&map));
   GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(&map, 0));
@@ -148,7 +148,7 @@ static void test_delete_evens_sweep(size_t n) {
 
   grpc_chttp2_stream_map_init(&map, 8);
   for (i = 1; i <= n; i++) {
-    grpc_chttp2_stream_map_add(&map, i, (void *)(gpr_uintptr) i);
+    grpc_chttp2_stream_map_add(&map, i, (void *)(gpr_uintptr)i);
   }
   for (i = 1; i <= n; i++) {
     if ((i & 1) == 0) {
@@ -170,7 +170,7 @@ static void test_delete_evens_incremental(size_t n) {
 
   grpc_chttp2_stream_map_init(&map, 8);
   for (i = 1; i <= n; i++) {
-    grpc_chttp2_stream_map_add(&map, i, (void *)(gpr_uintptr) i);
+    grpc_chttp2_stream_map_add(&map, i, (void *)(gpr_uintptr)i);
     if ((i & 1) == 0) {
       grpc_chttp2_stream_map_delete(&map, i);
     }

test/core/transport/chttp2_transport_end2end_test.c

@@ -100,8 +100,7 @@ grpc_transport_test_config fixture_configs[] = {
     {"chttp2_on_socketpair/medium",
      create_http2_transport_for_test_medium_slices},
     {"chttp2_on_socketpair/large",
-     create_http2_transport_for_test_large_slices},
-};
+     create_http2_transport_for_test_large_slices}, };
 
 /* Driver function: run the test suite for each test configuration */
 int main(int argc, char **argv) {

test/core/transport/transport_end2end_tests.c

@@ -63,7 +63,9 @@ static int g_pending_ops;
 typedef struct test_fixture test_fixture;
 
 /* User data passed to the transport and handed to each callback */
-typedef struct test_user_data { test_fixture *fixture; } test_user_data;
+typedef struct test_user_data {
+  test_fixture *fixture;
+} test_user_data;
 
 /* A message we expect to receive (forms a singly linked list with next) */
 typedef struct expected_message {
@@ -129,7 +131,7 @@ static void expect_metadata(test_stream *s, int from_client, const char *key,
 /* Convert some number of seconds into a gpr_timespec that many seconds in the
    future */
 static gpr_timespec deadline_from_seconds(double deadline_seconds) {
-  return gpr_time_add(gpr_now(), 
+  return gpr_time_add(gpr_now(),
                       gpr_time_from_micros((long)(deadline_seconds * 1e6)));
 }
 
@@ -589,10 +591,9 @@ static void begin_test(test_fixture *f, grpc_transport_test_config *config,
   f->client_transport = NULL;
   f->server_transport = NULL;
 
-  GPR_ASSERT(0 ==
-             config->create_transport(setup_client_transport, f,
-                                      setup_server_transport, f,
-                                      g_metadata_context));
+  GPR_ASSERT(0 == config->create_transport(setup_client_transport, f,
+                                           setup_server_transport, f,
+                                           g_metadata_context));
 
   gpr_mu_lock(&f->mu);
   while (!f->client_transport || !f->server_transport) {
@@ -908,9 +909,8 @@ static void test_ping(grpc_transport_test_config *config) {
  * Test driver
  */
 
-static const size_t interesting_message_lengths[] = {
-    1, 100, 10000, 100000, 1000000,
-};
+static const size_t interesting_message_lengths[] = {1,      100,     10000,
+                                                     100000, 1000000, };
 
 void grpc_transport_end2end_tests(grpc_transport_test_config *config) {
   int i;

test/core/util/port_posix.c

@@ -113,12 +113,11 @@ int grpc_pick_unused_port(void) {
 
   /* Type of port to first pick in next iteration */
   int is_tcp = 1;
-  int try
-    = 0;
+  int try = 0;
 
   for (;;) {
-    int port = try
-      < NUM_RANDOM_PORTS_TO_PICK ? rand() % (65536 - 30000) + 30000 : 0;
+    int port =
+        try < NUM_RANDOM_PORTS_TO_PICK ? rand() % (65536 - 30000) + 30000 : 0;
     if (!is_port_available(&port, is_tcp)) {
       continue;
     }

test/cpp/qps/client.cc

@@ -134,33 +134,37 @@ void RunTest(const int client_threads, const int client_channels,
     GPR_ASSERT(hist != NULL);
     thread_stats[i] = hist;
 
-    threads.push_back(std::thread(
-        [hist, client_threads, client_channels, num_rpcs, payload_size,
-         &channels](int channel_num) {
-          SimpleRequest request;
-          SimpleResponse response;
-          request.set_response_type(grpc::testing::PayloadType::COMPRESSABLE);
-          request.set_response_size(payload_size);
-
-          for (int j = 0; j < num_rpcs; j++) {
-            TestService::Stub *stub = channels[channel_num].get_stub();
-            double start = now();
-            grpc::ClientContext context;
-            grpc::Status s = stub->UnaryCall(&context, request, &response);
-            gpr_histogram_add(hist, now() - start);
-
-            GPR_ASSERT((s.code() == grpc::StatusCode::OK) &&
-                       (response.payload().type() ==
-                        grpc::testing::PayloadType::COMPRESSABLE) &&
-                       (response.payload().body().length() ==
-                        static_cast<size_t>(payload_size)));
-
-            // Now do runtime round-robin assignment of the next channel number
-            channel_num += client_threads;
-            channel_num %= client_channels;
-          }
-        },
-        i % client_channels));
+    threads.push_back(
+        std::thread([hist, client_threads, client_channels, num_rpcs,
+                     payload_size, &channels](int channel_num) {
+                      SimpleRequest request;
+                      SimpleResponse response;
+                      request.set_response_type(
+                          grpc::testing::PayloadType::COMPRESSABLE);
+                      request.set_response_size(payload_size);
+
+                      for (int j = 0; j < num_rpcs; j++) {
+                        TestService::Stub *stub =
+                            channels[channel_num].get_stub();
+                        double start = now();
+                        grpc::ClientContext context;
+                        grpc::Status s =
+                            stub->UnaryCall(&context, request, &response);
+                        gpr_histogram_add(hist, now() - start);
+
+                        GPR_ASSERT((s.code() == grpc::StatusCode::OK) &&
+                                   (response.payload().type() ==
+                                    grpc::testing::PayloadType::COMPRESSABLE) &&
+                                   (response.payload().body().length() ==
+                                    static_cast<size_t>(payload_size)));
+
+                        // Now do runtime round-robin assignment of the next
+                        // channel number
+                        channel_num += client_threads;
+                        channel_num %= client_channels;
+                      }
+                    },
+                    i % client_channels));
   }
 
   gpr_histogram *hist = gpr_histogram_create(0.01, 60e9);

test/cpp/util/create_test_channel.cc

@@ -72,7 +72,8 @@ std::shared_ptr<ChannelInterface> CreateTestChannel(
     const grpc::string& connect_to =
         server.empty() ? override_hostname : server;
     if (creds.get()) {
-      channel_creds = CredentialsFactory::ComposeCredentials(creds, channel_creds);
+      channel_creds =
+          CredentialsFactory::ComposeCredentials(creds, channel_creds);
     }
     return CreateChannel(connect_to, channel_creds, channel_args);
   } else {
@@ -83,7 +84,8 @@ std::shared_ptr<ChannelInterface> CreateTestChannel(
 std::shared_ptr<ChannelInterface> CreateTestChannel(
     const grpc::string& server, const grpc::string& override_hostname,
     bool enable_ssl, bool use_prod_roots) {
-  return CreateTestChannel(server, override_hostname, enable_ssl, use_prod_roots, std::unique_ptr<Credentials>());
+  return CreateTestChannel(server, override_hostname, enable_ssl,
+                           use_prod_roots, std::unique_ptr<Credentials>());
 }
 
 // Shortcut for end2end and interop tests.

test/cpp/util/create_test_channel.h

@@ -37,6 +37,7 @@
 #include <memory>
 
 #include <grpc++/config.h>
+#include <grpc++/credentials.h>
 
 namespace grpc {
 class ChannelInterface;
@@ -50,7 +51,8 @@ std::shared_ptr<ChannelInterface> CreateTestChannel(
 
 std::shared_ptr<ChannelInterface> CreateTestChannel(
     const grpc::string& server, const grpc::string& override_hostname,
-    bool enable_ssl, bool use_prod_roots, const std::unique_ptr<Credentials>& creds);
+    bool enable_ssl, bool use_prod_roots,
+    const std::unique_ptr<Credentials>& creds);
 
 }  // namespace grpc