clang-format all core files

src/core/census/aggregation.h

@@ -37,31 +37,30 @@
 #define GRPC_INTERNAL_CORE_CENSUS_AGGREGATION_H
 
 /** Structure used to describe an aggregation type. */
-struct census_aggregation_ops
-{
+struct census_aggregation_ops {
   /* Create a new aggregation. The pointer returned can be used in future calls
      to clone(), free(), record(), data() and reset(). */
-  void *(*create) (const void *create_arg);
+  void *(*create)(const void *create_arg);
   /* Make a copy of an aggregation created by create() */
-  void *(*clone) (const void *aggregation);
+  void *(*clone)(const void *aggregation);
   /* Destroy an aggregation created by create() */
-  void (*free) (void *aggregation);
+  void (*free)(void *aggregation);
   /* Record a new value against aggregation. */
-  void (*record) (void *aggregation, double value);
+  void (*record)(void *aggregation, double value);
   /* Return current aggregation data. The caller must cast this object into
      the correct type for the aggregation result. The object returned can be
      freed by using free_data(). */
-  void *(*data) (const void *aggregation);
+  void *(*data)(const void *aggregation);
   /* free data returned by data() */
-  void (*free_data) (void *data);
+  void (*free_data)(void *data);
   /* Reset an aggregation to default (zero) values. */
-  void (*reset) (void *aggregation);
+  void (*reset)(void *aggregation);
   /* Merge 'from' aggregation into 'to'. Both aggregations must be compatible */
-  void (*merge) (void *to, const void *from);
+  void (*merge)(void *to, const void *from);
   /* Fill buffer with printable string version of aggregation contents. For
      debugging only. Returns the number of bytes added to buffer (a value == n
      implies the buffer was of insufficient size). */
-    size_t (*print) (const void *aggregation, char *buffer, size_t n);
+  size_t (*print)(const void *aggregation, char *buffer, size_t n);
 };
 
 #endif /* GRPC_INTERNAL_CORE_CENSUS_AGGREGATION_H */

src/core/census/context.c

@@ -39,9 +39,8 @@
 
 /* Placeholder implementation only. */
 
-size_t
-census_context_serialize (const census_context * context, char *buffer, size_t buf_size)
-{
+size_t census_context_serialize(const census_context *context, char *buffer,
+                                size_t buf_size) {
   /* TODO(aveitch): implement serialization */
   return 0;
 }

src/core/census/context.h

@@ -38,13 +38,12 @@
 
 /* census_context is the in-memory representation of information needed to
  * maintain tracing, RPC statistics and resource usage information. */
-struct census_context
-{
-  gpr_uint64 op_id;		/* Operation identifier - unique per-context */
-  gpr_uint64 trace_id;		/* Globally unique trace identifier */
-  /* TODO(aveitch) Add census tags:
-     const census_tag_set *tags;
-   */
+struct census_context {
+  gpr_uint64 op_id;    /* Operation identifier - unique per-context */
+  gpr_uint64 trace_id; /* Globally unique trace identifier */
+                       /* TODO(aveitch) Add census tags:
+                          const census_tag_set *tags;
+                        */
 };
 
 #endif /* GRPC_INTERNAL_CORE_CENSUS_CONTEXT_H */

src/core/census/grpc_context.c

@@ -35,21 +35,15 @@
 #include <grpc/grpc.h>
 #include "src/core/surface/call.h"
 
-void
-grpc_census_call_set_context (grpc_call * call, census_context * context)
-{
-  if (census_enabled () == CENSUS_FEATURE_NONE)
-    {
-      return;
-    }
-  if (context != NULL)
-    {
-      grpc_call_context_set (call, GRPC_CONTEXT_TRACING, context, NULL);
-    }
+void grpc_census_call_set_context(grpc_call *call, census_context *context) {
+  if (census_enabled() == CENSUS_FEATURE_NONE) {
+    return;
+  }
+  if (context != NULL) {
+    grpc_call_context_set(call, GRPC_CONTEXT_TRACING, context, NULL);
+  }
 }
 
-census_context *
-grpc_census_call_get_context (grpc_call * call)
-{
-  return (census_context *) grpc_call_context_get (call, GRPC_CONTEXT_TRACING);
+census_context *grpc_census_call_get_context(grpc_call *call) {
+  return (census_context *)grpc_call_context_get(call, GRPC_CONTEXT_TRACING);
 }

src/core/census/grpc_filter.c

@@ -46,8 +46,7 @@
 #include <grpc/support/slice.h>
 #include <grpc/support/time.h>
 
-typedef struct call_data
-{
+typedef struct call_data {
   census_op_id op_id;
   census_context *ctxt;
   gpr_timespec start_ts;
@@ -58,154 +57,139 @@ typedef struct call_data
   grpc_closure *on_done_recv;
 } call_data;
 
-typedef struct channel_data
-{
-  grpc_mdstr *path_str;		/* pointer to meta data str with key == ":path" */
+typedef struct channel_data {
+  grpc_mdstr *path_str; /* pointer to meta data str with key == ":path" */
 } channel_data;
 
-static void
-extract_and_annotate_method_tag (grpc_stream_op_buffer * sopb, call_data * calld, channel_data * chand)
-{
+static void extract_and_annotate_method_tag(grpc_stream_op_buffer *sopb,
+                                            call_data *calld,
+                                            channel_data *chand) {
   grpc_linked_mdelem *m;
   size_t i;
-  for (i = 0; i < sopb->nops; i++)
-    {
-      grpc_stream_op *op = &sopb->ops[i];
-      if (op->type != GRPC_OP_METADATA)
-	continue;
-      for (m = op->data.metadata.list.head; m != NULL; m = m->next)
-	{
-	  if (m->md->key == chand->path_str)
-	    {
-	      gpr_log (GPR_DEBUG, "%s", (const char *) GPR_SLICE_START_PTR (m->md->value->slice));
-	      /* Add method tag here */
-	    }
-	}
+  for (i = 0; i < sopb->nops; i++) {
+    grpc_stream_op *op = &sopb->ops[i];
+    if (op->type != GRPC_OP_METADATA) continue;
+    for (m = op->data.metadata.list.head; m != NULL; m = m->next) {
+      if (m->md->key == chand->path_str) {
+        gpr_log(GPR_DEBUG, "%s",
+                (const char *)GPR_SLICE_START_PTR(m->md->value->slice));
+        /* Add method tag here */
+      }
     }
+  }
 }
 
-static void
-client_mutate_op (grpc_call_element * elem, grpc_transport_stream_op * op)
-{
+static void client_mutate_op(grpc_call_element *elem,
+                             grpc_transport_stream_op *op) {
   call_data *calld = elem->call_data;
   channel_data *chand = elem->channel_data;
-  if (op->send_ops)
-    {
-      extract_and_annotate_method_tag (op->send_ops, calld, chand);
-    }
+  if (op->send_ops) {
+    extract_and_annotate_method_tag(op->send_ops, calld, chand);
+  }
 }
 
-static void
-client_start_transport_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
-{
-  client_mutate_op (elem, op);
-  grpc_call_next_op (exec_ctx, elem, op);
+static void client_start_transport_op(grpc_exec_ctx *exec_ctx,
+                                      grpc_call_element *elem,
+                                      grpc_transport_stream_op *op) {
+  client_mutate_op(elem, op);
+  grpc_call_next_op(exec_ctx, elem, op);
 }
 
-static void
-server_on_done_recv (grpc_exec_ctx * exec_ctx, void *ptr, int success)
-{
+static void server_on_done_recv(grpc_exec_ctx *exec_ctx, void *ptr,
+                                int success) {
   grpc_call_element *elem = ptr;
   call_data *calld = elem->call_data;
   channel_data *chand = elem->channel_data;
-  if (success)
-    {
-      extract_and_annotate_method_tag (calld->recv_ops, calld, chand);
-    }
-  calld->on_done_recv->cb (exec_ctx, calld->on_done_recv->cb_arg, success);
+  if (success) {
+    extract_and_annotate_method_tag(calld->recv_ops, calld, chand);
+  }
+  calld->on_done_recv->cb(exec_ctx, calld->on_done_recv->cb_arg, success);
 }
 
-static void
-server_mutate_op (grpc_call_element * elem, grpc_transport_stream_op * op)
-{
+static void server_mutate_op(grpc_call_element *elem,
+                             grpc_transport_stream_op *op) {
   call_data *calld = elem->call_data;
-  if (op->recv_ops)
-    {
-      /* substitute our callback for the op callback */
-      calld->recv_ops = op->recv_ops;
-      calld->on_done_recv = op->on_done_recv;
-      op->on_done_recv = calld->on_done_recv;
-    }
+  if (op->recv_ops) {
+    /* substitute our callback for the op callback */
+    calld->recv_ops = op->recv_ops;
+    calld->on_done_recv = op->on_done_recv;
+    op->on_done_recv = calld->on_done_recv;
+  }
 }
 
-static void
-server_start_transport_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
-{
+static void server_start_transport_op(grpc_exec_ctx *exec_ctx,
+                                      grpc_call_element *elem,
+                                      grpc_transport_stream_op *op) {
   call_data *calld = elem->call_data;
-  GPR_ASSERT ((calld->op_id.upper != 0) || (calld->op_id.lower != 0));
-  server_mutate_op (elem, op);
-  grpc_call_next_op (exec_ctx, elem, op);
+  GPR_ASSERT((calld->op_id.upper != 0) || (calld->op_id.lower != 0));
+  server_mutate_op(elem, op);
+  grpc_call_next_op(exec_ctx, elem, op);
 }
 
-static void
-client_init_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op)
-{
+static void client_init_call_elem(grpc_exec_ctx *exec_ctx,
+                                  grpc_call_element *elem,
+                                  const void *server_transport_data,
+                                  grpc_transport_stream_op *initial_op) {
   call_data *d = elem->call_data;
-  GPR_ASSERT (d != NULL);
-  d->start_ts = gpr_now (GPR_CLOCK_REALTIME);
-  if (initial_op)
-    client_mutate_op (elem, initial_op);
+  GPR_ASSERT(d != NULL);
+  d->start_ts = gpr_now(GPR_CLOCK_REALTIME);
+  if (initial_op) client_mutate_op(elem, initial_op);
 }
 
-static void
-client_destroy_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
-{
+static void client_destroy_call_elem(grpc_exec_ctx *exec_ctx,
+                                     grpc_call_element *elem) {
   call_data *d = elem->call_data;
-  GPR_ASSERT (d != NULL);
+  GPR_ASSERT(d != NULL);
   /* TODO(hongyu): record rpc client stats and census_rpc_end_op here */
 }
 
-static void
-server_init_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op)
-{
+static void server_init_call_elem(grpc_exec_ctx *exec_ctx,
+                                  grpc_call_element *elem,
+                                  const void *server_transport_data,
+                                  grpc_transport_stream_op *initial_op) {
   call_data *d = elem->call_data;
-  GPR_ASSERT (d != NULL);
-  d->start_ts = gpr_now (GPR_CLOCK_REALTIME);
+  GPR_ASSERT(d != NULL);
+  d->start_ts = gpr_now(GPR_CLOCK_REALTIME);
   /* TODO(hongyu): call census_tracing_start_op here. */
-  grpc_closure_init (d->on_done_recv, server_on_done_recv, elem);
-  if (initial_op)
-    server_mutate_op (elem, initial_op);
+  grpc_closure_init(d->on_done_recv, server_on_done_recv, elem);
+  if (initial_op) server_mutate_op(elem, initial_op);
 }
 
-static void
-server_destroy_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
-{
+static void server_destroy_call_elem(grpc_exec_ctx *exec_ctx,
+                                     grpc_call_element *elem) {
   call_data *d = elem->call_data;
-  GPR_ASSERT (d != NULL);
+  GPR_ASSERT(d != NULL);
   /* TODO(hongyu): record rpc server stats and census_tracing_end_op here */
 }
 
-static void
-init_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_first, int is_last)
-{
+static void init_channel_elem(grpc_exec_ctx *exec_ctx,
+                              grpc_channel_element *elem, grpc_channel *master,
+                              const grpc_channel_args *args, grpc_mdctx *mdctx,
+                              int is_first, int is_last) {
   channel_data *chand = elem->channel_data;
-  GPR_ASSERT (chand != NULL);
-  chand->path_str = grpc_mdstr_from_string (mdctx, ":path", 0);
+  GPR_ASSERT(chand != NULL);
+  chand->path_str = grpc_mdstr_from_string(mdctx, ":path", 0);
 }
 
-static void
-destroy_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem)
-{
+static void destroy_channel_elem(grpc_exec_ctx *exec_ctx,
+                                 grpc_channel_element *elem) {
   channel_data *chand = elem->channel_data;
-  GPR_ASSERT (chand != NULL);
-  if (chand->path_str != NULL)
-    {
-      GRPC_MDSTR_UNREF (chand->path_str);
-    }
+  GPR_ASSERT(chand != NULL);
+  if (chand->path_str != NULL) {
+    GRPC_MDSTR_UNREF(chand->path_str);
+  }
 }
 
 const grpc_channel_filter grpc_client_census_filter = {
-  client_start_transport_op, grpc_channel_next_op,
-  sizeof (call_data), client_init_call_elem,
-  client_destroy_call_elem, sizeof (channel_data),
-  init_channel_elem, destroy_channel_elem,
-  grpc_call_next_get_peer, "census-client"
-};
+    client_start_transport_op, grpc_channel_next_op,
+    sizeof(call_data),         client_init_call_elem,
+    client_destroy_call_elem,  sizeof(channel_data),
+    init_channel_elem,         destroy_channel_elem,
+    grpc_call_next_get_peer,   "census-client"};
 
 const grpc_channel_filter grpc_server_census_filter = {
-  server_start_transport_op, grpc_channel_next_op,
-  sizeof (call_data), server_init_call_elem,
-  server_destroy_call_elem, sizeof (channel_data),
-  init_channel_elem, destroy_channel_elem,
-  grpc_call_next_get_peer, "census-server"
-};
+    server_start_transport_op, grpc_channel_next_op,
+    sizeof(call_data),         server_init_call_elem,
+    server_destroy_call_elem,  sizeof(channel_data),
+    init_channel_elem,         destroy_channel_elem,
+    grpc_call_next_get_peer,   "census-server"};

src/core/census/initialize.c

@@ -35,39 +35,23 @@
 
 static int features_enabled = CENSUS_FEATURE_NONE;
 
-int
-census_initialize (int features)
-{
-  if (features_enabled != CENSUS_FEATURE_NONE)
-    {
-      return 1;
-    }
-  if (features != CENSUS_FEATURE_NONE)
-    {
-      return 1;
-    }
-  else
-    {
-      features_enabled = features;
-      return 0;
-    }
+int census_initialize(int features) {
+  if (features_enabled != CENSUS_FEATURE_NONE) {
+    return 1;
+  }
+  if (features != CENSUS_FEATURE_NONE) {
+    return 1;
+  } else {
+    features_enabled = features;
+    return 0;
+  }
 }
 
-void
-census_shutdown (void)
-{
-  features_enabled = CENSUS_FEATURE_NONE;
-}
+void census_shutdown(void) { features_enabled = CENSUS_FEATURE_NONE; }
 
-int
-census_supported (void)
-{
+int census_supported(void) {
   /* TODO(aveitch): improve this as we implement features... */
   return CENSUS_FEATURE_NONE;
 }
 
-int
-census_enabled (void)
-{
-  return features_enabled;
-}
+int census_enabled(void) { return features_enabled; }

src/core/census/operation.c

@@ -34,34 +34,30 @@
 
 /* TODO(aveitch): These are all placeholder implementations. */
 
-census_timestamp
-census_start_rpc_op_timestamp (void)
-{
+census_timestamp census_start_rpc_op_timestamp(void) {
   census_timestamp ct;
   /* TODO(aveitch): assumes gpr_timespec implementation of census_timestamp. */
-  ct.ts = gpr_now (GPR_CLOCK_MONOTONIC);
+  ct.ts = gpr_now(GPR_CLOCK_MONOTONIC);
   return ct;
 }
 
-census_context *
-census_start_client_rpc_op (const census_context * context, gpr_int64 rpc_name_id, const census_rpc_name_info * rpc_name_info, const char *peer, int trace_mask, const census_timestamp * start_time)
-{
+census_context *census_start_client_rpc_op(
+    const census_context *context, gpr_int64 rpc_name_id,
+    const census_rpc_name_info *rpc_name_info, const char *peer, int trace_mask,
+    const census_timestamp *start_time) {
   return NULL;
 }
 
-census_context *
-census_start_server_rpc_op (const char *buffer, gpr_int64 rpc_name_id, const census_rpc_name_info * rpc_name_info, const char *peer, int trace_mask, census_timestamp * start_time)
-{
+census_context *census_start_server_rpc_op(
+    const char *buffer, gpr_int64 rpc_name_id,
+    const census_rpc_name_info *rpc_name_info, const char *peer, int trace_mask,
+    census_timestamp *start_time) {
   return NULL;
 }
 
-census_context *
-census_start_op (census_context * context, const char *family, const char *name, int trace_mask)
-{
+census_context *census_start_op(census_context *context, const char *family,
+                                const char *name, int trace_mask) {
   return NULL;
 }
 
-void
-census_end_op (census_context * context, int status)
-{
-}
+void census_end_op(census_context *context, int status) {}

src/core/census/tracing.c

@@ -35,18 +35,11 @@
 
 /* TODO(aveitch): These are all placeholder implementations. */
 
-int
-census_trace_mask (const census_context * context)
-{
+int census_trace_mask(const census_context *context) {
   return CENSUS_TRACE_MASK_NONE;
 }
 
-void
-census_set_trace_mask (int trace_mask)
-{
-}
+void census_set_trace_mask(int trace_mask) {}
 
-void
-census_trace_print (census_context * context, gpr_uint32 type, const char *buffer, size_t n)
-{
-}
+void census_trace_print(census_context *context, gpr_uint32 type,
+                        const char *buffer, size_t n) {}

src/core/channel/channel_args.c

@@ -41,206 +41,169 @@
 
 #include <string.h>
 
-static grpc_arg
-copy_arg (const grpc_arg * src)
-{
+static grpc_arg copy_arg(const grpc_arg *src) {
   grpc_arg dst;
   dst.type = src->type;
-  dst.key = gpr_strdup (src->key);
-  switch (dst.type)
-    {
+  dst.key = gpr_strdup(src->key);
+  switch (dst.type) {
     case GRPC_ARG_STRING:
-      dst.value.string = gpr_strdup (src->value.string);
+      dst.value.string = gpr_strdup(src->value.string);
       break;
     case GRPC_ARG_INTEGER:
       dst.value.integer = src->value.integer;
       break;
     case GRPC_ARG_POINTER:
       dst.value.pointer = src->value.pointer;
-      dst.value.pointer.p = src->value.pointer.copy ? src->value.pointer.copy (src->value.pointer.p) : src->value.pointer.p;
+      dst.value.pointer.p = src->value.pointer.copy
+                                ? src->value.pointer.copy(src->value.pointer.p)
+                                : src->value.pointer.p;
       break;
-    }
+  }
   return dst;
 }
 
-grpc_channel_args *
-grpc_channel_args_copy_and_add (const grpc_channel_args * src, const grpc_arg * to_add, size_t num_to_add)
-{
-  grpc_channel_args *dst = gpr_malloc (sizeof (grpc_channel_args));
+grpc_channel_args *grpc_channel_args_copy_and_add(const grpc_channel_args *src,
+                                                  const grpc_arg *to_add,
+                                                  size_t num_to_add) {
+  grpc_channel_args *dst = gpr_malloc(sizeof(grpc_channel_args));
   size_t i;
   size_t src_num_args = (src == NULL) ? 0 : src->num_args;
-  if (!src && !to_add)
-    {
-      dst->num_args = 0;
-      dst->args = NULL;
-      return dst;
-    }
+  if (!src && !to_add) {
+    dst->num_args = 0;
+    dst->args = NULL;
+    return dst;
+  }
   dst->num_args = src_num_args + num_to_add;
-  dst->args = gpr_malloc (sizeof (grpc_arg) * dst->num_args);
-  for (i = 0; i < src_num_args; i++)
-    {
-      dst->args[i] = copy_arg (&src->args[i]);
-    }
-  for (i = 0; i < num_to_add; i++)
-    {
-      dst->args[i + src_num_args] = copy_arg (&to_add[i]);
-    }
+  dst->args = gpr_malloc(sizeof(grpc_arg) * dst->num_args);
+  for (i = 0; i < src_num_args; i++) {
+    dst->args[i] = copy_arg(&src->args[i]);
+  }
+  for (i = 0; i < num_to_add; i++) {
+    dst->args[i + src_num_args] = copy_arg(&to_add[i]);
+  }
   return dst;
 }
 
-grpc_channel_args *
-grpc_channel_args_copy (const grpc_channel_args * src)
-{
-  return grpc_channel_args_copy_and_add (src, NULL, 0);
+grpc_channel_args *grpc_channel_args_copy(const grpc_channel_args *src) {
+  return grpc_channel_args_copy_and_add(src, NULL, 0);
 }
 
-grpc_channel_args *
-grpc_channel_args_merge (const grpc_channel_args * a, const grpc_channel_args * b)
-{
-  return grpc_channel_args_copy_and_add (a, b->args, b->num_args);
+grpc_channel_args *grpc_channel_args_merge(const grpc_channel_args *a,
+                                           const grpc_channel_args *b) {
+  return grpc_channel_args_copy_and_add(a, b->args, b->num_args);
 }
 
-void
-grpc_channel_args_destroy (grpc_channel_args * a)
-{
+void grpc_channel_args_destroy(grpc_channel_args *a) {
   size_t i;
-  for (i = 0; i < a->num_args; i++)
-    {
-      switch (a->args[i].type)
-	{
-	case GRPC_ARG_STRING:
-	  gpr_free (a->args[i].value.string);
-	  break;
-	case GRPC_ARG_INTEGER:
-	  break;
-	case GRPC_ARG_POINTER:
-	  if (a->args[i].value.pointer.destroy)
-	    {
-	      a->args[i].value.pointer.destroy (a->args[i].value.pointer.p);
-	    }
-	  break;
-	}
-      gpr_free (a->args[i].key);
+  for (i = 0; i < a->num_args; i++) {
+    switch (a->args[i].type) {
+      case GRPC_ARG_STRING:
+        gpr_free(a->args[i].value.string);
+        break;
+      case GRPC_ARG_INTEGER:
+        break;
+      case GRPC_ARG_POINTER:
+        if (a->args[i].value.pointer.destroy) {
+          a->args[i].value.pointer.destroy(a->args[i].value.pointer.p);
+        }
+        break;
     }
-  gpr_free (a->args);
-  gpr_free (a);
+    gpr_free(a->args[i].key);
+  }
+  gpr_free(a->args);
+  gpr_free(a);
 }
 
-int
-grpc_channel_args_is_census_enabled (const grpc_channel_args * a)
-{
+int grpc_channel_args_is_census_enabled(const grpc_channel_args *a) {
   size_t i;
-  if (a == NULL)
-    return 0;
-  for (i = 0; i < a->num_args; i++)
-    {
-      if (0 == strcmp (a->args[i].key, GRPC_ARG_ENABLE_CENSUS))
-	{
-	  return a->args[i].value.integer != 0;
-	}
+  if (a == NULL) return 0;
+  for (i = 0; i < a->num_args; i++) {
+    if (0 == strcmp(a->args[i].key, GRPC_ARG_ENABLE_CENSUS)) {
+      return a->args[i].value.integer != 0;
     }
+  }
   return 0;
 }
 
-grpc_compression_algorithm
-grpc_channel_args_get_compression_algorithm (const grpc_channel_args * a)
-{
+grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
+    const grpc_channel_args *a) {
   size_t i;
-  if (a == NULL)
-    return 0;
-  for (i = 0; i < a->num_args; ++i)
-    {
-      if (a->args[i].type == GRPC_ARG_INTEGER && !strcmp (GRPC_COMPRESSION_ALGORITHM_ARG, a->args[i].key))
-	{
-	  return (grpc_compression_algorithm) a->args[i].value.integer;
-	  break;
-	}
+  if (a == NULL) return 0;
+  for (i = 0; i < a->num_args; ++i) {
+    if (a->args[i].type == GRPC_ARG_INTEGER &&
+        !strcmp(GRPC_COMPRESSION_ALGORITHM_ARG, a->args[i].key)) {
+      return (grpc_compression_algorithm)a->args[i].value.integer;
+      break;
     }
+  }
   return GRPC_COMPRESS_NONE;
 }
 
-grpc_channel_args *
-grpc_channel_args_set_compression_algorithm (grpc_channel_args * a, grpc_compression_algorithm algorithm)
-{
+grpc_channel_args *grpc_channel_args_set_compression_algorithm(
+    grpc_channel_args *a, grpc_compression_algorithm algorithm) {
   grpc_arg tmp;
   tmp.type = GRPC_ARG_INTEGER;
   tmp.key = GRPC_COMPRESSION_ALGORITHM_ARG;
   tmp.value.integer = algorithm;
-  return grpc_channel_args_copy_and_add (a, &tmp, 1);
+  return grpc_channel_args_copy_and_add(a, &tmp, 1);
 }
 
 /** Returns 1 if the argument for compression algorithm's enabled states bitset
  * was found in \a a, returning the arg's value in \a states. Otherwise, returns
  * 0. */
-static int
-find_compression_algorithm_states_bitset (const grpc_channel_args * a, int **states_arg)
-{
-  if (a != NULL)
-    {
-      size_t i;
-      for (i = 0; i < a->num_args; ++i)
-	{
-	  if (a->args[i].type == GRPC_ARG_INTEGER && !strcmp (GRPC_COMPRESSION_ALGORITHM_STATE_ARG, a->args[i].key))
-	    {
-	      *states_arg = &a->args[i].value.integer;
-	      return 1;		/* GPR_TRUE */
-	    }
-	}
+static int find_compression_algorithm_states_bitset(const grpc_channel_args *a,
+                                                    int **states_arg) {
+  if (a != NULL) {
+    size_t i;
+    for (i = 0; i < a->num_args; ++i) {
+      if (a->args[i].type == GRPC_ARG_INTEGER &&
+          !strcmp(GRPC_COMPRESSION_ALGORITHM_STATE_ARG, a->args[i].key)) {
+        *states_arg = &a->args[i].value.integer;
+        return 1; /* GPR_TRUE */
+      }
     }
-  return 0;			/* GPR_FALSE */
+  }
+  return 0; /* GPR_FALSE */
 }
 
-grpc_channel_args *
-grpc_channel_args_compression_algorithm_set_state (grpc_channel_args ** a, grpc_compression_algorithm algorithm, int state)
-{
+grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(
+    grpc_channel_args **a, grpc_compression_algorithm algorithm, int state) {
   int *states_arg;
   grpc_channel_args *result = *a;
-  const int states_arg_found = find_compression_algorithm_states_bitset (*a, &states_arg);
+  const int states_arg_found =
+      find_compression_algorithm_states_bitset(*a, &states_arg);
 
-  if (states_arg_found)
-    {
-      if (state != 0)
-	{
-	  GPR_BITSET ((unsigned *) states_arg, algorithm);
-	}
-      else
-	{
-	  GPR_BITCLEAR ((unsigned *) states_arg, algorithm);
-	}
+  if (states_arg_found) {
+    if (state != 0) {
+      GPR_BITSET((unsigned *)states_arg, algorithm);
+    } else {
+      GPR_BITCLEAR((unsigned *)states_arg, algorithm);
     }
-  else
-    {
-      /* create a new arg */
-      grpc_arg tmp;
-      tmp.type = GRPC_ARG_INTEGER;
-      tmp.key = GRPC_COMPRESSION_ALGORITHM_STATE_ARG;
-      /* all enabled by default */
-      tmp.value.integer = (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
-      if (state != 0)
-	{
-	  GPR_BITSET ((unsigned *) &tmp.value.integer, algorithm);
-	}
-      else
-	{
-	  GPR_BITCLEAR ((unsigned *) &tmp.value.integer, algorithm);
-	}
-      result = grpc_channel_args_copy_and_add (*a, &tmp, 1);
-      grpc_channel_args_destroy (*a);
-      *a = result;
+  } else {
+    /* create a new arg */
+    grpc_arg tmp;
+    tmp.type = GRPC_ARG_INTEGER;
+    tmp.key = GRPC_COMPRESSION_ALGORITHM_STATE_ARG;
+    /* all enabled by default */
+    tmp.value.integer = (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
+    if (state != 0) {
+      GPR_BITSET((unsigned *)&tmp.value.integer, algorithm);
+    } else {
+      GPR_BITCLEAR((unsigned *)&tmp.value.integer, algorithm);
     }
+    result = grpc_channel_args_copy_and_add(*a, &tmp, 1);
+    grpc_channel_args_destroy(*a);
+    *a = result;
+  }
   return result;
 }
 
-int
-grpc_channel_args_compression_algorithm_get_states (const grpc_channel_args * a)
-{
+int grpc_channel_args_compression_algorithm_get_states(
+    const grpc_channel_args *a) {
   int *states_arg;
-  if (find_compression_algorithm_states_bitset (a, &states_arg))
-    {
-      return *states_arg;
-    }
-  else
-    {
-      return (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;	/* All algs. enabled */
-    }
+  if (find_compression_algorithm_states_bitset(a, &states_arg)) {
+    return *states_arg;
+  } else {
+    return (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1; /* All algs. enabled */
+  }
 }

src/core/channel/channel_args.h

@@ -38,29 +38,34 @@
 #include <grpc/grpc.h>
 
 /* Copy some arguments */
-grpc_channel_args *grpc_channel_args_copy (const grpc_channel_args * src);
+grpc_channel_args *grpc_channel_args_copy(const grpc_channel_args *src);
 
 /** Copy some arguments and add the to_add parameter in the end.
    If to_add is NULL, it is equivalent to call grpc_channel_args_copy. */
-grpc_channel_args *grpc_channel_args_copy_and_add (const grpc_channel_args * src, const grpc_arg * to_add, size_t num_to_add);
+grpc_channel_args *grpc_channel_args_copy_and_add(const grpc_channel_args *src,
+                                                  const grpc_arg *to_add,
+                                                  size_t num_to_add);
 
 /** Copy args from a then args from b into a new channel args */
-grpc_channel_args *grpc_channel_args_merge (const grpc_channel_args * a, const grpc_channel_args * b);
+grpc_channel_args *grpc_channel_args_merge(const grpc_channel_args *a,
+                                           const grpc_channel_args *b);
 
 /** Destroy arguments created by grpc_channel_args_copy */
-void grpc_channel_args_destroy (grpc_channel_args * a);
+void grpc_channel_args_destroy(grpc_channel_args *a);
 
 /** Reads census_enabled settings from channel args. Returns 1 if census_enabled
  * is specified in channel args, otherwise returns 0. */
-int grpc_channel_args_is_census_enabled (const grpc_channel_args * a);
+int grpc_channel_args_is_census_enabled(const grpc_channel_args *a);
 
 /** Returns the compression algorithm set in \a a. */
-grpc_compression_algorithm grpc_channel_args_get_compression_algorithm (const grpc_channel_args * a);
+grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
+    const grpc_channel_args *a);
 
 /** Returns a channel arg instance with compression enabled. If \a a is
  * non-NULL, its args are copied. N.B. GRPC_COMPRESS_NONE disables compression
  * for the channel. */
-grpc_channel_args *grpc_channel_args_set_compression_algorithm (grpc_channel_args * a, grpc_compression_algorithm algorithm);
+grpc_channel_args *grpc_channel_args_set_compression_algorithm(
+    grpc_channel_args *a, grpc_compression_algorithm algorithm);
 
 /** Sets the support for the given compression algorithm. By default, all
  * compression algorithms are enabled. It's an error to disable an algorithm set
@@ -69,13 +74,15 @@ grpc_channel_args *grpc_channel_args_set_compression_algorithm (grpc_channel_arg
  * Returns an instance will the updated algorithm states. The \a a pointer is
  * modified to point to the returned instance (which may be different from the
  * input value of \a a). */
-grpc_channel_args *grpc_channel_args_compression_algorithm_set_state (grpc_channel_args ** a, grpc_compression_algorithm algorithm, int enabled);
+grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(
+    grpc_channel_args **a, grpc_compression_algorithm algorithm, int enabled);
 
 /** Returns the bitset representing the support state (true for enabled, false
  * for disabled) for compression algorithms.
  *
  * The i-th bit of the returned bitset corresponds to the i-th entry in the
  * grpc_compression_algorithm enum. */
-int grpc_channel_args_compression_algorithm_get_states (const grpc_channel_args * a);
+int grpc_channel_args_compression_algorithm_get_states(
+    const grpc_channel_args *a);
 
 #endif /* GRPC_INTERNAL_CORE_CHANNEL_CHANNEL_ARGS_H */

src/core/channel/channel_stack.c

@@ -59,20 +59,21 @@ int grpc_trace_channel = 0;
 #define ROUND_UP_TO_ALIGNMENT_SIZE(x) \
   (((x) + GPR_MAX_ALIGNMENT - 1u) & ~(GPR_MAX_ALIGNMENT - 1u))
 
-size_t
-grpc_channel_stack_size (const grpc_channel_filter ** filters, size_t filter_count)
-{
+size_t grpc_channel_stack_size(const grpc_channel_filter **filters,
+                               size_t filter_count) {
   /* always need the header, and size for the channel elements */
-  size_t size = ROUND_UP_TO_ALIGNMENT_SIZE (sizeof (grpc_channel_stack)) + ROUND_UP_TO_ALIGNMENT_SIZE (filter_count * sizeof (grpc_channel_element));
+  size_t size =
+      ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_channel_stack)) +
+      ROUND_UP_TO_ALIGNMENT_SIZE(filter_count * sizeof(grpc_channel_element));
   size_t i;
 
-  GPR_ASSERT ((GPR_MAX_ALIGNMENT & (GPR_MAX_ALIGNMENT - 1)) == 0 && "GPR_MAX_ALIGNMENT must be a power of two");
+  GPR_ASSERT((GPR_MAX_ALIGNMENT & (GPR_MAX_ALIGNMENT - 1)) == 0 &&
+             "GPR_MAX_ALIGNMENT must be a power of two");
 
   /* add the size for each filter */
-  for (i = 0; i < filter_count; i++)
-    {
-      size += ROUND_UP_TO_ALIGNMENT_SIZE (filters[i]->sizeof_channel_data);
-    }
+  for (i = 0; i < filter_count; i++) {
+    size += ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_channel_data);
+  }
 
   return size;
 }
@@ -85,142 +86,142 @@ grpc_channel_stack_size (const grpc_channel_filter ** filters, size_t filter_cou
   ((grpc_call_element *)((char *)(stk) + \
                          ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack))))
 
-grpc_channel_element *
-grpc_channel_stack_element (grpc_channel_stack * channel_stack, size_t index)
-{
-  return CHANNEL_ELEMS_FROM_STACK (channel_stack) + index;
+grpc_channel_element *grpc_channel_stack_element(
+    grpc_channel_stack *channel_stack, size_t index) {
+  return CHANNEL_ELEMS_FROM_STACK(channel_stack) + index;
 }
 
-grpc_channel_element *
-grpc_channel_stack_last_element (grpc_channel_stack * channel_stack)
-{
-  return grpc_channel_stack_element (channel_stack, channel_stack->count - 1);
+grpc_channel_element *grpc_channel_stack_last_element(
+    grpc_channel_stack *channel_stack) {
+  return grpc_channel_stack_element(channel_stack, channel_stack->count - 1);
 }
 
-grpc_call_element *
-grpc_call_stack_element (grpc_call_stack * call_stack, size_t index)
-{
-  return CALL_ELEMS_FROM_STACK (call_stack) + index;
+grpc_call_element *grpc_call_stack_element(grpc_call_stack *call_stack,
+                                           size_t index) {
+  return CALL_ELEMS_FROM_STACK(call_stack) + index;
 }
 
-void
-grpc_channel_stack_init (grpc_exec_ctx * exec_ctx, const grpc_channel_filter ** filters, size_t filter_count, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * metadata_context, grpc_channel_stack * stack)
-{
-  size_t call_size = ROUND_UP_TO_ALIGNMENT_SIZE (sizeof (grpc_call_stack)) + ROUND_UP_TO_ALIGNMENT_SIZE (filter_count * sizeof (grpc_call_element));
+void grpc_channel_stack_init(grpc_exec_ctx *exec_ctx,
+                             const grpc_channel_filter **filters,
+                             size_t filter_count, grpc_channel *master,
+                             const grpc_channel_args *args,
+                             grpc_mdctx *metadata_context,
+                             grpc_channel_stack *stack) {
+  size_t call_size =
+      ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack)) +
+      ROUND_UP_TO_ALIGNMENT_SIZE(filter_count * sizeof(grpc_call_element));
   grpc_channel_element *elems;
   char *user_data;
   size_t i;
 
   stack->count = filter_count;
-  elems = CHANNEL_ELEMS_FROM_STACK (stack);
-  user_data = ((char *) elems) + ROUND_UP_TO_ALIGNMENT_SIZE (filter_count * sizeof (grpc_channel_element));
+  elems = CHANNEL_ELEMS_FROM_STACK(stack);
+  user_data =
+      ((char *)elems) +
+      ROUND_UP_TO_ALIGNMENT_SIZE(filter_count * sizeof(grpc_channel_element));
 
   /* init per-filter data */
-  for (i = 0; i < filter_count; i++)
-    {
-      elems[i].filter = filters[i];
-      elems[i].channel_data = user_data;
-      elems[i].filter->init_channel_elem (exec_ctx, &elems[i], master, args, metadata_context, i == 0, i == (filter_count - 1));
-      user_data += ROUND_UP_TO_ALIGNMENT_SIZE (filters[i]->sizeof_channel_data);
-      call_size += ROUND_UP_TO_ALIGNMENT_SIZE (filters[i]->sizeof_call_data);
-    }
-
-  GPR_ASSERT (user_data > (char *) stack);
-  GPR_ASSERT ((gpr_uintptr) (user_data - (char *) stack) == grpc_channel_stack_size (filters, filter_count));
+  for (i = 0; i < filter_count; i++) {
+    elems[i].filter = filters[i];
+    elems[i].channel_data = user_data;
+    elems[i].filter->init_channel_elem(exec_ctx, &elems[i], master, args,
+                                       metadata_context, i == 0,
+                                       i == (filter_count - 1));
+    user_data += ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_channel_data);
+    call_size += ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_call_data);
+  }
+
+  GPR_ASSERT(user_data > (char *)stack);
+  GPR_ASSERT((gpr_uintptr)(user_data - (char *)stack) ==
+             grpc_channel_stack_size(filters, filter_count));
 
   stack->call_stack_size = call_size;
 }
 
-void
-grpc_channel_stack_destroy (grpc_exec_ctx * exec_ctx, grpc_channel_stack * stack)
-{
-  grpc_channel_element *channel_elems = CHANNEL_ELEMS_FROM_STACK (stack);
+void grpc_channel_stack_destroy(grpc_exec_ctx *exec_ctx,
+                                grpc_channel_stack *stack) {
+  grpc_channel_element *channel_elems = CHANNEL_ELEMS_FROM_STACK(stack);
   size_t count = stack->count;
   size_t i;
 
   /* destroy per-filter data */
-  for (i = 0; i < count; i++)
-    {
-      channel_elems[i].filter->destroy_channel_elem (exec_ctx, &channel_elems[i]);
-    }
+  for (i = 0; i < count; i++) {
+    channel_elems[i].filter->destroy_channel_elem(exec_ctx, &channel_elems[i]);
+  }
 }
 
-void
-grpc_call_stack_init (grpc_exec_ctx * exec_ctx, grpc_channel_stack * channel_stack, const void *transport_server_data, grpc_transport_stream_op * initial_op, grpc_call_stack * call_stack)
-{
-  grpc_channel_element *channel_elems = CHANNEL_ELEMS_FROM_STACK (channel_stack);
+void grpc_call_stack_init(grpc_exec_ctx *exec_ctx,
+                          grpc_channel_stack *channel_stack,
+                          const void *transport_server_data,
+                          grpc_transport_stream_op *initial_op,
+                          grpc_call_stack *call_stack) {
+  grpc_channel_element *channel_elems = CHANNEL_ELEMS_FROM_STACK(channel_stack);
   size_t count = channel_stack->count;
   grpc_call_element *call_elems;
   char *user_data;
   size_t i;
 
   call_stack->count = count;
-  call_elems = CALL_ELEMS_FROM_STACK (call_stack);
-  user_data = ((char *) call_elems) + ROUND_UP_TO_ALIGNMENT_SIZE (count * sizeof (grpc_call_element));
+  call_elems = CALL_ELEMS_FROM_STACK(call_stack);
+  user_data = ((char *)call_elems) +
+              ROUND_UP_TO_ALIGNMENT_SIZE(count * sizeof(grpc_call_element));
 
   /* init per-filter data */
-  for (i = 0; i < count; i++)
-    {
-      call_elems[i].filter = channel_elems[i].filter;
-      call_elems[i].channel_data = channel_elems[i].channel_data;
-      call_elems[i].call_data = user_data;
-      call_elems[i].filter->init_call_elem (exec_ctx, &call_elems[i], transport_server_data, initial_op);
-      user_data += ROUND_UP_TO_ALIGNMENT_SIZE (call_elems[i].filter->sizeof_call_data);
-    }
+  for (i = 0; i < count; i++) {
+    call_elems[i].filter = channel_elems[i].filter;
+    call_elems[i].channel_data = channel_elems[i].channel_data;
+    call_elems[i].call_data = user_data;
+    call_elems[i].filter->init_call_elem(exec_ctx, &call_elems[i],
+                                         transport_server_data, initial_op);
+    user_data +=
+        ROUND_UP_TO_ALIGNMENT_SIZE(call_elems[i].filter->sizeof_call_data);
+  }
 }
 
-void
-grpc_call_stack_destroy (grpc_exec_ctx * exec_ctx, grpc_call_stack * stack)
-{
-  grpc_call_element *elems = CALL_ELEMS_FROM_STACK (stack);
+void grpc_call_stack_destroy(grpc_exec_ctx *exec_ctx, grpc_call_stack *stack) {
+  grpc_call_element *elems = CALL_ELEMS_FROM_STACK(stack);
   size_t count = stack->count;
   size_t i;
 
   /* destroy per-filter data */
-  for (i = 0; i < count; i++)
-    {
-      elems[i].filter->destroy_call_elem (exec_ctx, &elems[i]);
-    }
+  for (i = 0; i < count; i++) {
+    elems[i].filter->destroy_call_elem(exec_ctx, &elems[i]);
+  }
 }
 
-void
-grpc_call_next_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
-{
+void grpc_call_next_op(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
+                       grpc_transport_stream_op *op) {
   grpc_call_element *next_elem = elem + 1;
-  next_elem->filter->start_transport_stream_op (exec_ctx, next_elem, op);
+  next_elem->filter->start_transport_stream_op(exec_ctx, next_elem, op);
 }
 
-char *
-grpc_call_next_get_peer (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
-{
+char *grpc_call_next_get_peer(grpc_exec_ctx *exec_ctx,
+                              grpc_call_element *elem) {
   grpc_call_element *next_elem = elem + 1;
-  return next_elem->filter->get_peer (exec_ctx, next_elem);
+  return next_elem->filter->get_peer(exec_ctx, next_elem);
 }
 
-void
-grpc_channel_next_op (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_transport_op * op)
-{
+void grpc_channel_next_op(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
+                          grpc_transport_op *op) {
   grpc_channel_element *next_elem = elem + 1;
-  next_elem->filter->start_transport_op (exec_ctx, next_elem, op);
+  next_elem->filter->start_transport_op(exec_ctx, next_elem, op);
 }
 
-grpc_channel_stack *
-grpc_channel_stack_from_top_element (grpc_channel_element * elem)
-{
-  return (grpc_channel_stack *) ((char *) (elem) - ROUND_UP_TO_ALIGNMENT_SIZE (sizeof (grpc_channel_stack)));
+grpc_channel_stack *grpc_channel_stack_from_top_element(
+    grpc_channel_element *elem) {
+  return (grpc_channel_stack *)((char *)(elem)-ROUND_UP_TO_ALIGNMENT_SIZE(
+      sizeof(grpc_channel_stack)));
 }
 
-grpc_call_stack *
-grpc_call_stack_from_top_element (grpc_call_element * elem)
-{
-  return (grpc_call_stack *) ((char *) (elem) - ROUND_UP_TO_ALIGNMENT_SIZE (sizeof (grpc_call_stack)));
+grpc_call_stack *grpc_call_stack_from_top_element(grpc_call_element *elem) {
+  return (grpc_call_stack *)((char *)(elem)-ROUND_UP_TO_ALIGNMENT_SIZE(
+      sizeof(grpc_call_stack)));
 }
 
-void
-grpc_call_element_send_cancel (grpc_exec_ctx * exec_ctx, grpc_call_element * cur_elem)
-{
+void grpc_call_element_send_cancel(grpc_exec_ctx *exec_ctx,
+                                   grpc_call_element *cur_elem) {
   grpc_transport_stream_op op;
-  memset (&op, 0, sizeof (op));
+  memset(&op, 0, sizeof(op));
   op.cancel_with_status = GRPC_STATUS_CANCELLED;
-  grpc_call_next_op (exec_ctx, cur_elem, &op);
+  grpc_call_next_op(exec_ctx, cur_elem, &op);
 }

src/core/channel/channel_stack.h

@@ -61,15 +61,17 @@ typedef struct grpc_call_element grpc_call_element;
    4. a name, which is useful when debugging
 
    Members are laid out in approximate frequency of use order. */
-typedef struct
-{
+typedef struct {
   /* Called to eg. send/receive data on a call.
      See grpc_call_next_op on how to call the next element in the stack */
-  void (*start_transport_stream_op) (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op);
+  void (*start_transport_stream_op)(grpc_exec_ctx *exec_ctx,
+                                    grpc_call_element *elem,
+                                    grpc_transport_stream_op *op);
   /* Called to handle channel level operations - e.g. new calls, or transport
      closure.
      See grpc_channel_next_op on how to call the next element in the stack */
-  void (*start_transport_op) (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_transport_op * op);
+  void (*start_transport_op)(grpc_exec_ctx *exec_ctx,
+                             grpc_channel_element *elem, grpc_transport_op *op);
 
   /* sizeof(per call data) */
   size_t sizeof_call_data;
@@ -81,10 +83,12 @@ typedef struct
      on a client; if it is non-NULL, then it points to memory owned by the
      transport and is on the server. Most filters want to ignore this
      argument. */
-  void (*init_call_elem) (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op);
+  void (*init_call_elem)(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
+                         const void *server_transport_data,
+                         grpc_transport_stream_op *initial_op);
   /* Destroy per call data.
      The filter does not need to do any chaining */
-  void (*destroy_call_elem) (grpc_exec_ctx * exec_ctx, grpc_call_element * elem);
+  void (*destroy_call_elem)(grpc_exec_ctx *exec_ctx, grpc_call_element *elem);
 
   /* sizeof(per channel data) */
   size_t sizeof_channel_data;
@@ -94,13 +98,17 @@ typedef struct
      is_first, is_last designate this elements position in the stack, and are
      useful for asserting correct configuration by upper layer code.
      The filter does not need to do any chaining */
-  void (*init_channel_elem) (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * metadata_context, int is_first, int is_last);
+  void (*init_channel_elem)(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
+                            grpc_channel *master, const grpc_channel_args *args,
+                            grpc_mdctx *metadata_context, int is_first,
+                            int is_last);
   /* Destroy per channel data.
      The filter does not need to do any chaining */
-  void (*destroy_channel_elem) (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem);
+  void (*destroy_channel_elem)(grpc_exec_ctx *exec_ctx,
+                               grpc_channel_element *elem);
 
   /* Implement grpc_call_get_peer() */
-  char *(*get_peer) (grpc_exec_ctx * exec_ctx, grpc_call_element * elem);
+  char *(*get_peer)(grpc_exec_ctx *exec_ctx, grpc_call_element *elem);
 
   /* The name of this filter */
   const char *name;
@@ -108,8 +116,7 @@ typedef struct
 
 /* A channel_element tracks its filter and the filter requested memory within
    a channel allocation */
-struct grpc_channel_element
-{
+struct grpc_channel_element {
   const grpc_channel_filter *filter;
   void *channel_data;
 };
@@ -117,8 +124,7 @@ struct grpc_channel_element
 /* A call_element tracks its filter, the filter requested memory within
    a channel allocation, and the filter requested memory within a call
    allocation */
-struct grpc_call_element
-{
+struct grpc_call_element {
   const grpc_channel_filter *filter;
   void *channel_data;
   void *call_data;
@@ -126,8 +132,7 @@ struct grpc_call_element
 
 /* A channel stack tracks a set of related filters for one channel, and
    guarantees they live within a single malloc() allocation */
-typedef struct
-{
+typedef struct {
   size_t count;
   /* Memory required for a call stack (computed at channel stack
      initialization) */
@@ -136,48 +141,63 @@ 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, size_t i);
+grpc_channel_element *grpc_channel_stack_element(grpc_channel_stack *stack,
+                                                 size_t i);
 /* Get the last channel element in a channel stack */
-grpc_channel_element *grpc_channel_stack_last_element (grpc_channel_stack * stack);
+grpc_channel_element *grpc_channel_stack_last_element(
+    grpc_channel_stack *stack);
 /* Get a call stack element given a call stack and an index */
-grpc_call_element *grpc_call_stack_element (grpc_call_stack * stack, size_t i);
+grpc_call_element *grpc_call_stack_element(grpc_call_stack *stack, size_t i);
 
 /* Determine memory required for a channel stack containing a set of filters */
-size_t grpc_channel_stack_size (const grpc_channel_filter ** filters, size_t filter_count);
+size_t grpc_channel_stack_size(const grpc_channel_filter **filters,
+                               size_t filter_count);
 /* Initialize a channel stack given some filters */
-void grpc_channel_stack_init (grpc_exec_ctx * exec_ctx, const grpc_channel_filter ** filters, size_t filter_count, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * metadata_context, grpc_channel_stack * stack);
+void grpc_channel_stack_init(grpc_exec_ctx *exec_ctx,
+                             const grpc_channel_filter **filters,
+                             size_t filter_count, grpc_channel *master,
+                             const grpc_channel_args *args,
+                             grpc_mdctx *metadata_context,
+                             grpc_channel_stack *stack);
 /* Destroy a channel stack */
-void grpc_channel_stack_destroy (grpc_exec_ctx * exec_ctx, grpc_channel_stack * stack);
+void grpc_channel_stack_destroy(grpc_exec_ctx *exec_ctx,
+                                grpc_channel_stack *stack);
 
 /* Initialize a call stack given a channel stack. transport_server_data is
    expected to be NULL on a client, or an opaque transport owned pointer on the
    server. */
-void grpc_call_stack_init (grpc_exec_ctx * exec_ctx, grpc_channel_stack * channel_stack, const void *transport_server_data, grpc_transport_stream_op * initial_op, grpc_call_stack * call_stack);
+void grpc_call_stack_init(grpc_exec_ctx *exec_ctx,
+                          grpc_channel_stack *channel_stack,
+                          const void *transport_server_data,
+                          grpc_transport_stream_op *initial_op,
+                          grpc_call_stack *call_stack);
 /* Destroy a call stack */
-void grpc_call_stack_destroy (grpc_exec_ctx * exec_ctx, grpc_call_stack * stack);
+void grpc_call_stack_destroy(grpc_exec_ctx *exec_ctx, grpc_call_stack *stack);
 
 /* Call the next operation in a call stack */
-void grpc_call_next_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op);
+void grpc_call_next_op(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
+                       grpc_transport_stream_op *op);
 /* Call the next operation (depending on call directionality) in a channel
    stack */
-void grpc_channel_next_op (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_transport_op * op);
+void grpc_channel_next_op(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
+                          grpc_transport_op *op);
 /* Pass through a request to get_peer to the next child element */
-char *grpc_call_next_get_peer (grpc_exec_ctx * exec_ctx, grpc_call_element * elem);
+char *grpc_call_next_get_peer(grpc_exec_ctx *exec_ctx, grpc_call_element *elem);
 
 /* Given the top element of a channel stack, get the channel stack itself */
-grpc_channel_stack *grpc_channel_stack_from_top_element (grpc_channel_element * elem);
+grpc_channel_stack *grpc_channel_stack_from_top_element(
+    grpc_channel_element *elem);
 /* Given the top element of a call stack, get the call stack itself */
-grpc_call_stack *grpc_call_stack_from_top_element (grpc_call_element * elem);
+grpc_call_stack *grpc_call_stack_from_top_element(grpc_call_element *elem);
 
-void grpc_call_log_op (char *file, int line, gpr_log_severity severity, grpc_call_element * elem, grpc_transport_stream_op * op);
+void grpc_call_log_op(char *file, int line, gpr_log_severity severity,
+                      grpc_call_element *elem, grpc_transport_stream_op *op);
 
-void grpc_call_element_send_cancel (grpc_exec_ctx * exec_ctx, grpc_call_element * cur_elem);
+void grpc_call_element_send_cancel(grpc_exec_ctx *exec_ctx,
+                                   grpc_call_element *cur_elem);
 
 extern int grpc_trace_channel;
 

src/core/channel/client_channel.c

@@ -51,8 +51,7 @@
 
 typedef struct call_data call_data;
 
-typedef struct
-{
+typedef struct {
   /** metadata context for this channel */
   grpc_mdctx *mdctx;
   /** resolver for this channel */
@@ -90,16 +89,14 @@ typedef struct
     to watch for state changes from the lb_policy. When a state change is seen,
    we
     update the channel, and create a new watcher */
-typedef struct
-{
+typedef struct {
   channel_data *chand;
   grpc_closure on_changed;
   grpc_connectivity_state state;
   grpc_lb_policy *lb_policy;
 } lb_policy_connectivity_watcher;
 
-typedef enum
-{
+typedef enum {
   CALL_CREATED,
   CALL_WAITING_FOR_SEND,
   CALL_WAITING_FOR_CONFIG,
@@ -109,8 +106,7 @@ typedef enum
   CALL_CANCELLED
 } call_state;
 
-struct call_data
-{
+struct call_data {
   /* owning element */
   grpc_call_element *elem;
 
@@ -127,406 +123,361 @@ struct call_data
   grpc_linked_mdelem details;
 };
 
-static grpc_closure *
-merge_into_waiting_op (grpc_call_element * elem, grpc_transport_stream_op * new_op)
-  GRPC_MUST_USE_RESULT;
+static grpc_closure *merge_into_waiting_op(grpc_call_element *elem,
+                                           grpc_transport_stream_op *new_op)
+    GRPC_MUST_USE_RESULT;
 
-     static void handle_op_after_cancellation (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
-{
+static void handle_op_after_cancellation(grpc_exec_ctx *exec_ctx,
+                                         grpc_call_element *elem,
+                                         grpc_transport_stream_op *op) {
   call_data *calld = elem->call_data;
   channel_data *chand = elem->channel_data;
-  if (op->send_ops)
-    {
-      grpc_stream_ops_unref_owned_objects (op->send_ops->ops, op->send_ops->nops);
-      op->on_done_send->cb (exec_ctx, op->on_done_send->cb_arg, 0);
-    }
-  if (op->recv_ops)
-    {
-      char status[GPR_LTOA_MIN_BUFSIZE];
-      grpc_metadata_batch mdb;
-      gpr_ltoa (GRPC_STATUS_CANCELLED, status);
-      calld->status.md = grpc_mdelem_from_strings (chand->mdctx, "grpc-status", status);
-      calld->details.md = grpc_mdelem_from_strings (chand->mdctx, "grpc-message", "Cancelled");
-      calld->status.prev = calld->details.next = NULL;
-      calld->status.next = &calld->details;
-      calld->details.prev = &calld->status;
-      mdb.list.head = &calld->status;
-      mdb.list.tail = &calld->details;
-      mdb.garbage.head = mdb.garbage.tail = NULL;
-      mdb.deadline = gpr_inf_future (GPR_CLOCK_REALTIME);
-      grpc_sopb_add_metadata (op->recv_ops, mdb);
-      *op->recv_state = GRPC_STREAM_CLOSED;
-      op->on_done_recv->cb (exec_ctx, op->on_done_recv->cb_arg, 1);
-    }
-  if (op->on_consumed)
-    {
-      op->on_consumed->cb (exec_ctx, op->on_consumed->cb_arg, 0);
-    }
+  if (op->send_ops) {
+    grpc_stream_ops_unref_owned_objects(op->send_ops->ops, op->send_ops->nops);
+    op->on_done_send->cb(exec_ctx, op->on_done_send->cb_arg, 0);
+  }
+  if (op->recv_ops) {
+    char status[GPR_LTOA_MIN_BUFSIZE];
+    grpc_metadata_batch mdb;
+    gpr_ltoa(GRPC_STATUS_CANCELLED, status);
+    calld->status.md =
+        grpc_mdelem_from_strings(chand->mdctx, "grpc-status", status);
+    calld->details.md =
+        grpc_mdelem_from_strings(chand->mdctx, "grpc-message", "Cancelled");
+    calld->status.prev = calld->details.next = NULL;
+    calld->status.next = &calld->details;
+    calld->details.prev = &calld->status;
+    mdb.list.head = &calld->status;
+    mdb.list.tail = &calld->details;
+    mdb.garbage.head = mdb.garbage.tail = NULL;
+    mdb.deadline = gpr_inf_future(GPR_CLOCK_REALTIME);
+    grpc_sopb_add_metadata(op->recv_ops, mdb);
+    *op->recv_state = GRPC_STREAM_CLOSED;
+    op->on_done_recv->cb(exec_ctx, op->on_done_recv->cb_arg, 1);
+  }
+  if (op->on_consumed) {
+    op->on_consumed->cb(exec_ctx, op->on_consumed->cb_arg, 0);
+  }
 }
 
-typedef struct
-{
+typedef struct {
   grpc_closure closure;
   grpc_call_element *elem;
 } waiting_call;
 
-static void perform_transport_stream_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op, int continuation);
+static void perform_transport_stream_op(grpc_exec_ctx *exec_ctx,
+                                        grpc_call_element *elem,
+                                        grpc_transport_stream_op *op,
+                                        int continuation);
 
-static void
-continue_with_pick (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_success)
-{
+static void continue_with_pick(grpc_exec_ctx *exec_ctx, void *arg,
+                               int iomgr_success) {
   waiting_call *wc = arg;
   call_data *calld = wc->elem->call_data;
-  perform_transport_stream_op (exec_ctx, wc->elem, &calld->waiting_op, 1);
-  gpr_free (wc);
+  perform_transport_stream_op(exec_ctx, wc->elem, &calld->waiting_op, 1);
+  gpr_free(wc);
 }
 
-static void
-add_to_lb_policy_wait_queue_locked_state_config (grpc_call_element * elem)
-{
+static void add_to_lb_policy_wait_queue_locked_state_config(
+    grpc_call_element *elem) {
   channel_data *chand = elem->channel_data;
-  waiting_call *wc = gpr_malloc (sizeof (*wc));
-  grpc_closure_init (&wc->closure, continue_with_pick, wc);
+  waiting_call *wc = gpr_malloc(sizeof(*wc));
+  grpc_closure_init(&wc->closure, continue_with_pick, wc);
   wc->elem = elem;
-  grpc_closure_list_add (&chand->waiting_for_config_closures, &wc->closure, 1);
+  grpc_closure_list_add(&chand->waiting_for_config_closures, &wc->closure, 1);
 }
 
-static int
-is_empty (void *p, int len)
-{
+static int is_empty(void *p, int len) {
   char *ptr = p;
   int i;
-  for (i = 0; i < len; i++)
-    {
-      if (ptr[i] != 0)
-	return 0;
-    }
+  for (i = 0; i < len; i++) {
+    if (ptr[i] != 0) return 0;
+  }
   return 1;
 }
 
-static void
-started_call (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_success)
-{
+static void started_call(grpc_exec_ctx *exec_ctx, void *arg,
+                         int iomgr_success) {
   call_data *calld = arg;
   grpc_transport_stream_op op;
   int have_waiting;
 
-  gpr_mu_lock (&calld->mu_state);
-  if (calld->state == CALL_CANCELLED && calld->subchannel_call != NULL)
-    {
-      memset (&op, 0, sizeof (op));
-      op.cancel_with_status = GRPC_STATUS_CANCELLED;
-      gpr_mu_unlock (&calld->mu_state);
-      grpc_subchannel_call_process_op (exec_ctx, calld->subchannel_call, &op);
-    }
-  else if (calld->state == CALL_WAITING_FOR_CALL)
-    {
-      have_waiting = !is_empty (&calld->waiting_op, sizeof (calld->waiting_op));
-      if (calld->subchannel_call != NULL)
-	{
-	  calld->state = CALL_ACTIVE;
-	  gpr_mu_unlock (&calld->mu_state);
-	  if (have_waiting)
-	    {
-	      grpc_subchannel_call_process_op (exec_ctx, calld->subchannel_call, &calld->waiting_op);
-	    }
-	}
-      else
-	{
-	  calld->state = CALL_CANCELLED;
-	  gpr_mu_unlock (&calld->mu_state);
-	  if (have_waiting)
-	    {
-	      handle_op_after_cancellation (exec_ctx, calld->elem, &calld->waiting_op);
-	    }
-	}
-    }
-  else
-    {
-      GPR_ASSERT (calld->state == CALL_CANCELLED);
-      gpr_mu_unlock (&calld->mu_state);
-    }
+  gpr_mu_lock(&calld->mu_state);
+  if (calld->state == CALL_CANCELLED && calld->subchannel_call != NULL) {
+    memset(&op, 0, sizeof(op));
+    op.cancel_with_status = GRPC_STATUS_CANCELLED;
+    gpr_mu_unlock(&calld->mu_state);
+    grpc_subchannel_call_process_op(exec_ctx, calld->subchannel_call, &op);
+  } else if (calld->state == CALL_WAITING_FOR_CALL) {
+    have_waiting = !is_empty(&calld->waiting_op, sizeof(calld->waiting_op));
+    if (calld->subchannel_call != NULL) {
+      calld->state = CALL_ACTIVE;
+      gpr_mu_unlock(&calld->mu_state);
+      if (have_waiting) {
+        grpc_subchannel_call_process_op(exec_ctx, calld->subchannel_call,
+                                        &calld->waiting_op);
+      }
+    } else {
+      calld->state = CALL_CANCELLED;
+      gpr_mu_unlock(&calld->mu_state);
+      if (have_waiting) {
+        handle_op_after_cancellation(exec_ctx, calld->elem, &calld->waiting_op);
+      }
+    }
+  } else {
+    GPR_ASSERT(calld->state == CALL_CANCELLED);
+    gpr_mu_unlock(&calld->mu_state);
+  }
 }
 
-static void
-picked_target (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_success)
-{
+static void picked_target(grpc_exec_ctx *exec_ctx, void *arg,
+                          int iomgr_success) {
   call_data *calld = arg;
   grpc_pollset *pollset;
 
-  if (calld->picked_channel == NULL)
-    {
-      /* treat this like a cancellation */
-      calld->waiting_op.cancel_with_status = GRPC_STATUS_UNAVAILABLE;
-      perform_transport_stream_op (exec_ctx, calld->elem, &calld->waiting_op, 1);
-    }
-  else
-    {
-      gpr_mu_lock (&calld->mu_state);
-      if (calld->state == CALL_CANCELLED)
-	{
-	  gpr_mu_unlock (&calld->mu_state);
-	  handle_op_after_cancellation (exec_ctx, calld->elem, &calld->waiting_op);
-	}
-      else
-	{
-	  GPR_ASSERT (calld->state == CALL_WAITING_FOR_PICK);
-	  calld->state = CALL_WAITING_FOR_CALL;
-	  pollset = calld->waiting_op.bind_pollset;
-	  gpr_mu_unlock (&calld->mu_state);
-	  grpc_closure_init (&calld->async_setup_task, started_call, calld);
-	  grpc_subchannel_create_call (exec_ctx, calld->picked_channel, pollset, &calld->subchannel_call, &calld->async_setup_task);
-	}
-    }
+  if (calld->picked_channel == NULL) {
+    /* treat this like a cancellation */
+    calld->waiting_op.cancel_with_status = GRPC_STATUS_UNAVAILABLE;
+    perform_transport_stream_op(exec_ctx, calld->elem, &calld->waiting_op, 1);
+  } else {
+    gpr_mu_lock(&calld->mu_state);
+    if (calld->state == CALL_CANCELLED) {
+      gpr_mu_unlock(&calld->mu_state);
+      handle_op_after_cancellation(exec_ctx, calld->elem, &calld->waiting_op);
+    } else {
+      GPR_ASSERT(calld->state == CALL_WAITING_FOR_PICK);
+      calld->state = CALL_WAITING_FOR_CALL;
+      pollset = calld->waiting_op.bind_pollset;
+      gpr_mu_unlock(&calld->mu_state);
+      grpc_closure_init(&calld->async_setup_task, started_call, calld);
+      grpc_subchannel_create_call(exec_ctx, calld->picked_channel, pollset,
+                                  &calld->subchannel_call,
+                                  &calld->async_setup_task);
+    }
+  }
 }
 
-static grpc_closure *
-merge_into_waiting_op (grpc_call_element * elem, grpc_transport_stream_op * new_op)
-{
+static grpc_closure *merge_into_waiting_op(grpc_call_element *elem,
+                                           grpc_transport_stream_op *new_op) {
   call_data *calld = elem->call_data;
   grpc_closure *consumed_op = NULL;
   grpc_transport_stream_op *waiting_op = &calld->waiting_op;
-  GPR_ASSERT ((waiting_op->send_ops != NULL) + (new_op->send_ops != NULL) <= 1);
-  GPR_ASSERT ((waiting_op->recv_ops != NULL) + (new_op->recv_ops != NULL) <= 1);
-  if (new_op->send_ops != NULL)
-    {
-      waiting_op->send_ops = new_op->send_ops;
-      waiting_op->is_last_send = new_op->is_last_send;
-      waiting_op->on_done_send = new_op->on_done_send;
-    }
-  if (new_op->recv_ops != NULL)
-    {
-      waiting_op->recv_ops = new_op->recv_ops;
-      waiting_op->recv_state = new_op->recv_state;
-      waiting_op->on_done_recv = new_op->on_done_recv;
-    }
-  if (new_op->on_consumed != NULL)
-    {
-      if (waiting_op->on_consumed != NULL)
-	{
-	  consumed_op = waiting_op->on_consumed;
-	}
-      waiting_op->on_consumed = new_op->on_consumed;
-    }
-  if (new_op->cancel_with_status != GRPC_STATUS_OK)
-    {
-      waiting_op->cancel_with_status = new_op->cancel_with_status;
-    }
+  GPR_ASSERT((waiting_op->send_ops != NULL) + (new_op->send_ops != NULL) <= 1);
+  GPR_ASSERT((waiting_op->recv_ops != NULL) + (new_op->recv_ops != NULL) <= 1);
+  if (new_op->send_ops != NULL) {
+    waiting_op->send_ops = new_op->send_ops;
+    waiting_op->is_last_send = new_op->is_last_send;
+    waiting_op->on_done_send = new_op->on_done_send;
+  }
+  if (new_op->recv_ops != NULL) {
+    waiting_op->recv_ops = new_op->recv_ops;
+    waiting_op->recv_state = new_op->recv_state;
+    waiting_op->on_done_recv = new_op->on_done_recv;
+  }
+  if (new_op->on_consumed != NULL) {
+    if (waiting_op->on_consumed != NULL) {
+      consumed_op = waiting_op->on_consumed;
+    }
+    waiting_op->on_consumed = new_op->on_consumed;
+  }
+  if (new_op->cancel_with_status != GRPC_STATUS_OK) {
+    waiting_op->cancel_with_status = new_op->cancel_with_status;
+  }
   return consumed_op;
 }
 
-static char *
-cc_get_peer (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
-{
+static char *cc_get_peer(grpc_exec_ctx *exec_ctx, grpc_call_element *elem) {
   call_data *calld = elem->call_data;
   channel_data *chand = elem->channel_data;
   grpc_subchannel_call *subchannel_call;
   char *result;
 
-  gpr_mu_lock (&calld->mu_state);
-  if (calld->state == CALL_ACTIVE)
-    {
-      subchannel_call = calld->subchannel_call;
-      GRPC_SUBCHANNEL_CALL_REF (subchannel_call, "get_peer");
-      gpr_mu_unlock (&calld->mu_state);
-      result = grpc_subchannel_call_get_peer (exec_ctx, subchannel_call);
-      GRPC_SUBCHANNEL_CALL_UNREF (exec_ctx, subchannel_call, "get_peer");
-      return result;
-    }
-  else
-    {
-      gpr_mu_unlock (&calld->mu_state);
-      return grpc_channel_get_target (chand->master);
-    }
+  gpr_mu_lock(&calld->mu_state);
+  if (calld->state == CALL_ACTIVE) {
+    subchannel_call = calld->subchannel_call;
+    GRPC_SUBCHANNEL_CALL_REF(subchannel_call, "get_peer");
+    gpr_mu_unlock(&calld->mu_state);
+    result = grpc_subchannel_call_get_peer(exec_ctx, subchannel_call);
+    GRPC_SUBCHANNEL_CALL_UNREF(exec_ctx, subchannel_call, "get_peer");
+    return result;
+  } else {
+    gpr_mu_unlock(&calld->mu_state);
+    return grpc_channel_get_target(chand->master);
+  }
 }
 
-static void
-perform_transport_stream_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op, int continuation)
-{
+static void perform_transport_stream_op(grpc_exec_ctx *exec_ctx,
+                                        grpc_call_element *elem,
+                                        grpc_transport_stream_op *op,
+                                        int continuation) {
   call_data *calld = elem->call_data;
   channel_data *chand = elem->channel_data;
   grpc_subchannel_call *subchannel_call;
   grpc_lb_policy *lb_policy;
   grpc_transport_stream_op op2;
-  GPR_ASSERT (elem->filter == &grpc_client_channel_filter);
-  GRPC_CALL_LOG_OP (GPR_INFO, elem, op);
+  GPR_ASSERT(elem->filter == &grpc_client_channel_filter);
+  GRPC_CALL_LOG_OP(GPR_INFO, elem, op);
 
-  gpr_mu_lock (&calld->mu_state);
-  switch (calld->state)
-    {
+  gpr_mu_lock(&calld->mu_state);
+  switch (calld->state) {
     case CALL_ACTIVE:
-      GPR_ASSERT (!continuation);
+      GPR_ASSERT(!continuation);
       subchannel_call = calld->subchannel_call;
-      gpr_mu_unlock (&calld->mu_state);
-      grpc_subchannel_call_process_op (exec_ctx, subchannel_call, op);
+      gpr_mu_unlock(&calld->mu_state);
+      grpc_subchannel_call_process_op(exec_ctx, subchannel_call, op);
       break;
     case CALL_CANCELLED:
-      gpr_mu_unlock (&calld->mu_state);
-      handle_op_after_cancellation (exec_ctx, elem, op);
+      gpr_mu_unlock(&calld->mu_state);
+      handle_op_after_cancellation(exec_ctx, elem, op);
       break;
     case CALL_WAITING_FOR_SEND:
-      GPR_ASSERT (!continuation);
-      grpc_exec_ctx_enqueue (exec_ctx, merge_into_waiting_op (elem, op), 1);
-      if (!calld->waiting_op.send_ops && calld->waiting_op.cancel_with_status == GRPC_STATUS_OK)
-	{
-	  gpr_mu_unlock (&calld->mu_state);
-	  break;
-	}
+      GPR_ASSERT(!continuation);
+      grpc_exec_ctx_enqueue(exec_ctx, merge_into_waiting_op(elem, op), 1);
+      if (!calld->waiting_op.send_ops &&
+          calld->waiting_op.cancel_with_status == GRPC_STATUS_OK) {
+        gpr_mu_unlock(&calld->mu_state);
+        break;
+      }
       *op = calld->waiting_op;
-      memset (&calld->waiting_op, 0, sizeof (calld->waiting_op));
+      memset(&calld->waiting_op, 0, sizeof(calld->waiting_op));
       continuation = 1;
-      /* fall through */
+    /* fall through */
     case CALL_WAITING_FOR_CONFIG:
     case CALL_WAITING_FOR_PICK:
     case CALL_WAITING_FOR_CALL:
-      if (!continuation)
-	{
-	  if (op->cancel_with_status != GRPC_STATUS_OK)
-	    {
-	      calld->state = CALL_CANCELLED;
-	      op2 = calld->waiting_op;
-	      memset (&calld->waiting_op, 0, sizeof (calld->waiting_op));
-	      if (op->on_consumed)
-		{
-		  calld->waiting_op.on_consumed = op->on_consumed;
-		  op->on_consumed = NULL;
-		}
-	      else if (op2.on_consumed)
-		{
-		  calld->waiting_op.on_consumed = op2.on_consumed;
-		  op2.on_consumed = NULL;
-		}
-	      gpr_mu_unlock (&calld->mu_state);
-	      handle_op_after_cancellation (exec_ctx, elem, op);
-	      handle_op_after_cancellation (exec_ctx, elem, &op2);
-	    }
-	  else
-	    {
-	      grpc_exec_ctx_enqueue (exec_ctx, merge_into_waiting_op (elem, op), 1);
-	      gpr_mu_unlock (&calld->mu_state);
-	    }
-	  break;
-	}
-      /* fall through */
+      if (!continuation) {
+        if (op->cancel_with_status != GRPC_STATUS_OK) {
+          calld->state = CALL_CANCELLED;
+          op2 = calld->waiting_op;
+          memset(&calld->waiting_op, 0, sizeof(calld->waiting_op));
+          if (op->on_consumed) {
+            calld->waiting_op.on_consumed = op->on_consumed;
+            op->on_consumed = NULL;
+          } else if (op2.on_consumed) {
+            calld->waiting_op.on_consumed = op2.on_consumed;
+            op2.on_consumed = NULL;
+          }
+          gpr_mu_unlock(&calld->mu_state);
+          handle_op_after_cancellation(exec_ctx, elem, op);
+          handle_op_after_cancellation(exec_ctx, elem, &op2);
+        } else {
+          grpc_exec_ctx_enqueue(exec_ctx, merge_into_waiting_op(elem, op), 1);
+          gpr_mu_unlock(&calld->mu_state);
+        }
+        break;
+      }
+    /* fall through */
     case CALL_CREATED:
-      if (op->cancel_with_status != GRPC_STATUS_OK)
-	{
-	  calld->state = CALL_CANCELLED;
-	  gpr_mu_unlock (&calld->mu_state);
-	  handle_op_after_cancellation (exec_ctx, elem, op);
-	}
-      else
-	{
-	  calld->waiting_op = *op;
-
-	  if (op->send_ops == NULL)
-	    {
-	      /* need to have some send ops before we can select the
-	         lb target */
-	      calld->state = CALL_WAITING_FOR_SEND;
-	      gpr_mu_unlock (&calld->mu_state);
-	    }
-	  else
-	    {
-	      gpr_mu_lock (&chand->mu_config);
-	      lb_policy = chand->lb_policy;
-	      if (lb_policy)
-		{
-		  grpc_transport_stream_op *op = &calld->waiting_op;
-		  grpc_pollset *bind_pollset = op->bind_pollset;
-		  grpc_metadata_batch *initial_metadata = &op->send_ops->ops[0].data.metadata;
-		  GRPC_LB_POLICY_REF (lb_policy, "pick");
-		  gpr_mu_unlock (&chand->mu_config);
-		  calld->state = CALL_WAITING_FOR_PICK;
-
-		  GPR_ASSERT (op->bind_pollset);
-		  GPR_ASSERT (op->send_ops);
-		  GPR_ASSERT (op->send_ops->nops >= 1);
-		  GPR_ASSERT (op->send_ops->ops[0].type == GRPC_OP_METADATA);
-		  gpr_mu_unlock (&calld->mu_state);
-
-		  grpc_closure_init (&calld->async_setup_task, picked_target, calld);
-		  grpc_lb_policy_pick (exec_ctx, lb_policy, bind_pollset, initial_metadata, &calld->picked_channel, &calld->async_setup_task);
-
-		  GRPC_LB_POLICY_UNREF (exec_ctx, lb_policy, "pick");
-		}
-	      else if (chand->resolver != NULL)
-		{
-		  calld->state = CALL_WAITING_FOR_CONFIG;
-		  add_to_lb_policy_wait_queue_locked_state_config (elem);
-		  if (!chand->started_resolving && chand->resolver != NULL)
-		    {
-		      GRPC_CHANNEL_INTERNAL_REF (chand->master, "resolver");
-		      chand->started_resolving = 1;
-		      grpc_resolver_next (exec_ctx, chand->resolver, &chand->incoming_configuration, &chand->on_config_changed);
-		    }
-		  gpr_mu_unlock (&chand->mu_config);
-		  gpr_mu_unlock (&calld->mu_state);
-		}
-	      else
-		{
-		  calld->state = CALL_CANCELLED;
-		  gpr_mu_unlock (&chand->mu_config);
-		  gpr_mu_unlock (&calld->mu_state);
-		  handle_op_after_cancellation (exec_ctx, elem, op);
-		}
-	    }
-	}
+      if (op->cancel_with_status != GRPC_STATUS_OK) {
+        calld->state = CALL_CANCELLED;
+        gpr_mu_unlock(&calld->mu_state);
+        handle_op_after_cancellation(exec_ctx, elem, op);
+      } else {
+        calld->waiting_op = *op;
+
+        if (op->send_ops == NULL) {
+          /* need to have some send ops before we can select the
+             lb target */
+          calld->state = CALL_WAITING_FOR_SEND;
+          gpr_mu_unlock(&calld->mu_state);
+        } else {
+          gpr_mu_lock(&chand->mu_config);
+          lb_policy = chand->lb_policy;
+          if (lb_policy) {
+            grpc_transport_stream_op *op = &calld->waiting_op;
+            grpc_pollset *bind_pollset = op->bind_pollset;
+            grpc_metadata_batch *initial_metadata =
+                &op->send_ops->ops[0].data.metadata;
+            GRPC_LB_POLICY_REF(lb_policy, "pick");
+            gpr_mu_unlock(&chand->mu_config);
+            calld->state = CALL_WAITING_FOR_PICK;
+
+            GPR_ASSERT(op->bind_pollset);
+            GPR_ASSERT(op->send_ops);
+            GPR_ASSERT(op->send_ops->nops >= 1);
+            GPR_ASSERT(op->send_ops->ops[0].type == GRPC_OP_METADATA);
+            gpr_mu_unlock(&calld->mu_state);
+
+            grpc_closure_init(&calld->async_setup_task, picked_target, calld);
+            grpc_lb_policy_pick(exec_ctx, lb_policy, bind_pollset,
+                                initial_metadata, &calld->picked_channel,
+                                &calld->async_setup_task);
+
+            GRPC_LB_POLICY_UNREF(exec_ctx, lb_policy, "pick");
+          } else if (chand->resolver != NULL) {
+            calld->state = CALL_WAITING_FOR_CONFIG;
+            add_to_lb_policy_wait_queue_locked_state_config(elem);
+            if (!chand->started_resolving && chand->resolver != NULL) {
+              GRPC_CHANNEL_INTERNAL_REF(chand->master, "resolver");
+              chand->started_resolving = 1;
+              grpc_resolver_next(exec_ctx, chand->resolver,
+                                 &chand->incoming_configuration,
+                                 &chand->on_config_changed);
+            }
+            gpr_mu_unlock(&chand->mu_config);
+            gpr_mu_unlock(&calld->mu_state);
+          } else {
+            calld->state = CALL_CANCELLED;
+            gpr_mu_unlock(&chand->mu_config);
+            gpr_mu_unlock(&calld->mu_state);
+            handle_op_after_cancellation(exec_ctx, elem, op);
+          }
+        }
+      }
       break;
-    }
+  }
 }
 
-static void
-cc_start_transport_stream_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
-{
-  perform_transport_stream_op (exec_ctx, elem, op, 0);
+static void cc_start_transport_stream_op(grpc_exec_ctx *exec_ctx,
+                                         grpc_call_element *elem,
+                                         grpc_transport_stream_op *op) {
+  perform_transport_stream_op(exec_ctx, elem, op, 0);
 }
 
-static void watch_lb_policy (grpc_exec_ctx * exec_ctx, channel_data * chand, grpc_lb_policy * lb_policy, grpc_connectivity_state current_state);
+static void watch_lb_policy(grpc_exec_ctx *exec_ctx, channel_data *chand,
+                            grpc_lb_policy *lb_policy,
+                            grpc_connectivity_state current_state);
 
-static void
-on_lb_policy_state_changed_locked (grpc_exec_ctx * exec_ctx, lb_policy_connectivity_watcher * w)
-{
+static void on_lb_policy_state_changed_locked(
+    grpc_exec_ctx *exec_ctx, lb_policy_connectivity_watcher *w) {
   /* check if the notification is for a stale policy */
-  if (w->lb_policy != w->chand->lb_policy)
-    return;
+  if (w->lb_policy != w->chand->lb_policy) return;
 
-  grpc_connectivity_state_set (exec_ctx, &w->chand->state_tracker, w->state, "lb_changed");
-  if (w->state != GRPC_CHANNEL_FATAL_FAILURE)
-    {
-      watch_lb_policy (exec_ctx, w->chand, w->lb_policy, w->state);
-    }
+  grpc_connectivity_state_set(exec_ctx, &w->chand->state_tracker, w->state,
+                              "lb_changed");
+  if (w->state != GRPC_CHANNEL_FATAL_FAILURE) {
+    watch_lb_policy(exec_ctx, w->chand, w->lb_policy, w->state);
+  }
 }
 
-static void
-on_lb_policy_state_changed (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_success)
-{
+static void on_lb_policy_state_changed(grpc_exec_ctx *exec_ctx, void *arg,
+                                       int iomgr_success) {
   lb_policy_connectivity_watcher *w = arg;
 
-  gpr_mu_lock (&w->chand->mu_config);
-  on_lb_policy_state_changed_locked (exec_ctx, w);
-  gpr_mu_unlock (&w->chand->mu_config);
+  gpr_mu_lock(&w->chand->mu_config);
+  on_lb_policy_state_changed_locked(exec_ctx, w);
+  gpr_mu_unlock(&w->chand->mu_config);
 
-  GRPC_CHANNEL_INTERNAL_UNREF (exec_ctx, w->chand->master, "watch_lb_policy");
-  gpr_free (w);
+  GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, w->chand->master, "watch_lb_policy");
+  gpr_free(w);
 }
 
-static void
-watch_lb_policy (grpc_exec_ctx * exec_ctx, channel_data * chand, grpc_lb_policy * lb_policy, grpc_connectivity_state current_state)
-{
-  lb_policy_connectivity_watcher *w = gpr_malloc (sizeof (*w));
-  GRPC_CHANNEL_INTERNAL_REF (chand->master, "watch_lb_policy");
+static void watch_lb_policy(grpc_exec_ctx *exec_ctx, channel_data *chand,
+                            grpc_lb_policy *lb_policy,
+                            grpc_connectivity_state current_state) {
+  lb_policy_connectivity_watcher *w = gpr_malloc(sizeof(*w));
+  GRPC_CHANNEL_INTERNAL_REF(chand->master, "watch_lb_policy");
 
   w->chand = chand;
-  grpc_closure_init (&w->on_changed, on_lb_policy_state_changed, w);
+  grpc_closure_init(&w->on_changed, on_lb_policy_state_changed, w);
   w->state = current_state;
   w->lb_policy = lb_policy;
-  grpc_lb_policy_notify_on_state_change (exec_ctx, lb_policy, &w->state, &w->on_changed);
+  grpc_lb_policy_notify_on_state_change(exec_ctx, lb_policy, &w->state,
+                                        &w->on_changed);
 }
 
-static void
-cc_on_config_changed (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_success)
-{
+static void cc_on_config_changed(grpc_exec_ctx *exec_ctx, void *arg,
+                                 int iomgr_success) {
   channel_data *chand = arg;
   grpc_lb_policy *lb_policy = NULL;
   grpc_lb_policy *old_lb_policy;
@@ -534,313 +485,295 @@ cc_on_config_changed (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_success)
   grpc_connectivity_state state = GRPC_CHANNEL_TRANSIENT_FAILURE;
   int exit_idle = 0;
 
-  if (chand->incoming_configuration != NULL)
-    {
-      lb_policy = grpc_client_config_get_lb_policy (chand->incoming_configuration);
-      if (lb_policy != NULL)
-	{
-	  GRPC_LB_POLICY_REF (lb_policy, "channel");
-	  GRPC_LB_POLICY_REF (lb_policy, "config_change");
-	  state = grpc_lb_policy_check_connectivity (exec_ctx, lb_policy);
-	}
-
-      grpc_client_config_unref (exec_ctx, chand->incoming_configuration);
+  if (chand->incoming_configuration != NULL) {
+    lb_policy = grpc_client_config_get_lb_policy(chand->incoming_configuration);
+    if (lb_policy != NULL) {
+      GRPC_LB_POLICY_REF(lb_policy, "channel");
+      GRPC_LB_POLICY_REF(lb_policy, "config_change");
+      state = grpc_lb_policy_check_connectivity(exec_ctx, lb_policy);
     }
 
+    grpc_client_config_unref(exec_ctx, chand->incoming_configuration);
+  }
+
   chand->incoming_configuration = NULL;
 
-  gpr_mu_lock (&chand->mu_config);
+  gpr_mu_lock(&chand->mu_config);
   old_lb_policy = chand->lb_policy;
   chand->lb_policy = lb_policy;
-  if (lb_policy != NULL || chand->resolver == NULL /* disconnected */ )
-    {
-      grpc_exec_ctx_enqueue_list (exec_ctx, &chand->waiting_for_config_closures);
-    }
-  if (lb_policy != NULL && chand->exit_idle_when_lb_policy_arrives)
-    {
-      GRPC_LB_POLICY_REF (lb_policy, "exit_idle");
-      exit_idle = 1;
-      chand->exit_idle_when_lb_policy_arrives = 0;
-    }
-
-  if (iomgr_success && chand->resolver)
-    {
-      grpc_resolver *resolver = chand->resolver;
-      GRPC_RESOLVER_REF (resolver, "channel-next");
-      grpc_connectivity_state_set (exec_ctx, &chand->state_tracker, state, "new_lb+resolver");
-      if (lb_policy != NULL)
-	{
-	  watch_lb_policy (exec_ctx, chand, lb_policy, state);
-	}
-      gpr_mu_unlock (&chand->mu_config);
-      GRPC_CHANNEL_INTERNAL_REF (chand->master, "resolver");
-      grpc_resolver_next (exec_ctx, resolver, &chand->incoming_configuration, &chand->on_config_changed);
-      GRPC_RESOLVER_UNREF (exec_ctx, resolver, "channel-next");
-    }
-  else
-    {
-      old_resolver = chand->resolver;
-      chand->resolver = NULL;
-      grpc_connectivity_state_set (exec_ctx, &chand->state_tracker, GRPC_CHANNEL_FATAL_FAILURE, "resolver_gone");
-      gpr_mu_unlock (&chand->mu_config);
-      if (old_resolver != NULL)
-	{
-	  grpc_resolver_shutdown (exec_ctx, old_resolver);
-	  GRPC_RESOLVER_UNREF (exec_ctx, old_resolver, "channel");
-	}
-    }
-
-  if (exit_idle)
-    {
-      grpc_lb_policy_exit_idle (exec_ctx, lb_policy);
-      GRPC_LB_POLICY_UNREF (exec_ctx, lb_policy, "exit_idle");
-    }
-
-  if (old_lb_policy != NULL)
-    {
-      grpc_lb_policy_shutdown (exec_ctx, old_lb_policy);
-      GRPC_LB_POLICY_UNREF (exec_ctx, old_lb_policy, "channel");
-    }
-
-  if (lb_policy != NULL)
-    {
-      GRPC_LB_POLICY_UNREF (exec_ctx, lb_policy, "config_change");
-    }
-
-  GRPC_CHANNEL_INTERNAL_UNREF (exec_ctx, chand->master, "resolver");
+  if (lb_policy != NULL || chand->resolver == NULL /* disconnected */) {
+    grpc_exec_ctx_enqueue_list(exec_ctx, &chand->waiting_for_config_closures);
+  }
+  if (lb_policy != NULL && chand->exit_idle_when_lb_policy_arrives) {
+    GRPC_LB_POLICY_REF(lb_policy, "exit_idle");
+    exit_idle = 1;
+    chand->exit_idle_when_lb_policy_arrives = 0;
+  }
+
+  if (iomgr_success && chand->resolver) {
+    grpc_resolver *resolver = chand->resolver;
+    GRPC_RESOLVER_REF(resolver, "channel-next");
+    grpc_connectivity_state_set(exec_ctx, &chand->state_tracker, state,
+                                "new_lb+resolver");
+    if (lb_policy != NULL) {
+      watch_lb_policy(exec_ctx, chand, lb_policy, state);
+    }
+    gpr_mu_unlock(&chand->mu_config);
+    GRPC_CHANNEL_INTERNAL_REF(chand->master, "resolver");
+    grpc_resolver_next(exec_ctx, resolver, &chand->incoming_configuration,
+                       &chand->on_config_changed);
+    GRPC_RESOLVER_UNREF(exec_ctx, resolver, "channel-next");
+  } else {
+    old_resolver = chand->resolver;
+    chand->resolver = NULL;
+    grpc_connectivity_state_set(exec_ctx, &chand->state_tracker,
+                                GRPC_CHANNEL_FATAL_FAILURE, "resolver_gone");
+    gpr_mu_unlock(&chand->mu_config);
+    if (old_resolver != NULL) {
+      grpc_resolver_shutdown(exec_ctx, old_resolver);
+      GRPC_RESOLVER_UNREF(exec_ctx, old_resolver, "channel");
+    }
+  }
+
+  if (exit_idle) {
+    grpc_lb_policy_exit_idle(exec_ctx, lb_policy);
+    GRPC_LB_POLICY_UNREF(exec_ctx, lb_policy, "exit_idle");
+  }
+
+  if (old_lb_policy != NULL) {
+    grpc_lb_policy_shutdown(exec_ctx, old_lb_policy);
+    GRPC_LB_POLICY_UNREF(exec_ctx, old_lb_policy, "channel");
+  }
+
+  if (lb_policy != NULL) {
+    GRPC_LB_POLICY_UNREF(exec_ctx, lb_policy, "config_change");
+  }
+
+  GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, chand->master, "resolver");
 }
 
-static void
-cc_start_transport_op (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_transport_op * op)
-{
+static void cc_start_transport_op(grpc_exec_ctx *exec_ctx,
+                                  grpc_channel_element *elem,
+                                  grpc_transport_op *op) {
   grpc_lb_policy *lb_policy = NULL;
   channel_data *chand = elem->channel_data;
   grpc_resolver *destroy_resolver = NULL;
 
-  grpc_exec_ctx_enqueue (exec_ctx, op->on_consumed, 1);
-
-  GPR_ASSERT (op->set_accept_stream == NULL);
-  GPR_ASSERT (op->bind_pollset == NULL);
-
-  gpr_mu_lock (&chand->mu_config);
-  if (op->on_connectivity_state_change != NULL)
-    {
-      grpc_connectivity_state_notify_on_state_change (exec_ctx, &chand->state_tracker, op->connectivity_state, op->on_connectivity_state_change);
-      op->on_connectivity_state_change = NULL;
-      op->connectivity_state = NULL;
-    }
-
-  if (!is_empty (op, sizeof (*op)))
-    {
-      lb_policy = chand->lb_policy;
-      if (lb_policy)
-	{
-	  GRPC_LB_POLICY_REF (lb_policy, "broadcast");
-	}
-    }
-
-  if (op->disconnect && chand->resolver != NULL)
-    {
-      grpc_connectivity_state_set (exec_ctx, &chand->state_tracker, GRPC_CHANNEL_FATAL_FAILURE, "disconnect");
-      destroy_resolver = chand->resolver;
-      chand->resolver = NULL;
-      if (chand->lb_policy != NULL)
-	{
-	  grpc_lb_policy_shutdown (exec_ctx, chand->lb_policy);
-	  GRPC_LB_POLICY_UNREF (exec_ctx, chand->lb_policy, "channel");
-	  chand->lb_policy = NULL;
-	}
-    }
-  gpr_mu_unlock (&chand->mu_config);
-
-  if (destroy_resolver)
-    {
-      grpc_resolver_shutdown (exec_ctx, destroy_resolver);
-      GRPC_RESOLVER_UNREF (exec_ctx, destroy_resolver, "channel");
-    }
-
-  if (lb_policy)
-    {
-      grpc_lb_policy_broadcast (exec_ctx, lb_policy, op);
-      GRPC_LB_POLICY_UNREF (exec_ctx, lb_policy, "broadcast");
-    }
+  grpc_exec_ctx_enqueue(exec_ctx, op->on_consumed, 1);
+
+  GPR_ASSERT(op->set_accept_stream == NULL);
+  GPR_ASSERT(op->bind_pollset == NULL);
+
+  gpr_mu_lock(&chand->mu_config);
+  if (op->on_connectivity_state_change != NULL) {
+    grpc_connectivity_state_notify_on_state_change(
+        exec_ctx, &chand->state_tracker, op->connectivity_state,
+        op->on_connectivity_state_change);
+    op->on_connectivity_state_change = NULL;
+    op->connectivity_state = NULL;
+  }
+
+  if (!is_empty(op, sizeof(*op))) {
+    lb_policy = chand->lb_policy;
+    if (lb_policy) {
+      GRPC_LB_POLICY_REF(lb_policy, "broadcast");
+    }
+  }
+
+  if (op->disconnect && chand->resolver != NULL) {
+    grpc_connectivity_state_set(exec_ctx, &chand->state_tracker,
+                                GRPC_CHANNEL_FATAL_FAILURE, "disconnect");
+    destroy_resolver = chand->resolver;
+    chand->resolver = NULL;
+    if (chand->lb_policy != NULL) {
+      grpc_lb_policy_shutdown(exec_ctx, chand->lb_policy);
+      GRPC_LB_POLICY_UNREF(exec_ctx, chand->lb_policy, "channel");
+      chand->lb_policy = NULL;
+    }
+  }
+  gpr_mu_unlock(&chand->mu_config);
+
+  if (destroy_resolver) {
+    grpc_resolver_shutdown(exec_ctx, destroy_resolver);
+    GRPC_RESOLVER_UNREF(exec_ctx, destroy_resolver, "channel");
+  }
+
+  if (lb_policy) {
+    grpc_lb_policy_broadcast(exec_ctx, lb_policy, op);
+    GRPC_LB_POLICY_UNREF(exec_ctx, lb_policy, "broadcast");
+  }
 }
 
 /* Constructor for call_data */
-static void
-init_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op)
-{
+static void init_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
+                           const void *server_transport_data,
+                           grpc_transport_stream_op *initial_op) {
   call_data *calld = elem->call_data;
 
   /* TODO(ctiller): is there something useful we can do here? */
-  GPR_ASSERT (initial_op == NULL);
+  GPR_ASSERT(initial_op == NULL);
 
-  GPR_ASSERT (elem->filter == &grpc_client_channel_filter);
-  GPR_ASSERT (server_transport_data == NULL);
-  gpr_mu_init (&calld->mu_state);
+  GPR_ASSERT(elem->filter == &grpc_client_channel_filter);
+  GPR_ASSERT(server_transport_data == NULL);
+  gpr_mu_init(&calld->mu_state);
   calld->elem = elem;
   calld->state = CALL_CREATED;
-  calld->deadline = gpr_inf_future (GPR_CLOCK_REALTIME);
+  calld->deadline = gpr_inf_future(GPR_CLOCK_REALTIME);
 }
 
 /* Destructor for call_data */
-static void
-destroy_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
-{
+static void destroy_call_elem(grpc_exec_ctx *exec_ctx,
+                              grpc_call_element *elem) {
   call_data *calld = elem->call_data;
   grpc_subchannel_call *subchannel_call;
 
   /* if the call got activated, we need to destroy the child stack also, and
      remove it from the in-flight requests tracked by the child_entry we
      picked */
-  gpr_mu_lock (&calld->mu_state);
-  switch (calld->state)
-    {
+  gpr_mu_lock(&calld->mu_state);
+  switch (calld->state) {
     case CALL_ACTIVE:
       subchannel_call = calld->subchannel_call;
-      gpr_mu_unlock (&calld->mu_state);
-      GRPC_SUBCHANNEL_CALL_UNREF (exec_ctx, subchannel_call, "client_channel");
+      gpr_mu_unlock(&calld->mu_state);
+      GRPC_SUBCHANNEL_CALL_UNREF(exec_ctx, subchannel_call, "client_channel");
       break;
     case CALL_CREATED:
     case CALL_CANCELLED:
-      gpr_mu_unlock (&calld->mu_state);
+      gpr_mu_unlock(&calld->mu_state);
       break;
     case CALL_WAITING_FOR_PICK:
     case CALL_WAITING_FOR_CONFIG:
     case CALL_WAITING_FOR_CALL:
     case CALL_WAITING_FOR_SEND:
-      gpr_log (GPR_ERROR, "should never reach here");
-      abort ();
+      gpr_log(GPR_ERROR, "should never reach here");
+      abort();
       break;
-    }
+  }
 }
 
 /* Constructor for channel_data */
-static void
-init_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * metadata_context, int is_first, int is_last)
-{
+static void init_channel_elem(grpc_exec_ctx *exec_ctx,
+                              grpc_channel_element *elem, grpc_channel *master,
+                              const grpc_channel_args *args,
+                              grpc_mdctx *metadata_context, int is_first,
+                              int is_last) {
   channel_data *chand = elem->channel_data;
 
-  memset (chand, 0, sizeof (*chand));
+  memset(chand, 0, sizeof(*chand));
 
-  GPR_ASSERT (is_last);
-  GPR_ASSERT (elem->filter == &grpc_client_channel_filter);
+  GPR_ASSERT(is_last);
+  GPR_ASSERT(elem->filter == &grpc_client_channel_filter);
 
-  gpr_mu_init (&chand->mu_config);
+  gpr_mu_init(&chand->mu_config);
   chand->mdctx = metadata_context;
   chand->master = master;
-  grpc_pollset_set_init (&chand->pollset_set);
-  grpc_closure_init (&chand->on_config_changed, cc_on_config_changed, chand);
+  grpc_pollset_set_init(&chand->pollset_set);
+  grpc_closure_init(&chand->on_config_changed, cc_on_config_changed, chand);
 
-  grpc_connectivity_state_init (&chand->state_tracker, GRPC_CHANNEL_IDLE, "client_channel");
+  grpc_connectivity_state_init(&chand->state_tracker, GRPC_CHANNEL_IDLE,
+                               "client_channel");
 }
 
 /* Destructor for channel_data */
-static void
-destroy_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem)
-{
+static void destroy_channel_elem(grpc_exec_ctx *exec_ctx,
+                                 grpc_channel_element *elem) {
   channel_data *chand = elem->channel_data;
 
-  if (chand->resolver != NULL)
-    {
-      grpc_resolver_shutdown (exec_ctx, chand->resolver);
-      GRPC_RESOLVER_UNREF (exec_ctx, chand->resolver, "channel");
-    }
-  if (chand->lb_policy != NULL)
-    {
-      GRPC_LB_POLICY_UNREF (exec_ctx, chand->lb_policy, "channel");
-    }
-  grpc_connectivity_state_destroy (exec_ctx, &chand->state_tracker);
-  grpc_pollset_set_destroy (&chand->pollset_set);
-  gpr_mu_destroy (&chand->mu_config);
+  if (chand->resolver != NULL) {
+    grpc_resolver_shutdown(exec_ctx, chand->resolver);
+    GRPC_RESOLVER_UNREF(exec_ctx, chand->resolver, "channel");
+  }
+  if (chand->lb_policy != NULL) {
+    GRPC_LB_POLICY_UNREF(exec_ctx, chand->lb_policy, "channel");
+  }
+  grpc_connectivity_state_destroy(exec_ctx, &chand->state_tracker);
+  grpc_pollset_set_destroy(&chand->pollset_set);
+  gpr_mu_destroy(&chand->mu_config);
 }
 
 const grpc_channel_filter grpc_client_channel_filter = {
-  cc_start_transport_stream_op,
-  cc_start_transport_op,
-  sizeof (call_data),
-  init_call_elem,
-  destroy_call_elem,
-  sizeof (channel_data),
-  init_channel_elem,
-  destroy_channel_elem,
-  cc_get_peer,
-  "client-channel",
+    cc_start_transport_stream_op,
+    cc_start_transport_op,
+    sizeof(call_data),
+    init_call_elem,
+    destroy_call_elem,
+    sizeof(channel_data),
+    init_channel_elem,
+    destroy_channel_elem,
+    cc_get_peer,
+    "client-channel",
 };
 
-void
-grpc_client_channel_set_resolver (grpc_exec_ctx * exec_ctx, grpc_channel_stack * channel_stack, grpc_resolver * resolver)
-{
+void grpc_client_channel_set_resolver(grpc_exec_ctx *exec_ctx,
+                                      grpc_channel_stack *channel_stack,
+                                      grpc_resolver *resolver) {
   /* post construction initialization: set the transport setup pointer */
-  grpc_channel_element *elem = grpc_channel_stack_last_element (channel_stack);
+  grpc_channel_element *elem = grpc_channel_stack_last_element(channel_stack);
   channel_data *chand = elem->channel_data;
-  gpr_mu_lock (&chand->mu_config);
-  GPR_ASSERT (!chand->resolver);
+  gpr_mu_lock(&chand->mu_config);
+  GPR_ASSERT(!chand->resolver);
   chand->resolver = resolver;
-  GRPC_RESOLVER_REF (resolver, "channel");
-  if (!grpc_closure_list_empty (chand->waiting_for_config_closures) || chand->exit_idle_when_lb_policy_arrives)
-    {
-      chand->started_resolving = 1;
-      GRPC_CHANNEL_INTERNAL_REF (chand->master, "resolver");
-      grpc_resolver_next (exec_ctx, resolver, &chand->incoming_configuration, &chand->on_config_changed);
-    }
-  gpr_mu_unlock (&chand->mu_config);
+  GRPC_RESOLVER_REF(resolver, "channel");
+  if (!grpc_closure_list_empty(chand->waiting_for_config_closures) ||
+      chand->exit_idle_when_lb_policy_arrives) {
+    chand->started_resolving = 1;
+    GRPC_CHANNEL_INTERNAL_REF(chand->master, "resolver");
+    grpc_resolver_next(exec_ctx, resolver, &chand->incoming_configuration,
+                       &chand->on_config_changed);
+  }
+  gpr_mu_unlock(&chand->mu_config);
 }
 
-grpc_connectivity_state
-grpc_client_channel_check_connectivity_state (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, int try_to_connect)
-{
+grpc_connectivity_state grpc_client_channel_check_connectivity_state(
+    grpc_exec_ctx *exec_ctx, grpc_channel_element *elem, int try_to_connect) {
   channel_data *chand = elem->channel_data;
   grpc_connectivity_state out;
-  gpr_mu_lock (&chand->mu_config);
-  out = grpc_connectivity_state_check (&chand->state_tracker);
-  if (out == GRPC_CHANNEL_IDLE && try_to_connect)
-    {
-      if (chand->lb_policy != NULL)
-	{
-	  grpc_lb_policy_exit_idle (exec_ctx, chand->lb_policy);
-	}
-      else
-	{
-	  chand->exit_idle_when_lb_policy_arrives = 1;
-	  if (!chand->started_resolving && chand->resolver != NULL)
-	    {
-	      GRPC_CHANNEL_INTERNAL_REF (chand->master, "resolver");
-	      chand->started_resolving = 1;
-	      grpc_resolver_next (exec_ctx, chand->resolver, &chand->incoming_configuration, &chand->on_config_changed);
-	    }
-	}
-    }
-  gpr_mu_unlock (&chand->mu_config);
+  gpr_mu_lock(&chand->mu_config);
+  out = grpc_connectivity_state_check(&chand->state_tracker);
+  if (out == GRPC_CHANNEL_IDLE && try_to_connect) {
+    if (chand->lb_policy != NULL) {
+      grpc_lb_policy_exit_idle(exec_ctx, chand->lb_policy);
+    } else {
+      chand->exit_idle_when_lb_policy_arrives = 1;
+      if (!chand->started_resolving && chand->resolver != NULL) {
+        GRPC_CHANNEL_INTERNAL_REF(chand->master, "resolver");
+        chand->started_resolving = 1;
+        grpc_resolver_next(exec_ctx, chand->resolver,
+                           &chand->incoming_configuration,
+                           &chand->on_config_changed);
+      }
+    }
+  }
+  gpr_mu_unlock(&chand->mu_config);
   return out;
 }
 
-void
-grpc_client_channel_watch_connectivity_state (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_connectivity_state * state, grpc_closure * on_complete)
-{
+void grpc_client_channel_watch_connectivity_state(
+    grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
+    grpc_connectivity_state *state, grpc_closure *on_complete) {
   channel_data *chand = elem->channel_data;
-  gpr_mu_lock (&chand->mu_config);
-  grpc_connectivity_state_notify_on_state_change (exec_ctx, &chand->state_tracker, state, on_complete);
-  gpr_mu_unlock (&chand->mu_config);
+  gpr_mu_lock(&chand->mu_config);
+  grpc_connectivity_state_notify_on_state_change(
+      exec_ctx, &chand->state_tracker, state, on_complete);
+  gpr_mu_unlock(&chand->mu_config);
 }
 
-grpc_pollset_set *
-grpc_client_channel_get_connecting_pollset_set (grpc_channel_element * elem)
-{
+grpc_pollset_set *grpc_client_channel_get_connecting_pollset_set(
+    grpc_channel_element *elem) {
   channel_data *chand = elem->channel_data;
   return &chand->pollset_set;
 }
 
-void
-grpc_client_channel_add_interested_party (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_pollset * pollset)
-{
+void grpc_client_channel_add_interested_party(grpc_exec_ctx *exec_ctx,
+                                              grpc_channel_element *elem,
+                                              grpc_pollset *pollset) {
   channel_data *chand = elem->channel_data;
-  grpc_pollset_set_add_pollset (exec_ctx, &chand->pollset_set, pollset);
+  grpc_pollset_set_add_pollset(exec_ctx, &chand->pollset_set, pollset);
 }
 
-void
-grpc_client_channel_del_interested_party (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_pollset * pollset)
-{
+void grpc_client_channel_del_interested_party(grpc_exec_ctx *exec_ctx,
+                                              grpc_channel_element *elem,
+                                              grpc_pollset *pollset) {
   channel_data *chand = elem->channel_data;
-  grpc_pollset_set_del_pollset (exec_ctx, &chand->pollset_set, pollset);
+  grpc_pollset_set_del_pollset(exec_ctx, &chand->pollset_set, pollset);
 }

src/core/channel/client_channel.h

@@ -49,15 +49,25 @@ extern const grpc_channel_filter grpc_client_channel_filter;
 /* post-construction initializer to let the client channel know which
    transport setup it should cancel upon destruction, or initiate when it needs
    a connection */
-void grpc_client_channel_set_resolver (grpc_exec_ctx * exec_ctx, grpc_channel_stack * channel_stack, grpc_resolver * resolver);
+void grpc_client_channel_set_resolver(grpc_exec_ctx *exec_ctx,
+                                      grpc_channel_stack *channel_stack,
+                                      grpc_resolver *resolver);
 
-grpc_connectivity_state grpc_client_channel_check_connectivity_state (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, int try_to_connect);
+grpc_connectivity_state grpc_client_channel_check_connectivity_state(
+    grpc_exec_ctx *exec_ctx, grpc_channel_element *elem, int try_to_connect);
 
-void grpc_client_channel_watch_connectivity_state (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_connectivity_state * state, grpc_closure * on_complete);
+void grpc_client_channel_watch_connectivity_state(
+    grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
+    grpc_connectivity_state *state, grpc_closure *on_complete);
 
-grpc_pollset_set *grpc_client_channel_get_connecting_pollset_set (grpc_channel_element * elem);
+grpc_pollset_set *grpc_client_channel_get_connecting_pollset_set(
+    grpc_channel_element *elem);
 
-void grpc_client_channel_add_interested_party (grpc_exec_ctx * exec_ctx, grpc_channel_element * channel, grpc_pollset * pollset);
-void grpc_client_channel_del_interested_party (grpc_exec_ctx * exec_ctx, grpc_channel_element * channel, grpc_pollset * pollset);
+void grpc_client_channel_add_interested_party(grpc_exec_ctx *exec_ctx,
+                                              grpc_channel_element *channel,
+                                              grpc_pollset *pollset);
+void grpc_client_channel_del_interested_party(grpc_exec_ctx *exec_ctx,
+                                              grpc_channel_element *channel,
+                                              grpc_pollset *pollset);
 
 #endif /* GRPC_INTERNAL_CORE_CHANNEL_CLIENT_CHANNEL_H */

src/core/channel/compress_filter.c

@@ -44,14 +44,13 @@
 #include "src/core/compression/message_compress.h"
 #include "src/core/support/string.h"
 
-typedef struct call_data
-{
+typedef struct call_data {
   gpr_slice_buffer slices; /**< Buffers up input slices to be compressed */
   grpc_linked_mdelem compression_algorithm_storage;
   grpc_linked_mdelem accept_encoding_storage;
-    gpr_uint32 remaining_slice_bytes;
-			     /**< Input data to be read, as per BEGIN_MESSAGE */
-  int written_initial_metadata;	/**< Already processed initial md? */
+  gpr_uint32 remaining_slice_bytes;
+  /**< Input data to be read, as per BEGIN_MESSAGE */
+  int written_initial_metadata; /**< Already processed initial md? */
   /** Compression algorithm we'll try to use. It may be given by incoming
    * metadata, or by the channel's default compression settings. */
   grpc_compression_algorithm compression_algorithm;
@@ -59,8 +58,7 @@ typedef struct call_data
   int has_compression_algorithm;
 } call_data;
 
-typedef struct channel_data
-{
+typedef struct channel_data {
   /** Metadata key for the incoming (requested) compression algorithm */
   grpc_mdstr *mdstr_request_compression_algorithm_key;
   /** Metadata key for the outgoing (used) compression algorithm */
@@ -82,62 +80,59 @@ typedef struct channel_data
  * larger than the raw input).
  *
  * Returns 1 if the data was actually compress and 0 otherwise. */
-static int
-compress_send_sb (grpc_compression_algorithm algorithm, gpr_slice_buffer * slices)
-{
+static int compress_send_sb(grpc_compression_algorithm algorithm,
+                            gpr_slice_buffer *slices) {
   int did_compress;
   gpr_slice_buffer tmp;
-  gpr_slice_buffer_init (&tmp);
-  did_compress = grpc_msg_compress (algorithm, slices, &tmp);
-  if (did_compress)
-    {
-      gpr_slice_buffer_swap (slices, &tmp);
-    }
-  gpr_slice_buffer_destroy (&tmp);
+  gpr_slice_buffer_init(&tmp);
+  did_compress = grpc_msg_compress(algorithm, slices, &tmp);
+  if (did_compress) {
+    gpr_slice_buffer_swap(slices, &tmp);
+  }
+  gpr_slice_buffer_destroy(&tmp);
   return did_compress;
 }
 
 /** For each \a md element from the incoming metadata, filter out the entry for
  * "grpc-encoding", using its value to populate the call data's
  * compression_algorithm field. */
-static grpc_mdelem *
-compression_md_filter (void *user_data, grpc_mdelem * md)
-{
+static grpc_mdelem *compression_md_filter(void *user_data, grpc_mdelem *md) {
   grpc_call_element *elem = user_data;
   call_data *calld = elem->call_data;
   channel_data *channeld = elem->channel_data;
 
-  if (md->key == channeld->mdstr_request_compression_algorithm_key)
-    {
-      const char *md_c_str = grpc_mdstr_as_c_string (md->value);
-      if (!grpc_compression_algorithm_parse (md_c_str, strlen (md_c_str), &calld->compression_algorithm))
-	{
-	  gpr_log (GPR_ERROR, "Invalid compression algorithm: '%s' (unknown). Ignoring.", md_c_str);
-	  calld->compression_algorithm = GRPC_COMPRESS_NONE;
-	}
-      if (grpc_compression_options_is_algorithm_enabled (&channeld->compression_options, calld->compression_algorithm) == 0)
-	{
-	  gpr_log (GPR_ERROR, "Invalid compression algorithm: '%s' (previously disabled). " "Ignoring.", md_c_str);
-	  calld->compression_algorithm = GRPC_COMPRESS_NONE;
-	}
-      calld->has_compression_algorithm = 1;
-      return NULL;
+  if (md->key == channeld->mdstr_request_compression_algorithm_key) {
+    const char *md_c_str = grpc_mdstr_as_c_string(md->value);
+    if (!grpc_compression_algorithm_parse(md_c_str, strlen(md_c_str),
+                                          &calld->compression_algorithm)) {
+      gpr_log(GPR_ERROR,
+              "Invalid compression algorithm: '%s' (unknown). Ignoring.",
+              md_c_str);
+      calld->compression_algorithm = GRPC_COMPRESS_NONE;
+    }
+    if (grpc_compression_options_is_algorithm_enabled(
+            &channeld->compression_options, calld->compression_algorithm) ==
+        0) {
+      gpr_log(GPR_ERROR,
+              "Invalid compression algorithm: '%s' (previously disabled). "
+              "Ignoring.",
+              md_c_str);
+      calld->compression_algorithm = GRPC_COMPRESS_NONE;
     }
+    calld->has_compression_algorithm = 1;
+    return NULL;
+  }
 
   return md;
 }
 
-static int
-skip_compression (channel_data * channeld, call_data * calld)
-{
-  if (calld->has_compression_algorithm)
-    {
-      if (calld->compression_algorithm == GRPC_COMPRESS_NONE)
-	{
-	  return 1;
-	}
-      return 0;			/* we have an actual call-specific algorithm */
+static int skip_compression(channel_data *channeld, call_data *calld) {
+  if (calld->has_compression_algorithm) {
+    if (calld->compression_algorithm == GRPC_COMPRESS_NONE) {
+      return 1;
     }
+    return 0; /* we have an actual call-specific algorithm */
+  }
   /* no per-call compression override */
   return channeld->default_compression_algorithm == GRPC_COMPRESS_NONE;
 }
@@ -146,127 +141,126 @@ skip_compression (channel_data * channeld, call_data * calld)
  * the associated GRPC_OP_BEGIN_MESSAGE accordingly (new compressed length,
  * flags indicating compression is in effect) and replaces \a send_ops with it.
  * */
-static void
-finish_compressed_sopb (grpc_stream_op_buffer * send_ops, grpc_call_element * elem)
-{
+static void finish_compressed_sopb(grpc_stream_op_buffer *send_ops,
+                                   grpc_call_element *elem) {
   size_t i;
   call_data *calld = elem->call_data;
-  int new_slices_added = 0;	/* GPR_FALSE */
+  int new_slices_added = 0; /* GPR_FALSE */
   grpc_metadata_batch metadata;
   grpc_stream_op_buffer new_send_ops;
-  grpc_sopb_init (&new_send_ops);
-
-  for (i = 0; i < send_ops->nops; i++)
-    {
-      grpc_stream_op *sop = &send_ops->ops[i];
-      switch (sop->type)
-	{
-	case GRPC_OP_BEGIN_MESSAGE:
-	  GPR_ASSERT (calld->slices.length <= GPR_UINT32_MAX);
-	  grpc_sopb_add_begin_message (&new_send_ops, (gpr_uint32) calld->slices.length, sop->data.begin_message.flags | GRPC_WRITE_INTERNAL_COMPRESS);
-	  break;
-	case GRPC_OP_SLICE:
-	  /* Once we reach the slices section of the original buffer, simply add
-	   * all the new (compressed) slices. We obviously want to do this only
-	   * once, hence the "new_slices_added" guard. */
-	  if (!new_slices_added)
-	    {
-	      size_t j;
-	      for (j = 0; j < calld->slices.count; ++j)
-		{
-		  grpc_sopb_add_slice (&new_send_ops, gpr_slice_ref (calld->slices.slices[j]));
-		}
-	      new_slices_added = 1;	/* GPR_TRUE */
-	    }
-	  break;
-	case GRPC_OP_METADATA:
-	  /* move the metadata to the new buffer. */
-	  grpc_metadata_batch_move (&metadata, &sop->data.metadata);
-	  grpc_sopb_add_metadata (&new_send_ops, metadata);
-	  break;
-	case GRPC_NO_OP:
-	  break;
-	}
+  grpc_sopb_init(&new_send_ops);
+
+  for (i = 0; i < send_ops->nops; i++) {
+    grpc_stream_op *sop = &send_ops->ops[i];
+    switch (sop->type) {
+      case GRPC_OP_BEGIN_MESSAGE:
+        GPR_ASSERT(calld->slices.length <= GPR_UINT32_MAX);
+        grpc_sopb_add_begin_message(
+            &new_send_ops, (gpr_uint32)calld->slices.length,
+            sop->data.begin_message.flags | GRPC_WRITE_INTERNAL_COMPRESS);
+        break;
+      case GRPC_OP_SLICE:
+        /* Once we reach the slices section of the original buffer, simply add
+         * all the new (compressed) slices. We obviously want to do this only
+         * once, hence the "new_slices_added" guard. */
+        if (!new_slices_added) {
+          size_t j;
+          for (j = 0; j < calld->slices.count; ++j) {
+            grpc_sopb_add_slice(&new_send_ops,
+                                gpr_slice_ref(calld->slices.slices[j]));
+          }
+          new_slices_added = 1; /* GPR_TRUE */
+        }
+        break;
+      case GRPC_OP_METADATA:
+        /* move the metadata to the new buffer. */
+        grpc_metadata_batch_move(&metadata, &sop->data.metadata);
+        grpc_sopb_add_metadata(&new_send_ops, metadata);
+        break;
+      case GRPC_NO_OP:
+        break;
     }
-  grpc_sopb_swap (send_ops, &new_send_ops);
-  grpc_sopb_destroy (&new_send_ops);
+  }
+  grpc_sopb_swap(send_ops, &new_send_ops);
+  grpc_sopb_destroy(&new_send_ops);
 }
 
 /** Filter's "main" function, called for any incoming grpc_transport_stream_op
  * instance that holds a non-zero number of send operations, accesible to this
  * function in \a send_ops.  */
-static void
-process_send_ops (grpc_call_element * elem, grpc_stream_op_buffer * send_ops)
-{
+static void process_send_ops(grpc_call_element *elem,
+                             grpc_stream_op_buffer *send_ops) {
   call_data *calld = elem->call_data;
   channel_data *channeld = elem->channel_data;
   size_t i;
   int did_compress = 0;
 
   /* In streaming calls, we need to reset the previously accumulated slices */
-  gpr_slice_buffer_reset_and_unref (&calld->slices);
-  for (i = 0; i < send_ops->nops; ++i)
-    {
-      grpc_stream_op *sop = &send_ops->ops[i];
-      switch (sop->type)
-	{
-	case GRPC_OP_BEGIN_MESSAGE:
-	  /* buffer up slices until we've processed all the expected ones (as
-	   * given by GRPC_OP_BEGIN_MESSAGE) */
-	  calld->remaining_slice_bytes = sop->data.begin_message.length;
-	  if (sop->data.begin_message.flags & GRPC_WRITE_NO_COMPRESS)
-	    {
-	      calld->has_compression_algorithm = 1;	/* GPR_TRUE */
-	      calld->compression_algorithm = GRPC_COMPRESS_NONE;
-	    }
-	  break;
-	case GRPC_OP_METADATA:
-	  if (!calld->written_initial_metadata)
-	    {
-	      /* Parse incoming request for compression. If any, it'll be available
-	       * at calld->compression_algorithm */
-	      grpc_metadata_batch_filter (&(sop->data.metadata), compression_md_filter, elem);
-	      if (!calld->has_compression_algorithm)
-		{
-		  /* If no algorithm was found in the metadata and we aren't
-		   * exceptionally skipping compression, fall back to the channel
-		   * default */
-		  calld->compression_algorithm = channeld->default_compression_algorithm;
-		  calld->has_compression_algorithm = 1;	/* GPR_TRUE */
-		}
-	      /* hint compression algorithm */
-	      grpc_metadata_batch_add_tail (&(sop->data.metadata), &calld->compression_algorithm_storage, GRPC_MDELEM_REF (channeld->mdelem_compression_algorithms[calld->compression_algorithm]));
-
-	      /* convey supported compression algorithms */
-	      grpc_metadata_batch_add_tail (&(sop->data.metadata), &calld->accept_encoding_storage, GRPC_MDELEM_REF (channeld->mdelem_accept_encoding));
-
-	      calld->written_initial_metadata = 1;	/* GPR_TRUE */
-	    }
-	  break;
-	case GRPC_OP_SLICE:
-	  if (skip_compression (channeld, calld))
-	    continue;
-	  GPR_ASSERT (calld->remaining_slice_bytes > 0);
-	  /* Increase input ref count, gpr_slice_buffer_add takes ownership.  */
-	  gpr_slice_buffer_add (&calld->slices, gpr_slice_ref (sop->data.slice));
-	  GPR_ASSERT (GPR_SLICE_LENGTH (sop->data.slice) >= calld->remaining_slice_bytes);
-	  calld->remaining_slice_bytes -= (gpr_uint32) GPR_SLICE_LENGTH (sop->data.slice);
-	  if (calld->remaining_slice_bytes == 0)
-	    {
-	      did_compress = compress_send_sb (calld->compression_algorithm, &calld->slices);
-	    }
-	  break;
-	case GRPC_NO_OP:
-	  break;
-	}
+  gpr_slice_buffer_reset_and_unref(&calld->slices);
+  for (i = 0; i < send_ops->nops; ++i) {
+    grpc_stream_op *sop = &send_ops->ops[i];
+    switch (sop->type) {
+      case GRPC_OP_BEGIN_MESSAGE:
+        /* buffer up slices until we've processed all the expected ones (as
+         * given by GRPC_OP_BEGIN_MESSAGE) */
+        calld->remaining_slice_bytes = sop->data.begin_message.length;
+        if (sop->data.begin_message.flags & GRPC_WRITE_NO_COMPRESS) {
+          calld->has_compression_algorithm = 1; /* GPR_TRUE */
+          calld->compression_algorithm = GRPC_COMPRESS_NONE;
+        }
+        break;
+      case GRPC_OP_METADATA:
+        if (!calld->written_initial_metadata) {
+          /* Parse incoming request for compression. If any, it'll be available
+           * at calld->compression_algorithm */
+          grpc_metadata_batch_filter(&(sop->data.metadata),
+                                     compression_md_filter, elem);
+          if (!calld->has_compression_algorithm) {
+            /* If no algorithm was found in the metadata and we aren't
+             * exceptionally skipping compression, fall back to the channel
+             * default */
+            calld->compression_algorithm =
+                channeld->default_compression_algorithm;
+            calld->has_compression_algorithm = 1; /* GPR_TRUE */
+          }
+          /* hint compression algorithm */
+          grpc_metadata_batch_add_tail(
+              &(sop->data.metadata), &calld->compression_algorithm_storage,
+              GRPC_MDELEM_REF(channeld->mdelem_compression_algorithms
+                                  [calld->compression_algorithm]));
+
+          /* convey supported compression algorithms */
+          grpc_metadata_batch_add_tail(
+              &(sop->data.metadata), &calld->accept_encoding_storage,
+              GRPC_MDELEM_REF(channeld->mdelem_accept_encoding));
+
+          calld->written_initial_metadata = 1; /* GPR_TRUE */
+        }
+        break;
+      case GRPC_OP_SLICE:
+        if (skip_compression(channeld, calld)) continue;
+        GPR_ASSERT(calld->remaining_slice_bytes > 0);
+        /* Increase input ref count, gpr_slice_buffer_add takes ownership.  */
+        gpr_slice_buffer_add(&calld->slices, gpr_slice_ref(sop->data.slice));
+        GPR_ASSERT(GPR_SLICE_LENGTH(sop->data.slice) >=
+                   calld->remaining_slice_bytes);
+        calld->remaining_slice_bytes -=
+            (gpr_uint32)GPR_SLICE_LENGTH(sop->data.slice);
+        if (calld->remaining_slice_bytes == 0) {
+          did_compress =
+              compress_send_sb(calld->compression_algorithm, &calld->slices);
+        }
+        break;
+      case GRPC_NO_OP:
+        break;
     }
+  }
 
   /* Modify the send_ops stream_op_buffer depending on whether compression was
    * carried out */
-  if (did_compress)
-    {
-      finish_compressed_sopb (send_ops, elem);
-    }
+  if (did_compress) {
+    finish_compressed_sopb(send_ops, elem);
+  }
 }
 
 /* Called either:
@@ -274,52 +268,49 @@ process_send_ops (grpc_call_element * elem, grpc_stream_op_buffer * send_ops)
      - a network event (or similar) from below, to receive something
    op contains type and call direction information, in addition to the data
    that is being sent or received. */
-static void
-compress_start_transport_stream_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
-{
-  if (op->send_ops && op->send_ops->nops > 0)
-    {
-      process_send_ops (elem, op->send_ops);
-    }
+static void compress_start_transport_stream_op(grpc_exec_ctx *exec_ctx,
+                                               grpc_call_element *elem,
+                                               grpc_transport_stream_op *op) {
+  if (op->send_ops && op->send_ops->nops > 0) {
+    process_send_ops(elem, op->send_ops);
+  }
 
   /* pass control down the stack */
-  grpc_call_next_op (exec_ctx, elem, op);
+  grpc_call_next_op(exec_ctx, elem, op);
 }
 
 /* Constructor for call_data */
-static void
-init_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op)
-{
+static void init_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
+                           const void *server_transport_data,
+                           grpc_transport_stream_op *initial_op) {
   /* grab pointers to our data from the call element */
   call_data *calld = elem->call_data;
 
   /* initialize members */
-  gpr_slice_buffer_init (&calld->slices);
+  gpr_slice_buffer_init(&calld->slices);
   calld->has_compression_algorithm = 0;
-  calld->written_initial_metadata = 0;	/* GPR_FALSE */
-
-  if (initial_op)
-    {
-      if (initial_op->send_ops && initial_op->send_ops->nops > 0)
-	{
-	  process_send_ops (elem, initial_op->send_ops);
-	}
+  calld->written_initial_metadata = 0; /* GPR_FALSE */
+
+  if (initial_op) {
+    if (initial_op->send_ops && initial_op->send_ops->nops > 0) {
+      process_send_ops(elem, initial_op->send_ops);
     }
+  }
 }
 
 /* Destructor for call_data */
-static void
-destroy_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
-{
+static void destroy_call_elem(grpc_exec_ctx *exec_ctx,
+                              grpc_call_element *elem) {
   /* grab pointers to our data from the call element */
   call_data *calld = elem->call_data;
-  gpr_slice_buffer_destroy (&calld->slices);
+  gpr_slice_buffer_destroy(&calld->slices);
 }
 
 /* Constructor for channel_data */
-static void
-init_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_first, int is_last)
-{
+static void init_channel_elem(grpc_exec_ctx *exec_ctx,
+                              grpc_channel_element *elem, grpc_channel *master,
+                              const grpc_channel_args *args, grpc_mdctx *mdctx,
+                              int is_first, int is_last) {
   channel_data *channeld = elem->channel_data;
   grpc_compression_algorithm algo_idx;
   const char *supported_algorithms_names[GRPC_COMPRESS_ALGORITHMS_COUNT - 1];
@@ -327,72 +318,82 @@ init_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_c
   char *accept_encoding_str;
   size_t accept_encoding_str_len;
 
-  grpc_compression_options_init (&channeld->compression_options);
-  channeld->compression_options.enabled_algorithms_bitset = (gpr_uint32) grpc_channel_args_compression_algorithm_get_states (args);
+  grpc_compression_options_init(&channeld->compression_options);
+  channeld->compression_options.enabled_algorithms_bitset =
+      (gpr_uint32)grpc_channel_args_compression_algorithm_get_states(args);
 
-  channeld->default_compression_algorithm = grpc_channel_args_get_compression_algorithm (args);
+  channeld->default_compression_algorithm =
+      grpc_channel_args_get_compression_algorithm(args);
   /* Make sure the default isn't disabled. */
-  GPR_ASSERT (grpc_compression_options_is_algorithm_enabled (&channeld->compression_options, channeld->default_compression_algorithm));
-  channeld->compression_options.default_compression_algorithm = channeld->default_compression_algorithm;
-
-  channeld->mdstr_request_compression_algorithm_key = grpc_mdstr_from_string (mdctx, GRPC_COMPRESS_REQUEST_ALGORITHM_KEY, 0);
-
-  channeld->mdstr_outgoing_compression_algorithm_key = grpc_mdstr_from_string (mdctx, "grpc-encoding", 0);
-
-  channeld->mdstr_compression_capabilities_key = grpc_mdstr_from_string (mdctx, "grpc-accept-encoding", 0);
-
-  for (algo_idx = 0; algo_idx < GRPC_COMPRESS_ALGORITHMS_COUNT; ++algo_idx)
-    {
-      char *algorithm_name;
-      /* skip disabled algorithms */
-      if (grpc_compression_options_is_algorithm_enabled (&channeld->compression_options, algo_idx) == 0)
-	{
-	  continue;
-	}
-      GPR_ASSERT (grpc_compression_algorithm_name (algo_idx, &algorithm_name) != 0);
-      channeld->mdelem_compression_algorithms[algo_idx] = grpc_mdelem_from_metadata_strings (mdctx, GRPC_MDSTR_REF (channeld->mdstr_outgoing_compression_algorithm_key), grpc_mdstr_from_string (mdctx, algorithm_name, 0));
-      if (algo_idx > 0)
-	{
-	  supported_algorithms_names[supported_algorithms_idx++] = algorithm_name;
-	}
+  GPR_ASSERT(grpc_compression_options_is_algorithm_enabled(
+      &channeld->compression_options, channeld->default_compression_algorithm));
+  channeld->compression_options.default_compression_algorithm =
+      channeld->default_compression_algorithm;
+
+  channeld->mdstr_request_compression_algorithm_key =
+      grpc_mdstr_from_string(mdctx, GRPC_COMPRESS_REQUEST_ALGORITHM_KEY, 0);
+
+  channeld->mdstr_outgoing_compression_algorithm_key =
+      grpc_mdstr_from_string(mdctx, "grpc-encoding", 0);
+
+  channeld->mdstr_compression_capabilities_key =
+      grpc_mdstr_from_string(mdctx, "grpc-accept-encoding", 0);
+
+  for (algo_idx = 0; algo_idx < GRPC_COMPRESS_ALGORITHMS_COUNT; ++algo_idx) {
+    char *algorithm_name;
+    /* skip disabled algorithms */
+    if (grpc_compression_options_is_algorithm_enabled(
+            &channeld->compression_options, algo_idx) == 0) {
+      continue;
+    }
+    GPR_ASSERT(grpc_compression_algorithm_name(algo_idx, &algorithm_name) != 0);
+    channeld->mdelem_compression_algorithms[algo_idx] =
+        grpc_mdelem_from_metadata_strings(
+            mdctx,
+            GRPC_MDSTR_REF(channeld->mdstr_outgoing_compression_algorithm_key),
+            grpc_mdstr_from_string(mdctx, algorithm_name, 0));
+    if (algo_idx > 0) {
+      supported_algorithms_names[supported_algorithms_idx++] = algorithm_name;
     }
+  }
 
   /* TODO(dgq): gpr_strjoin_sep could be made to work with statically allocated
    * arrays, as to avoid the heap allocs */
-  accept_encoding_str = gpr_strjoin_sep (supported_algorithms_names, supported_algorithms_idx, ",", &accept_encoding_str_len);
+  accept_encoding_str =
+      gpr_strjoin_sep(supported_algorithms_names, supported_algorithms_idx, ",",
+                      &accept_encoding_str_len);
 
-  channeld->mdelem_accept_encoding = grpc_mdelem_from_metadata_strings (mdctx, GRPC_MDSTR_REF (channeld->mdstr_compression_capabilities_key), grpc_mdstr_from_string (mdctx, accept_encoding_str, 0));
-  gpr_free (accept_encoding_str);
+  channeld->mdelem_accept_encoding = grpc_mdelem_from_metadata_strings(
+      mdctx, GRPC_MDSTR_REF(channeld->mdstr_compression_capabilities_key),
+      grpc_mdstr_from_string(mdctx, accept_encoding_str, 0));
+  gpr_free(accept_encoding_str);
 
-  GPR_ASSERT (!is_last);
+  GPR_ASSERT(!is_last);
 }
 
 /* Destructor for channel data */
-static void
-destroy_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem)
-{
+static void destroy_channel_elem(grpc_exec_ctx *exec_ctx,
+                                 grpc_channel_element *elem) {
   channel_data *channeld = elem->channel_data;
   grpc_compression_algorithm algo_idx;
 
-  GRPC_MDSTR_UNREF (channeld->mdstr_request_compression_algorithm_key);
-  GRPC_MDSTR_UNREF (channeld->mdstr_outgoing_compression_algorithm_key);
-  GRPC_MDSTR_UNREF (channeld->mdstr_compression_capabilities_key);
-  for (algo_idx = 0; algo_idx < GRPC_COMPRESS_ALGORITHMS_COUNT; ++algo_idx)
-    {
-      GRPC_MDELEM_UNREF (channeld->mdelem_compression_algorithms[algo_idx]);
-    }
-  GRPC_MDELEM_UNREF (channeld->mdelem_accept_encoding);
+  GRPC_MDSTR_UNREF(channeld->mdstr_request_compression_algorithm_key);
+  GRPC_MDSTR_UNREF(channeld->mdstr_outgoing_compression_algorithm_key);
+  GRPC_MDSTR_UNREF(channeld->mdstr_compression_capabilities_key);
+  for (algo_idx = 0; algo_idx < GRPC_COMPRESS_ALGORITHMS_COUNT; ++algo_idx) {
+    GRPC_MDELEM_UNREF(channeld->mdelem_compression_algorithms[algo_idx]);
+  }
+  GRPC_MDELEM_UNREF(channeld->mdelem_accept_encoding);
 }
 
 const grpc_channel_filter grpc_compress_filter = {
-  compress_start_transport_stream_op,
-  grpc_channel_next_op,
-  sizeof (call_data),
-  init_call_elem,
-  destroy_call_elem,
-  sizeof (channel_data),
-  init_channel_elem,
-  destroy_channel_elem,
-  grpc_call_next_get_peer,
-  "compress"
-};
+    compress_start_transport_stream_op,
+    grpc_channel_next_op,
+    sizeof(call_data),
+    init_call_elem,
+    destroy_call_elem,
+    sizeof(channel_data),
+    init_channel_elem,
+    destroy_channel_elem,
+    grpc_call_next_get_peer,
+    "compress"};

src/core/channel/connected_channel.c

@@ -46,15 +46,11 @@
 
 #define MAX_BUFFER_LENGTH 8192
 
-typedef struct connected_channel_channel_data
-{
+typedef struct connected_channel_channel_data {
   grpc_transport *transport;
 } channel_data;
 
-typedef struct connected_channel_call_data
-{
-  void *unused;
-} call_data;
+typedef struct connected_channel_call_data { void *unused; } call_data;
 
 /* 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
@@ -65,95 +61,95 @@ typedef struct connected_channel_call_data
 
 /* Intercept a call operation and either push it directly up or translate it
    into transport stream operations */
-static void
-con_start_transport_stream_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
-{
+static void con_start_transport_stream_op(grpc_exec_ctx *exec_ctx,
+                                          grpc_call_element *elem,
+                                          grpc_transport_stream_op *op) {
   call_data *calld = elem->call_data;
   channel_data *chand = elem->channel_data;
-  GPR_ASSERT (elem->filter == &grpc_connected_channel_filter);
-  GRPC_CALL_LOG_OP (GPR_INFO, elem, op);
+  GPR_ASSERT(elem->filter == &grpc_connected_channel_filter);
+  GRPC_CALL_LOG_OP(GPR_INFO, elem, op);
 
-  grpc_transport_perform_stream_op (exec_ctx, chand->transport, TRANSPORT_STREAM_FROM_CALL_DATA (calld), op);
+  grpc_transport_perform_stream_op(exec_ctx, chand->transport,
+                                   TRANSPORT_STREAM_FROM_CALL_DATA(calld), op);
 }
 
-static void
-con_start_transport_op (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_transport_op * op)
-{
+static void con_start_transport_op(grpc_exec_ctx *exec_ctx,
+                                   grpc_channel_element *elem,
+                                   grpc_transport_op *op) {
   channel_data *chand = elem->channel_data;
-  grpc_transport_perform_op (exec_ctx, chand->transport, op);
+  grpc_transport_perform_op(exec_ctx, chand->transport, op);
 }
 
 /* Constructor for call_data */
-static void
-init_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op)
-{
+static void init_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
+                           const void *server_transport_data,
+                           grpc_transport_stream_op *initial_op) {
   call_data *calld = elem->call_data;
   channel_data *chand = elem->channel_data;
   int r;
 
-  GPR_ASSERT (elem->filter == &grpc_connected_channel_filter);
-  r = grpc_transport_init_stream (exec_ctx, chand->transport, TRANSPORT_STREAM_FROM_CALL_DATA (calld), server_transport_data, initial_op);
-  GPR_ASSERT (r == 0);
+  GPR_ASSERT(elem->filter == &grpc_connected_channel_filter);
+  r = grpc_transport_init_stream(exec_ctx, chand->transport,
+                                 TRANSPORT_STREAM_FROM_CALL_DATA(calld),
+                                 server_transport_data, initial_op);
+  GPR_ASSERT(r == 0);
 }
 
 /* Destructor for call_data */
-static void
-destroy_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
-{
+static void destroy_call_elem(grpc_exec_ctx *exec_ctx,
+                              grpc_call_element *elem) {
   call_data *calld = elem->call_data;
   channel_data *chand = elem->channel_data;
-  GPR_ASSERT (elem->filter == &grpc_connected_channel_filter);
-  grpc_transport_destroy_stream (exec_ctx, chand->transport, TRANSPORT_STREAM_FROM_CALL_DATA (calld));
+  GPR_ASSERT(elem->filter == &grpc_connected_channel_filter);
+  grpc_transport_destroy_stream(exec_ctx, chand->transport,
+                                TRANSPORT_STREAM_FROM_CALL_DATA(calld));
 }
 
 /* Constructor for channel_data */
-static void
-init_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_first, int is_last)
-{
-  channel_data *cd = (channel_data *) elem->channel_data;
-  GPR_ASSERT (is_last);
-  GPR_ASSERT (elem->filter == &grpc_connected_channel_filter);
+static void init_channel_elem(grpc_exec_ctx *exec_ctx,
+                              grpc_channel_element *elem, grpc_channel *master,
+                              const grpc_channel_args *args, grpc_mdctx *mdctx,
+                              int is_first, int is_last) {
+  channel_data *cd = (channel_data *)elem->channel_data;
+  GPR_ASSERT(is_last);
+  GPR_ASSERT(elem->filter == &grpc_connected_channel_filter);
   cd->transport = NULL;
 }
 
 /* Destructor for channel_data */
-static void
-destroy_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem)
-{
-  channel_data *cd = (channel_data *) elem->channel_data;
-  GPR_ASSERT (elem->filter == &grpc_connected_channel_filter);
-  grpc_transport_destroy (exec_ctx, cd->transport);
+static void destroy_channel_elem(grpc_exec_ctx *exec_ctx,
+                                 grpc_channel_element *elem) {
+  channel_data *cd = (channel_data *)elem->channel_data;
+  GPR_ASSERT(elem->filter == &grpc_connected_channel_filter);
+  grpc_transport_destroy(exec_ctx, cd->transport);
 }
 
-static char *
-con_get_peer (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
-{
+static char *con_get_peer(grpc_exec_ctx *exec_ctx, grpc_call_element *elem) {
   channel_data *chand = elem->channel_data;
-  return grpc_transport_get_peer (exec_ctx, chand->transport);
+  return grpc_transport_get_peer(exec_ctx, chand->transport);
 }
 
 const grpc_channel_filter grpc_connected_channel_filter = {
-  con_start_transport_stream_op,
-  con_start_transport_op,
-  sizeof (call_data),
-  init_call_elem,
-  destroy_call_elem,
-  sizeof (channel_data),
-  init_channel_elem,
-  destroy_channel_elem,
-  con_get_peer,
-  "connected",
+    con_start_transport_stream_op,
+    con_start_transport_op,
+    sizeof(call_data),
+    init_call_elem,
+    destroy_call_elem,
+    sizeof(channel_data),
+    init_channel_elem,
+    destroy_channel_elem,
+    con_get_peer,
+    "connected",
 };
 
-void
-grpc_connected_channel_bind_transport (grpc_channel_stack * channel_stack, grpc_transport * transport)
-{
+void grpc_connected_channel_bind_transport(grpc_channel_stack *channel_stack,
+                                           grpc_transport *transport) {
   /* Assumes that the connected channel filter is always the last filter
      in a channel stack */
-  grpc_channel_element *elem = grpc_channel_stack_last_element (channel_stack);
-  channel_data *cd = (channel_data *) elem->channel_data;
-  GPR_ASSERT (elem->filter == &grpc_connected_channel_filter);
-  GPR_ASSERT (cd->transport == NULL);
+  grpc_channel_element *elem = grpc_channel_stack_last_element(channel_stack);
+  channel_data *cd = (channel_data *)elem->channel_data;
+  GPR_ASSERT(elem->filter == &grpc_connected_channel_filter);
+  GPR_ASSERT(cd->transport == NULL);
   cd->transport = transport;
 
   /* HACK(ctiller): increase call stack size for the channel to make space
@@ -162,5 +158,5 @@ grpc_connected_channel_bind_transport (grpc_channel_stack * channel_stack, grpc_
      This is only "safe" because call stacks place no additional data after
      the last call element, and the last call element MUST be the connected
      channel. */
-  channel_stack->call_stack_size += grpc_transport_stream_size (transport);
+  channel_stack->call_stack_size += grpc_transport_stream_size(transport);
 }

src/core/channel/connected_channel.h

@@ -43,6 +43,7 @@ extern const grpc_channel_filter grpc_connected_channel_filter;
 
 /* Post construction fixup: set the transport in the connected channel.
    Must be called before any call stack using this filter is used. */
-void grpc_connected_channel_bind_transport (grpc_channel_stack * channel_stack, grpc_transport * transport);
+void grpc_connected_channel_bind_transport(grpc_channel_stack* channel_stack,
+                                           grpc_transport* transport);
 
 #endif /* GRPC_INTERNAL_CORE_CHANNEL_CONNECTED_CHANNEL_H */

src/core/channel/context.h

@@ -35,17 +35,15 @@
 #define GRPC_INTERNAL_CORE_CHANNEL_CONTEXT_H
 
 /* Call object context pointers */
-typedef enum
-{
+typedef enum {
   GRPC_CONTEXT_SECURITY = 0,
   GRPC_CONTEXT_TRACING,
   GRPC_CONTEXT_COUNT
 } grpc_context_index;
 
-typedef struct
-{
+typedef struct {
   void *value;
-  void (*destroy) (void *);
+  void (*destroy)(void *);
 } grpc_call_context_element;
 
 #endif /* GRPC_INTERNAL_CORE_CHANNEL_CONTEXT_H */

src/core/channel/http_client_filter.c

@@ -37,8 +37,7 @@
 #include <grpc/support/string_util.h>
 #include "src/core/support/string.h"
 
-typedef struct call_data
-{
+typedef struct call_data {
   grpc_linked_mdelem method;
   grpc_linked_mdelem scheme;
   grpc_linked_mdelem authority;
@@ -58,8 +57,7 @@ typedef struct call_data
   grpc_closure hc_on_recv;
 } call_data;
 
-typedef struct channel_data
-{
+typedef struct channel_data {
   grpc_mdelem *te_trailers;
   grpc_mdelem *method;
   grpc_mdelem *scheme;
@@ -69,255 +67,222 @@ typedef struct channel_data
   grpc_mdelem *user_agent;
 } channel_data;
 
-typedef struct
-{
+typedef struct {
   grpc_call_element *elem;
   grpc_exec_ctx *exec_ctx;
 } client_recv_filter_args;
 
-static grpc_mdelem *
-client_recv_filter (void *user_data, grpc_mdelem * md)
-{
+static grpc_mdelem *client_recv_filter(void *user_data, grpc_mdelem *md) {
   client_recv_filter_args *a = user_data;
   grpc_call_element *elem = a->elem;
   channel_data *channeld = elem->channel_data;
-  if (md == channeld->status)
-    {
-      return NULL;
-    }
-  else if (md->key == channeld->status->key)
-    {
-      grpc_call_element_send_cancel (a->exec_ctx, elem);
-      return NULL;
-    }
-  else if (md->key == channeld->content_type->key)
-    {
-      return NULL;
-    }
+  if (md == channeld->status) {
+    return NULL;
+  } else if (md->key == channeld->status->key) {
+    grpc_call_element_send_cancel(a->exec_ctx, elem);
+    return NULL;
+  } else if (md->key == channeld->content_type->key) {
+    return NULL;
+  }
   return md;
 }
 
-static void
-hc_on_recv (grpc_exec_ctx * exec_ctx, void *user_data, int success)
-{
+static void hc_on_recv(grpc_exec_ctx *exec_ctx, void *user_data, int success) {
   grpc_call_element *elem = user_data;
   call_data *calld = elem->call_data;
   size_t i;
   size_t nops = calld->recv_ops->nops;
   grpc_stream_op *ops = calld->recv_ops->ops;
-  for (i = 0; i < nops; i++)
-    {
-      grpc_stream_op *op = &ops[i];
-      client_recv_filter_args a;
-      if (op->type != GRPC_OP_METADATA)
-	continue;
-      calld->got_initial_metadata = 1;
-      a.elem = elem;
-      a.exec_ctx = exec_ctx;
-      grpc_metadata_batch_filter (&op->data.metadata, client_recv_filter, &a);
-    }
-  calld->on_done_recv->cb (exec_ctx, calld->on_done_recv->cb_arg, success);
+  for (i = 0; i < nops; i++) {
+    grpc_stream_op *op = &ops[i];
+    client_recv_filter_args a;
+    if (op->type != GRPC_OP_METADATA) continue;
+    calld->got_initial_metadata = 1;
+    a.elem = elem;
+    a.exec_ctx = exec_ctx;
+    grpc_metadata_batch_filter(&op->data.metadata, client_recv_filter, &a);
+  }
+  calld->on_done_recv->cb(exec_ctx, calld->on_done_recv->cb_arg, success);
 }
 
-static grpc_mdelem *
-client_strip_filter (void *user_data, grpc_mdelem * md)
-{
+static grpc_mdelem *client_strip_filter(void *user_data, grpc_mdelem *md) {
   grpc_call_element *elem = user_data;
   channel_data *channeld = elem->channel_data;
   /* eat the things we'd like to set ourselves */
-  if (md->key == channeld->method->key)
-    return NULL;
-  if (md->key == channeld->scheme->key)
-    return NULL;
-  if (md->key == channeld->te_trailers->key)
-    return NULL;
-  if (md->key == channeld->content_type->key)
-    return NULL;
-  if (md->key == channeld->user_agent->key)
-    return NULL;
+  if (md->key == channeld->method->key) return NULL;
+  if (md->key == channeld->scheme->key) return NULL;
+  if (md->key == channeld->te_trailers->key) return NULL;
+  if (md->key == channeld->content_type->key) return NULL;
+  if (md->key == channeld->user_agent->key) return NULL;
   return md;
 }
 
-static void
-hc_mutate_op (grpc_call_element * elem, grpc_transport_stream_op * op)
-{
+static void hc_mutate_op(grpc_call_element *elem,
+                         grpc_transport_stream_op *op) {
   /* grab pointers to our data from the call element */
   call_data *calld = elem->call_data;
   channel_data *channeld = elem->channel_data;
   size_t i;
-  if (op->send_ops && !calld->sent_initial_metadata)
-    {
-      size_t nops = op->send_ops->nops;
-      grpc_stream_op *ops = op->send_ops->ops;
-      for (i = 0; i < nops; i++)
-	{
-	  grpc_stream_op *op = &ops[i];
-	  if (op->type != GRPC_OP_METADATA)
-	    continue;
-	  calld->sent_initial_metadata = 1;
-	  grpc_metadata_batch_filter (&op->data.metadata, client_strip_filter, elem);
-	  /* Send : prefixed headers, which have to be before any application
-	     layer headers. */
-	  grpc_metadata_batch_add_head (&op->data.metadata, &calld->method, GRPC_MDELEM_REF (channeld->method));
-	  grpc_metadata_batch_add_head (&op->data.metadata, &calld->scheme, GRPC_MDELEM_REF (channeld->scheme));
-	  grpc_metadata_batch_add_tail (&op->data.metadata, &calld->te_trailers, GRPC_MDELEM_REF (channeld->te_trailers));
-	  grpc_metadata_batch_add_tail (&op->data.metadata, &calld->content_type, GRPC_MDELEM_REF (channeld->content_type));
-	  grpc_metadata_batch_add_tail (&op->data.metadata, &calld->user_agent, GRPC_MDELEM_REF (channeld->user_agent));
-	  break;
-	}
+  if (op->send_ops && !calld->sent_initial_metadata) {
+    size_t nops = op->send_ops->nops;
+    grpc_stream_op *ops = op->send_ops->ops;
+    for (i = 0; i < nops; i++) {
+      grpc_stream_op *op = &ops[i];
+      if (op->type != GRPC_OP_METADATA) continue;
+      calld->sent_initial_metadata = 1;
+      grpc_metadata_batch_filter(&op->data.metadata, client_strip_filter, elem);
+      /* Send : prefixed headers, which have to be before any application
+         layer headers. */
+      grpc_metadata_batch_add_head(&op->data.metadata, &calld->method,
+                                   GRPC_MDELEM_REF(channeld->method));
+      grpc_metadata_batch_add_head(&op->data.metadata, &calld->scheme,
+                                   GRPC_MDELEM_REF(channeld->scheme));
+      grpc_metadata_batch_add_tail(&op->data.metadata, &calld->te_trailers,
+                                   GRPC_MDELEM_REF(channeld->te_trailers));
+      grpc_metadata_batch_add_tail(&op->data.metadata, &calld->content_type,
+                                   GRPC_MDELEM_REF(channeld->content_type));
+      grpc_metadata_batch_add_tail(&op->data.metadata, &calld->user_agent,
+                                   GRPC_MDELEM_REF(channeld->user_agent));
+      break;
     }
+  }
 
-  if (op->recv_ops && !calld->got_initial_metadata)
-    {
-      /* substitute our callback for the higher callback */
-      calld->recv_ops = op->recv_ops;
-      calld->on_done_recv = op->on_done_recv;
-      op->on_done_recv = &calld->hc_on_recv;
-    }
+  if (op->recv_ops && !calld->got_initial_metadata) {
+    /* substitute our callback for the higher callback */
+    calld->recv_ops = op->recv_ops;
+    calld->on_done_recv = op->on_done_recv;
+    op->on_done_recv = &calld->hc_on_recv;
+  }
 }
 
-static void
-hc_start_transport_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
-{
-  GRPC_CALL_LOG_OP (GPR_INFO, elem, op);
-  hc_mutate_op (elem, op);
-  grpc_call_next_op (exec_ctx, elem, op);
+static void hc_start_transport_op(grpc_exec_ctx *exec_ctx,
+                                  grpc_call_element *elem,
+                                  grpc_transport_stream_op *op) {
+  GRPC_CALL_LOG_OP(GPR_INFO, elem, op);
+  hc_mutate_op(elem, op);
+  grpc_call_next_op(exec_ctx, elem, op);
 }
 
 /* Constructor for call_data */
-static void
-init_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op)
-{
+static void init_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
+                           const void *server_transport_data,
+                           grpc_transport_stream_op *initial_op) {
   call_data *calld = elem->call_data;
   calld->sent_initial_metadata = 0;
   calld->got_initial_metadata = 0;
   calld->on_done_recv = NULL;
-  grpc_closure_init (&calld->hc_on_recv, hc_on_recv, elem);
-  if (initial_op)
-    hc_mutate_op (elem, initial_op);
+  grpc_closure_init(&calld->hc_on_recv, hc_on_recv, elem);
+  if (initial_op) hc_mutate_op(elem, initial_op);
 }
 
 /* Destructor for call_data */
-static void
-destroy_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
-{
-}
+static void destroy_call_elem(grpc_exec_ctx *exec_ctx,
+                              grpc_call_element *elem) {}
 
-static const char *
-scheme_from_args (const grpc_channel_args * args)
-{
+static const char *scheme_from_args(const grpc_channel_args *args) {
   unsigned i;
-  if (args != NULL)
-    {
-      for (i = 0; i < args->num_args; ++i)
-	{
-	  if (args->args[i].type == GRPC_ARG_STRING && strcmp (args->args[i].key, GRPC_ARG_HTTP2_SCHEME) == 0)
-	    {
-	      return args->args[i].value.string;
-	    }
-	}
+  if (args != NULL) {
+    for (i = 0; i < args->num_args; ++i) {
+      if (args->args[i].type == GRPC_ARG_STRING &&
+          strcmp(args->args[i].key, GRPC_ARG_HTTP2_SCHEME) == 0) {
+        return args->args[i].value.string;
+      }
     }
+  }
   return "http";
 }
 
-static grpc_mdstr *
-user_agent_from_args (grpc_mdctx * mdctx, const grpc_channel_args * args)
-{
+static grpc_mdstr *user_agent_from_args(grpc_mdctx *mdctx,
+                                        const grpc_channel_args *args) {
   gpr_strvec v;
   size_t i;
   int is_first = 1;
   char *tmp;
   grpc_mdstr *result;
 
-  gpr_strvec_init (&v);
+  gpr_strvec_init(&v);
 
-  for (i = 0; args && i < args->num_args; i++)
-    {
-      if (0 == strcmp (args->args[i].key, GRPC_ARG_PRIMARY_USER_AGENT_STRING))
-	{
-	  if (args->args[i].type != GRPC_ARG_STRING)
-	    {
-	      gpr_log (GPR_ERROR, "Channel argument '%s' should be a string", GRPC_ARG_PRIMARY_USER_AGENT_STRING);
-	    }
-	  else
-	    {
-	      if (!is_first)
-		gpr_strvec_add (&v, gpr_strdup (" "));
-	      is_first = 0;
-	      gpr_strvec_add (&v, gpr_strdup (args->args[i].value.string));
-	    }
-	}
+  for (i = 0; args && i < args->num_args; i++) {
+    if (0 == strcmp(args->args[i].key, GRPC_ARG_PRIMARY_USER_AGENT_STRING)) {
+      if (args->args[i].type != GRPC_ARG_STRING) {
+        gpr_log(GPR_ERROR, "Channel argument '%s' should be a string",
+                GRPC_ARG_PRIMARY_USER_AGENT_STRING);
+      } else {
+        if (!is_first) gpr_strvec_add(&v, gpr_strdup(" "));
+        is_first = 0;
+        gpr_strvec_add(&v, gpr_strdup(args->args[i].value.string));
+      }
     }
+  }
 
-  gpr_asprintf (&tmp, "%sgrpc-c/%s (%s)", is_first ? "" : " ", grpc_version_string (), GPR_PLATFORM_STRING);
+  gpr_asprintf(&tmp, "%sgrpc-c/%s (%s)", is_first ? "" : " ",
+               grpc_version_string(), GPR_PLATFORM_STRING);
   is_first = 0;
-  gpr_strvec_add (&v, tmp);
+  gpr_strvec_add(&v, tmp);
 
-  for (i = 0; args && i < args->num_args; i++)
-    {
-      if (0 == strcmp (args->args[i].key, GRPC_ARG_SECONDARY_USER_AGENT_STRING))
-	{
-	  if (args->args[i].type != GRPC_ARG_STRING)
-	    {
-	      gpr_log (GPR_ERROR, "Channel argument '%s' should be a string", GRPC_ARG_SECONDARY_USER_AGENT_STRING);
-	    }
-	  else
-	    {
-	      if (!is_first)
-		gpr_strvec_add (&v, gpr_strdup (" "));
-	      is_first = 0;
-	      gpr_strvec_add (&v, gpr_strdup (args->args[i].value.string));
-	    }
-	}
+  for (i = 0; args && i < args->num_args; i++) {
+    if (0 == strcmp(args->args[i].key, GRPC_ARG_SECONDARY_USER_AGENT_STRING)) {
+      if (args->args[i].type != GRPC_ARG_STRING) {
+        gpr_log(GPR_ERROR, "Channel argument '%s' should be a string",
+                GRPC_ARG_SECONDARY_USER_AGENT_STRING);
+      } else {
+        if (!is_first) gpr_strvec_add(&v, gpr_strdup(" "));
+        is_first = 0;
+        gpr_strvec_add(&v, gpr_strdup(args->args[i].value.string));
+      }
     }
+  }
 
-  tmp = gpr_strvec_flatten (&v, NULL);
-  gpr_strvec_destroy (&v);
-  result = grpc_mdstr_from_string (mdctx, tmp, 0);
-  gpr_free (tmp);
+  tmp = gpr_strvec_flatten(&v, NULL);
+  gpr_strvec_destroy(&v);
+  result = grpc_mdstr_from_string(mdctx, tmp, 0);
+  gpr_free(tmp);
 
   return result;
 }
 
 /* Constructor for channel_data */
-static void
-init_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * channel_args, grpc_mdctx * mdctx, int is_first, int is_last)
-{
+static void init_channel_elem(grpc_exec_ctx *exec_ctx,
+                              grpc_channel_element *elem, grpc_channel *master,
+                              const grpc_channel_args *channel_args,
+                              grpc_mdctx *mdctx, int is_first, int is_last) {
   /* grab pointers to our data from the channel element */
   channel_data *channeld = elem->channel_data;
 
   /* The first and the last filters tend to be implemented differently to
      handle the case that there's no 'next' filter to call on the up or down
      path */
-  GPR_ASSERT (!is_last);
+  GPR_ASSERT(!is_last);
 
   /* initialize members */
-  channeld->te_trailers = grpc_mdelem_from_strings (mdctx, "te", "trailers");
-  channeld->method = grpc_mdelem_from_strings (mdctx, ":method", "POST");
-  channeld->scheme = grpc_mdelem_from_strings (mdctx, ":scheme", scheme_from_args (channel_args));
-  channeld->content_type = grpc_mdelem_from_strings (mdctx, "content-type", "application/grpc");
-  channeld->status = grpc_mdelem_from_strings (mdctx, ":status", "200");
-  channeld->user_agent = grpc_mdelem_from_metadata_strings (mdctx, grpc_mdstr_from_string (mdctx, "user-agent", 0), user_agent_from_args (mdctx, channel_args));
+  channeld->te_trailers = grpc_mdelem_from_strings(mdctx, "te", "trailers");
+  channeld->method = grpc_mdelem_from_strings(mdctx, ":method", "POST");
+  channeld->scheme = grpc_mdelem_from_strings(mdctx, ":scheme",
+                                              scheme_from_args(channel_args));
+  channeld->content_type =
+      grpc_mdelem_from_strings(mdctx, "content-type", "application/grpc");
+  channeld->status = grpc_mdelem_from_strings(mdctx, ":status", "200");
+  channeld->user_agent = grpc_mdelem_from_metadata_strings(
+      mdctx, grpc_mdstr_from_string(mdctx, "user-agent", 0),
+      user_agent_from_args(mdctx, channel_args));
 }
 
 /* Destructor for channel data */
-static void
-destroy_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem)
-{
+static void destroy_channel_elem(grpc_exec_ctx *exec_ctx,
+                                 grpc_channel_element *elem) {
   /* grab pointers to our data from the channel element */
   channel_data *channeld = elem->channel_data;
 
-  GRPC_MDELEM_UNREF (channeld->te_trailers);
-  GRPC_MDELEM_UNREF (channeld->method);
-  GRPC_MDELEM_UNREF (channeld->scheme);
-  GRPC_MDELEM_UNREF (channeld->content_type);
-  GRPC_MDELEM_UNREF (channeld->status);
-  GRPC_MDELEM_UNREF (channeld->user_agent);
+  GRPC_MDELEM_UNREF(channeld->te_trailers);
+  GRPC_MDELEM_UNREF(channeld->method);
+  GRPC_MDELEM_UNREF(channeld->scheme);
+  GRPC_MDELEM_UNREF(channeld->content_type);
+  GRPC_MDELEM_UNREF(channeld->status);
+  GRPC_MDELEM_UNREF(channeld->user_agent);
 }
 
 const grpc_channel_filter grpc_http_client_filter = {
-  hc_start_transport_op, grpc_channel_next_op, sizeof (call_data),
-  init_call_elem, destroy_call_elem, sizeof (channel_data),
-  init_channel_elem, destroy_channel_elem, grpc_call_next_get_peer,
-  "http-client"
-};
+    hc_start_transport_op, grpc_channel_next_op, sizeof(call_data),
+    init_call_elem,        destroy_call_elem,    sizeof(channel_data),
+    init_channel_elem,     destroy_channel_elem, grpc_call_next_get_peer,
+    "http-client"};

src/core/channel/http_server_filter.c

@@ -37,8 +37,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-typedef struct call_data
-{
+typedef struct call_data {
   gpr_uint8 got_initial_metadata;
   gpr_uint8 seen_path;
   gpr_uint8 seen_post;
@@ -58,8 +57,7 @@ typedef struct call_data
   grpc_closure hs_on_recv;
 } call_data;
 
-typedef struct channel_data
-{
+typedef struct channel_data {
   grpc_mdelem *te_trailers;
   grpc_mdelem *method_post;
   grpc_mdelem *http_scheme;
@@ -76,268 +74,234 @@ typedef struct channel_data
   grpc_mdctx *mdctx;
 } channel_data;
 
-typedef struct
-{
+typedef struct {
   grpc_call_element *elem;
   grpc_exec_ctx *exec_ctx;
 } server_filter_args;
 
-static grpc_mdelem *
-server_filter (void *user_data, grpc_mdelem * md)
-{
+static grpc_mdelem *server_filter(void *user_data, grpc_mdelem *md) {
   server_filter_args *a = user_data;
   grpc_call_element *elem = a->elem;
   channel_data *channeld = elem->channel_data;
   call_data *calld = elem->call_data;
 
   /* Check if it is one of the headers we care about. */
-  if (md == channeld->te_trailers || md == channeld->method_post || md == channeld->http_scheme || md == channeld->https_scheme || md == channeld->grpc_scheme || md == channeld->content_type)
-    {
-      /* swallow it */
-      if (md == channeld->method_post)
-	{
-	  calld->seen_post = 1;
-	}
-      else if (md->key == channeld->http_scheme->key)
-	{
-	  calld->seen_scheme = 1;
-	}
-      else if (md == channeld->te_trailers)
-	{
-	  calld->seen_te_trailers = 1;
-	}
-      /* TODO(klempner): Track that we've seen all the headers we should
-         require */
-      return NULL;
+  if (md == channeld->te_trailers || md == channeld->method_post ||
+      md == channeld->http_scheme || md == channeld->https_scheme ||
+      md == channeld->grpc_scheme || md == channeld->content_type) {
+    /* swallow it */
+    if (md == channeld->method_post) {
+      calld->seen_post = 1;
+    } else if (md->key == channeld->http_scheme->key) {
+      calld->seen_scheme = 1;
+    } else if (md == channeld->te_trailers) {
+      calld->seen_te_trailers = 1;
     }
-  else if (md->key == channeld->content_type->key)
-    {
-      if (strncmp (grpc_mdstr_as_c_string (md->value), "application/grpc+", 17) == 0)
-	{
-	  /* Although the C implementation doesn't (currently) generate them,
-	     any custom +-suffix is explicitly valid. */
-	  /* TODO(klempner): We should consider preallocating common values such
-	     as +proto or +json, or at least stashing them if we see them. */
-	  /* TODO(klempner): Should we be surfacing this to application code? */
-	}
-      else
-	{
-	  /* TODO(klempner): We're currently allowing this, but we shouldn't
-	     see it without a proxy so log for now. */
-	  gpr_log (GPR_INFO, "Unexpected content-type %s", channeld->content_type->key);
-	}
-      return NULL;
+    /* TODO(klempner): Track that we've seen all the headers we should
+       require */
+    return NULL;
+  } else if (md->key == channeld->content_type->key) {
+    if (strncmp(grpc_mdstr_as_c_string(md->value), "application/grpc+", 17) ==
+        0) {
+      /* Although the C implementation doesn't (currently) generate them,
+         any custom +-suffix is explicitly valid. */
+      /* TODO(klempner): We should consider preallocating common values such
+         as +proto or +json, or at least stashing them if we see them. */
+      /* TODO(klempner): Should we be surfacing this to application code? */
+    } else {
+      /* TODO(klempner): We're currently allowing this, but we shouldn't
+         see it without a proxy so log for now. */
+      gpr_log(GPR_INFO, "Unexpected content-type %s",
+              channeld->content_type->key);
     }
-  else if (md->key == channeld->te_trailers->key || md->key == channeld->method_post->key || md->key == channeld->http_scheme->key)
-    {
-      gpr_log (GPR_ERROR, "Invalid %s: header: '%s'", grpc_mdstr_as_c_string (md->key), grpc_mdstr_as_c_string (md->value));
-      /* swallow it and error everything out. */
-      /* TODO(klempner): We ought to generate more descriptive error messages
-         on the wire here. */
-      grpc_call_element_send_cancel (a->exec_ctx, elem);
+    return NULL;
+  } else if (md->key == channeld->te_trailers->key ||
+             md->key == channeld->method_post->key ||
+             md->key == channeld->http_scheme->key) {
+    gpr_log(GPR_ERROR, "Invalid %s: header: '%s'",
+            grpc_mdstr_as_c_string(md->key), grpc_mdstr_as_c_string(md->value));
+    /* swallow it and error everything out. */
+    /* TODO(klempner): We ought to generate more descriptive error messages
+       on the wire here. */
+    grpc_call_element_send_cancel(a->exec_ctx, elem);
+    return NULL;
+  } else if (md->key == channeld->path_key) {
+    if (calld->seen_path) {
+      gpr_log(GPR_ERROR, "Received :path twice");
       return NULL;
     }
-  else if (md->key == channeld->path_key)
-    {
-      if (calld->seen_path)
-	{
-	  gpr_log (GPR_ERROR, "Received :path twice");
-	  return NULL;
-	}
-      calld->seen_path = 1;
-      return md;
-    }
-  else if (md->key == channeld->authority_key)
-    {
-      calld->seen_authority = 1;
-      return md;
-    }
-  else if (md->key == channeld->host_key)
-    {
-      /* translate host to :authority since :authority may be
-         omitted */
-      grpc_mdelem *authority = grpc_mdelem_from_metadata_strings (channeld->mdctx, GRPC_MDSTR_REF (channeld->authority_key),
-								  GRPC_MDSTR_REF (md->value));
-      GRPC_MDELEM_UNREF (md);
-      calld->seen_authority = 1;
-      return authority;
-    }
-  else
-    {
-      return md;
-    }
+    calld->seen_path = 1;
+    return md;
+  } else if (md->key == channeld->authority_key) {
+    calld->seen_authority = 1;
+    return md;
+  } else if (md->key == channeld->host_key) {
+    /* translate host to :authority since :authority may be
+       omitted */
+    grpc_mdelem *authority = grpc_mdelem_from_metadata_strings(
+        channeld->mdctx, GRPC_MDSTR_REF(channeld->authority_key),
+        GRPC_MDSTR_REF(md->value));
+    GRPC_MDELEM_UNREF(md);
+    calld->seen_authority = 1;
+    return authority;
+  } else {
+    return md;
+  }
 }
 
-static void
-hs_on_recv (grpc_exec_ctx * exec_ctx, void *user_data, int success)
-{
+static void hs_on_recv(grpc_exec_ctx *exec_ctx, void *user_data, int success) {
   grpc_call_element *elem = user_data;
   call_data *calld = elem->call_data;
-  if (success)
-    {
-      size_t i;
-      size_t nops = calld->recv_ops->nops;
-      grpc_stream_op *ops = calld->recv_ops->ops;
-      for (i = 0; i < nops; i++)
-	{
-	  grpc_stream_op *op = &ops[i];
-	  server_filter_args a;
-	  if (op->type != GRPC_OP_METADATA)
-	    continue;
-	  calld->got_initial_metadata = 1;
-	  a.elem = elem;
-	  a.exec_ctx = exec_ctx;
-	  grpc_metadata_batch_filter (&op->data.metadata, server_filter, &a);
-	  /* Have we seen the required http2 transport headers?
-	     (:method, :scheme, content-type, with :path and :authority covered
-	     at the channel level right now) */
-	  if (calld->seen_post && calld->seen_scheme && calld->seen_te_trailers && calld->seen_path && calld->seen_authority)
-	    {
-	      /* do nothing */
-	    }
-	  else
-	    {
-	      if (!calld->seen_path)
-		{
-		  gpr_log (GPR_ERROR, "Missing :path header");
-		}
-	      if (!calld->seen_authority)
-		{
-		  gpr_log (GPR_ERROR, "Missing :authority header");
-		}
-	      if (!calld->seen_post)
-		{
-		  gpr_log (GPR_ERROR, "Missing :method header");
-		}
-	      if (!calld->seen_scheme)
-		{
-		  gpr_log (GPR_ERROR, "Missing :scheme header");
-		}
-	      if (!calld->seen_te_trailers)
-		{
-		  gpr_log (GPR_ERROR, "Missing te trailers header");
-		}
-	      /* Error this call out */
-	      success = 0;
-	      grpc_call_element_send_cancel (exec_ctx, elem);
-	    }
-	}
+  if (success) {
+    size_t i;
+    size_t nops = calld->recv_ops->nops;
+    grpc_stream_op *ops = calld->recv_ops->ops;
+    for (i = 0; i < nops; i++) {
+      grpc_stream_op *op = &ops[i];
+      server_filter_args a;
+      if (op->type != GRPC_OP_METADATA) continue;
+      calld->got_initial_metadata = 1;
+      a.elem = elem;
+      a.exec_ctx = exec_ctx;
+      grpc_metadata_batch_filter(&op->data.metadata, server_filter, &a);
+      /* Have we seen the required http2 transport headers?
+         (:method, :scheme, content-type, with :path and :authority covered
+         at the channel level right now) */
+      if (calld->seen_post && calld->seen_scheme && calld->seen_te_trailers &&
+          calld->seen_path && calld->seen_authority) {
+        /* do nothing */
+      } else {
+        if (!calld->seen_path) {
+          gpr_log(GPR_ERROR, "Missing :path header");
+        }
+        if (!calld->seen_authority) {
+          gpr_log(GPR_ERROR, "Missing :authority header");
+        }
+        if (!calld->seen_post) {
+          gpr_log(GPR_ERROR, "Missing :method header");
+        }
+        if (!calld->seen_scheme) {
+          gpr_log(GPR_ERROR, "Missing :scheme header");
+        }
+        if (!calld->seen_te_trailers) {
+          gpr_log(GPR_ERROR, "Missing te trailers header");
+        }
+        /* Error this call out */
+        success = 0;
+        grpc_call_element_send_cancel(exec_ctx, elem);
+      }
     }
-  calld->on_done_recv->cb (exec_ctx, calld->on_done_recv->cb_arg, success);
+  }
+  calld->on_done_recv->cb(exec_ctx, calld->on_done_recv->cb_arg, success);
 }
 
-static void
-hs_mutate_op (grpc_call_element * elem, grpc_transport_stream_op * op)
-{
+static void hs_mutate_op(grpc_call_element *elem,
+                         grpc_transport_stream_op *op) {
   /* grab pointers to our data from the call element */
   call_data *calld = elem->call_data;
   channel_data *channeld = elem->channel_data;
   size_t i;
 
-  if (op->send_ops && !calld->sent_status)
-    {
-      size_t nops = op->send_ops->nops;
-      grpc_stream_op *ops = op->send_ops->ops;
-      for (i = 0; i < nops; i++)
-	{
-	  grpc_stream_op *op = &ops[i];
-	  if (op->type != GRPC_OP_METADATA)
-	    continue;
-	  calld->sent_status = 1;
-	  grpc_metadata_batch_add_head (&op->data.metadata, &calld->status, GRPC_MDELEM_REF (channeld->status_ok));
-	  grpc_metadata_batch_add_tail (&op->data.metadata, &calld->content_type, GRPC_MDELEM_REF (channeld->content_type));
-	  break;
-	}
+  if (op->send_ops && !calld->sent_status) {
+    size_t nops = op->send_ops->nops;
+    grpc_stream_op *ops = op->send_ops->ops;
+    for (i = 0; i < nops; i++) {
+      grpc_stream_op *op = &ops[i];
+      if (op->type != GRPC_OP_METADATA) continue;
+      calld->sent_status = 1;
+      grpc_metadata_batch_add_head(&op->data.metadata, &calld->status,
+                                   GRPC_MDELEM_REF(channeld->status_ok));
+      grpc_metadata_batch_add_tail(&op->data.metadata, &calld->content_type,
+                                   GRPC_MDELEM_REF(channeld->content_type));
+      break;
     }
+  }
 
-  if (op->recv_ops && !calld->got_initial_metadata)
-    {
-      /* substitute our callback for the higher callback */
-      calld->recv_ops = op->recv_ops;
-      calld->on_done_recv = op->on_done_recv;
-      op->on_done_recv = &calld->hs_on_recv;
-    }
+  if (op->recv_ops && !calld->got_initial_metadata) {
+    /* substitute our callback for the higher callback */
+    calld->recv_ops = op->recv_ops;
+    calld->on_done_recv = op->on_done_recv;
+    op->on_done_recv = &calld->hs_on_recv;
+  }
 }
 
-static void
-hs_start_transport_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
-{
-  GRPC_CALL_LOG_OP (GPR_INFO, elem, op);
-  hs_mutate_op (elem, op);
-  grpc_call_next_op (exec_ctx, elem, op);
+static void hs_start_transport_op(grpc_exec_ctx *exec_ctx,
+                                  grpc_call_element *elem,
+                                  grpc_transport_stream_op *op) {
+  GRPC_CALL_LOG_OP(GPR_INFO, elem, op);
+  hs_mutate_op(elem, op);
+  grpc_call_next_op(exec_ctx, elem, op);
 }
 
 /* Constructor for call_data */
-static void
-init_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op)
-{
+static void init_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
+                           const void *server_transport_data,
+                           grpc_transport_stream_op *initial_op) {
   /* grab pointers to our data from the call element */
   call_data *calld = elem->call_data;
   /* initialize members */
-  memset (calld, 0, sizeof (*calld));
-  grpc_closure_init (&calld->hs_on_recv, hs_on_recv, elem);
-  if (initial_op)
-    hs_mutate_op (elem, initial_op);
+  memset(calld, 0, sizeof(*calld));
+  grpc_closure_init(&calld->hs_on_recv, hs_on_recv, elem);
+  if (initial_op) hs_mutate_op(elem, initial_op);
 }
 
 /* Destructor for call_data */
-static void
-destroy_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
-{
-}
+static void destroy_call_elem(grpc_exec_ctx *exec_ctx,
+                              grpc_call_element *elem) {}
 
 /* Constructor for channel_data */
-static void
-init_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_first, int is_last)
-{
+static void init_channel_elem(grpc_exec_ctx *exec_ctx,
+                              grpc_channel_element *elem, grpc_channel *master,
+                              const grpc_channel_args *args, grpc_mdctx *mdctx,
+                              int is_first, int is_last) {
   /* grab pointers to our data from the channel element */
   channel_data *channeld = elem->channel_data;
 
   /* The first and the last filters tend to be implemented differently to
      handle the case that there's no 'next' filter to call on the up or down
      path */
-  GPR_ASSERT (!is_first);
-  GPR_ASSERT (!is_last);
+  GPR_ASSERT(!is_first);
+  GPR_ASSERT(!is_last);
 
   /* initialize members */
-  channeld->te_trailers = grpc_mdelem_from_strings (mdctx, "te", "trailers");
-  channeld->status_ok = grpc_mdelem_from_strings (mdctx, ":status", "200");
-  channeld->status_not_found = grpc_mdelem_from_strings (mdctx, ":status", "404");
-  channeld->method_post = grpc_mdelem_from_strings (mdctx, ":method", "POST");
-  channeld->http_scheme = grpc_mdelem_from_strings (mdctx, ":scheme", "http");
-  channeld->https_scheme = grpc_mdelem_from_strings (mdctx, ":scheme", "https");
-  channeld->grpc_scheme = grpc_mdelem_from_strings (mdctx, ":scheme", "grpc");
-  channeld->path_key = grpc_mdstr_from_string (mdctx, ":path", 0);
-  channeld->authority_key = grpc_mdstr_from_string (mdctx, ":authority", 0);
-  channeld->host_key = grpc_mdstr_from_string (mdctx, "host", 0);
-  channeld->content_type = grpc_mdelem_from_strings (mdctx, "content-type", "application/grpc");
+  channeld->te_trailers = grpc_mdelem_from_strings(mdctx, "te", "trailers");
+  channeld->status_ok = grpc_mdelem_from_strings(mdctx, ":status", "200");
+  channeld->status_not_found =
+      grpc_mdelem_from_strings(mdctx, ":status", "404");
+  channeld->method_post = grpc_mdelem_from_strings(mdctx, ":method", "POST");
+  channeld->http_scheme = grpc_mdelem_from_strings(mdctx, ":scheme", "http");
+  channeld->https_scheme = grpc_mdelem_from_strings(mdctx, ":scheme", "https");
+  channeld->grpc_scheme = grpc_mdelem_from_strings(mdctx, ":scheme", "grpc");
+  channeld->path_key = grpc_mdstr_from_string(mdctx, ":path", 0);
+  channeld->authority_key = grpc_mdstr_from_string(mdctx, ":authority", 0);
+  channeld->host_key = grpc_mdstr_from_string(mdctx, "host", 0);
+  channeld->content_type =
+      grpc_mdelem_from_strings(mdctx, "content-type", "application/grpc");
 
   channeld->mdctx = mdctx;
 }
 
 /* Destructor for channel data */
-static void
-destroy_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem)
-{
+static void destroy_channel_elem(grpc_exec_ctx *exec_ctx,
+                                 grpc_channel_element *elem) {
   /* grab pointers to our data from the channel element */
   channel_data *channeld = elem->channel_data;
 
-  GRPC_MDELEM_UNREF (channeld->te_trailers);
-  GRPC_MDELEM_UNREF (channeld->status_ok);
-  GRPC_MDELEM_UNREF (channeld->status_not_found);
-  GRPC_MDELEM_UNREF (channeld->method_post);
-  GRPC_MDELEM_UNREF (channeld->http_scheme);
-  GRPC_MDELEM_UNREF (channeld->https_scheme);
-  GRPC_MDELEM_UNREF (channeld->grpc_scheme);
-  GRPC_MDELEM_UNREF (channeld->content_type);
-  GRPC_MDSTR_UNREF (channeld->path_key);
-  GRPC_MDSTR_UNREF (channeld->authority_key);
-  GRPC_MDSTR_UNREF (channeld->host_key);
+  GRPC_MDELEM_UNREF(channeld->te_trailers);
+  GRPC_MDELEM_UNREF(channeld->status_ok);
+  GRPC_MDELEM_UNREF(channeld->status_not_found);
+  GRPC_MDELEM_UNREF(channeld->method_post);
+  GRPC_MDELEM_UNREF(channeld->http_scheme);
+  GRPC_MDELEM_UNREF(channeld->https_scheme);
+  GRPC_MDELEM_UNREF(channeld->grpc_scheme);
+  GRPC_MDELEM_UNREF(channeld->content_type);
+  GRPC_MDSTR_UNREF(channeld->path_key);
+  GRPC_MDSTR_UNREF(channeld->authority_key);
+  GRPC_MDSTR_UNREF(channeld->host_key);
 }
 
 const grpc_channel_filter grpc_http_server_filter = {
-  hs_start_transport_op, grpc_channel_next_op, sizeof (call_data),
-  init_call_elem, destroy_call_elem, sizeof (channel_data),
-  init_channel_elem, destroy_channel_elem, grpc_call_next_get_peer,
-  "http-server"
-};
+    hs_start_transport_op, grpc_channel_next_op, sizeof(call_data),
+    init_call_elem,        destroy_call_elem,    sizeof(channel_data),
+    init_channel_elem,     destroy_channel_elem, grpc_call_next_get_peer,
+    "http-server"};

src/core/channel/noop_filter.c

@@ -34,31 +34,25 @@
 #include "src/core/channel/noop_filter.h"
 #include <grpc/support/log.h>
 
-typedef struct call_data
-{
-  int unused;			/* C89 requires at least one struct element */
+typedef struct call_data {
+  int unused; /* C89 requires at least one struct element */
 } call_data;
 
-typedef struct channel_data
-{
-  int unused;			/* C89 requires at least one struct element */
+typedef struct channel_data {
+  int unused; /* C89 requires at least one struct element */
 } channel_data;
 
 /* used to silence 'variable not used' warnings */
-static void
-ignore_unused (void *ignored)
-{
-}
+static void ignore_unused(void *ignored) {}
 
-static void
-noop_mutate_op (grpc_call_element * elem, grpc_transport_stream_op * op)
-{
+static void noop_mutate_op(grpc_call_element *elem,
+                           grpc_transport_stream_op *op) {
   /* grab pointers to our data from the call element */
   call_data *calld = elem->call_data;
   channel_data *channeld = elem->channel_data;
 
-  ignore_unused (calld);
-  ignore_unused (channeld);
+  ignore_unused(calld);
+  ignore_unused(channeld);
 
   /* do nothing */
 }
@@ -68,19 +62,19 @@ noop_mutate_op (grpc_call_element * elem, grpc_transport_stream_op * op)
      - a network event (or similar) from below, to receive something
    op contains type and call direction information, in addition to the data
    that is being sent or received. */
-static void
-noop_start_transport_stream_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
-{
-  noop_mutate_op (elem, op);
+static void noop_start_transport_stream_op(grpc_exec_ctx *exec_ctx,
+                                           grpc_call_element *elem,
+                                           grpc_transport_stream_op *op) {
+  noop_mutate_op(elem, op);
 
   /* pass control down the stack */
-  grpc_call_next_op (exec_ctx, elem, op);
+  grpc_call_next_op(exec_ctx, elem, op);
 }
 
 /* Constructor for call_data */
-static void
-init_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, const void *server_transport_data, grpc_transport_stream_op * initial_op)
-{
+static void init_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
+                           const void *server_transport_data,
+                           grpc_transport_stream_op *initial_op) {
   /* grab pointers to our data from the call element */
   call_data *calld = elem->call_data;
   channel_data *channeld = elem->channel_data;
@@ -88,51 +82,47 @@ init_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, const void *
   /* initialize members */
   calld->unused = channeld->unused;
 
-  if (initial_op)
-    noop_mutate_op (elem, initial_op);
+  if (initial_op) noop_mutate_op(elem, initial_op);
 }
 
 /* Destructor for call_data */
-static void
-destroy_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
-{
-}
+static void destroy_call_elem(grpc_exec_ctx *exec_ctx,
+                              grpc_call_element *elem) {}
 
 /* Constructor for channel_data */
-static void
-init_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_channel * master, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_first, int is_last)
-{
+static void init_channel_elem(grpc_exec_ctx *exec_ctx,
+                              grpc_channel_element *elem, grpc_channel *master,
+                              const grpc_channel_args *args, grpc_mdctx *mdctx,
+                              int is_first, int is_last) {
   /* grab pointers to our data from the channel element */
   channel_data *channeld = elem->channel_data;
 
   /* The first and the last filters tend to be implemented differently to
      handle the case that there's no 'next' filter to call on the up or down
      path */
-  GPR_ASSERT (!is_first);
-  GPR_ASSERT (!is_last);
+  GPR_ASSERT(!is_first);
+  GPR_ASSERT(!is_last);
 
   /* initialize members */
   channeld->unused = 0;
 }
 
 /* Destructor for channel data */
-static void
-destroy_channel_elem (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem)
-{
+static void destroy_channel_elem(grpc_exec_ctx *exec_ctx,
+                                 grpc_channel_element *elem) {
   /* grab pointers to our data from the channel element */
   channel_data *channeld = elem->channel_data;
 
-  ignore_unused (channeld);
+  ignore_unused(channeld);
 }
 
-const grpc_channel_filter grpc_no_op_filter = { noop_start_transport_stream_op,
-  grpc_channel_next_op,
-  sizeof (call_data),
-  init_call_elem,
-  destroy_call_elem,
-  sizeof (channel_data),
-  init_channel_elem,
-  destroy_channel_elem,
-  grpc_call_next_get_peer,
-  "no-op"
-};
+const grpc_channel_filter grpc_no_op_filter = {noop_start_transport_stream_op,
+                                               grpc_channel_next_op,
+                                               sizeof(call_data),
+                                               init_call_elem,
+                                               destroy_call_elem,
+                                               sizeof(channel_data),
+                                               init_channel_elem,
+                                               destroy_channel_elem,
+                                               grpc_call_next_get_peer,
+                                               "no-op"};

src/core/client_config/client_config.c

@@ -37,50 +37,36 @@
 
 #include <grpc/support/alloc.h>
 
-struct grpc_client_config
-{
+struct grpc_client_config {
   gpr_refcount refs;
   grpc_lb_policy *lb_policy;
 };
 
-grpc_client_config *
-grpc_client_config_create ()
-{
-  grpc_client_config *c = gpr_malloc (sizeof (*c));
-  memset (c, 0, sizeof (*c));
-  gpr_ref_init (&c->refs, 1);
+grpc_client_config *grpc_client_config_create() {
+  grpc_client_config *c = gpr_malloc(sizeof(*c));
+  memset(c, 0, sizeof(*c));
+  gpr_ref_init(&c->refs, 1);
   return c;
 }
 
-void
-grpc_client_config_ref (grpc_client_config * c)
-{
-  gpr_ref (&c->refs);
-}
+void grpc_client_config_ref(grpc_client_config *c) { gpr_ref(&c->refs); }
 
-void
-grpc_client_config_unref (grpc_exec_ctx * exec_ctx, grpc_client_config * c)
-{
-  if (gpr_unref (&c->refs))
-    {
-      GRPC_LB_POLICY_UNREF (exec_ctx, c->lb_policy, "client_config");
-      gpr_free (c);
-    }
+void grpc_client_config_unref(grpc_exec_ctx *exec_ctx, grpc_client_config *c) {
+  if (gpr_unref(&c->refs)) {
+    GRPC_LB_POLICY_UNREF(exec_ctx, c->lb_policy, "client_config");
+    gpr_free(c);
+  }
 }
 
-void
-grpc_client_config_set_lb_policy (grpc_client_config * c, grpc_lb_policy * lb_policy)
-{
-  GPR_ASSERT (c->lb_policy == NULL);
-  if (lb_policy)
-    {
-      GRPC_LB_POLICY_REF (lb_policy, "client_config");
-    }
+void grpc_client_config_set_lb_policy(grpc_client_config *c,
+                                      grpc_lb_policy *lb_policy) {
+  GPR_ASSERT(c->lb_policy == NULL);
+  if (lb_policy) {
+    GRPC_LB_POLICY_REF(lb_policy, "client_config");
+  }
   c->lb_policy = lb_policy;
 }
 
-grpc_lb_policy *
-grpc_client_config_get_lb_policy (grpc_client_config * c)
-{
+grpc_lb_policy *grpc_client_config_get_lb_policy(grpc_client_config *c) {
   return c->lb_policy;
 }

src/core/client_config/client_config.h

@@ -40,11 +40,14 @@
     grpc_resolver */
 typedef struct grpc_client_config grpc_client_config;
 
-grpc_client_config *grpc_client_config_create ();
-void grpc_client_config_ref (grpc_client_config * client_config);
-void grpc_client_config_unref (grpc_exec_ctx * exec_ctx, grpc_client_config * client_config);
+grpc_client_config *grpc_client_config_create();
+void grpc_client_config_ref(grpc_client_config *client_config);
+void grpc_client_config_unref(grpc_exec_ctx *exec_ctx,
+                              grpc_client_config *client_config);
 
-void grpc_client_config_set_lb_policy (grpc_client_config * client_config, grpc_lb_policy * lb_policy);
-grpc_lb_policy *grpc_client_config_get_lb_policy (grpc_client_config * client_config);
+void grpc_client_config_set_lb_policy(grpc_client_config *client_config,
+                                      grpc_lb_policy *lb_policy);
+grpc_lb_policy *grpc_client_config_get_lb_policy(
+    grpc_client_config *client_config);
 
 #endif /* GRPC_INTERNAL_CORE_CLIENT_CONFIG_CLIENT_CONFIG_H */

src/core/client_config/connector.c

@@ -33,26 +33,22 @@
 
 #include "src/core/client_config/connector.h"
 
-void
-grpc_connector_ref (grpc_connector * connector)
-{
-  connector->vtable->ref (connector);
+void grpc_connector_ref(grpc_connector* connector) {
+  connector->vtable->ref(connector);
 }
 
-void
-grpc_connector_unref (grpc_exec_ctx * exec_ctx, grpc_connector * connector)
-{
-  connector->vtable->unref (exec_ctx, connector);
+void grpc_connector_unref(grpc_exec_ctx* exec_ctx, grpc_connector* connector) {
+  connector->vtable->unref(exec_ctx, connector);
 }
 
-void
-grpc_connector_connect (grpc_exec_ctx * exec_ctx, grpc_connector * connector, const grpc_connect_in_args * in_args, grpc_connect_out_args * out_args, grpc_closure * notify)
-{
-  connector->vtable->connect (exec_ctx, connector, in_args, out_args, notify);
+void grpc_connector_connect(grpc_exec_ctx* exec_ctx, grpc_connector* connector,
+                            const grpc_connect_in_args* in_args,
+                            grpc_connect_out_args* out_args,
+                            grpc_closure* notify) {
+  connector->vtable->connect(exec_ctx, connector, in_args, out_args, notify);
 }
 
-void
-grpc_connector_shutdown (grpc_exec_ctx * exec_ctx, grpc_connector * connector)
-{
-  connector->vtable->shutdown (exec_ctx, connector);
+void grpc_connector_shutdown(grpc_exec_ctx* exec_ctx,
+                             grpc_connector* connector) {
+  connector->vtable->shutdown(exec_ctx, connector);
 }

src/core/client_config/connector.h

@@ -41,13 +41,11 @@
 typedef struct grpc_connector grpc_connector;
 typedef struct grpc_connector_vtable grpc_connector_vtable;
 
-struct grpc_connector
-{
+struct grpc_connector {
   const grpc_connector_vtable *vtable;
 };
 
-typedef struct
-{
+typedef struct {
   /** set of pollsets interested in this connection */
   grpc_pollset_set *interested_parties;
   /** address to connect to */
@@ -59,8 +57,7 @@ typedef struct
   const grpc_channel_args *channel_args;
 } grpc_connect_in_args;
 
-typedef struct
-{
+typedef struct {
   /** the connected transport */
   grpc_transport *transport;
   /** any additional filters (owned by the caller of connect) */
@@ -68,21 +65,26 @@ typedef struct
   size_t num_filters;
 } grpc_connect_out_args;
 
-struct grpc_connector_vtable
-{
-  void (*ref) (grpc_connector * connector);
-  void (*unref) (grpc_exec_ctx * exec_ctx, grpc_connector * connector);
+struct grpc_connector_vtable {
+  void (*ref)(grpc_connector *connector);
+  void (*unref)(grpc_exec_ctx *exec_ctx, grpc_connector *connector);
   /** Implementation of grpc_connector_shutdown */
-  void (*shutdown) (grpc_exec_ctx * exec_ctx, grpc_connector * connector);
+  void (*shutdown)(grpc_exec_ctx *exec_ctx, grpc_connector *connector);
   /** Implementation of grpc_connector_connect */
-  void (*connect) (grpc_exec_ctx * exec_ctx, grpc_connector * connector, const grpc_connect_in_args * in_args, grpc_connect_out_args * out_args, grpc_closure * notify);
+  void (*connect)(grpc_exec_ctx *exec_ctx, grpc_connector *connector,
+                  const grpc_connect_in_args *in_args,
+                  grpc_connect_out_args *out_args, grpc_closure *notify);
 };
 
-void grpc_connector_ref (grpc_connector * connector);
-void grpc_connector_unref (grpc_exec_ctx * exec_ctx, grpc_connector * connector);
+void grpc_connector_ref(grpc_connector *connector);
+void grpc_connector_unref(grpc_exec_ctx *exec_ctx, grpc_connector *connector);
 /** Connect using the connector: max one outstanding call at a time */
-void grpc_connector_connect (grpc_exec_ctx * exec_ctx, grpc_connector * connector, const grpc_connect_in_args * in_args, grpc_connect_out_args * out_args, grpc_closure * notify);
+void grpc_connector_connect(grpc_exec_ctx *exec_ctx, grpc_connector *connector,
+                            const grpc_connect_in_args *in_args,
+                            grpc_connect_out_args *out_args,
+                            grpc_closure *notify);
 /** Cancel any pending connection */
-void grpc_connector_shutdown (grpc_exec_ctx * exec_ctx, grpc_connector * connector);
+void grpc_connector_shutdown(grpc_exec_ctx *exec_ctx,
+                             grpc_connector *connector);
 
 #endif

src/core/client_config/lb_policies/pick_first.c

@@ -39,16 +39,14 @@
 #include <grpc/support/alloc.h>
 #include "src/core/transport/connectivity_state.h"
 
-typedef struct pending_pick
-{
+typedef struct pending_pick {
   struct pending_pick *next;
   grpc_pollset *pollset;
   grpc_subchannel **target;
   grpc_closure *on_complete;
 } pending_pick;
 
-typedef struct
-{
+typedef struct {
   /** base policy: must be first */
   grpc_lb_policy base;
   /** all our subchannels */
@@ -78,303 +76,284 @@ typedef struct
   grpc_connectivity_state_tracker state_tracker;
 } pick_first_lb_policy;
 
-static void
-del_interested_parties_locked (grpc_exec_ctx * exec_ctx, pick_first_lb_policy * p)
-{
+static void del_interested_parties_locked(grpc_exec_ctx *exec_ctx,
+                                          pick_first_lb_policy *p) {
   pending_pick *pp;
-  for (pp = p->pending_picks; pp; pp = pp->next)
-    {
-      grpc_subchannel_del_interested_party (exec_ctx, p->subchannels[p->checking_subchannel], pp->pollset);
-    }
+  for (pp = p->pending_picks; pp; pp = pp->next) {
+    grpc_subchannel_del_interested_party(
+        exec_ctx, p->subchannels[p->checking_subchannel], pp->pollset);
+  }
 }
 
-static void
-add_interested_parties_locked (grpc_exec_ctx * exec_ctx, pick_first_lb_policy * p)
-{
+static void add_interested_parties_locked(grpc_exec_ctx *exec_ctx,
+                                          pick_first_lb_policy *p) {
   pending_pick *pp;
-  for (pp = p->pending_picks; pp; pp = pp->next)
-    {
-      grpc_subchannel_add_interested_party (exec_ctx, p->subchannels[p->checking_subchannel], pp->pollset);
-    }
+  for (pp = p->pending_picks; pp; pp = pp->next) {
+    grpc_subchannel_add_interested_party(
+        exec_ctx, p->subchannels[p->checking_subchannel], pp->pollset);
+  }
 }
 
-void
-pf_destroy (grpc_exec_ctx * exec_ctx, grpc_lb_policy * pol)
-{
-  pick_first_lb_policy *p = (pick_first_lb_policy *) pol;
+void pf_destroy(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
+  pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
   size_t i;
-  GPR_ASSERT (p->pending_picks == NULL);
-  for (i = 0; i < p->num_subchannels; i++)
-    {
-      GRPC_SUBCHANNEL_UNREF (exec_ctx, p->subchannels[i], "pick_first");
-    }
-  grpc_connectivity_state_destroy (exec_ctx, &p->state_tracker);
-  gpr_free (p->subchannels);
-  gpr_mu_destroy (&p->mu);
-  gpr_free (p);
+  GPR_ASSERT(p->pending_picks == NULL);
+  for (i = 0; i < p->num_subchannels; i++) {
+    GRPC_SUBCHANNEL_UNREF(exec_ctx, p->subchannels[i], "pick_first");
+  }
+  grpc_connectivity_state_destroy(exec_ctx, &p->state_tracker);
+  gpr_free(p->subchannels);
+  gpr_mu_destroy(&p->mu);
+  gpr_free(p);
 }
 
-void
-pf_shutdown (grpc_exec_ctx * exec_ctx, grpc_lb_policy * pol)
-{
-  pick_first_lb_policy *p = (pick_first_lb_policy *) pol;
+void pf_shutdown(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
+  pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
   pending_pick *pp;
-  gpr_mu_lock (&p->mu);
-  del_interested_parties_locked (exec_ctx, p);
+  gpr_mu_lock(&p->mu);
+  del_interested_parties_locked(exec_ctx, p);
   p->shutdown = 1;
   pp = p->pending_picks;
   p->pending_picks = NULL;
-  grpc_connectivity_state_set (exec_ctx, &p->state_tracker, GRPC_CHANNEL_FATAL_FAILURE, "shutdown");
-  gpr_mu_unlock (&p->mu);
-  while (pp != NULL)
-    {
-      pending_pick *next = pp->next;
-      *pp->target = NULL;
-      grpc_exec_ctx_enqueue (exec_ctx, pp->on_complete, 1);
-      gpr_free (pp);
-      pp = next;
-    }
+  grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
+                              GRPC_CHANNEL_FATAL_FAILURE, "shutdown");
+  gpr_mu_unlock(&p->mu);
+  while (pp != NULL) {
+    pending_pick *next = pp->next;
+    *pp->target = NULL;
+    grpc_exec_ctx_enqueue(exec_ctx, pp->on_complete, 1);
+    gpr_free(pp);
+    pp = next;
+  }
 }
 
-static void
-start_picking (grpc_exec_ctx * exec_ctx, pick_first_lb_policy * p)
-{
+static void start_picking(grpc_exec_ctx *exec_ctx, pick_first_lb_policy *p) {
   p->started_picking = 1;
   p->checking_subchannel = 0;
   p->checking_connectivity = GRPC_CHANNEL_IDLE;
-  GRPC_LB_POLICY_REF (&p->base, "pick_first_connectivity");
-  grpc_subchannel_notify_on_state_change (exec_ctx, p->subchannels[p->checking_subchannel], &p->checking_connectivity, &p->connectivity_changed);
+  GRPC_LB_POLICY_REF(&p->base, "pick_first_connectivity");
+  grpc_subchannel_notify_on_state_change(
+      exec_ctx, p->subchannels[p->checking_subchannel],
+      &p->checking_connectivity, &p->connectivity_changed);
 }
 
-void
-pf_exit_idle (grpc_exec_ctx * exec_ctx, grpc_lb_policy * pol)
-{
-  pick_first_lb_policy *p = (pick_first_lb_policy *) pol;
-  gpr_mu_lock (&p->mu);
-  if (!p->started_picking)
-    {
-      start_picking (exec_ctx, p);
-    }
-  gpr_mu_unlock (&p->mu);
+void pf_exit_idle(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
+  pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
+  gpr_mu_lock(&p->mu);
+  if (!p->started_picking) {
+    start_picking(exec_ctx, p);
+  }
+  gpr_mu_unlock(&p->mu);
 }
 
-void
-pf_pick (grpc_exec_ctx * exec_ctx, grpc_lb_policy * pol, grpc_pollset * pollset, grpc_metadata_batch * initial_metadata, grpc_subchannel ** target, grpc_closure * on_complete)
-{
-  pick_first_lb_policy *p = (pick_first_lb_policy *) pol;
+void pf_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,
+             grpc_pollset *pollset, grpc_metadata_batch *initial_metadata,
+             grpc_subchannel **target, grpc_closure *on_complete) {
+  pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
   pending_pick *pp;
-  gpr_mu_lock (&p->mu);
-  if (p->selected)
-    {
-      gpr_mu_unlock (&p->mu);
-      *target = p->selected;
-      grpc_exec_ctx_enqueue (exec_ctx, on_complete, 1);
-    }
-  else
-    {
-      if (!p->started_picking)
-	{
-	  start_picking (exec_ctx, p);
-	}
-      grpc_subchannel_add_interested_party (exec_ctx, p->subchannels[p->checking_subchannel], pollset);
-      pp = gpr_malloc (sizeof (*pp));
-      pp->next = p->pending_picks;
-      pp->pollset = pollset;
-      pp->target = target;
-      pp->on_complete = on_complete;
-      p->pending_picks = pp;
-      gpr_mu_unlock (&p->mu);
+  gpr_mu_lock(&p->mu);
+  if (p->selected) {
+    gpr_mu_unlock(&p->mu);
+    *target = p->selected;
+    grpc_exec_ctx_enqueue(exec_ctx, on_complete, 1);
+  } else {
+    if (!p->started_picking) {
+      start_picking(exec_ctx, p);
     }
+    grpc_subchannel_add_interested_party(
+        exec_ctx, p->subchannels[p->checking_subchannel], pollset);
+    pp = gpr_malloc(sizeof(*pp));
+    pp->next = p->pending_picks;
+    pp->pollset = pollset;
+    pp->target = target;
+    pp->on_complete = on_complete;
+    p->pending_picks = pp;
+    gpr_mu_unlock(&p->mu);
+  }
 }
 
-static void
-pf_connectivity_changed (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_success)
-{
+static void pf_connectivity_changed(grpc_exec_ctx *exec_ctx, void *arg,
+                                    int iomgr_success) {
   pick_first_lb_policy *p = arg;
   pending_pick *pp;
 
-  gpr_mu_lock (&p->mu);
+  gpr_mu_lock(&p->mu);
 
-  if (p->shutdown)
-    {
-      gpr_mu_unlock (&p->mu);
-      GRPC_LB_POLICY_UNREF (exec_ctx, &p->base, "pick_first_connectivity");
-      return;
+  if (p->shutdown) {
+    gpr_mu_unlock(&p->mu);
+    GRPC_LB_POLICY_UNREF(exec_ctx, &p->base, "pick_first_connectivity");
+    return;
+  } else if (p->selected != NULL) {
+    grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
+                                p->checking_connectivity, "selected_changed");
+    if (p->checking_connectivity != GRPC_CHANNEL_FATAL_FAILURE) {
+      grpc_subchannel_notify_on_state_change(exec_ctx, p->selected,
+                                             &p->checking_connectivity,
+                                             &p->connectivity_changed);
+    } else {
+      GRPC_LB_POLICY_UNREF(exec_ctx, &p->base, "pick_first_connectivity");
     }
-  else if (p->selected != NULL)
-    {
-      grpc_connectivity_state_set (exec_ctx, &p->state_tracker, p->checking_connectivity, "selected_changed");
-      if (p->checking_connectivity != GRPC_CHANNEL_FATAL_FAILURE)
-	{
-	  grpc_subchannel_notify_on_state_change (exec_ctx, p->selected, &p->checking_connectivity, &p->connectivity_changed);
-	}
-      else
-	{
-	  GRPC_LB_POLICY_UNREF (exec_ctx, &p->base, "pick_first_connectivity");
-	}
-    }
-  else
-    {
-    loop:
-      switch (p->checking_connectivity)
-	{
-	case GRPC_CHANNEL_READY:
-	  grpc_connectivity_state_set (exec_ctx, &p->state_tracker, GRPC_CHANNEL_READY, "connecting_ready");
-	  p->selected = p->subchannels[p->checking_subchannel];
-	  while ((pp = p->pending_picks))
-	    {
-	      p->pending_picks = pp->next;
-	      *pp->target = p->selected;
-	      grpc_subchannel_del_interested_party (exec_ctx, p->selected, pp->pollset);
-	      grpc_exec_ctx_enqueue (exec_ctx, pp->on_complete, 1);
-	      gpr_free (pp);
-	    }
-	  grpc_subchannel_notify_on_state_change (exec_ctx, p->selected, &p->checking_connectivity, &p->connectivity_changed);
-	  break;
-	case GRPC_CHANNEL_TRANSIENT_FAILURE:
-	  grpc_connectivity_state_set (exec_ctx, &p->state_tracker, GRPC_CHANNEL_TRANSIENT_FAILURE, "connecting_transient_failure");
-	  del_interested_parties_locked (exec_ctx, p);
-	  p->checking_subchannel = (p->checking_subchannel + 1) % p->num_subchannels;
-	  p->checking_connectivity = grpc_subchannel_check_connectivity (p->subchannels[p->checking_subchannel]);
-	  add_interested_parties_locked (exec_ctx, p);
-	  if (p->checking_connectivity == GRPC_CHANNEL_TRANSIENT_FAILURE)
-	    {
-	      grpc_subchannel_notify_on_state_change (exec_ctx, p->subchannels[p->checking_subchannel], &p->checking_connectivity, &p->connectivity_changed);
-	    }
-	  else
-	    {
-	      goto loop;
-	    }
-	  break;
-	case GRPC_CHANNEL_CONNECTING:
-	case GRPC_CHANNEL_IDLE:
-	  grpc_connectivity_state_set (exec_ctx, &p->state_tracker, GRPC_CHANNEL_CONNECTING, "connecting_changed");
-	  grpc_subchannel_notify_on_state_change (exec_ctx, p->subchannels[p->checking_subchannel], &p->checking_connectivity, &p->connectivity_changed);
-	  break;
-	case GRPC_CHANNEL_FATAL_FAILURE:
-	  del_interested_parties_locked (exec_ctx, p);
-	  GPR_SWAP (grpc_subchannel *, p->subchannels[p->checking_subchannel], p->subchannels[p->num_subchannels - 1]);
-	  p->num_subchannels--;
-	  GRPC_SUBCHANNEL_UNREF (exec_ctx, p->subchannels[p->num_subchannels], "pick_first");
-	  if (p->num_subchannels == 0)
-	    {
-	      grpc_connectivity_state_set (exec_ctx, &p->state_tracker, GRPC_CHANNEL_FATAL_FAILURE, "no_more_channels");
-	      while ((pp = p->pending_picks))
-		{
-		  p->pending_picks = pp->next;
-		  *pp->target = NULL;
-		  grpc_exec_ctx_enqueue (exec_ctx, pp->on_complete, 1);
-		  gpr_free (pp);
-		}
-	      GRPC_LB_POLICY_UNREF (exec_ctx, &p->base, "pick_first_connectivity");
-	    }
-	  else
-	    {
-	      grpc_connectivity_state_set (exec_ctx, &p->state_tracker, GRPC_CHANNEL_TRANSIENT_FAILURE, "subchannel_failed");
-	      p->checking_subchannel %= p->num_subchannels;
-	      p->checking_connectivity = grpc_subchannel_check_connectivity (p->subchannels[p->checking_subchannel]);
-	      add_interested_parties_locked (exec_ctx, p);
-	      goto loop;
-	    }
-	}
+  } else {
+  loop:
+    switch (p->checking_connectivity) {
+      case GRPC_CHANNEL_READY:
+        grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
+                                    GRPC_CHANNEL_READY, "connecting_ready");
+        p->selected = p->subchannels[p->checking_subchannel];
+        while ((pp = p->pending_picks)) {
+          p->pending_picks = pp->next;
+          *pp->target = p->selected;
+          grpc_subchannel_del_interested_party(exec_ctx, p->selected,
+                                               pp->pollset);
+          grpc_exec_ctx_enqueue(exec_ctx, pp->on_complete, 1);
+          gpr_free(pp);
+        }
+        grpc_subchannel_notify_on_state_change(exec_ctx, p->selected,
+                                               &p->checking_connectivity,
+                                               &p->connectivity_changed);
+        break;
+      case GRPC_CHANNEL_TRANSIENT_FAILURE:
+        grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
+                                    GRPC_CHANNEL_TRANSIENT_FAILURE,
+                                    "connecting_transient_failure");
+        del_interested_parties_locked(exec_ctx, p);
+        p->checking_subchannel =
+            (p->checking_subchannel + 1) % p->num_subchannels;
+        p->checking_connectivity = grpc_subchannel_check_connectivity(
+            p->subchannels[p->checking_subchannel]);
+        add_interested_parties_locked(exec_ctx, p);
+        if (p->checking_connectivity == GRPC_CHANNEL_TRANSIENT_FAILURE) {
+          grpc_subchannel_notify_on_state_change(
+              exec_ctx, p->subchannels[p->checking_subchannel],
+              &p->checking_connectivity, &p->connectivity_changed);
+        } else {
+          goto loop;
+        }
+        break;
+      case GRPC_CHANNEL_CONNECTING:
+      case GRPC_CHANNEL_IDLE:
+        grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
+                                    GRPC_CHANNEL_CONNECTING,
+                                    "connecting_changed");
+        grpc_subchannel_notify_on_state_change(
+            exec_ctx, p->subchannels[p->checking_subchannel],
+            &p->checking_connectivity, &p->connectivity_changed);
+        break;
+      case GRPC_CHANNEL_FATAL_FAILURE:
+        del_interested_parties_locked(exec_ctx, p);
+        GPR_SWAP(grpc_subchannel *, p->subchannels[p->checking_subchannel],
+                 p->subchannels[p->num_subchannels - 1]);
+        p->num_subchannels--;
+        GRPC_SUBCHANNEL_UNREF(exec_ctx, p->subchannels[p->num_subchannels],
+                              "pick_first");
+        if (p->num_subchannels == 0) {
+          grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
+                                      GRPC_CHANNEL_FATAL_FAILURE,
+                                      "no_more_channels");
+          while ((pp = p->pending_picks)) {
+            p->pending_picks = pp->next;
+            *pp->target = NULL;
+            grpc_exec_ctx_enqueue(exec_ctx, pp->on_complete, 1);
+            gpr_free(pp);
+          }
+          GRPC_LB_POLICY_UNREF(exec_ctx, &p->base, "pick_first_connectivity");
+        } else {
+          grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
+                                      GRPC_CHANNEL_TRANSIENT_FAILURE,
+                                      "subchannel_failed");
+          p->checking_subchannel %= p->num_subchannels;
+          p->checking_connectivity = grpc_subchannel_check_connectivity(
+              p->subchannels[p->checking_subchannel]);
+          add_interested_parties_locked(exec_ctx, p);
+          goto loop;
+        }
     }
+  }
 
-  gpr_mu_unlock (&p->mu);
+  gpr_mu_unlock(&p->mu);
 }
 
-static void
-pf_broadcast (grpc_exec_ctx * exec_ctx, grpc_lb_policy * pol, grpc_transport_op * op)
-{
-  pick_first_lb_policy *p = (pick_first_lb_policy *) pol;
+static void pf_broadcast(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,
+                         grpc_transport_op *op) {
+  pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
   size_t i;
   size_t n;
   grpc_subchannel **subchannels;
 
-  gpr_mu_lock (&p->mu);
+  gpr_mu_lock(&p->mu);
   n = p->num_subchannels;
-  subchannels = gpr_malloc (n * sizeof (*subchannels));
-  for (i = 0; i < n; i++)
-    {
-      subchannels[i] = p->subchannels[i];
-      GRPC_SUBCHANNEL_REF (subchannels[i], "pf_broadcast");
-    }
-  gpr_mu_unlock (&p->mu);
+  subchannels = gpr_malloc(n * sizeof(*subchannels));
+  for (i = 0; i < n; i++) {
+    subchannels[i] = p->subchannels[i];
+    GRPC_SUBCHANNEL_REF(subchannels[i], "pf_broadcast");
+  }
+  gpr_mu_unlock(&p->mu);
 
-  for (i = 0; i < n; i++)
-    {
-      grpc_subchannel_process_transport_op (exec_ctx, subchannels[i], op);
-      GRPC_SUBCHANNEL_UNREF (exec_ctx, subchannels[i], "pf_broadcast");
-    }
-  gpr_free (subchannels);
+  for (i = 0; i < n; i++) {
+    grpc_subchannel_process_transport_op(exec_ctx, subchannels[i], op);
+    GRPC_SUBCHANNEL_UNREF(exec_ctx, subchannels[i], "pf_broadcast");
+  }
+  gpr_free(subchannels);
 }
 
-static grpc_connectivity_state
-pf_check_connectivity (grpc_exec_ctx * exec_ctx, grpc_lb_policy * pol)
-{
-  pick_first_lb_policy *p = (pick_first_lb_policy *) pol;
+static grpc_connectivity_state pf_check_connectivity(grpc_exec_ctx *exec_ctx,
+                                                     grpc_lb_policy *pol) {
+  pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
   grpc_connectivity_state st;
-  gpr_mu_lock (&p->mu);
-  st = grpc_connectivity_state_check (&p->state_tracker);
-  gpr_mu_unlock (&p->mu);
+  gpr_mu_lock(&p->mu);
+  st = grpc_connectivity_state_check(&p->state_tracker);
+  gpr_mu_unlock(&p->mu);
   return st;
 }
 
-void
-pf_notify_on_state_change (grpc_exec_ctx * exec_ctx, grpc_lb_policy * pol, grpc_connectivity_state * current, grpc_closure * notify)
-{
-  pick_first_lb_policy *p = (pick_first_lb_policy *) pol;
-  gpr_mu_lock (&p->mu);
-  grpc_connectivity_state_notify_on_state_change (exec_ctx, &p->state_tracker, current, notify);
-  gpr_mu_unlock (&p->mu);
+void pf_notify_on_state_change(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,
+                               grpc_connectivity_state *current,
+                               grpc_closure *notify) {
+  pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
+  gpr_mu_lock(&p->mu);
+  grpc_connectivity_state_notify_on_state_change(exec_ctx, &p->state_tracker,
+                                                 current, notify);
+  gpr_mu_unlock(&p->mu);
 }
 
 static const grpc_lb_policy_vtable pick_first_lb_policy_vtable = {
-  pf_destroy,
-  pf_shutdown,
-  pf_pick,
-  pf_exit_idle,
-  pf_broadcast,
-  pf_check_connectivity,
-  pf_notify_on_state_change
-};
+    pf_destroy,
+    pf_shutdown,
+    pf_pick,
+    pf_exit_idle,
+    pf_broadcast,
+    pf_check_connectivity,
+    pf_notify_on_state_change};
 
-static void
-pick_first_factory_ref (grpc_lb_policy_factory * factory)
-{
-}
+static void pick_first_factory_ref(grpc_lb_policy_factory *factory) {}
 
-static void
-pick_first_factory_unref (grpc_lb_policy_factory * factory)
-{
-}
+static void pick_first_factory_unref(grpc_lb_policy_factory *factory) {}
 
-static grpc_lb_policy *
-create_pick_first (grpc_lb_policy_factory * factory, grpc_lb_policy_args * args)
-{
-  pick_first_lb_policy *p = gpr_malloc (sizeof (*p));
-  GPR_ASSERT (args->num_subchannels > 0);
-  memset (p, 0, sizeof (*p));
-  grpc_lb_policy_init (&p->base, &pick_first_lb_policy_vtable);
-  p->subchannels = gpr_malloc (sizeof (grpc_subchannel *) * args->num_subchannels);
+static grpc_lb_policy *create_pick_first(grpc_lb_policy_factory *factory,
+                                         grpc_lb_policy_args *args) {
+  pick_first_lb_policy *p = gpr_malloc(sizeof(*p));
+  GPR_ASSERT(args->num_subchannels > 0);
+  memset(p, 0, sizeof(*p));
+  grpc_lb_policy_init(&p->base, &pick_first_lb_policy_vtable);
+  p->subchannels =
+      gpr_malloc(sizeof(grpc_subchannel *) * args->num_subchannels);
   p->num_subchannels = args->num_subchannels;
-  grpc_connectivity_state_init (&p->state_tracker, GRPC_CHANNEL_IDLE, "pick_first");
-  memcpy (p->subchannels, args->subchannels, sizeof (grpc_subchannel *) * args->num_subchannels);
-  grpc_closure_init (&p->connectivity_changed, pf_connectivity_changed, p);
-  gpr_mu_init (&p->mu);
+  grpc_connectivity_state_init(&p->state_tracker, GRPC_CHANNEL_IDLE,
+                               "pick_first");
+  memcpy(p->subchannels, args->subchannels,
+         sizeof(grpc_subchannel *) * args->num_subchannels);
+  grpc_closure_init(&p->connectivity_changed, pf_connectivity_changed, p);
+  gpr_mu_init(&p->mu);
   return &p->base;
 }
 
 static const grpc_lb_policy_factory_vtable pick_first_factory_vtable = {
-  pick_first_factory_ref, pick_first_factory_unref, create_pick_first,
-  "pick_first"
-};
+    pick_first_factory_ref, pick_first_factory_unref, create_pick_first,
+    "pick_first"};
 
 static grpc_lb_policy_factory pick_first_lb_policy_factory = {
-  &pick_first_factory_vtable
-};
+    &pick_first_factory_vtable};
 
-grpc_lb_policy_factory *
-grpc_pick_first_lb_factory_create ()
-{
+grpc_lb_policy_factory *grpc_pick_first_lb_factory_create() {
   return &pick_first_lb_policy_factory;
 }

src/core/client_config/lb_policies/pick_first.h

@@ -38,6 +38,6 @@
 
 /** Returns a load balancing factory for the pick first policy, which picks up
  * the first subchannel from \a subchannels to succesfully connect */
-grpc_lb_policy_factory *grpc_pick_first_lb_factory_create ();
+grpc_lb_policy_factory *grpc_pick_first_lb_factory_create();
 
 #endif

src/core/client_config/lb_policies/round_robin.c

@@ -43,8 +43,7 @@ int grpc_lb_round_robin_trace = 0;
 /** List of entities waiting for a pick.
  *
  * Once a pick is available, \a target is updated and \a on_complete called. */
-typedef struct pending_pick
-{
+typedef struct pending_pick {
   struct pending_pick *next;
   grpc_pollset *pollset;
   grpc_subchannel **target;
@@ -52,21 +51,18 @@ typedef struct pending_pick
 } pending_pick;
 
 /** List of subchannels in a connectivity READY state */
-typedef struct ready_list
-{
+typedef struct ready_list {
   grpc_subchannel *subchannel;
   struct ready_list *next;
   struct ready_list *prev;
 } ready_list;
 
-typedef struct
-{
+typedef struct {
   size_t subchannel_idx; /**< Index over p->subchannels */
-  void *p;		 /**< round_robin_lb_policy instance */
+  void *p;               /**< round_robin_lb_policy instance */
 } connectivity_changed_cb_arg;
 
-typedef struct
-{
+typedef struct {
   /** base policy: must be first */
   grpc_lb_policy base;
 
@@ -110,264 +106,224 @@ typedef struct
  *
  * Note that this function does *not* advance p->ready_list_last_pick. Use \a
  * advance_last_picked_locked() for that. */
-static ready_list *
-peek_next_connected_locked (const round_robin_lb_policy * p)
-{
+static ready_list *peek_next_connected_locked(const round_robin_lb_policy *p) {
   ready_list *selected;
   selected = p->ready_list_last_pick->next;
 
-  while (selected != NULL)
-    {
-      if (selected == &p->ready_list)
-	{
-	  GPR_ASSERT (selected->subchannel == NULL);
-	  /* skip dummy root */
-	  selected = selected->next;
-	}
-      else
-	{
-	  GPR_ASSERT (selected->subchannel != NULL);
-	  return selected;
-	}
+  while (selected != NULL) {
+    if (selected == &p->ready_list) {
+      GPR_ASSERT(selected->subchannel == NULL);
+      /* skip dummy root */
+      selected = selected->next;
+    } else {
+      GPR_ASSERT(selected->subchannel != NULL);
+      return selected;
     }
+  }
   return NULL;
 }
 
 /** Advance the \a ready_list picking head. */
-static void
-advance_last_picked_locked (round_robin_lb_policy * p)
-{
-  if (p->ready_list_last_pick->next != NULL)
-    {				/* non-empty list */
+static void advance_last_picked_locked(round_robin_lb_policy *p) {
+  if (p->ready_list_last_pick->next != NULL) { /* non-empty list */
+    p->ready_list_last_pick = p->ready_list_last_pick->next;
+    if (p->ready_list_last_pick == &p->ready_list) {
+      /* skip dummy root */
       p->ready_list_last_pick = p->ready_list_last_pick->next;
-      if (p->ready_list_last_pick == &p->ready_list)
-	{
-	  /* skip dummy root */
-	  p->ready_list_last_pick = p->ready_list_last_pick->next;
-	}
-    }
-  else
-    {				/* should be an empty list */
-      GPR_ASSERT (p->ready_list_last_pick == &p->ready_list);
-    }
-
-  if (grpc_lb_round_robin_trace)
-    {
-      gpr_log (GPR_DEBUG, "[READYLIST] ADVANCED LAST PICK. NOW AT NODE %p (SC %p)", p->ready_list_last_pick, p->ready_list_last_pick->subchannel);
     }
+  } else { /* should be an empty list */
+    GPR_ASSERT(p->ready_list_last_pick == &p->ready_list);
+  }
+
+  if (grpc_lb_round_robin_trace) {
+    gpr_log(GPR_DEBUG, "[READYLIST] ADVANCED LAST PICK. NOW AT NODE %p (SC %p)",
+            p->ready_list_last_pick, p->ready_list_last_pick->subchannel);
+  }
 }
 
 /** Prepends (relative to the root at p->ready_list) the connected subchannel \a
  * csc to the list of ready subchannels. */
-static ready_list *
-add_connected_sc_locked (round_robin_lb_policy * p, grpc_subchannel * csc)
-{
-  ready_list *new_elem = gpr_malloc (sizeof (ready_list));
+static ready_list *add_connected_sc_locked(round_robin_lb_policy *p,
+                                           grpc_subchannel *csc) {
+  ready_list *new_elem = gpr_malloc(sizeof(ready_list));
   new_elem->subchannel = csc;
-  if (p->ready_list.prev == NULL)
-    {
-      /* first element */
-      new_elem->next = &p->ready_list;
-      new_elem->prev = &p->ready_list;
-      p->ready_list.next = new_elem;
-      p->ready_list.prev = new_elem;
-    }
-  else
-    {
-      new_elem->next = &p->ready_list;
-      new_elem->prev = p->ready_list.prev;
-      p->ready_list.prev->next = new_elem;
-      p->ready_list.prev = new_elem;
-    }
-  if (grpc_lb_round_robin_trace)
-    {
-      gpr_log (GPR_DEBUG, "[READYLIST] ADDING NODE %p (SC %p)", new_elem, csc);
-    }
+  if (p->ready_list.prev == NULL) {
+    /* first element */
+    new_elem->next = &p->ready_list;
+    new_elem->prev = &p->ready_list;
+    p->ready_list.next = new_elem;
+    p->ready_list.prev = new_elem;
+  } else {
+    new_elem->next = &p->ready_list;
+    new_elem->prev = p->ready_list.prev;
+    p->ready_list.prev->next = new_elem;
+    p->ready_list.prev = new_elem;
+  }
+  if (grpc_lb_round_robin_trace) {
+    gpr_log(GPR_DEBUG, "[READYLIST] ADDING NODE %p (SC %p)", new_elem, csc);
+  }
   return new_elem;
 }
 
 /** Removes \a node from the list of connected subchannels */
-static void
-remove_disconnected_sc_locked (round_robin_lb_policy * p, ready_list * node)
-{
-  if (node == NULL)
-    {
-      return;
-    }
-  if (node == p->ready_list_last_pick)
-    {
-      /* If removing the lastly picked node, reset the last pick pointer to the
-       * dummy root of the list */
-      p->ready_list_last_pick = &p->ready_list;
-    }
+static void remove_disconnected_sc_locked(round_robin_lb_policy *p,
+                                          ready_list *node) {
+  if (node == NULL) {
+    return;
+  }
+  if (node == p->ready_list_last_pick) {
+    /* If removing the lastly picked node, reset the last pick pointer to the
+     * dummy root of the list */
+    p->ready_list_last_pick = &p->ready_list;
+  }
 
   /* removing last item */
-  if (node->next == &p->ready_list && node->prev == &p->ready_list)
-    {
-      GPR_ASSERT (p->ready_list.next == node);
-      GPR_ASSERT (p->ready_list.prev == node);
-      p->ready_list.next = NULL;
-      p->ready_list.prev = NULL;
-    }
-  else
-    {
-      node->prev->next = node->next;
-      node->next->prev = node->prev;
-    }
-
-  if (grpc_lb_round_robin_trace)
-    {
-      gpr_log (GPR_DEBUG, "[READYLIST] REMOVED NODE %p (SC %p)", node, node->subchannel);
-    }
+  if (node->next == &p->ready_list && node->prev == &p->ready_list) {
+    GPR_ASSERT(p->ready_list.next == node);
+    GPR_ASSERT(p->ready_list.prev == node);
+    p->ready_list.next = NULL;
+    p->ready_list.prev = NULL;
+  } else {
+    node->prev->next = node->next;
+    node->next->prev = node->prev;
+  }
+
+  if (grpc_lb_round_robin_trace) {
+    gpr_log(GPR_DEBUG, "[READYLIST] REMOVED NODE %p (SC %p)", node,
+            node->subchannel);
+  }
 
   node->next = NULL;
   node->prev = NULL;
   node->subchannel = NULL;
 
-  gpr_free (node);
+  gpr_free(node);
 }
 
-static void
-del_interested_parties_locked (grpc_exec_ctx * exec_ctx, round_robin_lb_policy * p, const size_t subchannel_idx)
-{
+static void del_interested_parties_locked(grpc_exec_ctx *exec_ctx,
+                                          round_robin_lb_policy *p,
+                                          const size_t subchannel_idx) {
   pending_pick *pp;
-  for (pp = p->pending_picks; pp; pp = pp->next)
-    {
-      grpc_subchannel_del_interested_party (exec_ctx, p->subchannels[subchannel_idx], pp->pollset);
-    }
+  for (pp = p->pending_picks; pp; pp = pp->next) {
+    grpc_subchannel_del_interested_party(
+        exec_ctx, p->subchannels[subchannel_idx], pp->pollset);
+  }
 }
 
-void
-rr_destroy (grpc_exec_ctx * exec_ctx, grpc_lb_policy * pol)
-{
-  round_robin_lb_policy *p = (round_robin_lb_policy *) pol;
+void rr_destroy(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
+  round_robin_lb_policy *p = (round_robin_lb_policy *)pol;
   size_t i;
   ready_list *elem;
-  for (i = 0; i < p->num_subchannels; i++)
-    {
-      del_interested_parties_locked (exec_ctx, p, i);
-    }
-  for (i = 0; i < p->num_subchannels; i++)
-    {
-      GRPC_SUBCHANNEL_UNREF (exec_ctx, p->subchannels[i], "round_robin");
-    }
-  gpr_free (p->connectivity_changed_cbs);
-  gpr_free (p->subchannel_connectivity);
-
-  grpc_connectivity_state_destroy (exec_ctx, &p->state_tracker);
-  gpr_free (p->subchannels);
-  gpr_mu_destroy (&p->mu);
+  for (i = 0; i < p->num_subchannels; i++) {
+    del_interested_parties_locked(exec_ctx, p, i);
+  }
+  for (i = 0; i < p->num_subchannels; i++) {
+    GRPC_SUBCHANNEL_UNREF(exec_ctx, p->subchannels[i], "round_robin");
+  }
+  gpr_free(p->connectivity_changed_cbs);
+  gpr_free(p->subchannel_connectivity);
+
+  grpc_connectivity_state_destroy(exec_ctx, &p->state_tracker);
+  gpr_free(p->subchannels);
+  gpr_mu_destroy(&p->mu);
 
   elem = p->ready_list.next;
-  while (elem != NULL && elem != &p->ready_list)
-    {
-      ready_list *tmp;
-      tmp = elem->next;
-      elem->next = NULL;
-      elem->prev = NULL;
-      elem->subchannel = NULL;
-      gpr_free (elem);
-      elem = tmp;
-    }
-  gpr_free (p->subchannel_index_to_readylist_node);
-  gpr_free (p->cb_args);
-  gpr_free (p);
+  while (elem != NULL && elem != &p->ready_list) {
+    ready_list *tmp;
+    tmp = elem->next;
+    elem->next = NULL;
+    elem->prev = NULL;
+    elem->subchannel = NULL;
+    gpr_free(elem);
+    elem = tmp;
+  }
+  gpr_free(p->subchannel_index_to_readylist_node);
+  gpr_free(p->cb_args);
+  gpr_free(p);
 }
 
-void
-rr_shutdown (grpc_exec_ctx * exec_ctx, grpc_lb_policy * pol)
-{
+void rr_shutdown(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
   size_t i;
-  round_robin_lb_policy *p = (round_robin_lb_policy *) pol;
+  round_robin_lb_policy *p = (round_robin_lb_policy *)pol;
   pending_pick *pp;
-  gpr_mu_lock (&p->mu);
+  gpr_mu_lock(&p->mu);
 
-  for (i = 0; i < p->num_subchannels; i++)
-    {
-      del_interested_parties_locked (exec_ctx, p, i);
-    }
+  for (i = 0; i < p->num_subchannels; i++) {
+    del_interested_parties_locked(exec_ctx, p, i);
+  }
 
   p->shutdown = 1;
-  while ((pp = p->pending_picks))
-    {
-      p->pending_picks = pp->next;
-      *pp->target = NULL;
-      grpc_exec_ctx_enqueue (exec_ctx, pp->on_complete, 0);
-      gpr_free (pp);
-    }
-  grpc_connectivity_state_set (exec_ctx, &p->state_tracker, GRPC_CHANNEL_FATAL_FAILURE, "shutdown");
-  gpr_mu_unlock (&p->mu);
+  while ((pp = p->pending_picks)) {
+    p->pending_picks = pp->next;
+    *pp->target = NULL;
+    grpc_exec_ctx_enqueue(exec_ctx, pp->on_complete, 0);
+    gpr_free(pp);
+  }
+  grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
+                              GRPC_CHANNEL_FATAL_FAILURE, "shutdown");
+  gpr_mu_unlock(&p->mu);
 }
 
-static void
-start_picking (grpc_exec_ctx * exec_ctx, round_robin_lb_policy * p)
-{
+static void start_picking(grpc_exec_ctx *exec_ctx, round_robin_lb_policy *p) {
   size_t i;
   p->started_picking = 1;
 
-  for (i = 0; i < p->num_subchannels; i++)
-    {
-      p->subchannel_connectivity[i] = GRPC_CHANNEL_IDLE;
-      grpc_subchannel_notify_on_state_change (exec_ctx, p->subchannels[i], &p->subchannel_connectivity[i], &p->connectivity_changed_cbs[i]);
-      GRPC_LB_POLICY_REF (&p->base, "round_robin_connectivity");
-    }
+  for (i = 0; i < p->num_subchannels; i++) {
+    p->subchannel_connectivity[i] = GRPC_CHANNEL_IDLE;
+    grpc_subchannel_notify_on_state_change(exec_ctx, p->subchannels[i],
+                                           &p->subchannel_connectivity[i],
+                                           &p->connectivity_changed_cbs[i]);
+    GRPC_LB_POLICY_REF(&p->base, "round_robin_connectivity");
+  }
 }
 
-void
-rr_exit_idle (grpc_exec_ctx * exec_ctx, grpc_lb_policy * pol)
-{
-  round_robin_lb_policy *p = (round_robin_lb_policy *) pol;
-  gpr_mu_lock (&p->mu);
-  if (!p->started_picking)
-    {
-      start_picking (exec_ctx, p);
-    }
-  gpr_mu_unlock (&p->mu);
+void rr_exit_idle(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
+  round_robin_lb_policy *p = (round_robin_lb_policy *)pol;
+  gpr_mu_lock(&p->mu);
+  if (!p->started_picking) {
+    start_picking(exec_ctx, p);
+  }
+  gpr_mu_unlock(&p->mu);
 }
 
-void
-rr_pick (grpc_exec_ctx * exec_ctx, grpc_lb_policy * pol, grpc_pollset * pollset, grpc_metadata_batch * initial_metadata, grpc_subchannel ** target, grpc_closure * on_complete)
-{
+void rr_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,
+             grpc_pollset *pollset, grpc_metadata_batch *initial_metadata,
+             grpc_subchannel **target, grpc_closure *on_complete) {
   size_t i;
-  round_robin_lb_policy *p = (round_robin_lb_policy *) pol;
+  round_robin_lb_policy *p = (round_robin_lb_policy *)pol;
   pending_pick *pp;
   ready_list *selected;
-  gpr_mu_lock (&p->mu);
-  if ((selected = peek_next_connected_locked (p)))
-    {
-      gpr_mu_unlock (&p->mu);
-      *target = selected->subchannel;
-      if (grpc_lb_round_robin_trace)
-	{
-	  gpr_log (GPR_DEBUG, "[RR PICK] TARGET <-- SUBCHANNEL %p (NODE %p)", selected->subchannel, selected);
-	}
-      /* only advance the last picked pointer if the selection was used */
-      advance_last_picked_locked (p);
-      on_complete->cb (exec_ctx, on_complete->cb_arg, 1);
+  gpr_mu_lock(&p->mu);
+  if ((selected = peek_next_connected_locked(p))) {
+    gpr_mu_unlock(&p->mu);
+    *target = selected->subchannel;
+    if (grpc_lb_round_robin_trace) {
+      gpr_log(GPR_DEBUG, "[RR PICK] TARGET <-- SUBCHANNEL %p (NODE %p)",
+              selected->subchannel, selected);
+    }
+    /* only advance the last picked pointer if the selection was used */
+    advance_last_picked_locked(p);
+    on_complete->cb(exec_ctx, on_complete->cb_arg, 1);
+  } else {
+    if (!p->started_picking) {
+      start_picking(exec_ctx, p);
     }
-  else
-    {
-      if (!p->started_picking)
-	{
-	  start_picking (exec_ctx, p);
-	}
-      for (i = 0; i < p->num_subchannels; i++)
-	{
-	  grpc_subchannel_add_interested_party (exec_ctx, p->subchannels[i], pollset);
-	}
-      pp = gpr_malloc (sizeof (*pp));
-      pp->next = p->pending_picks;
-      pp->pollset = pollset;
-      pp->target = target;
-      pp->on_complete = on_complete;
-      p->pending_picks = pp;
-      gpr_mu_unlock (&p->mu);
+    for (i = 0; i < p->num_subchannels; i++) {
+      grpc_subchannel_add_interested_party(exec_ctx, p->subchannels[i],
+                                           pollset);
     }
+    pp = gpr_malloc(sizeof(*pp));
+    pp->next = p->pending_picks;
+    pp->pollset = pollset;
+    pp->target = target;
+    pp->on_complete = on_complete;
+    p->pending_picks = pp;
+    gpr_mu_unlock(&p->mu);
+  }
 }
 
-static void
-rr_connectivity_changed (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_success)
-{
+static void rr_connectivity_changed(grpc_exec_ctx *exec_ctx, void *arg,
+                                    int iomgr_success) {
   connectivity_changed_cb_arg *cb_arg = arg;
   round_robin_lb_policy *p = cb_arg->p;
   /* index over p->subchannels of this cb's subchannel */
@@ -380,194 +336,198 @@ rr_connectivity_changed (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_success)
   /* connectivity state of this cb's subchannel */
   grpc_connectivity_state *this_connectivity;
 
-  gpr_mu_lock (&p->mu);
+  gpr_mu_lock(&p->mu);
 
   this_connectivity = &p->subchannel_connectivity[this_idx];
 
-  if (p->shutdown)
-    {
-      unref = 1;
-    }
-  else
-    {
-      switch (*this_connectivity)
-	{
-	case GRPC_CHANNEL_READY:
-	  grpc_connectivity_state_set (exec_ctx, &p->state_tracker, GRPC_CHANNEL_READY, "connecting_ready");
-	  /* add the newly connected subchannel to the list of connected ones.
-	   * Note that it goes to the "end of the line". */
-	  p->subchannel_index_to_readylist_node[this_idx] = add_connected_sc_locked (p, p->subchannels[this_idx]);
-	  /* at this point we know there's at least one suitable subchannel. Go
-	   * ahead and pick one and notify the pending suitors in
-	   * p->pending_picks. This preemtively replicates rr_pick()'s actions. */
-	  selected = peek_next_connected_locked (p);
-	  if (p->pending_picks != NULL)
-	    {
-	      /* if the selected subchannel is going to be used for the pending
-	       * picks, update the last picked pointer */
-	      advance_last_picked_locked (p);
-	    }
-	  while ((pp = p->pending_picks))
-	    {
-	      p->pending_picks = pp->next;
-	      *pp->target = selected->subchannel;
-	      if (grpc_lb_round_robin_trace)
-		{
-		  gpr_log (GPR_DEBUG, "[RR CONN CHANGED] TARGET <-- SUBCHANNEL %p (NODE %p)", selected->subchannel, selected);
-		}
-	      grpc_subchannel_del_interested_party (exec_ctx, selected->subchannel, pp->pollset);
-	      grpc_exec_ctx_enqueue (exec_ctx, pp->on_complete, 1);
-	      gpr_free (pp);
-	    }
-	  grpc_subchannel_notify_on_state_change (exec_ctx, p->subchannels[this_idx], this_connectivity, &p->connectivity_changed_cbs[this_idx]);
-	  break;
-	case GRPC_CHANNEL_CONNECTING:
-	case GRPC_CHANNEL_IDLE:
-	  grpc_connectivity_state_set (exec_ctx, &p->state_tracker, *this_connectivity, "connecting_changed");
-	  grpc_subchannel_notify_on_state_change (exec_ctx, p->subchannels[this_idx], this_connectivity, &p->connectivity_changed_cbs[this_idx]);
-	  break;
-	case GRPC_CHANNEL_TRANSIENT_FAILURE:
-	  del_interested_parties_locked (exec_ctx, p, this_idx);
-	  /* renew state notification */
-	  grpc_subchannel_notify_on_state_change (exec_ctx, p->subchannels[this_idx], this_connectivity, &p->connectivity_changed_cbs[this_idx]);
-
-	  /* remove from ready list if still present */
-	  if (p->subchannel_index_to_readylist_node[this_idx] != NULL)
-	    {
-	      remove_disconnected_sc_locked (p, p->subchannel_index_to_readylist_node[this_idx]);
-	      p->subchannel_index_to_readylist_node[this_idx] = NULL;
-	    }
-	  grpc_connectivity_state_set (exec_ctx, &p->state_tracker, GRPC_CHANNEL_TRANSIENT_FAILURE, "connecting_transient_failure");
-	  break;
-	case GRPC_CHANNEL_FATAL_FAILURE:
-	  del_interested_parties_locked (exec_ctx, p, this_idx);
-	  if (p->subchannel_index_to_readylist_node[this_idx] != NULL)
-	    {
-	      remove_disconnected_sc_locked (p, p->subchannel_index_to_readylist_node[this_idx]);
-	      p->subchannel_index_to_readylist_node[this_idx] = NULL;
-	    }
-
-	  GPR_SWAP (grpc_subchannel *, p->subchannels[this_idx], p->subchannels[p->num_subchannels - 1]);
-	  p->num_subchannels--;
-	  GRPC_SUBCHANNEL_UNREF (exec_ctx, p->subchannels[p->num_subchannels], "round_robin");
-
-	  if (p->num_subchannels == 0)
-	    {
-	      grpc_connectivity_state_set (exec_ctx, &p->state_tracker, GRPC_CHANNEL_FATAL_FAILURE, "no_more_channels");
-	      while ((pp = p->pending_picks))
-		{
-		  p->pending_picks = pp->next;
-		  *pp->target = NULL;
-		  grpc_exec_ctx_enqueue (exec_ctx, pp->on_complete, 1);
-		  gpr_free (pp);
-		}
-	      unref = 1;
-	    }
-	  else
-	    {
-	      grpc_connectivity_state_set (exec_ctx, &p->state_tracker, GRPC_CHANNEL_TRANSIENT_FAILURE, "subchannel_failed");
-	    }
-	}			/* switch */
-    }				/* !unref */
-
-  gpr_mu_unlock (&p->mu);
-
-  if (unref)
-    {
-      GRPC_LB_POLICY_UNREF (exec_ctx, &p->base, "round_robin_connectivity");
-    }
+  if (p->shutdown) {
+    unref = 1;
+  } else {
+    switch (*this_connectivity) {
+      case GRPC_CHANNEL_READY:
+        grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
+                                    GRPC_CHANNEL_READY, "connecting_ready");
+        /* add the newly connected subchannel to the list of connected ones.
+         * Note that it goes to the "end of the line". */
+        p->subchannel_index_to_readylist_node[this_idx] =
+            add_connected_sc_locked(p, p->subchannels[this_idx]);
+        /* at this point we know there's at least one suitable subchannel. Go
+         * ahead and pick one and notify the pending suitors in
+         * p->pending_picks. This preemtively replicates rr_pick()'s actions. */
+        selected = peek_next_connected_locked(p);
+        if (p->pending_picks != NULL) {
+          /* if the selected subchannel is going to be used for the pending
+           * picks, update the last picked pointer */
+          advance_last_picked_locked(p);
+        }
+        while ((pp = p->pending_picks)) {
+          p->pending_picks = pp->next;
+          *pp->target = selected->subchannel;
+          if (grpc_lb_round_robin_trace) {
+            gpr_log(GPR_DEBUG,
+                    "[RR CONN CHANGED] TARGET <-- SUBCHANNEL %p (NODE %p)",
+                    selected->subchannel, selected);
+          }
+          grpc_subchannel_del_interested_party(exec_ctx, selected->subchannel,
+                                               pp->pollset);
+          grpc_exec_ctx_enqueue(exec_ctx, pp->on_complete, 1);
+          gpr_free(pp);
+        }
+        grpc_subchannel_notify_on_state_change(
+            exec_ctx, p->subchannels[this_idx], this_connectivity,
+            &p->connectivity_changed_cbs[this_idx]);
+        break;
+      case GRPC_CHANNEL_CONNECTING:
+      case GRPC_CHANNEL_IDLE:
+        grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
+                                    *this_connectivity, "connecting_changed");
+        grpc_subchannel_notify_on_state_change(
+            exec_ctx, p->subchannels[this_idx], this_connectivity,
+            &p->connectivity_changed_cbs[this_idx]);
+        break;
+      case GRPC_CHANNEL_TRANSIENT_FAILURE:
+        del_interested_parties_locked(exec_ctx, p, this_idx);
+        /* renew state notification */
+        grpc_subchannel_notify_on_state_change(
+            exec_ctx, p->subchannels[this_idx], this_connectivity,
+            &p->connectivity_changed_cbs[this_idx]);
+
+        /* remove from ready list if still present */
+        if (p->subchannel_index_to_readylist_node[this_idx] != NULL) {
+          remove_disconnected_sc_locked(
+              p, p->subchannel_index_to_readylist_node[this_idx]);
+          p->subchannel_index_to_readylist_node[this_idx] = NULL;
+        }
+        grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
+                                    GRPC_CHANNEL_TRANSIENT_FAILURE,
+                                    "connecting_transient_failure");
+        break;
+      case GRPC_CHANNEL_FATAL_FAILURE:
+        del_interested_parties_locked(exec_ctx, p, this_idx);
+        if (p->subchannel_index_to_readylist_node[this_idx] != NULL) {
+          remove_disconnected_sc_locked(
+              p, p->subchannel_index_to_readylist_node[this_idx]);
+          p->subchannel_index_to_readylist_node[this_idx] = NULL;
+        }
+
+        GPR_SWAP(grpc_subchannel *, p->subchannels[this_idx],
+                 p->subchannels[p->num_subchannels - 1]);
+        p->num_subchannels--;
+        GRPC_SUBCHANNEL_UNREF(exec_ctx, p->subchannels[p->num_subchannels],
+                              "round_robin");
+
+        if (p->num_subchannels == 0) {
+          grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
+                                      GRPC_CHANNEL_FATAL_FAILURE,
+                                      "no_more_channels");
+          while ((pp = p->pending_picks)) {
+            p->pending_picks = pp->next;
+            *pp->target = NULL;
+            grpc_exec_ctx_enqueue(exec_ctx, pp->on_complete, 1);
+            gpr_free(pp);
+          }
+          unref = 1;
+        } else {
+          grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
+                                      GRPC_CHANNEL_TRANSIENT_FAILURE,
+                                      "subchannel_failed");
+        }
+    } /* switch */
+  }   /* !unref */
+
+  gpr_mu_unlock(&p->mu);
+
+  if (unref) {
+    GRPC_LB_POLICY_UNREF(exec_ctx, &p->base, "round_robin_connectivity");
+  }
 }
 
-static void
-rr_broadcast (grpc_exec_ctx * exec_ctx, grpc_lb_policy * pol, grpc_transport_op * op)
-{
-  round_robin_lb_policy *p = (round_robin_lb_policy *) pol;
+static void rr_broadcast(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,
+                         grpc_transport_op *op) {
+  round_robin_lb_policy *p = (round_robin_lb_policy *)pol;
   size_t i;
   size_t n;
   grpc_subchannel **subchannels;
 
-  gpr_mu_lock (&p->mu);
+  gpr_mu_lock(&p->mu);
   n = p->num_subchannels;
-  subchannels = gpr_malloc (n * sizeof (*subchannels));
-  for (i = 0; i < n; i++)
-    {
-      subchannels[i] = p->subchannels[i];
-      GRPC_SUBCHANNEL_REF (subchannels[i], "rr_broadcast");
-    }
-  gpr_mu_unlock (&p->mu);
-
-  for (i = 0; i < n; i++)
-    {
-      grpc_subchannel_process_transport_op (exec_ctx, subchannels[i], op);
-      GRPC_SUBCHANNEL_UNREF (exec_ctx, subchannels[i], "rr_broadcast");
-    }
-  gpr_free (subchannels);
+  subchannels = gpr_malloc(n * sizeof(*subchannels));
+  for (i = 0; i < n; i++) {
+    subchannels[i] = p->subchannels[i];
+    GRPC_SUBCHANNEL_REF(subchannels[i], "rr_broadcast");
+  }
+  gpr_mu_unlock(&p->mu);
+
+  for (i = 0; i < n; i++) {
+    grpc_subchannel_process_transport_op(exec_ctx, subchannels[i], op);
+    GRPC_SUBCHANNEL_UNREF(exec_ctx, subchannels[i], "rr_broadcast");
+  }
+  gpr_free(subchannels);
 }
 
-static grpc_connectivity_state
-rr_check_connectivity (grpc_exec_ctx * exec_ctx, grpc_lb_policy * pol)
-{
-  round_robin_lb_policy *p = (round_robin_lb_policy *) pol;
+static grpc_connectivity_state rr_check_connectivity(grpc_exec_ctx *exec_ctx,
+                                                     grpc_lb_policy *pol) {
+  round_robin_lb_policy *p = (round_robin_lb_policy *)pol;
   grpc_connectivity_state st;
-  gpr_mu_lock (&p->mu);
-  st = grpc_connectivity_state_check (&p->state_tracker);
-  gpr_mu_unlock (&p->mu);
+  gpr_mu_lock(&p->mu);
+  st = grpc_connectivity_state_check(&p->state_tracker);
+  gpr_mu_unlock(&p->mu);
   return st;
 }
 
-static void
-rr_notify_on_state_change (grpc_exec_ctx * exec_ctx, grpc_lb_policy * pol, grpc_connectivity_state * current, grpc_closure * notify)
-{
-  round_robin_lb_policy *p = (round_robin_lb_policy *) pol;
-  gpr_mu_lock (&p->mu);
-  grpc_connectivity_state_notify_on_state_change (exec_ctx, &p->state_tracker, current, notify);
-  gpr_mu_unlock (&p->mu);
+static void rr_notify_on_state_change(grpc_exec_ctx *exec_ctx,
+                                      grpc_lb_policy *pol,
+                                      grpc_connectivity_state *current,
+                                      grpc_closure *notify) {
+  round_robin_lb_policy *p = (round_robin_lb_policy *)pol;
+  gpr_mu_lock(&p->mu);
+  grpc_connectivity_state_notify_on_state_change(exec_ctx, &p->state_tracker,
+                                                 current, notify);
+  gpr_mu_unlock(&p->mu);
 }
 
 static const grpc_lb_policy_vtable round_robin_lb_policy_vtable = {
-  rr_destroy,
-  rr_shutdown,
-  rr_pick,
-  rr_exit_idle,
-  rr_broadcast,
-  rr_check_connectivity,
-  rr_notify_on_state_change
-};
-
-static void
-round_robin_factory_ref (grpc_lb_policy_factory * factory)
-{
-}
+    rr_destroy,
+    rr_shutdown,
+    rr_pick,
+    rr_exit_idle,
+    rr_broadcast,
+    rr_check_connectivity,
+    rr_notify_on_state_change};
 
-static void
-round_robin_factory_unref (grpc_lb_policy_factory * factory)
-{
-}
+static void round_robin_factory_ref(grpc_lb_policy_factory *factory) {}
+
+static void round_robin_factory_unref(grpc_lb_policy_factory *factory) {}
 
-static grpc_lb_policy *
-create_round_robin (grpc_lb_policy_factory * factory, grpc_lb_policy_args * args)
-{
+static grpc_lb_policy *create_round_robin(grpc_lb_policy_factory *factory,
+                                          grpc_lb_policy_args *args) {
   size_t i;
-  round_robin_lb_policy *p = gpr_malloc (sizeof (*p));
-  GPR_ASSERT (args->num_subchannels > 0);
-  memset (p, 0, sizeof (*p));
-  grpc_lb_policy_init (&p->base, &round_robin_lb_policy_vtable);
-  p->subchannels = gpr_malloc (sizeof (grpc_subchannel *) * args->num_subchannels);
+  round_robin_lb_policy *p = gpr_malloc(sizeof(*p));
+  GPR_ASSERT(args->num_subchannels > 0);
+  memset(p, 0, sizeof(*p));
+  grpc_lb_policy_init(&p->base, &round_robin_lb_policy_vtable);
+  p->subchannels =
+      gpr_malloc(sizeof(grpc_subchannel *) * args->num_subchannels);
   p->num_subchannels = args->num_subchannels;
-  grpc_connectivity_state_init (&p->state_tracker, GRPC_CHANNEL_IDLE, "round_robin");
-  memcpy (p->subchannels, args->subchannels, sizeof (grpc_subchannel *) * args->num_subchannels);
-
-  gpr_mu_init (&p->mu);
-  p->connectivity_changed_cbs = gpr_malloc (sizeof (grpc_closure) * args->num_subchannels);
-  p->subchannel_connectivity = gpr_malloc (sizeof (grpc_connectivity_state) * args->num_subchannels);
-
-  p->cb_args = gpr_malloc (sizeof (connectivity_changed_cb_arg) * args->num_subchannels);
-  for (i = 0; i < args->num_subchannels; i++)
-    {
-      p->cb_args[i].subchannel_idx = i;
-      p->cb_args[i].p = p;
-      grpc_closure_init (&p->connectivity_changed_cbs[i], rr_connectivity_changed, &p->cb_args[i]);
-    }
+  grpc_connectivity_state_init(&p->state_tracker, GRPC_CHANNEL_IDLE,
+                               "round_robin");
+  memcpy(p->subchannels, args->subchannels,
+         sizeof(grpc_subchannel *) * args->num_subchannels);
+
+  gpr_mu_init(&p->mu);
+  p->connectivity_changed_cbs =
+      gpr_malloc(sizeof(grpc_closure) * args->num_subchannels);
+  p->subchannel_connectivity =
+      gpr_malloc(sizeof(grpc_connectivity_state) * args->num_subchannels);
+
+  p->cb_args =
+      gpr_malloc(sizeof(connectivity_changed_cb_arg) * args->num_subchannels);
+  for (i = 0; i < args->num_subchannels; i++) {
+    p->cb_args[i].subchannel_idx = i;
+    p->cb_args[i].p = p;
+    grpc_closure_init(&p->connectivity_changed_cbs[i], rr_connectivity_changed,
+                      &p->cb_args[i]);
+  }
 
   /* The (dummy node) root of the ready list */
   p->ready_list.subchannel = NULL;
@@ -575,22 +535,20 @@ create_round_robin (grpc_lb_policy_factory * factory, grpc_lb_policy_args * args
   p->ready_list.next = NULL;
   p->ready_list_last_pick = &p->ready_list;
 
-  p->subchannel_index_to_readylist_node = gpr_malloc (sizeof (grpc_subchannel *) * args->num_subchannels);
-  memset (p->subchannel_index_to_readylist_node, 0, sizeof (grpc_subchannel *) * args->num_subchannels);
+  p->subchannel_index_to_readylist_node =
+      gpr_malloc(sizeof(grpc_subchannel *) * args->num_subchannels);
+  memset(p->subchannel_index_to_readylist_node, 0,
+         sizeof(grpc_subchannel *) * args->num_subchannels);
   return &p->base;
 }
 
 static const grpc_lb_policy_factory_vtable round_robin_factory_vtable = {
-  round_robin_factory_ref, round_robin_factory_unref, create_round_robin,
-  "round_robin"
-};
+    round_robin_factory_ref, round_robin_factory_unref, create_round_robin,
+    "round_robin"};
 
 static grpc_lb_policy_factory round_robin_lb_policy_factory = {
-  &round_robin_factory_vtable
-};
+    &round_robin_factory_vtable};
 
-grpc_lb_policy_factory *
-grpc_round_robin_lb_factory_create ()
-{
+grpc_lb_policy_factory *grpc_round_robin_lb_factory_create() {
   return &round_robin_lb_policy_factory;
 }

src/core/client_config/lb_policies/round_robin.h

@@ -41,6 +41,6 @@ extern int grpc_lb_round_robin_trace;
 #include "src/core/client_config/lb_policy_factory.h"
 
 /** Returns a load balancing factory for the round robin policy */
-grpc_lb_policy_factory *grpc_round_robin_lb_factory_create ();
+grpc_lb_policy_factory *grpc_round_robin_lb_factory_create();
 
 #endif

src/core/client_config/lb_policy.c

@@ -33,74 +33,66 @@
 
 #include "src/core/client_config/lb_policy.h"
 
-void
-grpc_lb_policy_init (grpc_lb_policy * policy, const grpc_lb_policy_vtable * vtable)
-{
+void grpc_lb_policy_init(grpc_lb_policy *policy,
+                         const grpc_lb_policy_vtable *vtable) {
   policy->vtable = vtable;
-  gpr_ref_init (&policy->refs, 1);
+  gpr_ref_init(&policy->refs, 1);
 }
 
 #ifdef GRPC_LB_POLICY_REFCOUNT_DEBUG
-void
-grpc_lb_policy_ref (grpc_lb_policy * policy, const char *file, int line, const char *reason)
-{
-  gpr_log (file, line, GPR_LOG_SEVERITY_DEBUG, "LB_POLICY:%p   ref %d -> %d %s", policy, (int) policy->refs.count, (int) policy->refs.count + 1, reason);
+void grpc_lb_policy_ref(grpc_lb_policy *policy, const char *file, int line,
+                        const char *reason) {
+  gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "LB_POLICY:%p   ref %d -> %d %s",
+          policy, (int)policy->refs.count, (int)policy->refs.count + 1, reason);
 #else
-void
-grpc_lb_policy_ref (grpc_lb_policy * policy)
-{
+void grpc_lb_policy_ref(grpc_lb_policy *policy) {
 #endif
-  gpr_ref (&policy->refs);
+  gpr_ref(&policy->refs);
 }
 
 #ifdef GRPC_LB_POLICY_REFCOUNT_DEBUG
-void
-grpc_lb_policy_unref (grpc_lb_policy * policy, grpc_closure_list * closure_list, const char *file, int line, const char *reason)
-{
-  gpr_log (file, line, GPR_LOG_SEVERITY_DEBUG, "LB_POLICY:%p unref %d -> %d %s", policy, (int) policy->refs.count, (int) policy->refs.count - 1, reason);
+void grpc_lb_policy_unref(grpc_lb_policy *policy,
+                          grpc_closure_list *closure_list, const char *file,
+                          int line, const char *reason) {
+  gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "LB_POLICY:%p unref %d -> %d %s",
+          policy, (int)policy->refs.count, (int)policy->refs.count - 1, reason);
 #else
-void
-grpc_lb_policy_unref (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy)
-{
+void grpc_lb_policy_unref(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy) {
 #endif
-  if (gpr_unref (&policy->refs))
-    {
-      policy->vtable->destroy (exec_ctx, policy);
-    }
+  if (gpr_unref(&policy->refs)) {
+    policy->vtable->destroy(exec_ctx, policy);
+  }
 }
 
-void
-grpc_lb_policy_shutdown (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy)
-{
-  policy->vtable->shutdown (exec_ctx, policy);
+void grpc_lb_policy_shutdown(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy) {
+  policy->vtable->shutdown(exec_ctx, policy);
 }
 
-void
-grpc_lb_policy_pick (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy, grpc_pollset * pollset, grpc_metadata_batch * initial_metadata, grpc_subchannel ** target, grpc_closure * on_complete)
-{
-  policy->vtable->pick (exec_ctx, policy, pollset, initial_metadata, target, on_complete);
+void grpc_lb_policy_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy,
+                         grpc_pollset *pollset,
+                         grpc_metadata_batch *initial_metadata,
+                         grpc_subchannel **target, grpc_closure *on_complete) {
+  policy->vtable->pick(exec_ctx, policy, pollset, initial_metadata, target,
+                       on_complete);
 }
 
-void
-grpc_lb_policy_broadcast (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy, grpc_transport_op * op)
-{
-  policy->vtable->broadcast (exec_ctx, policy, op);
+void grpc_lb_policy_broadcast(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy,
+                              grpc_transport_op *op) {
+  policy->vtable->broadcast(exec_ctx, policy, op);
 }
 
-void
-grpc_lb_policy_exit_idle (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy)
-{
-  policy->vtable->exit_idle (exec_ctx, policy);
+void grpc_lb_policy_exit_idle(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy) {
+  policy->vtable->exit_idle(exec_ctx, policy);
 }
 
-void
-grpc_lb_policy_notify_on_state_change (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy, grpc_connectivity_state * state, grpc_closure * closure)
-{
-  policy->vtable->notify_on_state_change (exec_ctx, policy, state, closure);
+void grpc_lb_policy_notify_on_state_change(grpc_exec_ctx *exec_ctx,
+                                           grpc_lb_policy *policy,
+                                           grpc_connectivity_state *state,
+                                           grpc_closure *closure) {
+  policy->vtable->notify_on_state_change(exec_ctx, policy, state, closure);
 }
 
-grpc_connectivity_state
-grpc_lb_policy_check_connectivity (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy)
-{
-  return policy->vtable->check_connectivity (exec_ctx, policy);
+grpc_connectivity_state grpc_lb_policy_check_connectivity(
+    grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy) {
+  return policy->vtable->check_connectivity(exec_ctx, policy);
 }

src/core/client_config/lb_policy.h

@@ -42,35 +42,41 @@
 typedef struct grpc_lb_policy grpc_lb_policy;
 typedef struct grpc_lb_policy_vtable grpc_lb_policy_vtable;
 
-typedef void (*grpc_lb_completion) (void *cb_arg, grpc_subchannel * subchannel, grpc_status_code status, const char *errmsg);
+typedef void (*grpc_lb_completion)(void *cb_arg, grpc_subchannel *subchannel,
+                                   grpc_status_code status, const char *errmsg);
 
-struct grpc_lb_policy
-{
+struct grpc_lb_policy {
   const grpc_lb_policy_vtable *vtable;
   gpr_refcount refs;
 };
 
-struct grpc_lb_policy_vtable
-{
-  void (*destroy) (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy);
+struct grpc_lb_policy_vtable {
+  void (*destroy)(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy);
 
-  void (*shutdown) (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy);
+  void (*shutdown)(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy);
 
   /** implement grpc_lb_policy_pick */
-  void (*pick) (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy, grpc_pollset * pollset, grpc_metadata_batch * initial_metadata, grpc_subchannel ** target, grpc_closure * on_complete);
+  void (*pick)(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy,
+               grpc_pollset *pollset, grpc_metadata_batch *initial_metadata,
+               grpc_subchannel **target, grpc_closure *on_complete);
 
   /** try to enter a READY connectivity state */
-  void (*exit_idle) (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy);
+  void (*exit_idle)(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy);
 
   /** broadcast a transport op to all subchannels */
-  void (*broadcast) (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy, grpc_transport_op * op);
+  void (*broadcast)(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy,
+                    grpc_transport_op *op);
 
   /** check the current connectivity of the lb_policy */
-    grpc_connectivity_state (*check_connectivity) (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy);
+  grpc_connectivity_state (*check_connectivity)(grpc_exec_ctx *exec_ctx,
+                                                grpc_lb_policy *policy);
 
   /** call notify when the connectivity state of a channel changes from *state.
       Updates *state with the new state of the policy */
-  void (*notify_on_state_change) (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy, grpc_connectivity_state * state, grpc_closure * closure);
+  void (*notify_on_state_change)(grpc_exec_ctx *exec_ctx,
+                                 grpc_lb_policy *policy,
+                                 grpc_connectivity_state *state,
+                                 grpc_closure *closure);
 };
 
 #ifdef GRPC_LB_POLICY_REFCOUNT_DEBUG
@@ -78,33 +84,44 @@ struct grpc_lb_policy_vtable
   grpc_lb_policy_ref((p), __FILE__, __LINE__, (r))
 #define GRPC_LB_POLICY_UNREF(exec_ctx, p, r) \
   grpc_lb_policy_unref((exec_ctx), (p), __FILE__, __LINE__, (r))
-void grpc_lb_policy_ref (grpc_lb_policy * policy, const char *file, int line, const char *reason);
-void grpc_lb_policy_unref (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy, const char *file, int line, const char *reason);
+void grpc_lb_policy_ref(grpc_lb_policy *policy, const char *file, int line,
+                        const char *reason);
+void grpc_lb_policy_unref(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy,
+                          const char *file, int line, const char *reason);
 #else
 #define GRPC_LB_POLICY_REF(p, r) grpc_lb_policy_ref((p))
 #define GRPC_LB_POLICY_UNREF(cl, p, r) grpc_lb_policy_unref((cl), (p))
-void grpc_lb_policy_ref (grpc_lb_policy * policy);
-void grpc_lb_policy_unref (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy);
+void grpc_lb_policy_ref(grpc_lb_policy *policy);
+void grpc_lb_policy_unref(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy);
 #endif
 
 /** called by concrete implementations to initialize the base struct */
-void grpc_lb_policy_init (grpc_lb_policy * policy, const grpc_lb_policy_vtable * vtable);
+void grpc_lb_policy_init(grpc_lb_policy *policy,
+                         const grpc_lb_policy_vtable *vtable);
 
 /** Start shutting down (fail any pending picks) */
-void grpc_lb_policy_shutdown (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy);
+void grpc_lb_policy_shutdown(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy);
 
 /** Given initial metadata in \a initial_metadata, find an appropriate
     target for this rpc, and 'return' it by calling \a on_complete after setting
     \a target.
     Picking can be asynchronous. Any IO should be done under \a pollset. */
-void grpc_lb_policy_pick (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy, grpc_pollset * pollset, grpc_metadata_batch * initial_metadata, grpc_subchannel ** target, grpc_closure * on_complete);
+void grpc_lb_policy_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy,
+                         grpc_pollset *pollset,
+                         grpc_metadata_batch *initial_metadata,
+                         grpc_subchannel **target, grpc_closure *on_complete);
 
-void grpc_lb_policy_broadcast (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy, grpc_transport_op * op);
+void grpc_lb_policy_broadcast(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy,
+                              grpc_transport_op *op);
 
-void grpc_lb_policy_exit_idle (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy);
+void grpc_lb_policy_exit_idle(grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy);
 
-void grpc_lb_policy_notify_on_state_change (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy, grpc_connectivity_state * state, grpc_closure * closure);
+void grpc_lb_policy_notify_on_state_change(grpc_exec_ctx *exec_ctx,
+                                           grpc_lb_policy *policy,
+                                           grpc_connectivity_state *state,
+                                           grpc_closure *closure);
 
-grpc_connectivity_state grpc_lb_policy_check_connectivity (grpc_exec_ctx * exec_ctx, grpc_lb_policy * policy);
+grpc_connectivity_state grpc_lb_policy_check_connectivity(
+    grpc_exec_ctx *exec_ctx, grpc_lb_policy *policy);
 
 #endif /* GRPC_INTERNAL_CORE_CONFIG_LB_POLICY_H */

src/core/client_config/lb_policy_factory.c

@@ -33,22 +33,16 @@
 
 #include "src/core/client_config/lb_policy_factory.h"
 
-void
-grpc_lb_policy_factory_ref (grpc_lb_policy_factory * factory)
-{
-  factory->vtable->ref (factory);
+void grpc_lb_policy_factory_ref(grpc_lb_policy_factory* factory) {
+  factory->vtable->ref(factory);
 }
 
-void
-grpc_lb_policy_factory_unref (grpc_lb_policy_factory * factory)
-{
-  factory->vtable->unref (factory);
+void grpc_lb_policy_factory_unref(grpc_lb_policy_factory* factory) {
+  factory->vtable->unref(factory);
 }
 
-grpc_lb_policy *
-grpc_lb_policy_factory_create_lb_policy (grpc_lb_policy_factory * factory, grpc_lb_policy_args * args)
-{
-  if (factory == NULL)
-    return NULL;
-  return factory->vtable->create_lb_policy (factory, args);
+grpc_lb_policy* grpc_lb_policy_factory_create_lb_policy(
+    grpc_lb_policy_factory* factory, grpc_lb_policy_args* args) {
+  if (factory == NULL) return NULL;
+  return factory->vtable->create_lb_policy(factory, args);
 }

src/core/client_config/lb_policy_factory.h

@@ -42,33 +42,32 @@ typedef struct grpc_lb_policy_factory_vtable grpc_lb_policy_factory_vtable;
 
 /** grpc_lb_policy provides grpc_client_config objects to grpc_channel
     objects */
-struct grpc_lb_policy_factory
-{
+struct grpc_lb_policy_factory {
   const grpc_lb_policy_factory_vtable *vtable;
 };
 
-typedef struct grpc_lb_policy_args
-{
+typedef struct grpc_lb_policy_args {
   grpc_subchannel **subchannels;
   size_t num_subchannels;
 } grpc_lb_policy_args;
 
-struct grpc_lb_policy_factory_vtable
-{
-  void (*ref) (grpc_lb_policy_factory * factory);
-  void (*unref) (grpc_lb_policy_factory * factory);
+struct grpc_lb_policy_factory_vtable {
+  void (*ref)(grpc_lb_policy_factory *factory);
+  void (*unref)(grpc_lb_policy_factory *factory);
 
   /** Implementation of grpc_lb_policy_factory_create_lb_policy */
-  grpc_lb_policy *(*create_lb_policy) (grpc_lb_policy_factory * factory, grpc_lb_policy_args * args);
+  grpc_lb_policy *(*create_lb_policy)(grpc_lb_policy_factory *factory,
+                                      grpc_lb_policy_args *args);
 
   /** Name for the LB policy this factory implements */
   const char *name;
 };
 
-void grpc_lb_policy_factory_ref (grpc_lb_policy_factory * factory);
-void grpc_lb_policy_factory_unref (grpc_lb_policy_factory * factory);
+void grpc_lb_policy_factory_ref(grpc_lb_policy_factory *factory);
+void grpc_lb_policy_factory_unref(grpc_lb_policy_factory *factory);
 
 /** Create a lb_policy instance. */
-grpc_lb_policy *grpc_lb_policy_factory_create_lb_policy (grpc_lb_policy_factory * factory, grpc_lb_policy_args * args);
+grpc_lb_policy *grpc_lb_policy_factory_create_lb_policy(
+    grpc_lb_policy_factory *factory, grpc_lb_policy_args *args);
 
 #endif /* GRPC_INTERNAL_CORE_CONFIG_LB_POLICY_FACTORY_H */

src/core/client_config/lb_policy_registry.c

@@ -42,59 +42,47 @@ static int g_number_of_lb_policies = 0;
 
 static grpc_lb_policy_factory *g_default_lb_policy_factory;
 
-void
-grpc_lb_policy_registry_init (grpc_lb_policy_factory * default_factory)
-{
+void grpc_lb_policy_registry_init(grpc_lb_policy_factory *default_factory) {
   g_number_of_lb_policies = 0;
   g_default_lb_policy_factory = default_factory;
 }
 
-void
-grpc_lb_policy_registry_shutdown (void)
-{
+void grpc_lb_policy_registry_shutdown(void) {
   int i;
-  for (i = 0; i < g_number_of_lb_policies; i++)
-    {
-      grpc_lb_policy_factory_unref (g_all_of_the_lb_policies[i]);
-    }
+  for (i = 0; i < g_number_of_lb_policies; i++) {
+    grpc_lb_policy_factory_unref(g_all_of_the_lb_policies[i]);
+  }
 }
 
-void
-grpc_register_lb_policy (grpc_lb_policy_factory * factory)
-{
+void grpc_register_lb_policy(grpc_lb_policy_factory *factory) {
   int i;
-  for (i = 0; i < g_number_of_lb_policies; i++)
-    {
-      GPR_ASSERT (0 != strcmp (factory->vtable->name, g_all_of_the_lb_policies[i]->vtable->name));
-    }
-  GPR_ASSERT (g_number_of_lb_policies != MAX_POLICIES);
-  grpc_lb_policy_factory_ref (factory);
+  for (i = 0; i < g_number_of_lb_policies; i++) {
+    GPR_ASSERT(0 != strcmp(factory->vtable->name,
+                           g_all_of_the_lb_policies[i]->vtable->name));
+  }
+  GPR_ASSERT(g_number_of_lb_policies != MAX_POLICIES);
+  grpc_lb_policy_factory_ref(factory);
   g_all_of_the_lb_policies[g_number_of_lb_policies++] = factory;
 }
 
-static grpc_lb_policy_factory *
-lookup_factory (const char *name)
-{
+static grpc_lb_policy_factory *lookup_factory(const char *name) {
   int i;
 
-  if (name == NULL)
-    return NULL;
+  if (name == NULL) return NULL;
 
-  for (i = 0; i < g_number_of_lb_policies; i++)
-    {
-      if (0 == strcmp (name, g_all_of_the_lb_policies[i]->vtable->name))
-	{
-	  return g_all_of_the_lb_policies[i];
-	}
+  for (i = 0; i < g_number_of_lb_policies; i++) {
+    if (0 == strcmp(name, g_all_of_the_lb_policies[i]->vtable->name)) {
+      return g_all_of_the_lb_policies[i];
     }
+  }
 
   return NULL;
 }
 
-grpc_lb_policy *
-grpc_lb_policy_create (const char *name, grpc_lb_policy_args * args)
-{
-  grpc_lb_policy_factory *factory = lookup_factory (name);
-  grpc_lb_policy *lb_policy = grpc_lb_policy_factory_create_lb_policy (factory, args);
+grpc_lb_policy *grpc_lb_policy_create(const char *name,
+                                      grpc_lb_policy_args *args) {
+  grpc_lb_policy_factory *factory = lookup_factory(name);
+  grpc_lb_policy *lb_policy =
+      grpc_lb_policy_factory_create_lb_policy(factory, args);
   return lb_policy;
 }

src/core/client_config/lb_policy_registry.h

@@ -38,16 +38,17 @@
 
 /** Initialize the registry and set \a default_factory as the factory to be
  * returned when no name is provided in a lookup */
-void grpc_lb_policy_registry_init (grpc_lb_policy_factory * default_factory);
-void grpc_lb_policy_registry_shutdown (void);
+void grpc_lb_policy_registry_init(grpc_lb_policy_factory *default_factory);
+void grpc_lb_policy_registry_shutdown(void);
 
 /** Register a LB policy factory. */
-void grpc_register_lb_policy (grpc_lb_policy_factory * factory);
+void grpc_register_lb_policy(grpc_lb_policy_factory *factory);
 
 /** Create a \a grpc_lb_policy instance.
  *
  * If \a name is NULL, the default factory from \a grpc_lb_policy_registry_init
  * will be returned. */
-grpc_lb_policy *grpc_lb_policy_create (const char *name, grpc_lb_policy_args * args);
+grpc_lb_policy *grpc_lb_policy_create(const char *name,
+                                      grpc_lb_policy_args *args);
 
 #endif /* GRPC_INTERNAL_CORE_CLIENT_CONFIG_LB_POLICY_REGISTRY_H */

src/core/client_config/resolver.c

@@ -33,56 +33,53 @@
 
 #include "src/core/client_config/resolver.h"
 
-void
-grpc_resolver_init (grpc_resolver * resolver, const grpc_resolver_vtable * vtable)
-{
+void grpc_resolver_init(grpc_resolver *resolver,
+                        const grpc_resolver_vtable *vtable) {
   resolver->vtable = vtable;
-  gpr_ref_init (&resolver->refs, 1);
+  gpr_ref_init(&resolver->refs, 1);
 }
 
 #ifdef GRPC_RESOLVER_REFCOUNT_DEBUG
-void
-grpc_resolver_ref (grpc_resolver * resolver, grpc_closure_list * closure_list, const char *file, int line, const char *reason)
-{
-  gpr_log (file, line, GPR_LOG_SEVERITY_DEBUG, "RESOLVER:%p   ref %d -> %d %s", resolver, (int) resolver->refs.count, (int) resolver->refs.count + 1, reason);
+void grpc_resolver_ref(grpc_resolver *resolver, grpc_closure_list *closure_list,
+                       const char *file, int line, const char *reason) {
+  gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "RESOLVER:%p   ref %d -> %d %s",
+          resolver, (int)resolver->refs.count, (int)resolver->refs.count + 1,
+          reason);
 #else
-void
-grpc_resolver_ref (grpc_resolver * resolver)
-{
+void grpc_resolver_ref(grpc_resolver *resolver) {
 #endif
-  gpr_ref (&resolver->refs);
+  gpr_ref(&resolver->refs);
 }
 
 #ifdef GRPC_RESOLVER_REFCOUNT_DEBUG
-void
-grpc_resolver_unref (grpc_resolver * resolver, grpc_closure_list * closure_list, const char *file, int line, const char *reason)
-{
-  gpr_log (file, line, GPR_LOG_SEVERITY_DEBUG, "RESOLVER:%p unref %d -> %d %s", resolver, (int) resolver->refs.count, (int) resolver->refs.count - 1, reason);
+void grpc_resolver_unref(grpc_resolver *resolver,
+                         grpc_closure_list *closure_list, const char *file,
+                         int line, const char *reason) {
+  gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "RESOLVER:%p unref %d -> %d %s",
+          resolver, (int)resolver->refs.count, (int)resolver->refs.count - 1,
+          reason);
 #else
-void
-grpc_resolver_unref (grpc_exec_ctx * exec_ctx, grpc_resolver * resolver)
-{
+void grpc_resolver_unref(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver) {
 #endif
-  if (gpr_unref (&resolver->refs))
-    {
-      resolver->vtable->destroy (exec_ctx, resolver);
-    }
+  if (gpr_unref(&resolver->refs)) {
+    resolver->vtable->destroy(exec_ctx, resolver);
+  }
 }
 
-void
-grpc_resolver_shutdown (grpc_exec_ctx * exec_ctx, grpc_resolver * resolver)
-{
-  resolver->vtable->shutdown (exec_ctx, resolver);
+void grpc_resolver_shutdown(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver) {
+  resolver->vtable->shutdown(exec_ctx, resolver);
 }
 
-void
-grpc_resolver_channel_saw_error (grpc_exec_ctx * exec_ctx, grpc_resolver * resolver, struct sockaddr *failing_address, int failing_address_len)
-{
-  resolver->vtable->channel_saw_error (exec_ctx, resolver, failing_address, failing_address_len);
+void grpc_resolver_channel_saw_error(grpc_exec_ctx *exec_ctx,
+                                     grpc_resolver *resolver,
+                                     struct sockaddr *failing_address,
+                                     int failing_address_len) {
+  resolver->vtable->channel_saw_error(exec_ctx, resolver, failing_address,
+                                      failing_address_len);
 }
 
-void
-grpc_resolver_next (grpc_exec_ctx * exec_ctx, grpc_resolver * resolver, grpc_client_config ** target_config, grpc_closure * on_complete)
-{
-  resolver->vtable->next (exec_ctx, resolver, target_config, on_complete);
+void grpc_resolver_next(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver,
+                        grpc_client_config **target_config,
+                        grpc_closure *on_complete) {
+  resolver->vtable->next(exec_ctx, resolver, target_config, on_complete);
 }

src/core/client_config/resolver.h

@@ -43,40 +43,47 @@ typedef struct grpc_resolver_vtable grpc_resolver_vtable;
 
 /** grpc_resolver provides grpc_client_config objects to grpc_channel
     objects */
-struct grpc_resolver
-{
+struct grpc_resolver {
   const grpc_resolver_vtable *vtable;
   gpr_refcount refs;
 };
 
-struct grpc_resolver_vtable
-{
-  void (*destroy) (grpc_exec_ctx * exec_ctx, grpc_resolver * resolver);
-  void (*shutdown) (grpc_exec_ctx * exec_ctx, grpc_resolver * resolver);
-  void (*channel_saw_error) (grpc_exec_ctx * exec_ctx, grpc_resolver * resolver, struct sockaddr * failing_address, int failing_address_len);
-  void (*next) (grpc_exec_ctx * exec_ctx, grpc_resolver * resolver, grpc_client_config ** target_config, grpc_closure * on_complete);
+struct grpc_resolver_vtable {
+  void (*destroy)(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver);
+  void (*shutdown)(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver);
+  void (*channel_saw_error)(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver,
+                            struct sockaddr *failing_address,
+                            int failing_address_len);
+  void (*next)(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver,
+               grpc_client_config **target_config, grpc_closure *on_complete);
 };
 
 #ifdef GRPC_RESOLVER_REFCOUNT_DEBUG
 #define GRPC_RESOLVER_REF(p, r) grpc_resolver_ref((p), __FILE__, __LINE__, (r))
 #define GRPC_RESOLVER_UNREF(cl, p, r) \
   grpc_resolver_unref((cl), (p), __FILE__, __LINE__, (r))
-void grpc_resolver_ref (grpc_resolver * policy, const char *file, int line, const char *reason);
-void grpc_resolver_unref (grpc_resolver * policy, grpc_closure_list * closure_list, const char *file, int line, const char *reason);
+void grpc_resolver_ref(grpc_resolver *policy, const char *file, int line,
+                       const char *reason);
+void grpc_resolver_unref(grpc_resolver *policy, grpc_closure_list *closure_list,
+                         const char *file, int line, const char *reason);
 #else
 #define GRPC_RESOLVER_REF(p, r) grpc_resolver_ref((p))
 #define GRPC_RESOLVER_UNREF(cl, p, r) grpc_resolver_unref((cl), (p))
-void grpc_resolver_ref (grpc_resolver * policy);
-void grpc_resolver_unref (grpc_exec_ctx * exec_ctx, grpc_resolver * policy);
+void grpc_resolver_ref(grpc_resolver *policy);
+void grpc_resolver_unref(grpc_exec_ctx *exec_ctx, grpc_resolver *policy);
 #endif
 
-void grpc_resolver_init (grpc_resolver * resolver, const grpc_resolver_vtable * vtable);
+void grpc_resolver_init(grpc_resolver *resolver,
+                        const grpc_resolver_vtable *vtable);
 
-void grpc_resolver_shutdown (grpc_exec_ctx * exec_ctx, grpc_resolver * resolver);
+void grpc_resolver_shutdown(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver);
 
 /** Notification that the channel has seen an error on some address.
     Can be used as a hint that re-resolution is desirable soon. */
-void grpc_resolver_channel_saw_error (grpc_exec_ctx * exec_ctx, grpc_resolver * resolver, struct sockaddr *failing_address, int failing_address_len);
+void grpc_resolver_channel_saw_error(grpc_exec_ctx *exec_ctx,
+                                     grpc_resolver *resolver,
+                                     struct sockaddr *failing_address,
+                                     int failing_address_len);
 
 /** Get the next client config. Called by the channel to fetch a new
     configuration. Expected to set *target_config with a new configuration,
@@ -84,6 +91,8 @@ void grpc_resolver_channel_saw_error (grpc_exec_ctx * exec_ctx, grpc_resolver *
 
     If resolution is fatally broken, set *target_config to NULL and
     schedule on_complete. */
-void grpc_resolver_next (grpc_exec_ctx * exec_ctx, grpc_resolver * resolver, grpc_client_config ** target_config, grpc_closure * on_complete);
+void grpc_resolver_next(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver,
+                        grpc_client_config **target_config,
+                        grpc_closure *on_complete);
 
 #endif /* GRPC_INTERNAL_CORE_CONFIG_RESOLVER_H */

src/core/client_config/resolver_factory.c

@@ -33,31 +33,23 @@
 
 #include "src/core/client_config/resolver_factory.h"
 
-void
-grpc_resolver_factory_ref (grpc_resolver_factory * factory)
-{
-  factory->vtable->ref (factory);
+void grpc_resolver_factory_ref(grpc_resolver_factory* factory) {
+  factory->vtable->ref(factory);
 }
 
-void
-grpc_resolver_factory_unref (grpc_resolver_factory * factory)
-{
-  factory->vtable->unref (factory);
+void grpc_resolver_factory_unref(grpc_resolver_factory* factory) {
+  factory->vtable->unref(factory);
 }
 
 /** Create a resolver instance for a name */
-grpc_resolver *
-grpc_resolver_factory_create_resolver (grpc_resolver_factory * factory, grpc_resolver_args * args)
-{
-  if (factory == NULL)
-    return NULL;
-  return factory->vtable->create_resolver (factory, args);
+grpc_resolver* grpc_resolver_factory_create_resolver(
+    grpc_resolver_factory* factory, grpc_resolver_args* args) {
+  if (factory == NULL) return NULL;
+  return factory->vtable->create_resolver(factory, args);
 }
 
-char *
-grpc_resolver_factory_get_default_authority (grpc_resolver_factory * factory, grpc_uri * uri)
-{
-  if (factory == NULL)
-    return NULL;
-  return factory->vtable->get_default_authority (factory, uri);
+char* grpc_resolver_factory_get_default_authority(
+    grpc_resolver_factory* factory, grpc_uri* uri) {
+  if (factory == NULL) return NULL;
+  return factory->vtable->get_default_authority(factory, uri);
 }

src/core/client_config/resolver_factory.h

@@ -43,40 +43,40 @@ typedef struct grpc_resolver_factory_vtable grpc_resolver_factory_vtable;
 
 /** grpc_resolver provides grpc_client_config objects to grpc_channel
     objects */
-struct grpc_resolver_factory
-{
+struct grpc_resolver_factory {
   const grpc_resolver_factory_vtable *vtable;
 };
 
-typedef struct grpc_resolver_args
-{
+typedef struct grpc_resolver_args {
   grpc_uri *uri;
   grpc_subchannel_factory *subchannel_factory;
 } grpc_resolver_args;
 
-struct grpc_resolver_factory_vtable
-{
-  void (*ref) (grpc_resolver_factory * factory);
-  void (*unref) (grpc_resolver_factory * factory);
+struct grpc_resolver_factory_vtable {
+  void (*ref)(grpc_resolver_factory *factory);
+  void (*unref)(grpc_resolver_factory *factory);
 
   /** Implementation of grpc_resolver_factory_create_resolver */
-  grpc_resolver *(*create_resolver) (grpc_resolver_factory * factory, grpc_resolver_args * args);
+  grpc_resolver *(*create_resolver)(grpc_resolver_factory *factory,
+                                    grpc_resolver_args *args);
 
   /** Implementation of grpc_resolver_factory_get_default_authority */
-  char *(*get_default_authority) (grpc_resolver_factory * factory, grpc_uri * uri);
+  char *(*get_default_authority)(grpc_resolver_factory *factory, grpc_uri *uri);
 
   /** URI scheme that this factory implements */
   const char *scheme;
 };
 
-void grpc_resolver_factory_ref (grpc_resolver_factory * resolver);
-void grpc_resolver_factory_unref (grpc_resolver_factory * resolver);
+void grpc_resolver_factory_ref(grpc_resolver_factory *resolver);
+void grpc_resolver_factory_unref(grpc_resolver_factory *resolver);
 
 /** Create a resolver instance for a name */
-grpc_resolver *grpc_resolver_factory_create_resolver (grpc_resolver_factory * factory, grpc_resolver_args * args);
+grpc_resolver *grpc_resolver_factory_create_resolver(
+    grpc_resolver_factory *factory, grpc_resolver_args *args);
 
 /** Return a (freshly allocated with gpr_malloc) string representing
     the default authority to use for this scheme. */
-char *grpc_resolver_factory_get_default_authority (grpc_resolver_factory * factory, grpc_uri * uri);
+char *grpc_resolver_factory_get_default_authority(
+    grpc_resolver_factory *factory, grpc_uri *uri);
 
 #endif /* GRPC_INTERNAL_CORE_CONFIG_RESOLVER_FACTORY_H */

src/core/client_config/resolver_registry.c

@@ -46,112 +46,92 @@ static int g_number_of_resolvers = 0;
 
 static char *g_default_resolver_prefix;
 
-void
-grpc_resolver_registry_init (const char *default_resolver_prefix)
-{
+void grpc_resolver_registry_init(const char *default_resolver_prefix) {
   g_number_of_resolvers = 0;
-  g_default_resolver_prefix = gpr_strdup (default_resolver_prefix);
+  g_default_resolver_prefix = gpr_strdup(default_resolver_prefix);
 }
 
-void
-grpc_resolver_registry_shutdown (void)
-{
+void grpc_resolver_registry_shutdown(void) {
   int i;
-  for (i = 0; i < g_number_of_resolvers; i++)
-    {
-      grpc_resolver_factory_unref (g_all_of_the_resolvers[i]);
-    }
-  gpr_free (g_default_resolver_prefix);
+  for (i = 0; i < g_number_of_resolvers; i++) {
+    grpc_resolver_factory_unref(g_all_of_the_resolvers[i]);
+  }
+  gpr_free(g_default_resolver_prefix);
 }
 
-void
-grpc_register_resolver_type (grpc_resolver_factory * factory)
-{
+void grpc_register_resolver_type(grpc_resolver_factory *factory) {
   int i;
-  for (i = 0; i < g_number_of_resolvers; i++)
-    {
-      GPR_ASSERT (0 != strcmp (factory->vtable->scheme, g_all_of_the_resolvers[i]->vtable->scheme));
-    }
-  GPR_ASSERT (g_number_of_resolvers != MAX_RESOLVERS);
-  grpc_resolver_factory_ref (factory);
+  for (i = 0; i < g_number_of_resolvers; i++) {
+    GPR_ASSERT(0 != strcmp(factory->vtable->scheme,
+                           g_all_of_the_resolvers[i]->vtable->scheme));
+  }
+  GPR_ASSERT(g_number_of_resolvers != MAX_RESOLVERS);
+  grpc_resolver_factory_ref(factory);
   g_all_of_the_resolvers[g_number_of_resolvers++] = factory;
 }
 
-static grpc_resolver_factory *
-lookup_factory (grpc_uri * uri)
-{
+static grpc_resolver_factory *lookup_factory(grpc_uri *uri) {
   int i;
 
   /* handling NULL uri's here simplifies grpc_resolver_create */
-  if (!uri)
-    return NULL;
-
-  for (i = 0; i < g_number_of_resolvers; i++)
-    {
-      if (0 == strcmp (uri->scheme, g_all_of_the_resolvers[i]->vtable->scheme))
-	{
-	  return g_all_of_the_resolvers[i];
-	}
+  if (!uri) return NULL;
+
+  for (i = 0; i < g_number_of_resolvers; i++) {
+    if (0 == strcmp(uri->scheme, g_all_of_the_resolvers[i]->vtable->scheme)) {
+      return g_all_of_the_resolvers[i];
     }
+  }
 
   return NULL;
 }
 
-static grpc_resolver_factory *
-resolve_factory (const char *target, grpc_uri ** uri)
-{
+static grpc_resolver_factory *resolve_factory(const char *target,
+                                              grpc_uri **uri) {
   char *tmp;
   grpc_resolver_factory *factory = NULL;
 
-  GPR_ASSERT (uri != NULL);
-  *uri = grpc_uri_parse (target, 1);
-  factory = lookup_factory (*uri);
-  if (factory == NULL)
-    {
-      if (g_default_resolver_prefix != NULL)
-	{
-	  grpc_uri_destroy (*uri);
-	  gpr_asprintf (&tmp, "%s%s", g_default_resolver_prefix, target);
-	  *uri = grpc_uri_parse (tmp, 1);
-	  factory = lookup_factory (*uri);
-	  if (factory == NULL)
-	    {
-	      grpc_uri_destroy (grpc_uri_parse (target, 0));
-	      grpc_uri_destroy (grpc_uri_parse (tmp, 0));
-	      gpr_log (GPR_ERROR, "don't know how to resolve '%s' or '%s'", target, tmp);
-	    }
-	  gpr_free (tmp);
-	}
-      else
-	{
-	  grpc_uri_destroy (grpc_uri_parse (target, 0));
-	  gpr_log (GPR_ERROR, "don't know how to resolve '%s'", target);
-	}
+  GPR_ASSERT(uri != NULL);
+  *uri = grpc_uri_parse(target, 1);
+  factory = lookup_factory(*uri);
+  if (factory == NULL) {
+    if (g_default_resolver_prefix != NULL) {
+      grpc_uri_destroy(*uri);
+      gpr_asprintf(&tmp, "%s%s", g_default_resolver_prefix, target);
+      *uri = grpc_uri_parse(tmp, 1);
+      factory = lookup_factory(*uri);
+      if (factory == NULL) {
+        grpc_uri_destroy(grpc_uri_parse(target, 0));
+        grpc_uri_destroy(grpc_uri_parse(tmp, 0));
+        gpr_log(GPR_ERROR, "don't know how to resolve '%s' or '%s'", target,
+                tmp);
+      }
+      gpr_free(tmp);
+    } else {
+      grpc_uri_destroy(grpc_uri_parse(target, 0));
+      gpr_log(GPR_ERROR, "don't know how to resolve '%s'", target);
     }
+  }
   return factory;
 }
 
-grpc_resolver *
-grpc_resolver_create (const char *target, grpc_subchannel_factory * subchannel_factory)
-{
+grpc_resolver *grpc_resolver_create(
+    const char *target, grpc_subchannel_factory *subchannel_factory) {
   grpc_uri *uri = NULL;
-  grpc_resolver_factory *factory = resolve_factory (target, &uri);
+  grpc_resolver_factory *factory = resolve_factory(target, &uri);
   grpc_resolver *resolver;
   grpc_resolver_args args;
-  memset (&args, 0, sizeof (args));
+  memset(&args, 0, sizeof(args));
   args.uri = uri;
   args.subchannel_factory = subchannel_factory;
-  resolver = grpc_resolver_factory_create_resolver (factory, &args);
-  grpc_uri_destroy (uri);
+  resolver = grpc_resolver_factory_create_resolver(factory, &args);
+  grpc_uri_destroy(uri);
   return resolver;
 }
 
-char *
-grpc_get_default_authority (const char *target)
-{
+char *grpc_get_default_authority(const char *target) {
   grpc_uri *uri = NULL;
-  grpc_resolver_factory *factory = resolve_factory (target, &uri);
-  char *authority = grpc_resolver_factory_get_default_authority (factory, uri);
-  grpc_uri_destroy (uri);
+  grpc_resolver_factory *factory = resolve_factory(target, &uri);
+  char *authority = grpc_resolver_factory_get_default_authority(factory, uri);
+  grpc_uri_destroy(uri);
   return authority;
 }

src/core/client_config/resolver_registry.h

@@ -36,15 +36,15 @@
 
 #include "src/core/client_config/resolver_factory.h"
 
-void grpc_resolver_registry_init (const char *default_prefix);
-void grpc_resolver_registry_shutdown (void);
+void grpc_resolver_registry_init(const char *default_prefix);
+void grpc_resolver_registry_shutdown(void);
 
 /** Register a resolver type.
     URI's of \a scheme will be resolved with the given resolver.
     If \a priority is greater than zero, then the resolver will be eligible
     to resolve names that are passed in with no scheme. Higher priority
     resolvers will be tried before lower priority schemes. */
-void grpc_register_resolver_type (grpc_resolver_factory * factory);
+void grpc_register_resolver_type(grpc_resolver_factory *factory);
 
 /** Create a resolver given \a target.
     First tries to parse \a target as a URI. If this succeeds, tries
@@ -55,10 +55,11 @@ void grpc_register_resolver_type (grpc_resolver_factory * factory);
     If a resolver factory was found, use it to instantiate a resolver and
     return it.
     If a resolver factory was not found, return NULL. */
-grpc_resolver *grpc_resolver_create (const char *target, grpc_subchannel_factory * subchannel_factory);
+grpc_resolver *grpc_resolver_create(
+    const char *target, grpc_subchannel_factory *subchannel_factory);
 
 /** Given a target, return a (freshly allocated with gpr_malloc) string
     representing the default authority to pass from a client. */
-char *grpc_get_default_authority (const char *target);
+char *grpc_get_default_authority(const char *target);
 
 #endif /* GRPC_INTERNAL_CORE_CLIENT_CONFIG_RESOLVER_REGISTRY_H */

src/core/client_config/resolvers/dns_resolver.c

@@ -44,8 +44,7 @@
 #include "src/core/iomgr/resolve_address.h"
 #include "src/core/support/string.h"
 
-typedef struct
-{
+typedef struct {
   /** base class: must be first */
   grpc_resolver base;
   /** refcount */
@@ -75,175 +74,160 @@ typedef struct
   grpc_client_config *resolved_config;
 } dns_resolver;
 
-static void dns_destroy (grpc_exec_ctx * exec_ctx, grpc_resolver * r);
+static void dns_destroy(grpc_exec_ctx *exec_ctx, grpc_resolver *r);
 
-static void dns_start_resolving_locked (dns_resolver * r);
-static void dns_maybe_finish_next_locked (grpc_exec_ctx * exec_ctx, dns_resolver * r);
+static void dns_start_resolving_locked(dns_resolver *r);
+static void dns_maybe_finish_next_locked(grpc_exec_ctx *exec_ctx,
+                                         dns_resolver *r);
 
-static void dns_shutdown (grpc_exec_ctx * exec_ctx, grpc_resolver * r);
-static void dns_channel_saw_error (grpc_exec_ctx * exec_ctx, grpc_resolver * r, struct sockaddr *failing_address, int failing_address_len);
-static void dns_next (grpc_exec_ctx * exec_ctx, grpc_resolver * r, grpc_client_config ** target_config, grpc_closure * on_complete);
+static void dns_shutdown(grpc_exec_ctx *exec_ctx, grpc_resolver *r);
+static void dns_channel_saw_error(grpc_exec_ctx *exec_ctx, grpc_resolver *r,
+                                  struct sockaddr *failing_address,
+                                  int failing_address_len);
+static void dns_next(grpc_exec_ctx *exec_ctx, grpc_resolver *r,
+                     grpc_client_config **target_config,
+                     grpc_closure *on_complete);
 
 static const grpc_resolver_vtable dns_resolver_vtable = {
-  dns_destroy, dns_shutdown, dns_channel_saw_error, dns_next
-};
+    dns_destroy, dns_shutdown, dns_channel_saw_error, dns_next};
 
-static void
-dns_shutdown (grpc_exec_ctx * exec_ctx, grpc_resolver * resolver)
-{
-  dns_resolver *r = (dns_resolver *) resolver;
-  gpr_mu_lock (&r->mu);
-  if (r->next_completion != NULL)
-    {
-      *r->target_config = NULL;
-      grpc_exec_ctx_enqueue (exec_ctx, r->next_completion, 1);
-      r->next_completion = NULL;
-    }
-  gpr_mu_unlock (&r->mu);
+static void dns_shutdown(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver) {
+  dns_resolver *r = (dns_resolver *)resolver;
+  gpr_mu_lock(&r->mu);
+  if (r->next_completion != NULL) {
+    *r->target_config = NULL;
+    grpc_exec_ctx_enqueue(exec_ctx, r->next_completion, 1);
+    r->next_completion = NULL;
+  }
+  gpr_mu_unlock(&r->mu);
 }
 
-static void
-dns_channel_saw_error (grpc_exec_ctx * exec_ctx, grpc_resolver * resolver, struct sockaddr *sa, int len)
-{
-  dns_resolver *r = (dns_resolver *) resolver;
-  gpr_mu_lock (&r->mu);
-  if (!r->resolving)
-    {
-      dns_start_resolving_locked (r);
-    }
-  gpr_mu_unlock (&r->mu);
+static void dns_channel_saw_error(grpc_exec_ctx *exec_ctx,
+                                  grpc_resolver *resolver, struct sockaddr *sa,
+                                  int len) {
+  dns_resolver *r = (dns_resolver *)resolver;
+  gpr_mu_lock(&r->mu);
+  if (!r->resolving) {
+    dns_start_resolving_locked(r);
+  }
+  gpr_mu_unlock(&r->mu);
 }
 
-static void
-dns_next (grpc_exec_ctx * exec_ctx, grpc_resolver * resolver, grpc_client_config ** target_config, grpc_closure * on_complete)
-{
-  dns_resolver *r = (dns_resolver *) resolver;
-  gpr_mu_lock (&r->mu);
-  GPR_ASSERT (!r->next_completion);
+static void dns_next(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver,
+                     grpc_client_config **target_config,
+                     grpc_closure *on_complete) {
+  dns_resolver *r = (dns_resolver *)resolver;
+  gpr_mu_lock(&r->mu);
+  GPR_ASSERT(!r->next_completion);
   r->next_completion = on_complete;
   r->target_config = target_config;
-  if (r->resolved_version == 0 && !r->resolving)
-    {
-      dns_start_resolving_locked (r);
-    }
-  else
-    {
-      dns_maybe_finish_next_locked (exec_ctx, r);
-    }
-  gpr_mu_unlock (&r->mu);
+  if (r->resolved_version == 0 && !r->resolving) {
+    dns_start_resolving_locked(r);
+  } else {
+    dns_maybe_finish_next_locked(exec_ctx, r);
+  }
+  gpr_mu_unlock(&r->mu);
 }
 
-static void
-dns_on_resolved (grpc_exec_ctx * exec_ctx, void *arg, grpc_resolved_addresses * addresses)
-{
+static void dns_on_resolved(grpc_exec_ctx *exec_ctx, void *arg,
+                            grpc_resolved_addresses *addresses) {
   dns_resolver *r = arg;
   grpc_client_config *config = NULL;
   grpc_subchannel **subchannels;
   grpc_subchannel_args args;
   grpc_lb_policy *lb_policy;
   size_t i;
-  if (addresses)
-    {
-      grpc_lb_policy_args lb_policy_args;
-      config = grpc_client_config_create ();
-      subchannels = gpr_malloc (sizeof (grpc_subchannel *) * addresses->naddrs);
-      for (i = 0; i < addresses->naddrs; i++)
-	{
-	  memset (&args, 0, sizeof (args));
-	  args.addr = (struct sockaddr *) (addresses->addrs[i].addr);
-	  args.addr_len = (size_t) addresses->addrs[i].len;
-	  subchannels[i] = grpc_subchannel_factory_create_subchannel (exec_ctx, r->subchannel_factory, &args);
-	}
-      memset (&lb_policy_args, 0, sizeof (lb_policy_args));
-      lb_policy_args.subchannels = subchannels;
-      lb_policy_args.num_subchannels = addresses->naddrs;
-      lb_policy = grpc_lb_policy_create (r->lb_policy_name, &lb_policy_args);
-      grpc_client_config_set_lb_policy (config, lb_policy);
-      GRPC_LB_POLICY_UNREF (exec_ctx, lb_policy, "construction");
-      grpc_resolved_addresses_destroy (addresses);
-      gpr_free (subchannels);
+  if (addresses) {
+    grpc_lb_policy_args lb_policy_args;
+    config = grpc_client_config_create();
+    subchannels = gpr_malloc(sizeof(grpc_subchannel *) * addresses->naddrs);
+    for (i = 0; i < addresses->naddrs; i++) {
+      memset(&args, 0, sizeof(args));
+      args.addr = (struct sockaddr *)(addresses->addrs[i].addr);
+      args.addr_len = (size_t)addresses->addrs[i].len;
+      subchannels[i] = grpc_subchannel_factory_create_subchannel(
+          exec_ctx, r->subchannel_factory, &args);
     }
-  gpr_mu_lock (&r->mu);
-  GPR_ASSERT (r->resolving);
+    memset(&lb_policy_args, 0, sizeof(lb_policy_args));
+    lb_policy_args.subchannels = subchannels;
+    lb_policy_args.num_subchannels = addresses->naddrs;
+    lb_policy = grpc_lb_policy_create(r->lb_policy_name, &lb_policy_args);
+    grpc_client_config_set_lb_policy(config, lb_policy);
+    GRPC_LB_POLICY_UNREF(exec_ctx, lb_policy, "construction");
+    grpc_resolved_addresses_destroy(addresses);
+    gpr_free(subchannels);
+  }
+  gpr_mu_lock(&r->mu);
+  GPR_ASSERT(r->resolving);
   r->resolving = 0;
-  if (r->resolved_config)
-    {
-      grpc_client_config_unref (exec_ctx, r->resolved_config);
-    }
+  if (r->resolved_config) {
+    grpc_client_config_unref(exec_ctx, r->resolved_config);
+  }
   r->resolved_config = config;
   r->resolved_version++;
-  dns_maybe_finish_next_locked (exec_ctx, r);
-  gpr_mu_unlock (&r->mu);
+  dns_maybe_finish_next_locked(exec_ctx, r);
+  gpr_mu_unlock(&r->mu);
 
-  GRPC_RESOLVER_UNREF (exec_ctx, &r->base, "dns-resolving");
+  GRPC_RESOLVER_UNREF(exec_ctx, &r->base, "dns-resolving");
 }
 
-static void
-dns_start_resolving_locked (dns_resolver * r)
-{
-  GRPC_RESOLVER_REF (&r->base, "dns-resolving");
-  GPR_ASSERT (!r->resolving);
+static void dns_start_resolving_locked(dns_resolver *r) {
+  GRPC_RESOLVER_REF(&r->base, "dns-resolving");
+  GPR_ASSERT(!r->resolving);
   r->resolving = 1;
-  grpc_resolve_address (r->name, r->default_port, dns_on_resolved, r);
+  grpc_resolve_address(r->name, r->default_port, dns_on_resolved, r);
 }
 
-static void
-dns_maybe_finish_next_locked (grpc_exec_ctx * exec_ctx, dns_resolver * r)
-{
-  if (r->next_completion != NULL && r->resolved_version != r->published_version)
-    {
-      *r->target_config = r->resolved_config;
-      if (r->resolved_config)
-	{
-	  grpc_client_config_ref (r->resolved_config);
-	}
-      grpc_exec_ctx_enqueue (exec_ctx, r->next_completion, 1);
-      r->next_completion = NULL;
-      r->published_version = r->resolved_version;
+static void dns_maybe_finish_next_locked(grpc_exec_ctx *exec_ctx,
+                                         dns_resolver *r) {
+  if (r->next_completion != NULL &&
+      r->resolved_version != r->published_version) {
+    *r->target_config = r->resolved_config;
+    if (r->resolved_config) {
+      grpc_client_config_ref(r->resolved_config);
     }
+    grpc_exec_ctx_enqueue(exec_ctx, r->next_completion, 1);
+    r->next_completion = NULL;
+    r->published_version = r->resolved_version;
+  }
 }
 
-static void
-dns_destroy (grpc_exec_ctx * exec_ctx, grpc_resolver * gr)
-{
-  dns_resolver *r = (dns_resolver *) gr;
-  gpr_mu_destroy (&r->mu);
-  if (r->resolved_config)
-    {
-      grpc_client_config_unref (exec_ctx, r->resolved_config);
-    }
-  grpc_subchannel_factory_unref (exec_ctx, r->subchannel_factory);
-  gpr_free (r->name);
-  gpr_free (r->default_port);
-  gpr_free (r->lb_policy_name);
-  gpr_free (r);
+static void dns_destroy(grpc_exec_ctx *exec_ctx, grpc_resolver *gr) {
+  dns_resolver *r = (dns_resolver *)gr;
+  gpr_mu_destroy(&r->mu);
+  if (r->resolved_config) {
+    grpc_client_config_unref(exec_ctx, r->resolved_config);
+  }
+  grpc_subchannel_factory_unref(exec_ctx, r->subchannel_factory);
+  gpr_free(r->name);
+  gpr_free(r->default_port);
+  gpr_free(r->lb_policy_name);
+  gpr_free(r);
 }
 
-static grpc_resolver *
-dns_create (grpc_resolver_args * args, const char *default_port, const char *lb_policy_name)
-{
+static grpc_resolver *dns_create(grpc_resolver_args *args,
+                                 const char *default_port,
+                                 const char *lb_policy_name) {
   dns_resolver *r;
   const char *path = args->uri->path;
 
-  if (0 != strcmp (args->uri->authority, ""))
-    {
-      gpr_log (GPR_ERROR, "authority based dns uri's not supported");
-      return NULL;
-    }
+  if (0 != strcmp(args->uri->authority, "")) {
+    gpr_log(GPR_ERROR, "authority based dns uri's not supported");
+    return NULL;
+  }
 
-  if (path[0] == '/')
-    ++path;
+  if (path[0] == '/') ++path;
 
-  r = gpr_malloc (sizeof (dns_resolver));
-  memset (r, 0, sizeof (*r));
-  gpr_ref_init (&r->refs, 1);
-  gpr_mu_init (&r->mu);
-  grpc_resolver_init (&r->base, &dns_resolver_vtable);
-  r->name = gpr_strdup (path);
-  r->default_port = gpr_strdup (default_port);
+  r = gpr_malloc(sizeof(dns_resolver));
+  memset(r, 0, sizeof(*r));
+  gpr_ref_init(&r->refs, 1);
+  gpr_mu_init(&r->mu);
+  grpc_resolver_init(&r->base, &dns_resolver_vtable);
+  r->name = gpr_strdup(path);
+  r->default_port = gpr_strdup(default_port);
   r->subchannel_factory = args->subchannel_factory;
-  grpc_subchannel_factory_ref (r->subchannel_factory);
-  r->lb_policy_name = gpr_strdup (lb_policy_name);
+  grpc_subchannel_factory_ref(r->subchannel_factory);
+  r->lb_policy_name = gpr_strdup(lb_policy_name);
   return &r->base;
 }
 
@@ -251,39 +235,27 @@ dns_create (grpc_resolver_args * args, const char *default_port, const char *lb_
  * FACTORY
  */
 
-static void
-dns_factory_ref (grpc_resolver_factory * factory)
-{
-}
+static void dns_factory_ref(grpc_resolver_factory *factory) {}
 
-static void
-dns_factory_unref (grpc_resolver_factory * factory)
-{
-}
+static void dns_factory_unref(grpc_resolver_factory *factory) {}
 
-static grpc_resolver *
-dns_factory_create_resolver (grpc_resolver_factory * factory, grpc_resolver_args * args)
-{
-  return dns_create (args, "https", "pick_first");
+static grpc_resolver *dns_factory_create_resolver(
+    grpc_resolver_factory *factory, grpc_resolver_args *args) {
+  return dns_create(args, "https", "pick_first");
 }
 
-char *
-dns_factory_get_default_host_name (grpc_resolver_factory * factory, grpc_uri * uri)
-{
+char *dns_factory_get_default_host_name(grpc_resolver_factory *factory,
+                                        grpc_uri *uri) {
   const char *path = uri->path;
-  if (path[0] == '/')
-    ++path;
-  return gpr_strdup (path);
+  if (path[0] == '/') ++path;
+  return gpr_strdup(path);
 }
 
 static const grpc_resolver_factory_vtable dns_factory_vtable = {
-  dns_factory_ref, dns_factory_unref, dns_factory_create_resolver,
-  dns_factory_get_default_host_name, "dns"
-};
-static grpc_resolver_factory dns_resolver_factory = { &dns_factory_vtable };
+    dns_factory_ref, dns_factory_unref, dns_factory_create_resolver,
+    dns_factory_get_default_host_name, "dns"};
+static grpc_resolver_factory dns_resolver_factory = {&dns_factory_vtable};
 
-grpc_resolver_factory *
-grpc_dns_resolver_factory_create ()
-{
+grpc_resolver_factory *grpc_dns_resolver_factory_create() {
   return &dns_resolver_factory;
 }

src/core/client_config/resolvers/dns_resolver.h

@@ -37,6 +37,6 @@
 #include "src/core/client_config/resolver_factory.h"
 
 /** Create a dns resolver factory */
-grpc_resolver_factory *grpc_dns_resolver_factory_create (void);
+grpc_resolver_factory *grpc_dns_resolver_factory_create(void);
 
 #endif /* GRPC_INTERNAL_CORE_CLIENT_CONFIG_RESOLVERS_DNS_RESOLVER_H */

src/core/client_config/resolvers/sockaddr_resolver.c

@@ -49,8 +49,7 @@
 #include "src/core/iomgr/resolve_address.h"
 #include "src/core/support/string.h"
 
-typedef struct
-{
+typedef struct {
   /** base class: must be first */
   grpc_resolver base;
   /** refcount */
@@ -77,314 +76,283 @@ typedef struct
   grpc_client_config **target_config;
 } sockaddr_resolver;
 
-static void sockaddr_destroy (grpc_exec_ctx * exec_ctx, grpc_resolver * r);
+static void sockaddr_destroy(grpc_exec_ctx *exec_ctx, grpc_resolver *r);
 
-static void sockaddr_maybe_finish_next_locked (grpc_exec_ctx * exec_ctx, sockaddr_resolver * r);
+static void sockaddr_maybe_finish_next_locked(grpc_exec_ctx *exec_ctx,
+                                              sockaddr_resolver *r);
 
-static void sockaddr_shutdown (grpc_exec_ctx * exec_ctx, grpc_resolver * r);
-static void sockaddr_channel_saw_error (grpc_exec_ctx * exec_ctx, grpc_resolver * r, struct sockaddr *failing_address, int failing_address_len);
-static void sockaddr_next (grpc_exec_ctx * exec_ctx, grpc_resolver * r, grpc_client_config ** target_config, grpc_closure * on_complete);
+static void sockaddr_shutdown(grpc_exec_ctx *exec_ctx, grpc_resolver *r);
+static void sockaddr_channel_saw_error(grpc_exec_ctx *exec_ctx,
+                                       grpc_resolver *r,
+                                       struct sockaddr *failing_address,
+                                       int failing_address_len);
+static void sockaddr_next(grpc_exec_ctx *exec_ctx, grpc_resolver *r,
+                          grpc_client_config **target_config,
+                          grpc_closure *on_complete);
 
 static const grpc_resolver_vtable sockaddr_resolver_vtable = {
-  sockaddr_destroy, sockaddr_shutdown, sockaddr_channel_saw_error,
-  sockaddr_next
-};
-
-static void
-sockaddr_shutdown (grpc_exec_ctx * exec_ctx, grpc_resolver * resolver)
-{
-  sockaddr_resolver *r = (sockaddr_resolver *) resolver;
-  gpr_mu_lock (&r->mu);
-  if (r->next_completion != NULL)
-    {
-      *r->target_config = NULL;
-      grpc_exec_ctx_enqueue (exec_ctx, r->next_completion, 1);
-      r->next_completion = NULL;
-    }
-  gpr_mu_unlock (&r->mu);
+    sockaddr_destroy, sockaddr_shutdown, sockaddr_channel_saw_error,
+    sockaddr_next};
+
+static void sockaddr_shutdown(grpc_exec_ctx *exec_ctx,
+                              grpc_resolver *resolver) {
+  sockaddr_resolver *r = (sockaddr_resolver *)resolver;
+  gpr_mu_lock(&r->mu);
+  if (r->next_completion != NULL) {
+    *r->target_config = NULL;
+    grpc_exec_ctx_enqueue(exec_ctx, r->next_completion, 1);
+    r->next_completion = NULL;
+  }
+  gpr_mu_unlock(&r->mu);
 }
 
-static void
-sockaddr_channel_saw_error (grpc_exec_ctx * exec_ctx, grpc_resolver * resolver, struct sockaddr *sa, int len)
-{
-}
+static void sockaddr_channel_saw_error(grpc_exec_ctx *exec_ctx,
+                                       grpc_resolver *resolver,
+                                       struct sockaddr *sa, int len) {}
 
-static void
-sockaddr_next (grpc_exec_ctx * exec_ctx, grpc_resolver * resolver, grpc_client_config ** target_config, grpc_closure * on_complete)
-{
-  sockaddr_resolver *r = (sockaddr_resolver *) resolver;
-  gpr_mu_lock (&r->mu);
-  GPR_ASSERT (!r->next_completion);
+static void sockaddr_next(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver,
+                          grpc_client_config **target_config,
+                          grpc_closure *on_complete) {
+  sockaddr_resolver *r = (sockaddr_resolver *)resolver;
+  gpr_mu_lock(&r->mu);
+  GPR_ASSERT(!r->next_completion);
   r->next_completion = on_complete;
   r->target_config = target_config;
-  sockaddr_maybe_finish_next_locked (exec_ctx, r);
-  gpr_mu_unlock (&r->mu);
+  sockaddr_maybe_finish_next_locked(exec_ctx, r);
+  gpr_mu_unlock(&r->mu);
 }
 
-static void
-sockaddr_maybe_finish_next_locked (grpc_exec_ctx * exec_ctx, sockaddr_resolver * r)
-{
+static void sockaddr_maybe_finish_next_locked(grpc_exec_ctx *exec_ctx,
+                                              sockaddr_resolver *r) {
   grpc_client_config *cfg;
   grpc_lb_policy *lb_policy;
   grpc_lb_policy_args lb_policy_args;
   grpc_subchannel **subchannels;
   grpc_subchannel_args args;
 
-  if (r->next_completion != NULL && !r->published)
-    {
-      size_t i;
-      cfg = grpc_client_config_create ();
-      subchannels = gpr_malloc (sizeof (grpc_subchannel *) * r->num_addrs);
-      for (i = 0; i < r->num_addrs; i++)
-	{
-	  memset (&args, 0, sizeof (args));
-	  args.addr = (struct sockaddr *) &r->addrs[i];
-	  args.addr_len = r->addrs_len[i];
-	  subchannels[i] = grpc_subchannel_factory_create_subchannel (exec_ctx, r->subchannel_factory, &args);
-	}
-      memset (&lb_policy_args, 0, sizeof (lb_policy_args));
-      lb_policy_args.subchannels = subchannels;
-      lb_policy_args.num_subchannels = r->num_addrs;
-      lb_policy = grpc_lb_policy_create (r->lb_policy_name, &lb_policy_args);
-      gpr_free (subchannels);
-      grpc_client_config_set_lb_policy (cfg, lb_policy);
-      GRPC_LB_POLICY_UNREF (exec_ctx, lb_policy, "sockaddr");
-      r->published = 1;
-      *r->target_config = cfg;
-      grpc_exec_ctx_enqueue (exec_ctx, r->next_completion, 1);
-      r->next_completion = NULL;
+  if (r->next_completion != NULL && !r->published) {
+    size_t i;
+    cfg = grpc_client_config_create();
+    subchannels = gpr_malloc(sizeof(grpc_subchannel *) * r->num_addrs);
+    for (i = 0; i < r->num_addrs; i++) {
+      memset(&args, 0, sizeof(args));
+      args.addr = (struct sockaddr *)&r->addrs[i];
+      args.addr_len = r->addrs_len[i];
+      subchannels[i] = grpc_subchannel_factory_create_subchannel(
+          exec_ctx, r->subchannel_factory, &args);
     }
+    memset(&lb_policy_args, 0, sizeof(lb_policy_args));
+    lb_policy_args.subchannels = subchannels;
+    lb_policy_args.num_subchannels = r->num_addrs;
+    lb_policy = grpc_lb_policy_create(r->lb_policy_name, &lb_policy_args);
+    gpr_free(subchannels);
+    grpc_client_config_set_lb_policy(cfg, lb_policy);
+    GRPC_LB_POLICY_UNREF(exec_ctx, lb_policy, "sockaddr");
+    r->published = 1;
+    *r->target_config = cfg;
+    grpc_exec_ctx_enqueue(exec_ctx, r->next_completion, 1);
+    r->next_completion = NULL;
+  }
 }
 
-static void
-sockaddr_destroy (grpc_exec_ctx * exec_ctx, grpc_resolver * gr)
-{
-  sockaddr_resolver *r = (sockaddr_resolver *) gr;
-  gpr_mu_destroy (&r->mu);
-  grpc_subchannel_factory_unref (exec_ctx, r->subchannel_factory);
-  gpr_free (r->addrs);
-  gpr_free (r->addrs_len);
-  gpr_free (r->lb_policy_name);
-  gpr_free (r);
+static void sockaddr_destroy(grpc_exec_ctx *exec_ctx, grpc_resolver *gr) {
+  sockaddr_resolver *r = (sockaddr_resolver *)gr;
+  gpr_mu_destroy(&r->mu);
+  grpc_subchannel_factory_unref(exec_ctx, r->subchannel_factory);
+  gpr_free(r->addrs);
+  gpr_free(r->addrs_len);
+  gpr_free(r->lb_policy_name);
+  gpr_free(r);
 }
 
 #ifdef GPR_POSIX_SOCKET
-static int
-parse_unix (grpc_uri * uri, struct sockaddr_storage *addr, size_t * len)
-{
-  struct sockaddr_un *un = (struct sockaddr_un *) addr;
+static int parse_unix(grpc_uri *uri, struct sockaddr_storage *addr,
+                      size_t *len) {
+  struct sockaddr_un *un = (struct sockaddr_un *)addr;
 
   un->sun_family = AF_UNIX;
-  strcpy (un->sun_path, uri->path);
-  *len = strlen (un->sun_path) + sizeof (un->sun_family) + 1;
+  strcpy(un->sun_path, uri->path);
+  *len = strlen(un->sun_path) + sizeof(un->sun_family) + 1;
 
   return 1;
 }
 
-static char *
-unix_get_default_authority (grpc_resolver_factory * factory, grpc_uri * uri)
-{
-  return gpr_strdup ("localhost");
+static char *unix_get_default_authority(grpc_resolver_factory *factory,
+                                        grpc_uri *uri) {
+  return gpr_strdup("localhost");
 }
 #endif
 
-static char *
-ip_get_default_authority (grpc_uri * uri)
-{
+static char *ip_get_default_authority(grpc_uri *uri) {
   const char *path = uri->path;
-  if (path[0] == '/')
-    ++path;
-  return gpr_strdup (path);
+  if (path[0] == '/') ++path;
+  return gpr_strdup(path);
 }
 
-static char *
-ipv4_get_default_authority (grpc_resolver_factory * factory, grpc_uri * uri)
-{
-  return ip_get_default_authority (uri);
+static char *ipv4_get_default_authority(grpc_resolver_factory *factory,
+                                        grpc_uri *uri) {
+  return ip_get_default_authority(uri);
 }
 
-static char *
-ipv6_get_default_authority (grpc_resolver_factory * factory, grpc_uri * uri)
-{
-  return ip_get_default_authority (uri);
+static char *ipv6_get_default_authority(grpc_resolver_factory *factory,
+                                        grpc_uri *uri) {
+  return ip_get_default_authority(uri);
 }
 
-static int
-parse_ipv4 (grpc_uri * uri, struct sockaddr_storage *addr, size_t * len)
-{
+static int parse_ipv4(grpc_uri *uri, struct sockaddr_storage *addr,
+                      size_t *len) {
   const char *host_port = uri->path;
   char *host;
   char *port;
   int port_num;
   int result = 0;
-  struct sockaddr_in *in = (struct sockaddr_in *) addr;
+  struct sockaddr_in *in = (struct sockaddr_in *)addr;
 
-  if (*host_port == '/')
-    ++host_port;
-  if (!gpr_split_host_port (host_port, &host, &port))
-    {
-      return 0;
-    }
+  if (*host_port == '/') ++host_port;
+  if (!gpr_split_host_port(host_port, &host, &port)) {
+    return 0;
+  }
 
-  memset (in, 0, sizeof (*in));
-  *len = sizeof (*in);
+  memset(in, 0, sizeof(*in));
+  *len = sizeof(*in);
   in->sin_family = AF_INET;
-  if (inet_pton (AF_INET, host, &in->sin_addr) == 0)
-    {
-      gpr_log (GPR_ERROR, "invalid ipv4 address: '%s'", host);
-      goto done;
-    }
+  if (inet_pton(AF_INET, host, &in->sin_addr) == 0) {
+    gpr_log(GPR_ERROR, "invalid ipv4 address: '%s'", host);
+    goto done;
+  }
 
-  if (port != NULL)
-    {
-      if (sscanf (port, "%d", &port_num) != 1 || port_num < 0 || port_num > 65535)
-	{
-	  gpr_log (GPR_ERROR, "invalid ipv4 port: '%s'", port);
-	  goto done;
-	}
-      in->sin_port = htons ((gpr_uint16) port_num);
-    }
-  else
-    {
-      gpr_log (GPR_ERROR, "no port given for ipv4 scheme");
+  if (port != NULL) {
+    if (sscanf(port, "%d", &port_num) != 1 || port_num < 0 ||
+        port_num > 65535) {
+      gpr_log(GPR_ERROR, "invalid ipv4 port: '%s'", port);
       goto done;
     }
+    in->sin_port = htons((gpr_uint16)port_num);
+  } else {
+    gpr_log(GPR_ERROR, "no port given for ipv4 scheme");
+    goto done;
+  }
 
   result = 1;
 done:
-  gpr_free (host);
-  gpr_free (port);
+  gpr_free(host);
+  gpr_free(port);
   return result;
 }
 
-static int
-parse_ipv6 (grpc_uri * uri, struct sockaddr_storage *addr, size_t * len)
-{
+static int parse_ipv6(grpc_uri *uri, struct sockaddr_storage *addr,
+                      size_t *len) {
   const char *host_port = uri->path;
   char *host;
   char *port;
   int port_num;
   int result = 0;
-  struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) addr;
+  struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)addr;
 
-  if (*host_port == '/')
-    ++host_port;
-  if (!gpr_split_host_port (host_port, &host, &port))
-    {
-      return 0;
-    }
+  if (*host_port == '/') ++host_port;
+  if (!gpr_split_host_port(host_port, &host, &port)) {
+    return 0;
+  }
 
-  memset (in6, 0, sizeof (*in6));
-  *len = sizeof (*in6);
+  memset(in6, 0, sizeof(*in6));
+  *len = sizeof(*in6);
   in6->sin6_family = AF_INET6;
-  if (inet_pton (AF_INET6, host, &in6->sin6_addr) == 0)
-    {
-      gpr_log (GPR_ERROR, "invalid ipv6 address: '%s'", host);
-      goto done;
-    }
+  if (inet_pton(AF_INET6, host, &in6->sin6_addr) == 0) {
+    gpr_log(GPR_ERROR, "invalid ipv6 address: '%s'", host);
+    goto done;
+  }
 
-  if (port != NULL)
-    {
-      if (sscanf (port, "%d", &port_num) != 1 || port_num < 0 || port_num > 65535)
-	{
-	  gpr_log (GPR_ERROR, "invalid ipv6 port: '%s'", port);
-	  goto done;
-	}
-      in6->sin6_port = htons ((gpr_uint16) port_num);
-    }
-  else
-    {
-      gpr_log (GPR_ERROR, "no port given for ipv6 scheme");
+  if (port != NULL) {
+    if (sscanf(port, "%d", &port_num) != 1 || port_num < 0 ||
+        port_num > 65535) {
+      gpr_log(GPR_ERROR, "invalid ipv6 port: '%s'", port);
       goto done;
     }
+    in6->sin6_port = htons((gpr_uint16)port_num);
+  } else {
+    gpr_log(GPR_ERROR, "no port given for ipv6 scheme");
+    goto done;
+  }
 
   result = 1;
 done:
-  gpr_free (host);
-  gpr_free (port);
+  gpr_free(host);
+  gpr_free(port);
   return result;
 }
 
-static void
-do_nothing (void *ignored)
-{
-}
+static void do_nothing(void *ignored) {}
 
-static grpc_resolver *
-sockaddr_create (grpc_resolver_args * args, const char *default_lb_policy_name, int parse (grpc_uri * uri, struct sockaddr_storage *dst, size_t * len))
-{
+static grpc_resolver *sockaddr_create(
+    grpc_resolver_args *args, const char *default_lb_policy_name,
+    int parse(grpc_uri *uri, struct sockaddr_storage *dst, size_t *len)) {
   size_t i;
-  int errors_found = 0;		/* GPR_FALSE */
+  int errors_found = 0; /* GPR_FALSE */
   sockaddr_resolver *r;
   gpr_slice path_slice;
   gpr_slice_buffer path_parts;
 
-  if (0 != strcmp (args->uri->authority, ""))
-    {
-      gpr_log (GPR_ERROR, "authority based uri's not supported by the %s scheme", args->uri->scheme);
-      return NULL;
-    }
+  if (0 != strcmp(args->uri->authority, "")) {
+    gpr_log(GPR_ERROR, "authority based uri's not supported by the %s scheme",
+            args->uri->scheme);
+    return NULL;
+  }
 
-  r = gpr_malloc (sizeof (sockaddr_resolver));
-  memset (r, 0, sizeof (*r));
+  r = gpr_malloc(sizeof(sockaddr_resolver));
+  memset(r, 0, sizeof(*r));
 
   r->lb_policy_name = NULL;
-  if (0 != strcmp (args->uri->query, ""))
-    {
-      gpr_slice query_slice;
-      gpr_slice_buffer query_parts;
-
-      query_slice = gpr_slice_new (args->uri->query, strlen (args->uri->query), do_nothing);
-      gpr_slice_buffer_init (&query_parts);
-      gpr_slice_split (query_slice, "=", &query_parts);
-      GPR_ASSERT (query_parts.count == 2);
-      if (0 == gpr_slice_str_cmp (query_parts.slices[0], "lb_policy"))
-	{
-	  r->lb_policy_name = gpr_dump_slice (query_parts.slices[1], GPR_DUMP_ASCII);
-	}
-      gpr_slice_buffer_destroy (&query_parts);
-      gpr_slice_unref (query_slice);
-    }
-  if (r->lb_policy_name == NULL)
-    {
-      r->lb_policy_name = gpr_strdup (default_lb_policy_name);
+  if (0 != strcmp(args->uri->query, "")) {
+    gpr_slice query_slice;
+    gpr_slice_buffer query_parts;
+
+    query_slice =
+        gpr_slice_new(args->uri->query, strlen(args->uri->query), do_nothing);
+    gpr_slice_buffer_init(&query_parts);
+    gpr_slice_split(query_slice, "=", &query_parts);
+    GPR_ASSERT(query_parts.count == 2);
+    if (0 == gpr_slice_str_cmp(query_parts.slices[0], "lb_policy")) {
+      r->lb_policy_name = gpr_dump_slice(query_parts.slices[1], GPR_DUMP_ASCII);
     }
+    gpr_slice_buffer_destroy(&query_parts);
+    gpr_slice_unref(query_slice);
+  }
+  if (r->lb_policy_name == NULL) {
+    r->lb_policy_name = gpr_strdup(default_lb_policy_name);
+  }
 
-  path_slice = gpr_slice_new (args->uri->path, strlen (args->uri->path), do_nothing);
-  gpr_slice_buffer_init (&path_parts);
+  path_slice =
+      gpr_slice_new(args->uri->path, strlen(args->uri->path), do_nothing);
+  gpr_slice_buffer_init(&path_parts);
 
-  gpr_slice_split (path_slice, ",", &path_parts);
+  gpr_slice_split(path_slice, ",", &path_parts);
   r->num_addrs = path_parts.count;
-  r->addrs = gpr_malloc (sizeof (struct sockaddr_storage) * r->num_addrs);
-  r->addrs_len = gpr_malloc (sizeof (*r->addrs_len) * r->num_addrs);
-
-  for (i = 0; i < r->num_addrs; i++)
-    {
-      grpc_uri ith_uri = *args->uri;
-      char *part_str = gpr_dump_slice (path_parts.slices[i], GPR_DUMP_ASCII);
-      ith_uri.path = part_str;
-      if (!parse (&ith_uri, &r->addrs[i], &r->addrs_len[i]))
-	{
-	  errors_found = 1;	/* GPR_TRUE */
-	}
-      gpr_free (part_str);
-      if (errors_found)
-	break;
+  r->addrs = gpr_malloc(sizeof(struct sockaddr_storage) * r->num_addrs);
+  r->addrs_len = gpr_malloc(sizeof(*r->addrs_len) * r->num_addrs);
+
+  for (i = 0; i < r->num_addrs; i++) {
+    grpc_uri ith_uri = *args->uri;
+    char *part_str = gpr_dump_slice(path_parts.slices[i], GPR_DUMP_ASCII);
+    ith_uri.path = part_str;
+    if (!parse(&ith_uri, &r->addrs[i], &r->addrs_len[i])) {
+      errors_found = 1; /* GPR_TRUE */
     }
+    gpr_free(part_str);
+    if (errors_found) break;
+  }
 
-  gpr_slice_buffer_destroy (&path_parts);
-  gpr_slice_unref (path_slice);
-  if (errors_found)
-    {
-      gpr_free (r);
-      return NULL;
-    }
+  gpr_slice_buffer_destroy(&path_parts);
+  gpr_slice_unref(path_slice);
+  if (errors_found) {
+    gpr_free(r);
+    return NULL;
+  }
 
-  gpr_ref_init (&r->refs, 1);
-  gpr_mu_init (&r->mu);
-  grpc_resolver_init (&r->base, &sockaddr_resolver_vtable);
+  gpr_ref_init(&r->refs, 1);
+  gpr_mu_init(&r->mu);
+  grpc_resolver_init(&r->base, &sockaddr_resolver_vtable);
   r->subchannel_factory = args->subchannel_factory;
-  grpc_subchannel_factory_ref (r->subchannel_factory);
+  grpc_subchannel_factory_ref(r->subchannel_factory);
 
   return &r->base;
 }
@@ -393,15 +361,9 @@ sockaddr_create (grpc_resolver_args * args, const char *default_lb_policy_name,
  * FACTORY
  */
 
-static void
-sockaddr_factory_ref (grpc_resolver_factory * factory)
-{
-}
+static void sockaddr_factory_ref(grpc_resolver_factory *factory) {}
 
-static void
-sockaddr_factory_unref (grpc_resolver_factory * factory)
-{
-}
+static void sockaddr_factory_unref(grpc_resolver_factory *factory) {}
 
 #define DECL_FACTORY(name)                                                  \
   static grpc_resolver *name##_factory_create_resolver(                     \
@@ -418,6 +380,6 @@ sockaddr_factory_unref (grpc_resolver_factory * factory)
   }
 
 #ifdef GPR_POSIX_SOCKET
-DECL_FACTORY (unix)
+DECL_FACTORY(unix)
 #endif
-  DECL_FACTORY (ipv4) DECL_FACTORY (ipv6)
+DECL_FACTORY(ipv4) DECL_FACTORY(ipv6)

src/core/client_config/resolvers/sockaddr_resolver.h

@@ -38,13 +38,13 @@
 
 #include "src/core/client_config/resolver_factory.h"
 
-grpc_resolver_factory *grpc_ipv4_resolver_factory_create (void);
+grpc_resolver_factory *grpc_ipv4_resolver_factory_create(void);
 
-grpc_resolver_factory *grpc_ipv6_resolver_factory_create (void);
+grpc_resolver_factory *grpc_ipv6_resolver_factory_create(void);
 
 #ifdef GPR_POSIX_SOCKET
 /** Create a unix resolver factory */
-grpc_resolver_factory *grpc_unix_resolver_factory_create (void);
+grpc_resolver_factory *grpc_unix_resolver_factory_create(void);
 #endif
 
 #endif /* GRPC_INTERNAL_CORE_CLIENT_CONFIG_RESOLVERS_UNIX_RESOLVER_H */

src/core/client_config/resolvers/zookeeper_resolver.c

@@ -50,8 +50,7 @@
 /** Zookeeper session expiration time in milliseconds */
 #define GRPC_ZOOKEEPER_SESSION_TIMEOUT 15000
 
-typedef struct
-{
+typedef struct {
   /** base class: must be first */
   grpc_resolver base;
   /** refcount */
@@ -88,119 +87,101 @@ typedef struct
   int resolved_num;
 } zookeeper_resolver;
 
-static void zookeeper_destroy (grpc_resolver * r);
+static void zookeeper_destroy(grpc_resolver *r);
 
-static void zookeeper_start_resolving_locked (zookeeper_resolver * r);
-static grpc_closure *
-zookeeper_maybe_finish_next_locked (zookeeper_resolver * r)
-  GRPC_MUST_USE_RESULT;
+static void zookeeper_start_resolving_locked(zookeeper_resolver *r);
+static grpc_closure *zookeeper_maybe_finish_next_locked(zookeeper_resolver *r)
+    GRPC_MUST_USE_RESULT;
 
-     static void zookeeper_shutdown (grpc_resolver * r);
-     static void zookeeper_channel_saw_error (grpc_resolver * r, struct sockaddr *failing_address, int failing_address_len);
-     static void zookeeper_next (grpc_resolver * r, grpc_client_config ** target_config, grpc_closure * on_complete);
+static void zookeeper_shutdown(grpc_resolver *r);
+static void zookeeper_channel_saw_error(grpc_resolver *r,
+                                        struct sockaddr *failing_address,
+                                        int failing_address_len);
+static void zookeeper_next(grpc_resolver *r, grpc_client_config **target_config,
+                           grpc_closure *on_complete);
 
-     static const grpc_resolver_vtable zookeeper_resolver_vtable = {
-       zookeeper_destroy, zookeeper_shutdown, zookeeper_channel_saw_error,
-       zookeeper_next
-     };
+static const grpc_resolver_vtable zookeeper_resolver_vtable = {
+    zookeeper_destroy, zookeeper_shutdown, zookeeper_channel_saw_error,
+    zookeeper_next};
 
-static void
-zookeeper_shutdown (grpc_resolver * resolver)
-{
-  zookeeper_resolver *r = (zookeeper_resolver *) resolver;
+static void zookeeper_shutdown(grpc_resolver *resolver) {
+  zookeeper_resolver *r = (zookeeper_resolver *)resolver;
   grpc_closure *call = NULL;
-  gpr_mu_lock (&r->mu);
-  if (r->next_completion != NULL)
-    {
-      *r->target_config = NULL;
-      call = r->next_completion;
-      r->next_completion = NULL;
-    }
-  zookeeper_close (r->zookeeper_handle);
-  gpr_mu_unlock (&r->mu);
-  if (call != NULL)
-    {
-      call->cb (call->cb_arg, 1);
-    }
+  gpr_mu_lock(&r->mu);
+  if (r->next_completion != NULL) {
+    *r->target_config = NULL;
+    call = r->next_completion;
+    r->next_completion = NULL;
+  }
+  zookeeper_close(r->zookeeper_handle);
+  gpr_mu_unlock(&r->mu);
+  if (call != NULL) {
+    call->cb(call->cb_arg, 1);
+  }
 }
 
-static void
-zookeeper_channel_saw_error (grpc_resolver * resolver, struct sockaddr *sa, int len)
-{
-  zookeeper_resolver *r = (zookeeper_resolver *) resolver;
-  gpr_mu_lock (&r->mu);
-  if (r->resolving == 0)
-    {
-      zookeeper_start_resolving_locked (r);
-    }
-  gpr_mu_unlock (&r->mu);
+static void zookeeper_channel_saw_error(grpc_resolver *resolver,
+                                        struct sockaddr *sa, int len) {
+  zookeeper_resolver *r = (zookeeper_resolver *)resolver;
+  gpr_mu_lock(&r->mu);
+  if (r->resolving == 0) {
+    zookeeper_start_resolving_locked(r);
+  }
+  gpr_mu_unlock(&r->mu);
 }
 
-static void
-zookeeper_next (grpc_resolver * resolver, grpc_client_config ** target_config, grpc_closure * on_complete)
-{
-  zookeeper_resolver *r = (zookeeper_resolver *) resolver;
+static void zookeeper_next(grpc_resolver *resolver,
+                           grpc_client_config **target_config,
+                           grpc_closure *on_complete) {
+  zookeeper_resolver *r = (zookeeper_resolver *)resolver;
   grpc_closure *call;
-  gpr_mu_lock (&r->mu);
-  GPR_ASSERT (r->next_completion == NULL);
+  gpr_mu_lock(&r->mu);
+  GPR_ASSERT(r->next_completion == NULL);
   r->next_completion = on_complete;
   r->target_config = target_config;
-  if (r->resolved_version == 0 && r->resolving == 0)
-    {
-      zookeeper_start_resolving_locked (r);
-    }
-  else
-    {
-      call = zookeeper_maybe_finish_next_locked (r);
-    }
-  gpr_mu_unlock (&r->mu);
-  if (call)
-    call->cb (call->cb_arg, 1);
+  if (r->resolved_version == 0 && r->resolving == 0) {
+    zookeeper_start_resolving_locked(r);
+  } else {
+    call = zookeeper_maybe_finish_next_locked(r);
+  }
+  gpr_mu_unlock(&r->mu);
+  if (call) call->cb(call->cb_arg, 1);
 }
 
 /** Zookeeper global watcher for connection management
     TODO: better connection management besides logs */
-static void
-zookeeper_global_watcher (zhandle_t * zookeeper_handle, int type, int state, const char *path, void *watcher_ctx)
-{
-  if (type == ZOO_SESSION_EVENT)
-    {
-      if (state == ZOO_EXPIRED_SESSION_STATE)
-	{
-	  gpr_log (GPR_ERROR, "Zookeeper session expired");
-	}
-      else if (state == ZOO_AUTH_FAILED_STATE)
-	{
-	  gpr_log (GPR_ERROR, "Zookeeper authentication failed");
-	}
+static void zookeeper_global_watcher(zhandle_t *zookeeper_handle, int type,
+                                     int state, const char *path,
+                                     void *watcher_ctx) {
+  if (type == ZOO_SESSION_EVENT) {
+    if (state == ZOO_EXPIRED_SESSION_STATE) {
+      gpr_log(GPR_ERROR, "Zookeeper session expired");
+    } else if (state == ZOO_AUTH_FAILED_STATE) {
+      gpr_log(GPR_ERROR, "Zookeeper authentication failed");
     }
+  }
 }
 
 /** Zookeeper watcher triggered by changes to watched nodes
     Once triggered, it tries to resolve again to get updated addresses */
-static void
-zookeeper_watcher (zhandle_t * zookeeper_handle, int type, int state, const char *path, void *watcher_ctx)
-{
-  if (watcher_ctx != NULL)
-    {
-      zookeeper_resolver *r = (zookeeper_resolver *) watcher_ctx;
-      if (state == ZOO_CONNECTED_STATE)
-	{
-	  gpr_mu_lock (&r->mu);
-	  if (r->resolving == 0)
-	    {
-	      zookeeper_start_resolving_locked (r);
-	    }
-	  gpr_mu_unlock (&r->mu);
-	}
+static void zookeeper_watcher(zhandle_t *zookeeper_handle, int type, int state,
+                              const char *path, void *watcher_ctx) {
+  if (watcher_ctx != NULL) {
+    zookeeper_resolver *r = (zookeeper_resolver *)watcher_ctx;
+    if (state == ZOO_CONNECTED_STATE) {
+      gpr_mu_lock(&r->mu);
+      if (r->resolving == 0) {
+        zookeeper_start_resolving_locked(r);
+      }
+      gpr_mu_unlock(&r->mu);
     }
+  }
 }
 
 /** Callback function after getting all resolved addresses
     Creates a subchannel for each address */
-static void
-zookeeper_on_resolved (void *arg, grpc_resolved_addresses * addresses)
-{
+static void zookeeper_on_resolved(void *arg,
+                                  grpc_resolved_addresses *addresses) {
   zookeeper_resolver *r = arg;
   grpc_client_config *config = NULL;
   grpc_subchannel **subchannels;
@@ -208,77 +189,74 @@ zookeeper_on_resolved (void *arg, grpc_resolved_addresses * addresses)
   grpc_lb_policy *lb_policy;
   grpc_closure *call;
   size_t i;
-  if (addresses != NULL)
-    {
-      grpc_lb_policy_args lb_policy_args;
-      config = grpc_client_config_create ();
-      subchannels = gpr_malloc (sizeof (grpc_subchannel *) * addresses->naddrs);
-      for (i = 0; i < addresses->naddrs; i++)
-	{
-	  memset (&args, 0, sizeof (args));
-	  args.addr = (struct sockaddr *) (addresses->addrs[i].addr);
-	  args.addr_len = addresses->addrs[i].len;
-	  subchannels[i] = grpc_subchannel_factory_create_subchannel (r->subchannel_factory, &args);
-	}
-      lb_policy_args.subchannels = subchannels;
-      lb_policy_args.num_subchannels = addresses->naddrs;
-      lb_policy = grpc_lb_policy_create (r->lb_policy_name, &lb_policy_args);
-      grpc_client_config_set_lb_policy (config, lb_policy);
-      GRPC_LB_POLICY_UNREF (lb_policy, "construction");
-      grpc_resolved_addresses_destroy (addresses);
-      gpr_free (subchannels);
+  if (addresses != NULL) {
+    grpc_lb_policy_args lb_policy_args;
+    config = grpc_client_config_create();
+    subchannels = gpr_malloc(sizeof(grpc_subchannel *) * addresses->naddrs);
+    for (i = 0; i < addresses->naddrs; i++) {
+      memset(&args, 0, sizeof(args));
+      args.addr = (struct sockaddr *)(addresses->addrs[i].addr);
+      args.addr_len = addresses->addrs[i].len;
+      subchannels[i] = grpc_subchannel_factory_create_subchannel(
+          r->subchannel_factory, &args);
     }
-  gpr_mu_lock (&r->mu);
-  GPR_ASSERT (r->resolving == 1);
+    lb_policy_args.subchannels = subchannels;
+    lb_policy_args.num_subchannels = addresses->naddrs;
+    lb_policy = grpc_lb_policy_create(r->lb_policy_name, &lb_policy_args);
+    grpc_client_config_set_lb_policy(config, lb_policy);
+    GRPC_LB_POLICY_UNREF(lb_policy, "construction");
+    grpc_resolved_addresses_destroy(addresses);
+    gpr_free(subchannels);
+  }
+  gpr_mu_lock(&r->mu);
+  GPR_ASSERT(r->resolving == 1);
   r->resolving = 0;
-  if (r->resolved_config != NULL)
-    {
-      grpc_client_config_unref (r->resolved_config);
-    }
+  if (r->resolved_config != NULL) {
+    grpc_client_config_unref(r->resolved_config);
+  }
   r->resolved_config = config;
   r->resolved_version++;
-  call = zookeeper_maybe_finish_next_locked (r);
-  gpr_mu_unlock (&r->mu);
+  call = zookeeper_maybe_finish_next_locked(r);
+  gpr_mu_unlock(&r->mu);
 
-  if (call)
-    call->cb (call->cb_arg, 1);
+  if (call) call->cb(call->cb_arg, 1);
 
-  GRPC_RESOLVER_UNREF (&r->base, "zookeeper-resolving");
+  GRPC_RESOLVER_UNREF(&r->base, "zookeeper-resolving");
 }
 
 /** Callback function for each DNS resolved address */
-static void
-zookeeper_dns_resolved (void *arg, grpc_resolved_addresses * addresses)
-{
+static void zookeeper_dns_resolved(void *arg,
+                                   grpc_resolved_addresses *addresses) {
   size_t i;
   zookeeper_resolver *r = arg;
   int resolve_done = 0;
 
-  gpr_mu_lock (&r->mu);
+  gpr_mu_lock(&r->mu);
   r->resolved_num++;
-  r->resolved_addrs->addrs = gpr_realloc (r->resolved_addrs->addrs, sizeof (grpc_resolved_address) * (r->resolved_addrs->naddrs + addresses->naddrs));
-  for (i = 0; i < addresses->naddrs; i++)
-    {
-      memcpy (r->resolved_addrs->addrs[i + r->resolved_addrs->naddrs].addr, addresses->addrs[i].addr, addresses->addrs[i].len);
-      r->resolved_addrs->addrs[i + r->resolved_addrs->naddrs].len = addresses->addrs[i].len;
-    }
+  r->resolved_addrs->addrs =
+      gpr_realloc(r->resolved_addrs->addrs,
+                  sizeof(grpc_resolved_address) *
+                      (r->resolved_addrs->naddrs + addresses->naddrs));
+  for (i = 0; i < addresses->naddrs; i++) {
+    memcpy(r->resolved_addrs->addrs[i + r->resolved_addrs->naddrs].addr,
+           addresses->addrs[i].addr, addresses->addrs[i].len);
+    r->resolved_addrs->addrs[i + r->resolved_addrs->naddrs].len =
+        addresses->addrs[i].len;
+  }
 
   r->resolved_addrs->naddrs += addresses->naddrs;
-  grpc_resolved_addresses_destroy (addresses);
+  grpc_resolved_addresses_destroy(addresses);
 
   /** Wait for all addresses to be resolved */
   resolve_done = (r->resolved_num == r->resolved_total);
-  gpr_mu_unlock (&r->mu);
-  if (resolve_done)
-    {
-      zookeeper_on_resolved (r, r->resolved_addrs);
-    }
+  gpr_mu_unlock(&r->mu);
+  if (resolve_done) {
+    zookeeper_on_resolved(r, r->resolved_addrs);
+  }
 }
 
 /** Parses JSON format address of a zookeeper node */
-static char *
-zookeeper_parse_address (const char *value, size_t value_len)
-{
+static char *zookeeper_parse_address(const char *value, size_t value_len) {
   grpc_json *json;
   grpc_json *cur;
   const char *host;
@@ -286,301 +264,256 @@ zookeeper_parse_address (const char *value, size_t value_len)
   char *buffer;
   char *address = NULL;
 
-  buffer = gpr_malloc (value_len);
-  memcpy (buffer, value, value_len);
-  json = grpc_json_parse_string_with_len (buffer, value_len);
-  if (json != NULL)
-    {
-      host = NULL;
-      port = NULL;
-      for (cur = json->child; cur != NULL; cur = cur->next)
-	{
-	  if (!strcmp (cur->key, "host"))
-	    {
-	      host = cur->value;
-	      if (port != NULL)
-		{
-		  break;
-		}
-	    }
-	  else if (!strcmp (cur->key, "port"))
-	    {
-	      port = cur->value;
-	      if (host != NULL)
-		{
-		  break;
-		}
-	    }
-	}
-      if (host != NULL && port != NULL)
-	{
-	  gpr_asprintf (&address, "%s:%s", host, port);
-	}
-      grpc_json_destroy (json);
+  buffer = gpr_malloc(value_len);
+  memcpy(buffer, value, value_len);
+  json = grpc_json_parse_string_with_len(buffer, value_len);
+  if (json != NULL) {
+    host = NULL;
+    port = NULL;
+    for (cur = json->child; cur != NULL; cur = cur->next) {
+      if (!strcmp(cur->key, "host")) {
+        host = cur->value;
+        if (port != NULL) {
+          break;
+        }
+      } else if (!strcmp(cur->key, "port")) {
+        port = cur->value;
+        if (host != NULL) {
+          break;
+        }
+      }
+    }
+    if (host != NULL && port != NULL) {
+      gpr_asprintf(&address, "%s:%s", host, port);
     }
-  gpr_free (buffer);
+    grpc_json_destroy(json);
+  }
+  gpr_free(buffer);
 
   return address;
 }
 
-static void
-zookeeper_get_children_node_completion (int rc, const char *value, int value_len, const struct Stat *stat, const void *arg)
-{
+static void zookeeper_get_children_node_completion(int rc, const char *value,
+                                                   int value_len,
+                                                   const struct Stat *stat,
+                                                   const void *arg) {
   char *address = NULL;
-  zookeeper_resolver *r = (zookeeper_resolver *) arg;
+  zookeeper_resolver *r = (zookeeper_resolver *)arg;
   int resolve_done = 0;
 
-  if (rc != 0)
-    {
-      gpr_log (GPR_ERROR, "Error in getting a child node of %s", r->name);
-      return;
-    }
+  if (rc != 0) {
+    gpr_log(GPR_ERROR, "Error in getting a child node of %s", r->name);
+    return;
+  }
 
-  address = zookeeper_parse_address (value, (size_t) value_len);
-  if (address != NULL)
-    {
+  address = zookeeper_parse_address(value, (size_t)value_len);
+  if (address != NULL) {
     /** Further resolves address by DNS */
-      grpc_resolve_address (address, NULL, zookeeper_dns_resolved, r);
-      gpr_free (address);
-    }
-  else
-    {
-      gpr_log (GPR_ERROR, "Error in resolving a child node of %s", r->name);
-      gpr_mu_lock (&r->mu);
-      r->resolved_total--;
-      resolve_done = (r->resolved_num == r->resolved_total);
-      gpr_mu_unlock (&r->mu);
-      if (resolve_done)
-	{
-	  zookeeper_on_resolved (r, r->resolved_addrs);
-	}
+    grpc_resolve_address(address, NULL, zookeeper_dns_resolved, r);
+    gpr_free(address);
+  } else {
+    gpr_log(GPR_ERROR, "Error in resolving a child node of %s", r->name);
+    gpr_mu_lock(&r->mu);
+    r->resolved_total--;
+    resolve_done = (r->resolved_num == r->resolved_total);
+    gpr_mu_unlock(&r->mu);
+    if (resolve_done) {
+      zookeeper_on_resolved(r, r->resolved_addrs);
     }
+  }
 }
 
-static void
-zookeeper_get_children_completion (int rc, const struct String_vector *children, const void *arg)
-{
+static void zookeeper_get_children_completion(
+    int rc, const struct String_vector *children, const void *arg) {
   char *path;
   int status;
   int i;
-  zookeeper_resolver *r = (zookeeper_resolver *) arg;
+  zookeeper_resolver *r = (zookeeper_resolver *)arg;
 
-  if (rc != 0)
-    {
-      gpr_log (GPR_ERROR, "Error in getting zookeeper children of %s", r->name);
-      return;
-    }
+  if (rc != 0) {
+    gpr_log(GPR_ERROR, "Error in getting zookeeper children of %s", r->name);
+    return;
+  }
 
-  if (children->count == 0)
-    {
-      gpr_log (GPR_ERROR, "Error in resolving zookeeper address %s", r->name);
-      return;
-    }
+  if (children->count == 0) {
+    gpr_log(GPR_ERROR, "Error in resolving zookeeper address %s", r->name);
+    return;
+  }
 
-  r->resolved_addrs = gpr_malloc (sizeof (grpc_resolved_addresses));
+  r->resolved_addrs = gpr_malloc(sizeof(grpc_resolved_addresses));
   r->resolved_addrs->addrs = NULL;
   r->resolved_addrs->naddrs = 0;
   r->resolved_total = children->count;
 
   /** TODO: Replace expensive heap allocation with stack
       if we can get maximum length of zookeeper path */
-  for (i = 0; i < children->count; i++)
-    {
-      gpr_asprintf (&path, "%s/%s", r->name, children->data[i]);
-      status = zoo_awget (r->zookeeper_handle, path, zookeeper_watcher, r, zookeeper_get_children_node_completion, r);
-      gpr_free (path);
-      if (status != 0)
-	{
-	  gpr_log (GPR_ERROR, "Error in getting zookeeper node %s", path);
-	}
+  for (i = 0; i < children->count; i++) {
+    gpr_asprintf(&path, "%s/%s", r->name, children->data[i]);
+    status = zoo_awget(r->zookeeper_handle, path, zookeeper_watcher, r,
+                       zookeeper_get_children_node_completion, r);
+    gpr_free(path);
+    if (status != 0) {
+      gpr_log(GPR_ERROR, "Error in getting zookeeper node %s", path);
     }
+  }
 }
 
-static void
-zookeeper_get_node_completion (int rc, const char *value, int value_len, const struct Stat *stat, const void *arg)
-{
+static void zookeeper_get_node_completion(int rc, const char *value,
+                                          int value_len,
+                                          const struct Stat *stat,
+                                          const void *arg) {
   int status;
   char *address = NULL;
-  zookeeper_resolver *r = (zookeeper_resolver *) arg;
+  zookeeper_resolver *r = (zookeeper_resolver *)arg;
   r->resolved_addrs = NULL;
   r->resolved_total = 0;
   r->resolved_num = 0;
 
-  if (rc != 0)
-    {
-      gpr_log (GPR_ERROR, "Error in getting zookeeper node %s", r->name);
-      return;
-    }
+  if (rc != 0) {
+    gpr_log(GPR_ERROR, "Error in getting zookeeper node %s", r->name);
+    return;
+  }
 
   /** If zookeeper node of path r->name does not have address
       (i.e. service node), get its children */
-  address = zookeeper_parse_address (value, (size_t) value_len);
-  if (address != NULL)
-    {
-      r->resolved_addrs = gpr_malloc (sizeof (grpc_resolved_addresses));
-      r->resolved_addrs->addrs = NULL;
-      r->resolved_addrs->naddrs = 0;
-      r->resolved_total = 1;
+  address = zookeeper_parse_address(value, (size_t)value_len);
+  if (address != NULL) {
+    r->resolved_addrs = gpr_malloc(sizeof(grpc_resolved_addresses));
+    r->resolved_addrs->addrs = NULL;
+    r->resolved_addrs->naddrs = 0;
+    r->resolved_total = 1;
     /** Further resolves address by DNS */
-      grpc_resolve_address (address, NULL, zookeeper_dns_resolved, r);
-      gpr_free (address);
-      return;
-    }
-
-  status = zoo_awget_children (r->zookeeper_handle, r->name, zookeeper_watcher, r, zookeeper_get_children_completion, r);
-  if (status != 0)
-    {
-      gpr_log (GPR_ERROR, "Error in getting zookeeper children of %s", r->name);
-    }
+    grpc_resolve_address(address, NULL, zookeeper_dns_resolved, r);
+    gpr_free(address);
+    return;
+  }
+
+  status = zoo_awget_children(r->zookeeper_handle, r->name, zookeeper_watcher,
+                              r, zookeeper_get_children_completion, r);
+  if (status != 0) {
+    gpr_log(GPR_ERROR, "Error in getting zookeeper children of %s", r->name);
+  }
 }
 
-static void
-zookeeper_resolve_address (zookeeper_resolver * r)
-{
+static void zookeeper_resolve_address(zookeeper_resolver *r) {
   int status;
-  status = zoo_awget (r->zookeeper_handle, r->name, zookeeper_watcher, r, zookeeper_get_node_completion, r);
-  if (status != 0)
-    {
-      gpr_log (GPR_ERROR, "Error in getting zookeeper node %s", r->name);
-    }
+  status = zoo_awget(r->zookeeper_handle, r->name, zookeeper_watcher, r,
+                     zookeeper_get_node_completion, r);
+  if (status != 0) {
+    gpr_log(GPR_ERROR, "Error in getting zookeeper node %s", r->name);
+  }
 }
 
-static void
-zookeeper_start_resolving_locked (zookeeper_resolver * r)
-{
-  GRPC_RESOLVER_REF (&r->base, "zookeeper-resolving");
-  GPR_ASSERT (r->resolving == 0);
+static void zookeeper_start_resolving_locked(zookeeper_resolver *r) {
+  GRPC_RESOLVER_REF(&r->base, "zookeeper-resolving");
+  GPR_ASSERT(r->resolving == 0);
   r->resolving = 1;
-  zookeeper_resolve_address (r);
+  zookeeper_resolve_address(r);
 }
 
-static grpc_closure *
-zookeeper_maybe_finish_next_locked (zookeeper_resolver * r)
-{
+static grpc_closure *zookeeper_maybe_finish_next_locked(zookeeper_resolver *r) {
   grpc_closure *call = NULL;
-  if (r->next_completion != NULL && r->resolved_version != r->published_version)
-    {
-      *r->target_config = r->resolved_config;
-      if (r->resolved_config != NULL)
-	{
-	  grpc_client_config_ref (r->resolved_config);
-	}
-      call = r->next_completion;
-      r->next_completion = NULL;
-      r->published_version = r->resolved_version;
+  if (r->next_completion != NULL &&
+      r->resolved_version != r->published_version) {
+    *r->target_config = r->resolved_config;
+    if (r->resolved_config != NULL) {
+      grpc_client_config_ref(r->resolved_config);
     }
+    call = r->next_completion;
+    r->next_completion = NULL;
+    r->published_version = r->resolved_version;
+  }
   return call;
 }
 
-static void
-zookeeper_destroy (grpc_resolver * gr)
-{
-  zookeeper_resolver *r = (zookeeper_resolver *) gr;
-  gpr_mu_destroy (&r->mu);
-  if (r->resolved_config != NULL)
-    {
-      grpc_client_config_unref (r->resolved_config);
-    }
-  grpc_subchannel_factory_unref (r->subchannel_factory);
-  gpr_free (r->name);
-  gpr_free (r->lb_policy_name);
-  gpr_free (r);
+static void zookeeper_destroy(grpc_resolver *gr) {
+  zookeeper_resolver *r = (zookeeper_resolver *)gr;
+  gpr_mu_destroy(&r->mu);
+  if (r->resolved_config != NULL) {
+    grpc_client_config_unref(r->resolved_config);
+  }
+  grpc_subchannel_factory_unref(r->subchannel_factory);
+  gpr_free(r->name);
+  gpr_free(r->lb_policy_name);
+  gpr_free(r);
 }
 
-static grpc_resolver *
-zookeeper_create (grpc_resolver_args * args, const char *lb_policy_name)
-{
+static grpc_resolver *zookeeper_create(grpc_resolver_args *args,
+                                       const char *lb_policy_name) {
   zookeeper_resolver *r;
   size_t length;
   char *path = args->uri->path;
 
-  if (0 == strcmp (args->uri->authority, ""))
-    {
-      gpr_log (GPR_ERROR, "No authority specified in zookeeper uri");
-      return NULL;
-    }
+  if (0 == strcmp(args->uri->authority, "")) {
+    gpr_log(GPR_ERROR, "No authority specified in zookeeper uri");
+    return NULL;
+  }
 
   /** Removes the trailing slash if exists */
-  length = strlen (path);
-  if (length > 1 && path[length - 1] == '/')
-    {
-      path[length - 1] = 0;
-    }
-
-  r = gpr_malloc (sizeof (zookeeper_resolver));
-  memset (r, 0, sizeof (*r));
-  gpr_ref_init (&r->refs, 1);
-  gpr_mu_init (&r->mu);
-  grpc_resolver_init (&r->base, &zookeeper_resolver_vtable);
-  r->name = gpr_strdup (path);
+  length = strlen(path);
+  if (length > 1 && path[length - 1] == '/') {
+    path[length - 1] = 0;
+  }
+
+  r = gpr_malloc(sizeof(zookeeper_resolver));
+  memset(r, 0, sizeof(*r));
+  gpr_ref_init(&r->refs, 1);
+  gpr_mu_init(&r->mu);
+  grpc_resolver_init(&r->base, &zookeeper_resolver_vtable);
+  r->name = gpr_strdup(path);
 
   r->subchannel_factory = args->subchannel_factory;
-  grpc_subchannel_factory_ref (r->subchannel_factory);
+  grpc_subchannel_factory_ref(r->subchannel_factory);
 
-  r->lb_policy_name = gpr_strdup (lb_policy_name);
+  r->lb_policy_name = gpr_strdup(lb_policy_name);
 
   /** Initializes zookeeper client */
-  zoo_set_debug_level (ZOO_LOG_LEVEL_WARN);
-  r->zookeeper_handle = zookeeper_init (args->uri->authority, zookeeper_global_watcher, GRPC_ZOOKEEPER_SESSION_TIMEOUT, 0, 0, 0);
-  if (r->zookeeper_handle == NULL)
-    {
-      gpr_log (GPR_ERROR, "Unable to connect to zookeeper server");
-      return NULL;
-    }
+  zoo_set_debug_level(ZOO_LOG_LEVEL_WARN);
+  r->zookeeper_handle =
+      zookeeper_init(args->uri->authority, zookeeper_global_watcher,
+                     GRPC_ZOOKEEPER_SESSION_TIMEOUT, 0, 0, 0);
+  if (r->zookeeper_handle == NULL) {
+    gpr_log(GPR_ERROR, "Unable to connect to zookeeper server");
+    return NULL;
+  }
 
   return &r->base;
 }
 
-static void
-zookeeper_plugin_init ()
-{
-  grpc_register_resolver_type (grpc_zookeeper_resolver_factory_create ());
+static void zookeeper_plugin_init() {
+  grpc_register_resolver_type(grpc_zookeeper_resolver_factory_create());
 }
 
-void
-grpc_zookeeper_register ()
-{
-  grpc_register_plugin (zookeeper_plugin_init, NULL);
+void grpc_zookeeper_register() {
+  grpc_register_plugin(zookeeper_plugin_init, NULL);
 }
 
 /*
  * FACTORY
  */
 
-static void
-zookeeper_factory_ref (grpc_resolver_factory * factory)
-{
-}
+static void zookeeper_factory_ref(grpc_resolver_factory *factory) {}
 
-static void
-zookeeper_factory_unref (grpc_resolver_factory * factory)
-{
-}
+static void zookeeper_factory_unref(grpc_resolver_factory *factory) {}
 
-static char *
-zookeeper_factory_get_default_hostname (grpc_resolver_factory * factory, grpc_uri * uri)
-{
+static char *zookeeper_factory_get_default_hostname(
+    grpc_resolver_factory *factory, grpc_uri *uri) {
   return NULL;
 }
 
-static grpc_resolver *
-zookeeper_factory_create_resolver (grpc_resolver_factory * factory, grpc_resolver_args * args)
-{
-  return zookeeper_create (args, "pick_first");
+static grpc_resolver *zookeeper_factory_create_resolver(
+    grpc_resolver_factory *factory, grpc_resolver_args *args) {
+  return zookeeper_create(args, "pick_first");
 }
 
 static const grpc_resolver_factory_vtable zookeeper_factory_vtable = {
-  zookeeper_factory_ref, zookeeper_factory_unref,
-  zookeeper_factory_create_resolver, zookeeper_factory_get_default_hostname,
-  "zookeeper"
-};
+    zookeeper_factory_ref, zookeeper_factory_unref,
+    zookeeper_factory_create_resolver, zookeeper_factory_get_default_hostname,
+    "zookeeper"};
 
 static grpc_resolver_factory zookeeper_resolver_factory = {
-  &zookeeper_factory_vtable
-};
+    &zookeeper_factory_vtable};
 
-grpc_resolver_factory *
-grpc_zookeeper_resolver_factory_create ()
-{
+grpc_resolver_factory *grpc_zookeeper_resolver_factory_create() {
   return &zookeeper_resolver_factory;
 }

src/core/client_config/resolvers/zookeeper_resolver.h

@@ -37,6 +37,6 @@
 #include "src/core/client_config/resolver_factory.h"
 
 /** Create a zookeeper resolver factory */
-grpc_resolver_factory *grpc_zookeeper_resolver_factory_create (void);
+grpc_resolver_factory *grpc_zookeeper_resolver_factory_create(void);
 
 #endif /* GRPC_INTERNAL_CORE_CLIENT_CONFIG_RESOLVERS_ZOOKEEPER_RESOLVER_H */

src/core/client_config/subchannel.c

@@ -50,8 +50,7 @@
 #define GRPC_SUBCHANNEL_RECONNECT_MAX_BACKOFF_SECONDS 120
 #define GRPC_SUBCHANNEL_RECONNECT_JITTER 0.2
 
-typedef struct
-{
+typedef struct {
   /* all fields protected by subchannel->mu */
   /** refcount */
   int refs;
@@ -59,16 +58,14 @@ typedef struct
   grpc_subchannel *subchannel;
 } connection;
 
-typedef struct
-{
+typedef struct {
   grpc_closure closure;
   size_t version;
   grpc_subchannel *subchannel;
   grpc_connectivity_state connectivity_state;
 } state_watcher;
 
-typedef struct waiting_for_connect
-{
+typedef struct waiting_for_connect {
   struct waiting_for_connect *next;
   grpc_closure *notify;
   grpc_pollset *pollset;
@@ -77,8 +74,7 @@ typedef struct waiting_for_connect
   grpc_closure continuation;
 } waiting_for_connect;
 
-struct grpc_subchannel
-{
+struct grpc_subchannel {
   grpc_connector *connector;
 
   /** non-transport related channel filters */
@@ -139,8 +135,7 @@ struct grpc_subchannel
   gpr_uint32 random;
 };
 
-struct grpc_subchannel_call
-{
+struct grpc_subchannel_call {
   connection *connection;
   gpr_refcount refs;
 };
@@ -148,19 +143,25 @@ struct grpc_subchannel_call
 #define SUBCHANNEL_CALL_TO_CALL_STACK(call) ((grpc_call_stack *)((call) + 1))
 #define CHANNEL_STACK_FROM_CONNECTION(con) ((grpc_channel_stack *)((con) + 1))
 
-static grpc_subchannel_call *create_call (grpc_exec_ctx * exec_ctx, connection * con);
-static void connectivity_state_changed_locked (grpc_exec_ctx * exec_ctx, grpc_subchannel * c, const char *reason);
-static grpc_connectivity_state compute_connectivity_locked (grpc_subchannel * c);
-static gpr_timespec compute_connect_deadline (grpc_subchannel * c);
-static void subchannel_connected (grpc_exec_ctx * exec_ctx, void *subchannel, int iomgr_success);
-
-static void subchannel_ref_locked (grpc_subchannel * c GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-static int
-subchannel_unref_locked (grpc_subchannel * c GRPC_SUBCHANNEL_REF_EXTRA_ARGS)
-  GRPC_MUST_USE_RESULT;
-     static void connection_ref_locked (connection * c GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-     static grpc_subchannel *connection_unref_locked (grpc_exec_ctx *exec_ctx, connection * c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) GRPC_MUST_USE_RESULT;
-     static void subchannel_destroy (grpc_exec_ctx * exec_ctx, grpc_subchannel * c);
+static grpc_subchannel_call *create_call(grpc_exec_ctx *exec_ctx,
+                                         connection *con);
+static void connectivity_state_changed_locked(grpc_exec_ctx *exec_ctx,
+                                              grpc_subchannel *c,
+                                              const char *reason);
+static grpc_connectivity_state compute_connectivity_locked(grpc_subchannel *c);
+static gpr_timespec compute_connect_deadline(grpc_subchannel *c);
+static void subchannel_connected(grpc_exec_ctx *exec_ctx, void *subchannel,
+                                 int iomgr_success);
+
+static void subchannel_ref_locked(
+    grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
+static int subchannel_unref_locked(
+    grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) GRPC_MUST_USE_RESULT;
+static void connection_ref_locked(connection *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
+static grpc_subchannel *connection_unref_locked(
+    grpc_exec_ctx *exec_ctx,
+    connection *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) GRPC_MUST_USE_RESULT;
+static void subchannel_destroy(grpc_exec_ctx *exec_ctx, grpc_subchannel *c);
 
 #ifdef GRPC_SUBCHANNEL_REFCOUNT_DEBUG
 #define SUBCHANNEL_REF_LOCKED(p, r) \
@@ -196,34 +197,29 @@ subchannel_unref_locked (grpc_subchannel * c GRPC_SUBCHANNEL_REF_EXTRA_ARGS)
  * connection implementation
  */
 
-     static void connection_destroy (grpc_exec_ctx * exec_ctx, connection * c)
-{
-  GPR_ASSERT (c->refs == 0);
-  grpc_channel_stack_destroy (exec_ctx, CHANNEL_STACK_FROM_CONNECTION (c));
-  gpr_free (c);
+static void connection_destroy(grpc_exec_ctx *exec_ctx, connection *c) {
+  GPR_ASSERT(c->refs == 0);
+  grpc_channel_stack_destroy(exec_ctx, CHANNEL_STACK_FROM_CONNECTION(c));
+  gpr_free(c);
 }
 
-static void
-connection_ref_locked (connection * c GRPC_SUBCHANNEL_REF_EXTRA_ARGS)
-{
-  REF_LOG ("CONNECTION", c);
-  subchannel_ref_locked (c->subchannel REF_PASS_ARGS);
+static void connection_ref_locked(
+    connection *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
+  REF_LOG("CONNECTION", c);
+  subchannel_ref_locked(c->subchannel REF_PASS_ARGS);
   ++c->refs;
 }
 
-static grpc_subchannel *
-connection_unref_locked (grpc_exec_ctx *exec_ctx, connection * c GRPC_SUBCHANNEL_REF_EXTRA_ARGS)
-{
+static grpc_subchannel *connection_unref_locked(
+    grpc_exec_ctx *exec_ctx, connection *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
   grpc_subchannel *destroy = NULL;
-  UNREF_LOG ("CONNECTION", c);
-  if (subchannel_unref_locked (c->subchannel REF_PASS_ARGS))
-    {
-      destroy = c->subchannel;
-    }
-  if (--c->refs == 0 && c->subchannel->active != c)
-    {
-      connection_destroy (exec_ctx, c);
-    }
+  UNREF_LOG("CONNECTION", c);
+  if (subchannel_unref_locked(c->subchannel REF_PASS_ARGS)) {
+    destroy = c->subchannel;
+  }
+  if (--c->refs == 0 && c->subchannel->active != c) {
+    connection_destroy(exec_ctx, c);
+  }
   return destroy;
 }
 
@@ -231,261 +227,237 @@ connection_unref_locked (grpc_exec_ctx *exec_ctx, connection * c GRPC_SUBCHANNEL
  * grpc_subchannel implementation
  */
 
-static void
-subchannel_ref_locked (grpc_subchannel * c GRPC_SUBCHANNEL_REF_EXTRA_ARGS)
-{
-  REF_LOG ("SUBCHANNEL", c);
+static void subchannel_ref_locked(
+    grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
+  REF_LOG("SUBCHANNEL", c);
   ++c->refs;
 }
 
-static int
-subchannel_unref_locked (grpc_subchannel * c GRPC_SUBCHANNEL_REF_EXTRA_ARGS)
-{
-  UNREF_LOG ("SUBCHANNEL", c);
+static int subchannel_unref_locked(
+    grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
+  UNREF_LOG("SUBCHANNEL", c);
   return --c->refs == 0;
 }
 
-void
-grpc_subchannel_ref (grpc_subchannel * c GRPC_SUBCHANNEL_REF_EXTRA_ARGS)
-{
-  gpr_mu_lock (&c->mu);
-  subchannel_ref_locked (c REF_PASS_ARGS);
-  gpr_mu_unlock (&c->mu);
+void grpc_subchannel_ref(grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
+  gpr_mu_lock(&c->mu);
+  subchannel_ref_locked(c REF_PASS_ARGS);
+  gpr_mu_unlock(&c->mu);
 }
 
-void
-grpc_subchannel_unref (grpc_exec_ctx *exec_ctx, grpc_subchannel * c GRPC_SUBCHANNEL_REF_EXTRA_ARGS)
-{
+void grpc_subchannel_unref(grpc_exec_ctx *exec_ctx,
+                           grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
   int destroy;
-  gpr_mu_lock (&c->mu);
-  destroy = subchannel_unref_locked (c REF_PASS_ARGS);
-  gpr_mu_unlock (&c->mu);
-  if (destroy)
-    subchannel_destroy (exec_ctx, c);
-}
-
-static void
-subchannel_destroy (grpc_exec_ctx * exec_ctx, grpc_subchannel * c)
-{
-  if (c->active != NULL)
-    {
-      connection_destroy (exec_ctx, c->active);
-    }
-  gpr_free (c->filters);
-  grpc_channel_args_destroy (c->args);
-  gpr_free (c->addr);
-  grpc_mdctx_unref (c->mdctx);
-  grpc_connectivity_state_destroy (exec_ctx, &c->state_tracker);
-  grpc_connector_unref (exec_ctx, c->connector);
-  gpr_free (c);
+  gpr_mu_lock(&c->mu);
+  destroy = subchannel_unref_locked(c REF_PASS_ARGS);
+  gpr_mu_unlock(&c->mu);
+  if (destroy) subchannel_destroy(exec_ctx, c);
+}
+
+static void subchannel_destroy(grpc_exec_ctx *exec_ctx, grpc_subchannel *c) {
+  if (c->active != NULL) {
+    connection_destroy(exec_ctx, c->active);
+  }
+  gpr_free(c->filters);
+  grpc_channel_args_destroy(c->args);
+  gpr_free(c->addr);
+  grpc_mdctx_unref(c->mdctx);
+  grpc_connectivity_state_destroy(exec_ctx, &c->state_tracker);
+  grpc_connector_unref(exec_ctx, c->connector);
+  gpr_free(c);
 }
 
-void
-grpc_subchannel_add_interested_party (grpc_exec_ctx * exec_ctx, grpc_subchannel * c, grpc_pollset * pollset)
-{
-  grpc_pollset_set_add_pollset (exec_ctx, c->pollset_set, pollset);
+void grpc_subchannel_add_interested_party(grpc_exec_ctx *exec_ctx,
+                                          grpc_subchannel *c,
+                                          grpc_pollset *pollset) {
+  grpc_pollset_set_add_pollset(exec_ctx, c->pollset_set, pollset);
 }
 
-void
-grpc_subchannel_del_interested_party (grpc_exec_ctx * exec_ctx, grpc_subchannel * c, grpc_pollset * pollset)
-{
-  grpc_pollset_set_del_pollset (exec_ctx, c->pollset_set, pollset);
+void grpc_subchannel_del_interested_party(grpc_exec_ctx *exec_ctx,
+                                          grpc_subchannel *c,
+                                          grpc_pollset *pollset) {
+  grpc_pollset_set_del_pollset(exec_ctx, c->pollset_set, pollset);
 }
 
-static gpr_uint32
-random_seed ()
-{
-  return (gpr_uint32) (gpr_time_to_millis (gpr_now (GPR_CLOCK_MONOTONIC)));
+static gpr_uint32 random_seed() {
+  return (gpr_uint32)(gpr_time_to_millis(gpr_now(GPR_CLOCK_MONOTONIC)));
 }
 
-grpc_subchannel *
-grpc_subchannel_create (grpc_connector * connector, grpc_subchannel_args * args)
-{
-  grpc_subchannel *c = gpr_malloc (sizeof (*c));
-  grpc_channel_element *parent_elem = grpc_channel_stack_last_element (grpc_channel_get_channel_stack (args->master));
-  memset (c, 0, sizeof (*c));
+grpc_subchannel *grpc_subchannel_create(grpc_connector *connector,
+                                        grpc_subchannel_args *args) {
+  grpc_subchannel *c = gpr_malloc(sizeof(*c));
+  grpc_channel_element *parent_elem = grpc_channel_stack_last_element(
+      grpc_channel_get_channel_stack(args->master));
+  memset(c, 0, sizeof(*c));
   c->refs = 1;
   c->connector = connector;
-  grpc_connector_ref (c->connector);
+  grpc_connector_ref(c->connector);
   c->num_filters = args->filter_count;
-  c->filters = gpr_malloc (sizeof (grpc_channel_filter *) * c->num_filters);
-  memcpy (c->filters, args->filters, sizeof (grpc_channel_filter *) * c->num_filters);
-  c->addr = gpr_malloc (args->addr_len);
-  memcpy (c->addr, args->addr, args->addr_len);
+  c->filters = gpr_malloc(sizeof(grpc_channel_filter *) * c->num_filters);
+  memcpy(c->filters, args->filters,
+         sizeof(grpc_channel_filter *) * c->num_filters);
+  c->addr = gpr_malloc(args->addr_len);
+  memcpy(c->addr, args->addr, args->addr_len);
   c->addr_len = args->addr_len;
-  c->args = grpc_channel_args_copy (args->args);
+  c->args = grpc_channel_args_copy(args->args);
   c->mdctx = args->mdctx;
   c->master = args->master;
-  c->pollset_set = grpc_client_channel_get_connecting_pollset_set (parent_elem);
-  c->random = random_seed ();
-  grpc_mdctx_ref (c->mdctx);
-  grpc_closure_init (&c->connected, subchannel_connected, c);
-  grpc_connectivity_state_init (&c->state_tracker, GRPC_CHANNEL_IDLE, "subchannel");
-  gpr_mu_init (&c->mu);
+  c->pollset_set = grpc_client_channel_get_connecting_pollset_set(parent_elem);
+  c->random = random_seed();
+  grpc_mdctx_ref(c->mdctx);
+  grpc_closure_init(&c->connected, subchannel_connected, c);
+  grpc_connectivity_state_init(&c->state_tracker, GRPC_CHANNEL_IDLE,
+                               "subchannel");
+  gpr_mu_init(&c->mu);
   return c;
 }
 
-static void
-continue_connect (grpc_exec_ctx * exec_ctx, grpc_subchannel * c)
-{
+static void continue_connect(grpc_exec_ctx *exec_ctx, grpc_subchannel *c) {
   grpc_connect_in_args args;
 
   args.interested_parties = c->pollset_set;
   args.addr = c->addr;
   args.addr_len = c->addr_len;
-  args.deadline = compute_connect_deadline (c);
+  args.deadline = compute_connect_deadline(c);
   args.channel_args = c->args;
 
-  grpc_connector_connect (exec_ctx, c->connector, &args, &c->connecting_result, &c->connected);
+  grpc_connector_connect(exec_ctx, c->connector, &args, &c->connecting_result,
+                         &c->connected);
 }
 
-static void
-start_connect (grpc_exec_ctx * exec_ctx, grpc_subchannel * c)
-{
-  c->backoff_delta = gpr_time_from_seconds (GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS, GPR_TIMESPAN);
-  c->next_attempt = gpr_time_add (gpr_now (GPR_CLOCK_MONOTONIC), c->backoff_delta);
-  continue_connect (exec_ctx, c);
+static void start_connect(grpc_exec_ctx *exec_ctx, grpc_subchannel *c) {
+  c->backoff_delta = gpr_time_from_seconds(
+      GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS, GPR_TIMESPAN);
+  c->next_attempt =
+      gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC), c->backoff_delta);
+  continue_connect(exec_ctx, c);
 }
 
-static void
-continue_creating_call (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_success)
-{
+static void continue_creating_call(grpc_exec_ctx *exec_ctx, void *arg,
+                                   int iomgr_success) {
   waiting_for_connect *w4c = arg;
-  grpc_subchannel_del_interested_party (exec_ctx, w4c->subchannel, w4c->pollset);
-  grpc_subchannel_create_call (exec_ctx, w4c->subchannel, w4c->pollset, w4c->target, w4c->notify);
-  GRPC_SUBCHANNEL_UNREF (exec_ctx, w4c->subchannel, "waiting_for_connect");
-  gpr_free (w4c);
+  grpc_subchannel_del_interested_party(exec_ctx, w4c->subchannel, w4c->pollset);
+  grpc_subchannel_create_call(exec_ctx, w4c->subchannel, w4c->pollset,
+                              w4c->target, w4c->notify);
+  GRPC_SUBCHANNEL_UNREF(exec_ctx, w4c->subchannel, "waiting_for_connect");
+  gpr_free(w4c);
 }
 
-void
-grpc_subchannel_create_call (grpc_exec_ctx * exec_ctx, grpc_subchannel * c, grpc_pollset * pollset, grpc_subchannel_call ** target, grpc_closure * notify)
-{
+void grpc_subchannel_create_call(grpc_exec_ctx *exec_ctx, grpc_subchannel *c,
+                                 grpc_pollset *pollset,
+                                 grpc_subchannel_call **target,
+                                 grpc_closure *notify) {
   connection *con;
-  gpr_mu_lock (&c->mu);
-  if (c->active != NULL)
-    {
-      con = c->active;
-      CONNECTION_REF_LOCKED (con, "call");
-      gpr_mu_unlock (&c->mu);
-
-      *target = create_call (exec_ctx, con);
-      notify->cb (exec_ctx, notify->cb_arg, 1);
-    }
-  else
-    {
-      waiting_for_connect *w4c = gpr_malloc (sizeof (*w4c));
-      w4c->next = c->waiting;
-      w4c->notify = notify;
-      w4c->pollset = pollset;
-      w4c->target = target;
-      w4c->subchannel = c;
-      /* released when clearing w4c */
-      SUBCHANNEL_REF_LOCKED (c, "waiting_for_connect");
-      grpc_closure_init (&w4c->continuation, continue_creating_call, w4c);
-      c->waiting = w4c;
-      grpc_subchannel_add_interested_party (exec_ctx, c, pollset);
-      if (!c->connecting)
-	{
-	  c->connecting = 1;
-	  connectivity_state_changed_locked (exec_ctx, c, "create_call");
-	  /* released by connection */
-	  SUBCHANNEL_REF_LOCKED (c, "connecting");
-	  GRPC_CHANNEL_INTERNAL_REF (c->master, "connecting");
-	  gpr_mu_unlock (&c->mu);
-
-	  start_connect (exec_ctx, c);
-	}
-      else
-	{
-	  gpr_mu_unlock (&c->mu);
-	}
+  gpr_mu_lock(&c->mu);
+  if (c->active != NULL) {
+    con = c->active;
+    CONNECTION_REF_LOCKED(con, "call");
+    gpr_mu_unlock(&c->mu);
+
+    *target = create_call(exec_ctx, con);
+    notify->cb(exec_ctx, notify->cb_arg, 1);
+  } else {
+    waiting_for_connect *w4c = gpr_malloc(sizeof(*w4c));
+    w4c->next = c->waiting;
+    w4c->notify = notify;
+    w4c->pollset = pollset;
+    w4c->target = target;
+    w4c->subchannel = c;
+    /* released when clearing w4c */
+    SUBCHANNEL_REF_LOCKED(c, "waiting_for_connect");
+    grpc_closure_init(&w4c->continuation, continue_creating_call, w4c);
+    c->waiting = w4c;
+    grpc_subchannel_add_interested_party(exec_ctx, c, pollset);
+    if (!c->connecting) {
+      c->connecting = 1;
+      connectivity_state_changed_locked(exec_ctx, c, "create_call");
+      /* released by connection */
+      SUBCHANNEL_REF_LOCKED(c, "connecting");
+      GRPC_CHANNEL_INTERNAL_REF(c->master, "connecting");
+      gpr_mu_unlock(&c->mu);
+
+      start_connect(exec_ctx, c);
+    } else {
+      gpr_mu_unlock(&c->mu);
     }
+  }
 }
 
-grpc_connectivity_state
-grpc_subchannel_check_connectivity (grpc_subchannel * c)
-{
+grpc_connectivity_state grpc_subchannel_check_connectivity(grpc_subchannel *c) {
   grpc_connectivity_state state;
-  gpr_mu_lock (&c->mu);
-  state = grpc_connectivity_state_check (&c->state_tracker);
-  gpr_mu_unlock (&c->mu);
+  gpr_mu_lock(&c->mu);
+  state = grpc_connectivity_state_check(&c->state_tracker);
+  gpr_mu_unlock(&c->mu);
   return state;
 }
 
-void
-grpc_subchannel_notify_on_state_change (grpc_exec_ctx * exec_ctx, grpc_subchannel * c, grpc_connectivity_state * state, grpc_closure * notify)
-{
+void grpc_subchannel_notify_on_state_change(grpc_exec_ctx *exec_ctx,
+                                            grpc_subchannel *c,
+                                            grpc_connectivity_state *state,
+                                            grpc_closure *notify) {
   int do_connect = 0;
-  gpr_mu_lock (&c->mu);
-  if (grpc_connectivity_state_notify_on_state_change (exec_ctx, &c->state_tracker, state, notify))
-    {
-      do_connect = 1;
-      c->connecting = 1;
-      /* released by connection */
-      SUBCHANNEL_REF_LOCKED (c, "connecting");
-      GRPC_CHANNEL_INTERNAL_REF (c->master, "connecting");
-      connectivity_state_changed_locked (exec_ctx, c, "state_change");
-    }
-  gpr_mu_unlock (&c->mu);
-
-  if (do_connect)
-    {
-      start_connect (exec_ctx, c);
-    }
-}
-
-void
-grpc_subchannel_process_transport_op (grpc_exec_ctx * exec_ctx, grpc_subchannel * c, grpc_transport_op * op)
-{
+  gpr_mu_lock(&c->mu);
+  if (grpc_connectivity_state_notify_on_state_change(
+          exec_ctx, &c->state_tracker, state, notify)) {
+    do_connect = 1;
+    c->connecting = 1;
+    /* released by connection */
+    SUBCHANNEL_REF_LOCKED(c, "connecting");
+    GRPC_CHANNEL_INTERNAL_REF(c->master, "connecting");
+    connectivity_state_changed_locked(exec_ctx, c, "state_change");
+  }
+  gpr_mu_unlock(&c->mu);
+
+  if (do_connect) {
+    start_connect(exec_ctx, c);
+  }
+}
+
+void grpc_subchannel_process_transport_op(grpc_exec_ctx *exec_ctx,
+                                          grpc_subchannel *c,
+                                          grpc_transport_op *op) {
   connection *con = NULL;
   grpc_subchannel *destroy;
   int cancel_alarm = 0;
-  gpr_mu_lock (&c->mu);
-  if (c->active != NULL)
-    {
-      con = c->active;
-      CONNECTION_REF_LOCKED (con, "transport-op");
-    }
-  if (op->disconnect)
-    {
-      c->disconnected = 1;
-      connectivity_state_changed_locked (exec_ctx, c, "disconnect");
-      if (c->have_alarm)
-	{
-	  cancel_alarm = 1;
-	}
+  gpr_mu_lock(&c->mu);
+  if (c->active != NULL) {
+    con = c->active;
+    CONNECTION_REF_LOCKED(con, "transport-op");
+  }
+  if (op->disconnect) {
+    c->disconnected = 1;
+    connectivity_state_changed_locked(exec_ctx, c, "disconnect");
+    if (c->have_alarm) {
+      cancel_alarm = 1;
     }
-  gpr_mu_unlock (&c->mu);
-
-  if (con != NULL)
-    {
-      grpc_channel_stack *channel_stack = CHANNEL_STACK_FROM_CONNECTION (con);
-      grpc_channel_element *top_elem = grpc_channel_stack_element (channel_stack, 0);
-      top_elem->filter->start_transport_op (exec_ctx, top_elem, op);
-
-      gpr_mu_lock (&c->mu);
-      destroy = CONNECTION_UNREF_LOCKED (exec_ctx, con, "transport-op");
-      gpr_mu_unlock (&c->mu);
-      if (destroy)
-	{
-	  subchannel_destroy (exec_ctx, destroy);
-	}
+  }
+  gpr_mu_unlock(&c->mu);
+
+  if (con != NULL) {
+    grpc_channel_stack *channel_stack = CHANNEL_STACK_FROM_CONNECTION(con);
+    grpc_channel_element *top_elem =
+        grpc_channel_stack_element(channel_stack, 0);
+    top_elem->filter->start_transport_op(exec_ctx, top_elem, op);
+
+    gpr_mu_lock(&c->mu);
+    destroy = CONNECTION_UNREF_LOCKED(exec_ctx, con, "transport-op");
+    gpr_mu_unlock(&c->mu);
+    if (destroy) {
+      subchannel_destroy(exec_ctx, destroy);
     }
+  }
 
-  if (cancel_alarm)
-    {
-      grpc_alarm_cancel (exec_ctx, &c->alarm);
-    }
+  if (cancel_alarm) {
+    grpc_alarm_cancel(exec_ctx, &c->alarm);
+  }
 
-  if (op->disconnect)
-    {
-      grpc_connector_shutdown (exec_ctx, c->connector);
-    }
+  if (op->disconnect) {
+    grpc_connector_shutdown(exec_ctx, c->connector);
+  }
 }
 
-static void
-on_state_changed (grpc_exec_ctx * exec_ctx, void *p, int iomgr_success)
-{
+static void on_state_changed(grpc_exec_ctx *exec_ctx, void *p,
+                             int iomgr_success) {
   state_watcher *sw = p;
   grpc_subchannel *c = sw->subchannel;
   gpr_mu *mu = &c->mu;
@@ -494,59 +466,57 @@ on_state_changed (grpc_exec_ctx * exec_ctx, void *p, int iomgr_success)
   grpc_channel_element *elem;
   connection *destroy_connection = NULL;
 
-  gpr_mu_lock (mu);
+  gpr_mu_lock(mu);
 
   /* if we failed or there is a version number mismatch, just leave
      this closure */
-  if (!iomgr_success || sw->subchannel->active_version != sw->version)
-    {
-      goto done;
-    }
+  if (!iomgr_success || sw->subchannel->active_version != sw->version) {
+    goto done;
+  }
 
-  switch (sw->connectivity_state)
-    {
+  switch (sw->connectivity_state) {
     case GRPC_CHANNEL_CONNECTING:
     case GRPC_CHANNEL_READY:
     case GRPC_CHANNEL_IDLE:
       /* all is still good: keep watching */
-      memset (&op, 0, sizeof (op));
+      memset(&op, 0, sizeof(op));
       op.connectivity_state = &sw->connectivity_state;
       op.on_connectivity_state_change = &sw->closure;
-      elem = grpc_channel_stack_element (CHANNEL_STACK_FROM_CONNECTION (c->active), 0);
-      elem->filter->start_transport_op (exec_ctx, elem, &op);
+      elem = grpc_channel_stack_element(
+          CHANNEL_STACK_FROM_CONNECTION(c->active), 0);
+      elem->filter->start_transport_op(exec_ctx, elem, &op);
       /* early out */
-      gpr_mu_unlock (mu);
+      gpr_mu_unlock(mu);
       return;
     case GRPC_CHANNEL_FATAL_FAILURE:
     case GRPC_CHANNEL_TRANSIENT_FAILURE:
       /* things have gone wrong, deactivate and enter idle */
-      if (sw->subchannel->active->refs == 0)
-	{
-	  destroy_connection = sw->subchannel->active;
-	}
+      if (sw->subchannel->active->refs == 0) {
+        destroy_connection = sw->subchannel->active;
+      }
       sw->subchannel->active = NULL;
-      grpc_connectivity_state_set (exec_ctx, &c->state_tracker, c->disconnected ? GRPC_CHANNEL_FATAL_FAILURE : GRPC_CHANNEL_TRANSIENT_FAILURE, "connection_failed");
+      grpc_connectivity_state_set(exec_ctx, &c->state_tracker,
+                                  c->disconnected
+                                      ? GRPC_CHANNEL_FATAL_FAILURE
+                                      : GRPC_CHANNEL_TRANSIENT_FAILURE,
+                                  "connection_failed");
       break;
-    }
+  }
 
 done:
-  connectivity_state_changed_locked (exec_ctx, c, "transport_state_changed");
-  destroy = SUBCHANNEL_UNREF_LOCKED (c, "state_watcher");
-  gpr_free (sw);
-  gpr_mu_unlock (mu);
-  if (destroy)
-    {
-      subchannel_destroy (exec_ctx, c);
-    }
-  if (destroy_connection != NULL)
-    {
-      connection_destroy (exec_ctx, destroy_connection);
-    }
-}
-
-static void
-publish_transport (grpc_exec_ctx * exec_ctx, grpc_subchannel * c)
-{
+  connectivity_state_changed_locked(exec_ctx, c, "transport_state_changed");
+  destroy = SUBCHANNEL_UNREF_LOCKED(c, "state_watcher");
+  gpr_free(sw);
+  gpr_mu_unlock(mu);
+  if (destroy) {
+    subchannel_destroy(exec_ctx, c);
+  }
+  if (destroy_connection != NULL) {
+    connection_destroy(exec_ctx, destroy_connection);
+  }
+}
+
+static void publish_transport(grpc_exec_ctx *exec_ctx, grpc_subchannel *c) {
   size_t channel_stack_size;
   connection *con;
   grpc_channel_stack *stk;
@@ -560,46 +530,46 @@ publish_transport (grpc_exec_ctx * exec_ctx, grpc_subchannel * c)
 
   /* build final filter list */
   num_filters = c->num_filters + c->connecting_result.num_filters + 1;
-  filters = gpr_malloc (sizeof (*filters) * num_filters);
-  memcpy (filters, c->filters, sizeof (*filters) * c->num_filters);
-  memcpy (filters + c->num_filters, c->connecting_result.filters, sizeof (*filters) * c->connecting_result.num_filters);
+  filters = gpr_malloc(sizeof(*filters) * num_filters);
+  memcpy(filters, c->filters, sizeof(*filters) * c->num_filters);
+  memcpy(filters + c->num_filters, c->connecting_result.filters,
+         sizeof(*filters) * c->connecting_result.num_filters);
   filters[num_filters - 1] = &grpc_connected_channel_filter;
 
   /* construct channel stack */
-  channel_stack_size = grpc_channel_stack_size (filters, num_filters);
-  con = gpr_malloc (sizeof (connection) + channel_stack_size);
-  stk = (grpc_channel_stack *) (con + 1);
+  channel_stack_size = grpc_channel_stack_size(filters, num_filters);
+  con = gpr_malloc(sizeof(connection) + channel_stack_size);
+  stk = (grpc_channel_stack *)(con + 1);
   con->refs = 0;
   con->subchannel = c;
-  grpc_channel_stack_init (exec_ctx, filters, num_filters, c->master, c->args, c->mdctx, stk);
-  grpc_connected_channel_bind_transport (stk, c->connecting_result.transport);
-  gpr_free (c->connecting_result.filters);
-  memset (&c->connecting_result, 0, sizeof (c->connecting_result));
+  grpc_channel_stack_init(exec_ctx, filters, num_filters, c->master, c->args,
+                          c->mdctx, stk);
+  grpc_connected_channel_bind_transport(stk, c->connecting_result.transport);
+  gpr_free(c->connecting_result.filters);
+  memset(&c->connecting_result, 0, sizeof(c->connecting_result));
 
   /* initialize state watcher */
-  sw = gpr_malloc (sizeof (*sw));
-  grpc_closure_init (&sw->closure, on_state_changed, sw);
+  sw = gpr_malloc(sizeof(*sw));
+  grpc_closure_init(&sw->closure, on_state_changed, sw);
   sw->subchannel = c;
   sw->connectivity_state = GRPC_CHANNEL_READY;
 
-  gpr_mu_lock (&c->mu);
+  gpr_mu_lock(&c->mu);
 
-  if (c->disconnected)
-    {
-      gpr_mu_unlock (&c->mu);
-      gpr_free (sw);
-      gpr_free (filters);
-      grpc_channel_stack_destroy (exec_ctx, stk);
-      GRPC_CHANNEL_INTERNAL_UNREF (exec_ctx, c->master, "connecting");
-      GRPC_SUBCHANNEL_UNREF (exec_ctx, c, "connecting");
-      return;
-    }
+  if (c->disconnected) {
+    gpr_mu_unlock(&c->mu);
+    gpr_free(sw);
+    gpr_free(filters);
+    grpc_channel_stack_destroy(exec_ctx, stk);
+    GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, c->master, "connecting");
+    GRPC_SUBCHANNEL_UNREF(exec_ctx, c, "connecting");
+    return;
+  }
 
   /* publish */
-  if (c->active != NULL && c->active->refs == 0)
-    {
-      destroy_connection = c->active;
-    }
+  if (c->active != NULL && c->active->refs == 0) {
+    destroy_connection = c->active;
+  }
   c->active = con;
   c->active_version++;
   sw->version = c->active_version;
@@ -607,202 +577,183 @@ publish_transport (grpc_exec_ctx * exec_ctx, grpc_subchannel * c)
 
   /* watch for changes; subchannel ref for connecting is donated
      to the state watcher */
-  memset (&op, 0, sizeof (op));
+  memset(&op, 0, sizeof(op));
   op.connectivity_state = &sw->connectivity_state;
   op.on_connectivity_state_change = &sw->closure;
   op.bind_pollset_set = c->pollset_set;
-  SUBCHANNEL_REF_LOCKED (c, "state_watcher");
-  GRPC_CHANNEL_INTERNAL_UNREF (exec_ctx, c->master, "connecting");
-  GPR_ASSERT (!SUBCHANNEL_UNREF_LOCKED (c, "connecting"));
-  elem = grpc_channel_stack_element (CHANNEL_STACK_FROM_CONNECTION (c->active), 0);
-  elem->filter->start_transport_op (exec_ctx, elem, &op);
+  SUBCHANNEL_REF_LOCKED(c, "state_watcher");
+  GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, c->master, "connecting");
+  GPR_ASSERT(!SUBCHANNEL_UNREF_LOCKED(c, "connecting"));
+  elem =
+      grpc_channel_stack_element(CHANNEL_STACK_FROM_CONNECTION(c->active), 0);
+  elem->filter->start_transport_op(exec_ctx, elem, &op);
 
   /* signal completion */
-  connectivity_state_changed_locked (exec_ctx, c, "connected");
+  connectivity_state_changed_locked(exec_ctx, c, "connected");
   w4c = c->waiting;
   c->waiting = NULL;
 
-  gpr_mu_unlock (&c->mu);
+  gpr_mu_unlock(&c->mu);
 
-  while (w4c != NULL)
-    {
-      waiting_for_connect *next = w4c->next;
-      grpc_exec_ctx_enqueue (exec_ctx, &w4c->continuation, 1);
-      w4c = next;
-    }
+  while (w4c != NULL) {
+    waiting_for_connect *next = w4c->next;
+    grpc_exec_ctx_enqueue(exec_ctx, &w4c->continuation, 1);
+    w4c = next;
+  }
 
-  gpr_free (filters);
+  gpr_free(filters);
 
-  if (destroy_connection != NULL)
-    {
-      connection_destroy (exec_ctx, destroy_connection);
-    }
+  if (destroy_connection != NULL) {
+    connection_destroy(exec_ctx, destroy_connection);
+  }
 }
 
 /* Generate a random number between 0 and 1. */
-static double
-generate_uniform_random_number (grpc_subchannel * c)
-{
-  c->random = (1103515245 * c->random + 12345) % ((gpr_uint32) 1 << 31);
-  return c->random / (double) ((gpr_uint32) 1 << 31);
+static double generate_uniform_random_number(grpc_subchannel *c) {
+  c->random = (1103515245 * c->random + 12345) % ((gpr_uint32)1 << 31);
+  return c->random / (double)((gpr_uint32)1 << 31);
 }
 
 /* Update backoff_delta and next_attempt in subchannel */
-static void
-update_reconnect_parameters (grpc_subchannel * c)
-{
+static void update_reconnect_parameters(grpc_subchannel *c) {
   gpr_int32 backoff_delta_millis, jitter;
-  gpr_int32 max_backoff_millis = GRPC_SUBCHANNEL_RECONNECT_MAX_BACKOFF_SECONDS * 1000;
+  gpr_int32 max_backoff_millis =
+      GRPC_SUBCHANNEL_RECONNECT_MAX_BACKOFF_SECONDS * 1000;
   double jitter_range;
-  backoff_delta_millis = (gpr_int32) (gpr_time_to_millis (c->backoff_delta) * GRPC_SUBCHANNEL_RECONNECT_BACKOFF_MULTIPLIER);
-  if (backoff_delta_millis > max_backoff_millis)
-    {
-      backoff_delta_millis = max_backoff_millis;
-    }
-  c->backoff_delta = gpr_time_from_millis (backoff_delta_millis, GPR_TIMESPAN);
-  c->next_attempt = gpr_time_add (gpr_now (GPR_CLOCK_MONOTONIC), c->backoff_delta);
+  backoff_delta_millis =
+      (gpr_int32)(gpr_time_to_millis(c->backoff_delta) *
+                  GRPC_SUBCHANNEL_RECONNECT_BACKOFF_MULTIPLIER);
+  if (backoff_delta_millis > max_backoff_millis) {
+    backoff_delta_millis = max_backoff_millis;
+  }
+  c->backoff_delta = gpr_time_from_millis(backoff_delta_millis, GPR_TIMESPAN);
+  c->next_attempt =
+      gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC), c->backoff_delta);
 
   jitter_range = GRPC_SUBCHANNEL_RECONNECT_JITTER * backoff_delta_millis;
-  jitter = (gpr_int32) ((2 * generate_uniform_random_number (c) - 1) * jitter_range);
-  c->next_attempt = gpr_time_add (c->next_attempt, gpr_time_from_millis (jitter, GPR_TIMESPAN));
+  jitter =
+      (gpr_int32)((2 * generate_uniform_random_number(c) - 1) * jitter_range);
+  c->next_attempt =
+      gpr_time_add(c->next_attempt, gpr_time_from_millis(jitter, GPR_TIMESPAN));
 }
 
-static void
-on_alarm (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_success)
-{
+static void on_alarm(grpc_exec_ctx *exec_ctx, void *arg, int iomgr_success) {
   grpc_subchannel *c = arg;
-  gpr_mu_lock (&c->mu);
+  gpr_mu_lock(&c->mu);
   c->have_alarm = 0;
-  if (c->disconnected)
-    {
-      iomgr_success = 0;
-    }
-  connectivity_state_changed_locked (exec_ctx, c, "alarm");
-  gpr_mu_unlock (&c->mu);
-  if (iomgr_success)
-    {
-      update_reconnect_parameters (c);
-      continue_connect (exec_ctx, c);
-    }
-  else
-    {
-      GRPC_CHANNEL_INTERNAL_UNREF (exec_ctx, c->master, "connecting");
-      GRPC_SUBCHANNEL_UNREF (exec_ctx, c, "connecting");
-    }
-}
-
-static void
-subchannel_connected (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_success)
-{
+  if (c->disconnected) {
+    iomgr_success = 0;
+  }
+  connectivity_state_changed_locked(exec_ctx, c, "alarm");
+  gpr_mu_unlock(&c->mu);
+  if (iomgr_success) {
+    update_reconnect_parameters(c);
+    continue_connect(exec_ctx, c);
+  } else {
+    GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, c->master, "connecting");
+    GRPC_SUBCHANNEL_UNREF(exec_ctx, c, "connecting");
+  }
+}
+
+static void subchannel_connected(grpc_exec_ctx *exec_ctx, void *arg,
+                                 int iomgr_success) {
   grpc_subchannel *c = arg;
-  if (c->connecting_result.transport != NULL)
-    {
-      publish_transport (exec_ctx, c);
-    }
-  else
-    {
-      gpr_timespec now = gpr_now (GPR_CLOCK_MONOTONIC);
-      gpr_mu_lock (&c->mu);
-      GPR_ASSERT (!c->have_alarm);
-      c->have_alarm = 1;
-      connectivity_state_changed_locked (exec_ctx, c, "connect_failed");
-      grpc_alarm_init (exec_ctx, &c->alarm, c->next_attempt, on_alarm, c, now);
-      gpr_mu_unlock (&c->mu);
-    }
-}
-
-static gpr_timespec
-compute_connect_deadline (grpc_subchannel * c)
-{
-  gpr_timespec current_deadline = gpr_time_add (c->next_attempt, c->backoff_delta);
-  gpr_timespec min_deadline = gpr_time_add (gpr_now (GPR_CLOCK_MONOTONIC),
-					    gpr_time_from_seconds (GRPC_SUBCHANNEL_MIN_CONNECT_TIMEOUT_SECONDS,
-								   GPR_TIMESPAN));
-  return gpr_time_cmp (current_deadline, min_deadline) > 0 ? current_deadline : min_deadline;
-}
-
-static grpc_connectivity_state
-compute_connectivity_locked (grpc_subchannel * c)
-{
-  if (c->disconnected)
-    {
-      return GRPC_CHANNEL_FATAL_FAILURE;
-    }
-  if (c->connecting)
-    {
-      if (c->have_alarm)
-	{
-	  return GRPC_CHANNEL_TRANSIENT_FAILURE;
-	}
-      return GRPC_CHANNEL_CONNECTING;
-    }
-  if (c->active)
-    {
-      return GRPC_CHANNEL_READY;
+  if (c->connecting_result.transport != NULL) {
+    publish_transport(exec_ctx, c);
+  } else {
+    gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);
+    gpr_mu_lock(&c->mu);
+    GPR_ASSERT(!c->have_alarm);
+    c->have_alarm = 1;
+    connectivity_state_changed_locked(exec_ctx, c, "connect_failed");
+    grpc_alarm_init(exec_ctx, &c->alarm, c->next_attempt, on_alarm, c, now);
+    gpr_mu_unlock(&c->mu);
+  }
+}
+
+static gpr_timespec compute_connect_deadline(grpc_subchannel *c) {
+  gpr_timespec current_deadline =
+      gpr_time_add(c->next_attempt, c->backoff_delta);
+  gpr_timespec min_deadline = gpr_time_add(
+      gpr_now(GPR_CLOCK_MONOTONIC),
+      gpr_time_from_seconds(GRPC_SUBCHANNEL_MIN_CONNECT_TIMEOUT_SECONDS,
+                            GPR_TIMESPAN));
+  return gpr_time_cmp(current_deadline, min_deadline) > 0 ? current_deadline
+                                                          : min_deadline;
+}
+
+static grpc_connectivity_state compute_connectivity_locked(grpc_subchannel *c) {
+  if (c->disconnected) {
+    return GRPC_CHANNEL_FATAL_FAILURE;
+  }
+  if (c->connecting) {
+    if (c->have_alarm) {
+      return GRPC_CHANNEL_TRANSIENT_FAILURE;
     }
+    return GRPC_CHANNEL_CONNECTING;
+  }
+  if (c->active) {
+    return GRPC_CHANNEL_READY;
+  }
   return GRPC_CHANNEL_IDLE;
 }
 
-static void
-connectivity_state_changed_locked (grpc_exec_ctx * exec_ctx, grpc_subchannel * c, const char *reason)
-{
-  grpc_connectivity_state current = compute_connectivity_locked (c);
-  grpc_connectivity_state_set (exec_ctx, &c->state_tracker, current, reason);
+static void connectivity_state_changed_locked(grpc_exec_ctx *exec_ctx,
+                                              grpc_subchannel *c,
+                                              const char *reason) {
+  grpc_connectivity_state current = compute_connectivity_locked(c);
+  grpc_connectivity_state_set(exec_ctx, &c->state_tracker, current, reason);
 }
 
 /*
  * grpc_subchannel_call implementation
  */
 
-void
-grpc_subchannel_call_ref (grpc_subchannel_call * c GRPC_SUBCHANNEL_REF_EXTRA_ARGS)
-{
-  gpr_ref (&c->refs);
-}
-
-void
-grpc_subchannel_call_unref (grpc_exec_ctx *exec_ctx, grpc_subchannel_call * c GRPC_SUBCHANNEL_REF_EXTRA_ARGS)
-{
-  if (gpr_unref (&c->refs))
-    {
-      gpr_mu *mu = &c->connection->subchannel->mu;
-      grpc_subchannel *destroy;
-      grpc_call_stack_destroy (exec_ctx, SUBCHANNEL_CALL_TO_CALL_STACK (c));
-      gpr_mu_lock (mu);
-      destroy = CONNECTION_UNREF_LOCKED (exec_ctx, c->connection, "call");
-      gpr_mu_unlock (mu);
-      gpr_free (c);
-      if (destroy != NULL)
-	{
-	  subchannel_destroy (exec_ctx, destroy);
-	}
+void grpc_subchannel_call_ref(
+    grpc_subchannel_call *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
+  gpr_ref(&c->refs);
+}
+
+void grpc_subchannel_call_unref(grpc_exec_ctx *exec_ctx,
+                                grpc_subchannel_call *c
+                                    GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
+  if (gpr_unref(&c->refs)) {
+    gpr_mu *mu = &c->connection->subchannel->mu;
+    grpc_subchannel *destroy;
+    grpc_call_stack_destroy(exec_ctx, SUBCHANNEL_CALL_TO_CALL_STACK(c));
+    gpr_mu_lock(mu);
+    destroy = CONNECTION_UNREF_LOCKED(exec_ctx, c->connection, "call");
+    gpr_mu_unlock(mu);
+    gpr_free(c);
+    if (destroy != NULL) {
+      subchannel_destroy(exec_ctx, destroy);
     }
+  }
 }
 
-char *
-grpc_subchannel_call_get_peer (grpc_exec_ctx * exec_ctx, grpc_subchannel_call * call)
-{
-  grpc_call_stack *call_stack = SUBCHANNEL_CALL_TO_CALL_STACK (call);
-  grpc_call_element *top_elem = grpc_call_stack_element (call_stack, 0);
-  return top_elem->filter->get_peer (exec_ctx, top_elem);
+char *grpc_subchannel_call_get_peer(grpc_exec_ctx *exec_ctx,
+                                    grpc_subchannel_call *call) {
+  grpc_call_stack *call_stack = SUBCHANNEL_CALL_TO_CALL_STACK(call);
+  grpc_call_element *top_elem = grpc_call_stack_element(call_stack, 0);
+  return top_elem->filter->get_peer(exec_ctx, top_elem);
 }
 
-void
-grpc_subchannel_call_process_op (grpc_exec_ctx * exec_ctx, grpc_subchannel_call * call, grpc_transport_stream_op * op)
-{
-  grpc_call_stack *call_stack = SUBCHANNEL_CALL_TO_CALL_STACK (call);
-  grpc_call_element *top_elem = grpc_call_stack_element (call_stack, 0);
-  top_elem->filter->start_transport_stream_op (exec_ctx, top_elem, op);
+void grpc_subchannel_call_process_op(grpc_exec_ctx *exec_ctx,
+                                     grpc_subchannel_call *call,
+                                     grpc_transport_stream_op *op) {
+  grpc_call_stack *call_stack = SUBCHANNEL_CALL_TO_CALL_STACK(call);
+  grpc_call_element *top_elem = grpc_call_stack_element(call_stack, 0);
+  top_elem->filter->start_transport_stream_op(exec_ctx, top_elem, op);
 }
 
-static grpc_subchannel_call *
-create_call (grpc_exec_ctx * exec_ctx, connection * con)
-{
-  grpc_channel_stack *chanstk = CHANNEL_STACK_FROM_CONNECTION (con);
-  grpc_subchannel_call *call = gpr_malloc (sizeof (grpc_subchannel_call) + chanstk->call_stack_size);
-  grpc_call_stack *callstk = SUBCHANNEL_CALL_TO_CALL_STACK (call);
+static grpc_subchannel_call *create_call(grpc_exec_ctx *exec_ctx,
+                                         connection *con) {
+  grpc_channel_stack *chanstk = CHANNEL_STACK_FROM_CONNECTION(con);
+  grpc_subchannel_call *call =
+      gpr_malloc(sizeof(grpc_subchannel_call) + chanstk->call_stack_size);
+  grpc_call_stack *callstk = SUBCHANNEL_CALL_TO_CALL_STACK(call);
   call->connection = con;
-  gpr_ref_init (&call->refs, 1);
-  grpc_call_stack_init (exec_ctx, chanstk, NULL, NULL, callstk);
+  gpr_ref_init(&call->refs, 1);
+  grpc_call_stack_init(exec_ctx, chanstk, NULL, NULL, callstk);
   return call;
 }

src/core/client_config/subchannel.h

@@ -64,37 +64,59 @@ typedef struct grpc_subchannel_args grpc_subchannel_args;
 #define GRPC_SUBCHANNEL_REF_EXTRA_ARGS
 #endif
 
-void grpc_subchannel_ref (grpc_subchannel * channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-void grpc_subchannel_unref (grpc_exec_ctx *exec_ctx, grpc_subchannel * channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-void grpc_subchannel_call_ref (grpc_subchannel_call * call GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-void grpc_subchannel_call_unref (grpc_exec_ctx *exec_ctx, grpc_subchannel_call * call GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
+void grpc_subchannel_ref(
+    grpc_subchannel *channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
+void grpc_subchannel_unref(grpc_exec_ctx *exec_ctx,
+                           grpc_subchannel *channel
+                               GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
+void grpc_subchannel_call_ref(
+    grpc_subchannel_call *call GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
+void grpc_subchannel_call_unref(grpc_exec_ctx *exec_ctx,
+                                grpc_subchannel_call *call
+                                    GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
 
 /** construct a call (possibly asynchronously) */
-void grpc_subchannel_create_call (grpc_exec_ctx * exec_ctx, grpc_subchannel * subchannel, grpc_pollset * pollset, grpc_subchannel_call ** target, grpc_closure * notify);
+void grpc_subchannel_create_call(grpc_exec_ctx *exec_ctx,
+                                 grpc_subchannel *subchannel,
+                                 grpc_pollset *pollset,
+                                 grpc_subchannel_call **target,
+                                 grpc_closure *notify);
 
 /** process a transport level op */
-void grpc_subchannel_process_transport_op (grpc_exec_ctx * exec_ctx, grpc_subchannel * subchannel, grpc_transport_op * op);
+void grpc_subchannel_process_transport_op(grpc_exec_ctx *exec_ctx,
+                                          grpc_subchannel *subchannel,
+                                          grpc_transport_op *op);
 
 /** poll the current connectivity state of a channel */
-grpc_connectivity_state grpc_subchannel_check_connectivity (grpc_subchannel * channel);
+grpc_connectivity_state grpc_subchannel_check_connectivity(
+    grpc_subchannel *channel);
 
 /** call notify when the connectivity state of a channel changes from *state.
     Updates *state with the new state of the channel */
-void grpc_subchannel_notify_on_state_change (grpc_exec_ctx * exec_ctx, grpc_subchannel * channel, grpc_connectivity_state * state, grpc_closure * notify);
+void grpc_subchannel_notify_on_state_change(grpc_exec_ctx *exec_ctx,
+                                            grpc_subchannel *channel,
+                                            grpc_connectivity_state *state,
+                                            grpc_closure *notify);
 
 /** express interest in \a channel's activities through \a pollset. */
-void grpc_subchannel_add_interested_party (grpc_exec_ctx * exec_ctx, grpc_subchannel * channel, grpc_pollset * pollset);
+void grpc_subchannel_add_interested_party(grpc_exec_ctx *exec_ctx,
+                                          grpc_subchannel *channel,
+                                          grpc_pollset *pollset);
 /** stop following \a channel's activity through \a pollset. */
-void grpc_subchannel_del_interested_party (grpc_exec_ctx * exec_ctx, grpc_subchannel * channel, grpc_pollset * pollset);
+void grpc_subchannel_del_interested_party(grpc_exec_ctx *exec_ctx,
+                                          grpc_subchannel *channel,
+                                          grpc_pollset *pollset);
 
 /** continue processing a transport op */
-void grpc_subchannel_call_process_op (grpc_exec_ctx * exec_ctx, grpc_subchannel_call * subchannel_call, grpc_transport_stream_op * op);
+void grpc_subchannel_call_process_op(grpc_exec_ctx *exec_ctx,
+                                     grpc_subchannel_call *subchannel_call,
+                                     grpc_transport_stream_op *op);
 
 /** continue querying for peer */
-char *grpc_subchannel_call_get_peer (grpc_exec_ctx * exec_ctx, grpc_subchannel_call * subchannel_call);
+char *grpc_subchannel_call_get_peer(grpc_exec_ctx *exec_ctx,
+                                    grpc_subchannel_call *subchannel_call);
 
-struct grpc_subchannel_args
-{
+struct grpc_subchannel_args {
   /** Channel filters for this channel - wrapped factories will likely
       want to mutate this */
   const grpc_channel_filter **filters;
@@ -112,6 +134,7 @@ struct grpc_subchannel_args
 };
 
 /** create a subchannel given a connector */
-grpc_subchannel *grpc_subchannel_create (grpc_connector * connector, grpc_subchannel_args * args);
+grpc_subchannel *grpc_subchannel_create(grpc_connector *connector,
+                                        grpc_subchannel_args *args);
 
 #endif /* GRPC_INTERNAL_CORE_CLIENT_CONFIG_SUBCHANNEL_H */

src/core/client_config/subchannel_factory.c

@@ -33,20 +33,17 @@
 
 #include "src/core/client_config/subchannel_factory.h"
 
-void
-grpc_subchannel_factory_ref (grpc_subchannel_factory * factory)
-{
-  factory->vtable->ref (factory);
+void grpc_subchannel_factory_ref(grpc_subchannel_factory* factory) {
+  factory->vtable->ref(factory);
 }
 
-void
-grpc_subchannel_factory_unref (grpc_exec_ctx * exec_ctx, grpc_subchannel_factory * factory)
-{
-  factory->vtable->unref (exec_ctx, factory);
+void grpc_subchannel_factory_unref(grpc_exec_ctx* exec_ctx,
+                                   grpc_subchannel_factory* factory) {
+  factory->vtable->unref(exec_ctx, factory);
 }
 
-grpc_subchannel *
-grpc_subchannel_factory_create_subchannel (grpc_exec_ctx * exec_ctx, grpc_subchannel_factory * factory, grpc_subchannel_args * args)
-{
-  return factory->vtable->create_subchannel (exec_ctx, factory, args);
+grpc_subchannel* grpc_subchannel_factory_create_subchannel(
+    grpc_exec_ctx* exec_ctx, grpc_subchannel_factory* factory,
+    grpc_subchannel_args* args) {
+  return factory->vtable->create_subchannel(exec_ctx, factory, args);
 }

src/core/client_config/subchannel_factory.h

@@ -42,22 +42,25 @@ typedef struct grpc_subchannel_factory_vtable grpc_subchannel_factory_vtable;
 
 /** Constructor for new configured channels.
     Creating decorators around this type is encouraged to adapt behavior. */
-struct grpc_subchannel_factory
-{
+struct grpc_subchannel_factory {
   const grpc_subchannel_factory_vtable *vtable;
 };
 
-struct grpc_subchannel_factory_vtable
-{
-  void (*ref) (grpc_subchannel_factory * factory);
-  void (*unref) (grpc_exec_ctx * exec_ctx, grpc_subchannel_factory * factory);
-  grpc_subchannel *(*create_subchannel) (grpc_exec_ctx * exec_ctx, grpc_subchannel_factory * factory, grpc_subchannel_args * args);
+struct grpc_subchannel_factory_vtable {
+  void (*ref)(grpc_subchannel_factory *factory);
+  void (*unref)(grpc_exec_ctx *exec_ctx, grpc_subchannel_factory *factory);
+  grpc_subchannel *(*create_subchannel)(grpc_exec_ctx *exec_ctx,
+                                        grpc_subchannel_factory *factory,
+                                        grpc_subchannel_args *args);
 };
 
-void grpc_subchannel_factory_ref (grpc_subchannel_factory * factory);
-void grpc_subchannel_factory_unref (grpc_exec_ctx * exec_ctx, grpc_subchannel_factory * factory);
+void grpc_subchannel_factory_ref(grpc_subchannel_factory *factory);
+void grpc_subchannel_factory_unref(grpc_exec_ctx *exec_ctx,
+                                   grpc_subchannel_factory *factory);
 
 /** Create a new grpc_subchannel */
-grpc_subchannel *grpc_subchannel_factory_create_subchannel (grpc_exec_ctx * exec_ctx, grpc_subchannel_factory * factory, grpc_subchannel_args * args);
+grpc_subchannel *grpc_subchannel_factory_create_subchannel(
+    grpc_exec_ctx *exec_ctx, grpc_subchannel_factory *factory,
+    grpc_subchannel_args *args);
 
 #endif /* GRPC_INTERNAL_CORE_CLIENT_CONFIG_SUBCHANNEL_FACTORY_H */

src/core/client_config/subchannel_factory_decorators/add_channel_arg.c

@@ -34,11 +34,10 @@
 #include "src/core/client_config/subchannel_factory_decorators/add_channel_arg.h"
 #include "src/core/client_config/subchannel_factory_decorators/merge_channel_args.h"
 
-grpc_subchannel_factory *
-grpc_subchannel_factory_add_channel_arg (grpc_subchannel_factory * input, const grpc_arg * arg)
-{
+grpc_subchannel_factory *grpc_subchannel_factory_add_channel_arg(
+    grpc_subchannel_factory *input, const grpc_arg *arg) {
   grpc_channel_args args;
   args.num_args = 1;
-  args.args = (grpc_arg *) arg;
-  return grpc_subchannel_factory_merge_channel_args (input, &args);
+  args.args = (grpc_arg *)arg;
+  return grpc_subchannel_factory_merge_channel_args(input, &args);
 }

src/core/client_config/subchannel_factory_decorators/add_channel_arg.h

@@ -39,7 +39,8 @@
 /** Takes a subchannel factory, returns a new one that mutates incoming
     channel_args by adding a new argument; ownership of input, arg is retained
     by the caller. */
-grpc_subchannel_factory *grpc_subchannel_factory_add_channel_arg (grpc_subchannel_factory * input, const grpc_arg * arg);
+grpc_subchannel_factory *grpc_subchannel_factory_add_channel_arg(
+    grpc_subchannel_factory *input, const grpc_arg *arg);
 
 #endif /* GRPC_INTERNAL_CORE_CLIENT_CONFIG_SUBCHANNEL_FACTORY_DECORATORS_ADD_CHANNEL_ARG_H \
         */

src/core/client_config/subchannel_factory_decorators/merge_channel_args.c

@@ -35,58 +35,52 @@
 #include <grpc/support/alloc.h>
 #include "src/core/channel/channel_args.h"
 
-typedef struct
-{
+typedef struct {
   grpc_subchannel_factory base;
   gpr_refcount refs;
   grpc_subchannel_factory *wrapped;
   grpc_channel_args *merge_args;
 } merge_args_factory;
 
-static void
-merge_args_factory_ref (grpc_subchannel_factory * scf)
-{
-  merge_args_factory *f = (merge_args_factory *) scf;
-  gpr_ref (&f->refs);
+static void merge_args_factory_ref(grpc_subchannel_factory *scf) {
+  merge_args_factory *f = (merge_args_factory *)scf;
+  gpr_ref(&f->refs);
 }
 
-static void
-merge_args_factory_unref (grpc_exec_ctx * exec_ctx, grpc_subchannel_factory * scf)
-{
-  merge_args_factory *f = (merge_args_factory *) scf;
-  if (gpr_unref (&f->refs))
-    {
-      grpc_subchannel_factory_unref (exec_ctx, f->wrapped);
-      grpc_channel_args_destroy (f->merge_args);
-      gpr_free (f);
-    }
+static void merge_args_factory_unref(grpc_exec_ctx *exec_ctx,
+                                     grpc_subchannel_factory *scf) {
+  merge_args_factory *f = (merge_args_factory *)scf;
+  if (gpr_unref(&f->refs)) {
+    grpc_subchannel_factory_unref(exec_ctx, f->wrapped);
+    grpc_channel_args_destroy(f->merge_args);
+    gpr_free(f);
+  }
 }
 
-static grpc_subchannel *
-merge_args_factory_create_subchannel (grpc_exec_ctx * exec_ctx, grpc_subchannel_factory * scf, grpc_subchannel_args * args)
-{
-  merge_args_factory *f = (merge_args_factory *) scf;
-  grpc_channel_args *final_args = grpc_channel_args_merge (args->args, f->merge_args);
+static grpc_subchannel *merge_args_factory_create_subchannel(
+    grpc_exec_ctx *exec_ctx, grpc_subchannel_factory *scf,
+    grpc_subchannel_args *args) {
+  merge_args_factory *f = (merge_args_factory *)scf;
+  grpc_channel_args *final_args =
+      grpc_channel_args_merge(args->args, f->merge_args);
   grpc_subchannel *s;
   args->args = final_args;
-  s = grpc_subchannel_factory_create_subchannel (exec_ctx, f->wrapped, args);
-  grpc_channel_args_destroy (final_args);
+  s = grpc_subchannel_factory_create_subchannel(exec_ctx, f->wrapped, args);
+  grpc_channel_args_destroy(final_args);
   return s;
 }
 
 static const grpc_subchannel_factory_vtable merge_args_factory_vtable = {
-  merge_args_factory_ref, merge_args_factory_unref,
-  merge_args_factory_create_subchannel
-};
+    merge_args_factory_ref, merge_args_factory_unref,
+    merge_args_factory_create_subchannel};
 
-grpc_subchannel_factory *
-grpc_subchannel_factory_merge_channel_args (grpc_subchannel_factory * input, const grpc_channel_args * args)
-{
-  merge_args_factory *f = gpr_malloc (sizeof (*f));
+grpc_subchannel_factory *grpc_subchannel_factory_merge_channel_args(
+    grpc_subchannel_factory *input, const grpc_channel_args *args) {
+  merge_args_factory *f = gpr_malloc(sizeof(*f));
   f->base.vtable = &merge_args_factory_vtable;
-  gpr_ref_init (&f->refs, 1);
-  grpc_subchannel_factory_ref (input);
+  gpr_ref_init(&f->refs, 1);
+  grpc_subchannel_factory_ref(input);
   f->wrapped = input;
-  f->merge_args = grpc_channel_args_copy (args);
+  f->merge_args = grpc_channel_args_copy(args);
   return &f->base;
 }

src/core/client_config/subchannel_factory_decorators/merge_channel_args.h

@@ -39,7 +39,8 @@
 /** Takes a subchannel factory, returns a new one that mutates incoming
     channel_args by adding a new argument; ownership of input, args is retained
     by the caller. */
-grpc_subchannel_factory *grpc_subchannel_factory_merge_channel_args (grpc_subchannel_factory * input, const grpc_channel_args * args);
+grpc_subchannel_factory *grpc_subchannel_factory_merge_channel_args(
+    grpc_subchannel_factory *input, const grpc_channel_args *args);
 
 #endif /* GRPC_INTERNAL_CORE_CLIENT_CONFIG_SUBCHANNEL_FACTORY_DECORATORS_MERGE_CHANNEL_ARGS_H \
         */

src/core/client_config/uri_parser.c

@@ -42,35 +42,31 @@
 /** a size_t default value... maps to all 1's */
 #define NOT_SET (~(size_t)0)
 
-static grpc_uri *
-bad_uri (const char *uri_text, size_t pos, const char *section, int suppress_errors)
-{
+static grpc_uri *bad_uri(const char *uri_text, size_t pos, const char *section,
+                         int suppress_errors) {
   char *line_prefix;
   size_t pfx_len;
 
-  if (!suppress_errors)
-    {
-      gpr_asprintf (&line_prefix, "bad uri.%s: '", section);
-      pfx_len = strlen (line_prefix) + pos;
-      gpr_log (GPR_ERROR, "%s%s'", line_prefix, uri_text);
-      gpr_free (line_prefix);
+  if (!suppress_errors) {
+    gpr_asprintf(&line_prefix, "bad uri.%s: '", section);
+    pfx_len = strlen(line_prefix) + pos;
+    gpr_log(GPR_ERROR, "%s%s'", line_prefix, uri_text);
+    gpr_free(line_prefix);
 
-      line_prefix = gpr_malloc (pfx_len + 1);
-      memset (line_prefix, ' ', pfx_len);
-      line_prefix[pfx_len] = 0;
-      gpr_log (GPR_ERROR, "%s^ here", line_prefix);
-      gpr_free (line_prefix);
-    }
+    line_prefix = gpr_malloc(pfx_len + 1);
+    memset(line_prefix, ' ', pfx_len);
+    line_prefix[pfx_len] = 0;
+    gpr_log(GPR_ERROR, "%s^ here", line_prefix);
+    gpr_free(line_prefix);
+  }
 
   return NULL;
 }
 
 /** Returns a copy of \a src[begin, end) */
-static char *
-copy_component (const char *src, size_t begin, size_t end)
-{
-  char *out = gpr_malloc (end - begin + 1);
-  memcpy (out, src + begin, end - begin);
+static char *copy_component(const char *src, size_t begin, size_t end) {
+  char *out = gpr_malloc(end - begin + 1);
+  memcpy(out, src + begin, end - begin);
   out[end - begin] = 0;
   return out;
 }
@@ -78,77 +74,66 @@ copy_component (const char *src, size_t begin, size_t end)
 /** Returns how many chars to advance if \a uri_text[i] begins a valid \a pchar
  * production. If \a uri_text[i] introduces an invalid \a pchar (such as percent
  * sign not followed by two hex digits), NOT_SET is returned. */
-static size_t
-parse_pchar (const char *uri_text, size_t i)
-{
+static size_t parse_pchar(const char *uri_text, size_t i) {
   /* pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
    * unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
    * pct-encoded = "%" HEXDIG HEXDIG
    * sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
    / "*" / "+" / "," / ";" / "=" */
   char c = uri_text[i];
-  if (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')) || ((c >= '0') && (c <= '9')) || (c == '-' || c == '.' || c == '_' || c == '~') ||	/* unreserved */
-      (c == '!' || c == '$' || c == '&' || c == '\'' || c == '$' || c == '&' || c == '(' || c == ')' || c == '*' || c == '+' || c == ',' || c == ';' || c == '=') /* sub-delims */ )
-    {
-      return 1;
+  if (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')) ||
+      ((c >= '0') && (c <= '9')) ||
+      (c == '-' || c == '.' || c == '_' || c == '~') || /* unreserved */
+      (c == '!' || c == '$' || c == '&' || c == '\'' || c == '$' || c == '&' ||
+       c == '(' || c == ')' || c == '*' || c == '+' || c == ',' || c == ';' ||
+       c == '=') /* sub-delims */) {
+    return 1;
+  }
+  if (c == '%') { /* pct-encoded */
+    size_t j;
+    if (uri_text[i + 1] == 0 || uri_text[i + 2] == 0) {
+      return NOT_SET;
     }
-  if (c == '%')
-    {				/* pct-encoded */
-      size_t j;
-      if (uri_text[i + 1] == 0 || uri_text[i + 2] == 0)
-	{
-	  return NOT_SET;
-	}
-      for (j = i + 1; j < 2; j++)
-	{
-	  c = uri_text[j];
-	  if (!(((c >= '0') && (c <= '9')) || ((c >= 'a') && (c <= 'f')) || ((c >= 'A') && (c <= 'F'))))
-	    {
-	      return NOT_SET;
-	    }
-	}
-      return 2;
+    for (j = i + 1; j < 2; j++) {
+      c = uri_text[j];
+      if (!(((c >= '0') && (c <= '9')) || ((c >= 'a') && (c <= 'f')) ||
+            ((c >= 'A') && (c <= 'F')))) {
+        return NOT_SET;
+      }
     }
+    return 2;
+  }
   return 0;
 }
 
 /* *( pchar / "?" / "/" ) */
-static int
-parse_fragment_or_query (const char *uri_text, size_t * i)
-{
+static int parse_fragment_or_query(const char *uri_text, size_t *i) {
   char c;
-  while ((c = uri_text[*i]) != 0)
-    {
-      const size_t advance = parse_pchar (uri_text, *i);	/* pchar */
-      switch (advance)
-	{
-	case 0:		/* uri_text[i] isn't in pchar */
-	  /* maybe it's ? or / */
-	  if (uri_text[*i] == '?' || uri_text[*i] == '/')
-	    {
-	      (*i)++;
-	      break;
-	    }
-	  else
-	    {
-	      return 1;
-	    }
-	  gpr_log (GPR_ERROR, "should never reach here");
-	  abort ();
-	default:
-	  (*i) += advance;
-	  break;
-	case NOT_SET:		/* uri_text[i] introduces an invalid URI */
-	  return 0;
-	}
+  while ((c = uri_text[*i]) != 0) {
+    const size_t advance = parse_pchar(uri_text, *i); /* pchar */
+    switch (advance) {
+      case 0: /* uri_text[i] isn't in pchar */
+        /* maybe it's ? or / */
+        if (uri_text[*i] == '?' || uri_text[*i] == '/') {
+          (*i)++;
+          break;
+        } else {
+          return 1;
+        }
+        gpr_log(GPR_ERROR, "should never reach here");
+        abort();
+      default:
+        (*i) += advance;
+        break;
+      case NOT_SET: /* uri_text[i] introduces an invalid URI */
+        return 0;
     }
+  }
   /* *i is the first uri_text position past the \a query production, maybe \0 */
   return 1;
 }
 
-grpc_uri *
-grpc_uri_parse (const char *uri_text, int suppress_errors)
-{
+grpc_uri *grpc_uri_parse(const char *uri_text, int suppress_errors) {
   grpc_uri *uri;
   size_t scheme_begin = 0;
   size_t scheme_end = NOT_SET;
@@ -162,127 +147,96 @@ grpc_uri_parse (const char *uri_text, int suppress_errors)
   size_t fragment_end = NOT_SET;
   size_t i;
 
-  for (i = scheme_begin; uri_text[i] != 0; i++)
-    {
-      if (uri_text[i] == ':')
-	{
-	  scheme_end = i;
-	  break;
-	}
-      if (uri_text[i] >= 'a' && uri_text[i] <= 'z')
-	continue;
-      if (uri_text[i] >= 'A' && uri_text[i] <= 'Z')
-	continue;
-      if (i != scheme_begin)
-	{
-	  if (uri_text[i] >= '0' && uri_text[i] <= '9')
-	    continue;
-	  if (uri_text[i] == '+')
-	    continue;
-	  if (uri_text[i] == '-')
-	    continue;
-	  if (uri_text[i] == '.')
-	    continue;
-	}
+  for (i = scheme_begin; uri_text[i] != 0; i++) {
+    if (uri_text[i] == ':') {
+      scheme_end = i;
       break;
     }
-  if (scheme_end == NOT_SET)
-    {
-      return bad_uri (uri_text, i, "scheme", suppress_errors);
+    if (uri_text[i] >= 'a' && uri_text[i] <= 'z') continue;
+    if (uri_text[i] >= 'A' && uri_text[i] <= 'Z') continue;
+    if (i != scheme_begin) {
+      if (uri_text[i] >= '0' && uri_text[i] <= '9') continue;
+      if (uri_text[i] == '+') continue;
+      if (uri_text[i] == '-') continue;
+      if (uri_text[i] == '.') continue;
     }
-
-  if (uri_text[scheme_end + 1] == '/' && uri_text[scheme_end + 2] == '/')
-    {
-      authority_begin = scheme_end + 3;
-      for (i = authority_begin; uri_text[i] != 0 && authority_end == NOT_SET; i++)
-	{
-	  if (uri_text[i] == '/' || uri_text[i] == '?' || uri_text[i] == '#')
-	    {
-	      authority_end = i;
-	    }
-	}
-      if (authority_end == NOT_SET && uri_text[i] == 0)
-	{
-	  authority_end = i;
-	}
-      if (authority_end == NOT_SET)
-	{
-	  return bad_uri (uri_text, i, "authority", suppress_errors);
-	}
-      /* TODO(ctiller): parse the authority correctly */
-      path_begin = authority_end;
+    break;
+  }
+  if (scheme_end == NOT_SET) {
+    return bad_uri(uri_text, i, "scheme", suppress_errors);
+  }
+
+  if (uri_text[scheme_end + 1] == '/' && uri_text[scheme_end + 2] == '/') {
+    authority_begin = scheme_end + 3;
+    for (i = authority_begin; uri_text[i] != 0 && authority_end == NOT_SET;
+         i++) {
+      if (uri_text[i] == '/' || uri_text[i] == '?' || uri_text[i] == '#') {
+        authority_end = i;
+      }
     }
-  else
-    {
-      path_begin = scheme_end + 1;
+    if (authority_end == NOT_SET && uri_text[i] == 0) {
+      authority_end = i;
     }
-
-  for (i = path_begin; uri_text[i] != 0; i++)
-    {
-      if (uri_text[i] == '?' || uri_text[i] == '#')
-	{
-	  path_end = i;
-	  break;
-	}
+    if (authority_end == NOT_SET) {
+      return bad_uri(uri_text, i, "authority", suppress_errors);
     }
-  if (path_end == NOT_SET && uri_text[i] == 0)
-    {
+    /* TODO(ctiller): parse the authority correctly */
+    path_begin = authority_end;
+  } else {
+    path_begin = scheme_end + 1;
+  }
+
+  for (i = path_begin; uri_text[i] != 0; i++) {
+    if (uri_text[i] == '?' || uri_text[i] == '#') {
       path_end = i;
+      break;
     }
-  if (path_end == NOT_SET)
-    {
-      return bad_uri (uri_text, i, "path", suppress_errors);
-    }
-
-  if (uri_text[i] == '?')
-    {
-      query_begin = ++i;
-      if (!parse_fragment_or_query (uri_text, &i))
-	{
-	  return bad_uri (uri_text, i, "query", suppress_errors);
-	}
-      else if (uri_text[i] != 0 && uri_text[i] != '#')
-	{
-	  /* We must be at the end or at the beginning of a fragment */
-	  return bad_uri (uri_text, i, "query", suppress_errors);
-	}
-      query_end = i;
+  }
+  if (path_end == NOT_SET && uri_text[i] == 0) {
+    path_end = i;
+  }
+  if (path_end == NOT_SET) {
+    return bad_uri(uri_text, i, "path", suppress_errors);
+  }
+
+  if (uri_text[i] == '?') {
+    query_begin = ++i;
+    if (!parse_fragment_or_query(uri_text, &i)) {
+      return bad_uri(uri_text, i, "query", suppress_errors);
+    } else if (uri_text[i] != 0 && uri_text[i] != '#') {
+      /* We must be at the end or at the beginning of a fragment */
+      return bad_uri(uri_text, i, "query", suppress_errors);
     }
-  if (uri_text[i] == '#')
-    {
-      fragment_begin = ++i;
-      if (!parse_fragment_or_query (uri_text, &i))
-	{
-	  return bad_uri (uri_text, i - fragment_end, "fragment", suppress_errors);
-	}
-      else if (uri_text[i] != 0)
-	{
-	  /* We must be at the end */
-	  return bad_uri (uri_text, i, "fragment", suppress_errors);
-	}
-      fragment_end = i;
+    query_end = i;
+  }
+  if (uri_text[i] == '#') {
+    fragment_begin = ++i;
+    if (!parse_fragment_or_query(uri_text, &i)) {
+      return bad_uri(uri_text, i - fragment_end, "fragment", suppress_errors);
+    } else if (uri_text[i] != 0) {
+      /* We must be at the end */
+      return bad_uri(uri_text, i, "fragment", suppress_errors);
     }
+    fragment_end = i;
+  }
 
-  uri = gpr_malloc (sizeof (*uri));
-  memset (uri, 0, sizeof (*uri));
-  uri->scheme = copy_component (uri_text, scheme_begin, scheme_end);
-  uri->authority = copy_component (uri_text, authority_begin, authority_end);
-  uri->path = copy_component (uri_text, path_begin, path_end);
-  uri->query = copy_component (uri_text, query_begin, query_end);
-  uri->fragment = copy_component (uri_text, fragment_begin, fragment_end);
+  uri = gpr_malloc(sizeof(*uri));
+  memset(uri, 0, sizeof(*uri));
+  uri->scheme = copy_component(uri_text, scheme_begin, scheme_end);
+  uri->authority = copy_component(uri_text, authority_begin, authority_end);
+  uri->path = copy_component(uri_text, path_begin, path_end);
+  uri->query = copy_component(uri_text, query_begin, query_end);
+  uri->fragment = copy_component(uri_text, fragment_begin, fragment_end);
 
   return uri;
 }
 
-void
-grpc_uri_destroy (grpc_uri * uri)
-{
-  if (!uri)
-    return;
-  gpr_free (uri->scheme);
-  gpr_free (uri->authority);
-  gpr_free (uri->path);
-  gpr_free (uri->query);
-  gpr_free (uri->fragment);
-  gpr_free (uri);
+void grpc_uri_destroy(grpc_uri *uri) {
+  if (!uri) return;
+  gpr_free(uri->scheme);
+  gpr_free(uri->authority);
+  gpr_free(uri->path);
+  gpr_free(uri->query);
+  gpr_free(uri->fragment);
+  gpr_free(uri);
 }

src/core/client_config/uri_parser.h

@@ -34,8 +34,7 @@
 #ifndef GRPC_INTERNAL_CORE_CLIENT_CONFIG_URI_PARSER_H
 #define GRPC_INTERNAL_CORE_CLIENT_CONFIG_URI_PARSER_H
 
-typedef struct
-{
+typedef struct {
   char *scheme;
   char *authority;
   char *path;
@@ -44,9 +43,9 @@ typedef struct
 } grpc_uri;
 
 /** parse a uri, return NULL on failure */
-grpc_uri *grpc_uri_parse (const char *uri_text, int suppress_errors);
+grpc_uri *grpc_uri_parse(const char *uri_text, int suppress_errors);
 
 /** destroy a uri */
-void grpc_uri_destroy (grpc_uri * uri);
+void grpc_uri_destroy(grpc_uri *uri);
 
 #endif

src/core/compression/algorithm.c

@@ -37,41 +37,30 @@
 #include <grpc/compression.h>
 #include <grpc/support/useful.h>
 
-int
-grpc_compression_algorithm_parse (const char *name, size_t name_length, grpc_compression_algorithm * algorithm)
-{
+int grpc_compression_algorithm_parse(const char *name, size_t name_length,
+                                     grpc_compression_algorithm *algorithm) {
   /* we use strncmp not only because it's safer (even though in this case it
    * doesn't matter, given that we are comparing against string literals, but
    * because this way we needn't have "name" nil-terminated (useful for slice
    * data, for example) */
-  if (name_length == 0)
-    {
-      return 0;
-    }
-  if (strncmp (name, "identity", name_length) == 0)
-    {
-      *algorithm = GRPC_COMPRESS_NONE;
-    }
-  else if (strncmp (name, "gzip", name_length) == 0)
-    {
-      *algorithm = GRPC_COMPRESS_GZIP;
-    }
-  else if (strncmp (name, "deflate", name_length) == 0)
-    {
-      *algorithm = GRPC_COMPRESS_DEFLATE;
-    }
-  else
-    {
-      return 0;
-    }
+  if (name_length == 0) {
+    return 0;
+  }
+  if (strncmp(name, "identity", name_length) == 0) {
+    *algorithm = GRPC_COMPRESS_NONE;
+  } else if (strncmp(name, "gzip", name_length) == 0) {
+    *algorithm = GRPC_COMPRESS_GZIP;
+  } else if (strncmp(name, "deflate", name_length) == 0) {
+    *algorithm = GRPC_COMPRESS_DEFLATE;
+  } else {
+    return 0;
+  }
   return 1;
 }
 
-int
-grpc_compression_algorithm_name (grpc_compression_algorithm algorithm, char **name)
-{
-  switch (algorithm)
-    {
+int grpc_compression_algorithm_name(grpc_compression_algorithm algorithm,
+                                    char **name) {
+  switch (algorithm) {
     case GRPC_COMPRESS_NONE:
       *name = "identity";
       break;
@@ -83,17 +72,15 @@ grpc_compression_algorithm_name (grpc_compression_algorithm algorithm, char **na
       break;
     default:
       return 0;
-    }
+  }
   return 1;
 }
 
 /* TODO(dgq): Add the ability to specify parameters to the individual
  * compression algorithms */
-grpc_compression_algorithm
-grpc_compression_algorithm_for_level (grpc_compression_level level)
-{
-  switch (level)
-    {
+grpc_compression_algorithm grpc_compression_algorithm_for_level(
+    grpc_compression_level level) {
+  switch (level) {
     case GRPC_COMPRESS_LEVEL_NONE:
       return GRPC_COMPRESS_NONE;
     case GRPC_COMPRESS_LEVEL_LOW:
@@ -102,45 +89,39 @@ grpc_compression_algorithm_for_level (grpc_compression_level level)
       return GRPC_COMPRESS_DEFLATE;
     default:
       /* we shouldn't be making it here */
-      abort ();
-    }
+      abort();
+  }
 }
 
-grpc_compression_level
-grpc_compression_level_for_algorithm (grpc_compression_algorithm algorithm)
-{
+grpc_compression_level grpc_compression_level_for_algorithm(
+    grpc_compression_algorithm algorithm) {
   grpc_compression_level clevel;
-  for (clevel = GRPC_COMPRESS_LEVEL_NONE; clevel < GRPC_COMPRESS_LEVEL_COUNT; ++clevel)
-    {
-      if (grpc_compression_algorithm_for_level (clevel) == algorithm)
-	{
-	  return clevel;
-	}
+  for (clevel = GRPC_COMPRESS_LEVEL_NONE; clevel < GRPC_COMPRESS_LEVEL_COUNT;
+       ++clevel) {
+    if (grpc_compression_algorithm_for_level(clevel) == algorithm) {
+      return clevel;
     }
-  abort ();
+  }
+  abort();
 }
 
-void
-grpc_compression_options_init (grpc_compression_options * opts)
-{
+void grpc_compression_options_init(grpc_compression_options *opts) {
   opts->enabled_algorithms_bitset = (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
   opts->default_compression_algorithm = GRPC_COMPRESS_NONE;
 }
 
-void
-grpc_compression_options_enable_algorithm (grpc_compression_options * opts, grpc_compression_algorithm algorithm)
-{
-  GPR_BITSET (&opts->enabled_algorithms_bitset, algorithm);
+void grpc_compression_options_enable_algorithm(
+    grpc_compression_options *opts, grpc_compression_algorithm algorithm) {
+  GPR_BITSET(&opts->enabled_algorithms_bitset, algorithm);
 }
 
-void
-grpc_compression_options_disable_algorithm (grpc_compression_options * opts, grpc_compression_algorithm algorithm)
-{
-  GPR_BITCLEAR (&opts->enabled_algorithms_bitset, algorithm);
+void grpc_compression_options_disable_algorithm(
+    grpc_compression_options *opts, grpc_compression_algorithm algorithm) {
+  GPR_BITCLEAR(&opts->enabled_algorithms_bitset, algorithm);
 }
 
-int
-grpc_compression_options_is_algorithm_enabled (const grpc_compression_options * opts, grpc_compression_algorithm algorithm)
-{
-  return GPR_BITGET (opts->enabled_algorithms_bitset, algorithm);
+int grpc_compression_options_is_algorithm_enabled(
+    const grpc_compression_options *opts,
+    grpc_compression_algorithm algorithm) {
+  return GPR_BITGET(opts->enabled_algorithms_bitset, algorithm);
 }

src/core/compression/message_compress.c

@@ -42,176 +42,153 @@
 
 #define OUTPUT_BLOCK_SIZE 1024
 
-static int
-zlib_body (z_stream * zs, gpr_slice_buffer * input, gpr_slice_buffer * output, int (*flate) (z_stream * zs, int flush))
-{
+static int zlib_body(z_stream* zs, gpr_slice_buffer* input,
+                     gpr_slice_buffer* output,
+                     int (*flate)(z_stream* zs, int flush)) {
   int r;
   int flush;
   size_t i;
-  gpr_slice outbuf = gpr_slice_malloc (OUTPUT_BLOCK_SIZE);
-  const uInt uint_max = ~(uInt) 0;
+  gpr_slice outbuf = gpr_slice_malloc(OUTPUT_BLOCK_SIZE);
+  const uInt uint_max = ~(uInt)0;
 
-  GPR_ASSERT (GPR_SLICE_LENGTH (outbuf) <= uint_max);
-  zs->avail_out = (uInt) GPR_SLICE_LENGTH (outbuf);
-  zs->next_out = GPR_SLICE_START_PTR (outbuf);
+  GPR_ASSERT(GPR_SLICE_LENGTH(outbuf) <= uint_max);
+  zs->avail_out = (uInt)GPR_SLICE_LENGTH(outbuf);
+  zs->next_out = GPR_SLICE_START_PTR(outbuf);
   flush = Z_NO_FLUSH;
-  for (i = 0; i < input->count; i++)
-    {
-      if (i == input->count - 1)
-	flush = Z_FINISH;
-      GPR_ASSERT (GPR_SLICE_LENGTH (input->slices[i]) <= uint_max);
-      zs->avail_in = (uInt) GPR_SLICE_LENGTH (input->slices[i]);
-      zs->next_in = GPR_SLICE_START_PTR (input->slices[i]);
-      do
-	{
-	  if (zs->avail_out == 0)
-	    {
-	      gpr_slice_buffer_add_indexed (output, outbuf);
-	      outbuf = gpr_slice_malloc (OUTPUT_BLOCK_SIZE);
-	      GPR_ASSERT (GPR_SLICE_LENGTH (outbuf) <= uint_max);
-	      zs->avail_out = (uInt) GPR_SLICE_LENGTH (outbuf);
-	      zs->next_out = GPR_SLICE_START_PTR (outbuf);
-	    }
-	  r = flate (zs, flush);
-	  if (r == Z_STREAM_ERROR)
-	    {
-	      gpr_log (GPR_INFO, "zlib: stream error");
-	      goto error;
-	    }
-	}
-      while (zs->avail_out == 0);
-      if (zs->avail_in)
-	{
-	  gpr_log (GPR_INFO, "zlib: not all input consumed");
-	  goto error;
-	}
+  for (i = 0; i < input->count; i++) {
+    if (i == input->count - 1) flush = Z_FINISH;
+    GPR_ASSERT(GPR_SLICE_LENGTH(input->slices[i]) <= uint_max);
+    zs->avail_in = (uInt)GPR_SLICE_LENGTH(input->slices[i]);
+    zs->next_in = GPR_SLICE_START_PTR(input->slices[i]);
+    do {
+      if (zs->avail_out == 0) {
+        gpr_slice_buffer_add_indexed(output, outbuf);
+        outbuf = gpr_slice_malloc(OUTPUT_BLOCK_SIZE);
+        GPR_ASSERT(GPR_SLICE_LENGTH(outbuf) <= uint_max);
+        zs->avail_out = (uInt)GPR_SLICE_LENGTH(outbuf);
+        zs->next_out = GPR_SLICE_START_PTR(outbuf);
+      }
+      r = flate(zs, flush);
+      if (r == Z_STREAM_ERROR) {
+        gpr_log(GPR_INFO, "zlib: stream error");
+        goto error;
+      }
+    } while (zs->avail_out == 0);
+    if (zs->avail_in) {
+      gpr_log(GPR_INFO, "zlib: not all input consumed");
+      goto error;
     }
+  }
 
-  GPR_ASSERT (outbuf.refcount);
+  GPR_ASSERT(outbuf.refcount);
   outbuf.data.refcounted.length -= zs->avail_out;
-  gpr_slice_buffer_add_indexed (output, outbuf);
+  gpr_slice_buffer_add_indexed(output, outbuf);
 
   return 1;
 
 error:
-  gpr_slice_unref (outbuf);
+  gpr_slice_unref(outbuf);
   return 0;
 }
 
-static int
-zlib_compress (gpr_slice_buffer * input, gpr_slice_buffer * output, int gzip)
-{
+static int zlib_compress(gpr_slice_buffer* input, gpr_slice_buffer* output,
+                         int gzip) {
   z_stream zs;
   int r;
   size_t i;
   size_t count_before = output->count;
   size_t length_before = output->length;
-  memset (&zs, 0, sizeof (zs));
-  r = deflateInit2 (&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 | (gzip ? 16 : 0), 8, Z_DEFAULT_STRATEGY);
-  if (r != Z_OK)
-    {
-      gpr_log (GPR_ERROR, "deflateInit2 returns %d", r);
-      return 0;
-    }
-  r = zlib_body (&zs, input, output, deflate) && output->length < input->length;
-  if (!r)
-    {
-      for (i = count_before; i < output->count; i++)
-	{
-	  gpr_slice_unref (output->slices[i]);
-	}
-      output->count = count_before;
-      output->length = length_before;
+  memset(&zs, 0, sizeof(zs));
+  r = deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 | (gzip ? 16 : 0),
+                   8, Z_DEFAULT_STRATEGY);
+  if (r != Z_OK) {
+    gpr_log(GPR_ERROR, "deflateInit2 returns %d", r);
+    return 0;
+  }
+  r = zlib_body(&zs, input, output, deflate) && output->length < input->length;
+  if (!r) {
+    for (i = count_before; i < output->count; i++) {
+      gpr_slice_unref(output->slices[i]);
     }
-  deflateEnd (&zs);
+    output->count = count_before;
+    output->length = length_before;
+  }
+  deflateEnd(&zs);
   return r;
 }
 
-static int
-zlib_decompress (gpr_slice_buffer * input, gpr_slice_buffer * output, int gzip)
-{
+static int zlib_decompress(gpr_slice_buffer* input, gpr_slice_buffer* output,
+                           int gzip) {
   z_stream zs;
   int r;
   size_t i;
   size_t count_before = output->count;
   size_t length_before = output->length;
-  memset (&zs, 0, sizeof (zs));
-  r = inflateInit2 (&zs, 15 | (gzip ? 16 : 0));
-  if (r != Z_OK)
-    {
-      gpr_log (GPR_ERROR, "inflateInit2 returns %d", r);
-      return 0;
+  memset(&zs, 0, sizeof(zs));
+  r = inflateInit2(&zs, 15 | (gzip ? 16 : 0));
+  if (r != Z_OK) {
+    gpr_log(GPR_ERROR, "inflateInit2 returns %d", r);
+    return 0;
+  }
+  r = zlib_body(&zs, input, output, inflate);
+  if (!r) {
+    for (i = count_before; i < output->count; i++) {
+      gpr_slice_unref(output->slices[i]);
     }
-  r = zlib_body (&zs, input, output, inflate);
-  if (!r)
-    {
-      for (i = count_before; i < output->count; i++)
-	{
-	  gpr_slice_unref (output->slices[i]);
-	}
-      output->count = count_before;
-      output->length = length_before;
-    }
-  inflateEnd (&zs);
+    output->count = count_before;
+    output->length = length_before;
+  }
+  inflateEnd(&zs);
   return r;
 }
 
-static int
-copy (gpr_slice_buffer * input, gpr_slice_buffer * output)
-{
+static int copy(gpr_slice_buffer* input, gpr_slice_buffer* output) {
   size_t i;
-  for (i = 0; i < input->count; i++)
-    {
-      gpr_slice_buffer_add (output, gpr_slice_ref (input->slices[i]));
-    }
+  for (i = 0; i < input->count; i++) {
+    gpr_slice_buffer_add(output, gpr_slice_ref(input->slices[i]));
+  }
   return 1;
 }
 
-int
-compress_inner (grpc_compression_algorithm algorithm, gpr_slice_buffer * input, gpr_slice_buffer * output)
-{
-  switch (algorithm)
-    {
+int compress_inner(grpc_compression_algorithm algorithm,
+                   gpr_slice_buffer* input, gpr_slice_buffer* output) {
+  switch (algorithm) {
     case GRPC_COMPRESS_NONE:
       /* the fallback path always needs to be send uncompressed: we simply
          rely on that here */
       return 0;
     case GRPC_COMPRESS_DEFLATE:
-      return zlib_compress (input, output, 0);
+      return zlib_compress(input, output, 0);
     case GRPC_COMPRESS_GZIP:
-      return zlib_compress (input, output, 1);
+      return zlib_compress(input, output, 1);
     case GRPC_COMPRESS_ALGORITHMS_COUNT:
       break;
-    }
-  gpr_log (GPR_ERROR, "invalid compression algorithm %d", algorithm);
+  }
+  gpr_log(GPR_ERROR, "invalid compression algorithm %d", algorithm);
   return 0;
 }
 
-int
-grpc_msg_compress (grpc_compression_algorithm algorithm, gpr_slice_buffer * input, gpr_slice_buffer * output)
-{
-  if (!compress_inner (algorithm, input, output))
-    {
-      copy (input, output);
-      return 0;
-    }
+int grpc_msg_compress(grpc_compression_algorithm algorithm,
+                      gpr_slice_buffer* input, gpr_slice_buffer* output) {
+  if (!compress_inner(algorithm, input, output)) {
+    copy(input, output);
+    return 0;
+  }
   return 1;
 }
 
-int
-grpc_msg_decompress (grpc_compression_algorithm algorithm, gpr_slice_buffer * input, gpr_slice_buffer * output)
-{
-  switch (algorithm)
-    {
+int grpc_msg_decompress(grpc_compression_algorithm algorithm,
+                        gpr_slice_buffer* input, gpr_slice_buffer* output) {
+  switch (algorithm) {
     case GRPC_COMPRESS_NONE:
-      return copy (input, output);
+      return copy(input, output);
     case GRPC_COMPRESS_DEFLATE:
-      return zlib_decompress (input, output, 0);
+      return zlib_decompress(input, output, 0);
     case GRPC_COMPRESS_GZIP:
-      return zlib_decompress (input, output, 1);
+      return zlib_decompress(input, output, 1);
     case GRPC_COMPRESS_ALGORITHMS_COUNT:
       break;
-    }
-  gpr_log (GPR_ERROR, "invalid compression algorithm %d", algorithm);
+  }
+  gpr_log(GPR_ERROR, "invalid compression algorithm %d", algorithm);
   return 0;
 }

src/core/compression/message_compress.h

@@ -40,11 +40,13 @@
 /* compress 'input' to 'output' using 'algorithm'.
    On success, appends compressed slices to output and returns 1.
    On failure, appends uncompressed slices to output and returns 0. */
-int grpc_msg_compress (grpc_compression_algorithm algorithm, gpr_slice_buffer * input, gpr_slice_buffer * output);
+int grpc_msg_compress(grpc_compression_algorithm algorithm,
+                      gpr_slice_buffer* input, gpr_slice_buffer* output);
 
 /* decompress 'input' to 'output' using 'algorithm'.
    On success, appends slices to output and returns 1.
    On failure, output is unchanged, and returns 0. */
-int grpc_msg_decompress (grpc_compression_algorithm algorithm, gpr_slice_buffer * input, gpr_slice_buffer * output);
+int grpc_msg_decompress(grpc_compression_algorithm algorithm,
+                        gpr_slice_buffer* input, gpr_slice_buffer* output);
 
 #endif /* GRPC_INTERNAL_CORE_COMPRESSION_MESSAGE_COMPRESS_H */

src/core/debug/trace.c

@@ -40,18 +40,15 @@
 #include <grpc/support/log.h>
 #include "src/core/support/env.h"
 
-typedef struct tracer
-{
+typedef struct tracer {
   const char *name;
   int *flag;
   struct tracer *next;
 } tracer;
 static tracer *tracers;
 
-void
-grpc_register_tracer (const char *name, int *flag)
-{
-  tracer *t = gpr_malloc (sizeof (*t));
+void grpc_register_tracer(const char *name, int *flag) {
+  tracer *t = gpr_malloc(sizeof(*t));
   t->name = name;
   t->flag = flag;
   t->next = tracers;
@@ -59,107 +56,81 @@ grpc_register_tracer (const char *name, int *flag)
   tracers = t;
 }
 
-static void
-add (const char *beg, const char *end, char ***ss, size_t * ns)
-{
+static void add(const char *beg, const char *end, char ***ss, size_t *ns) {
   size_t n = *ns;
   size_t np = n + 1;
   char *s;
   size_t len;
-  GPR_ASSERT (end >= beg);
-  len = (size_t) (end - beg);
-  s = gpr_malloc (len + 1);
-  memcpy (s, beg, len);
+  GPR_ASSERT(end >= beg);
+  len = (size_t)(end - beg);
+  s = gpr_malloc(len + 1);
+  memcpy(s, beg, len);
   s[len] = 0;
-  *ss = gpr_realloc (*ss, sizeof (char **) * np);
+  *ss = gpr_realloc(*ss, sizeof(char **) * np);
   (*ss)[n] = s;
   *ns = np;
 }
 
-static void
-split (const char *s, char ***ss, size_t * ns)
-{
-  const char *c = strchr (s, ',');
-  if (c == NULL)
-    {
-      add (s, s + strlen (s), ss, ns);
-    }
-  else
-    {
-      add (s, c, ss, ns);
-      split (c + 1, ss, ns);
-    }
+static void split(const char *s, char ***ss, size_t *ns) {
+  const char *c = strchr(s, ',');
+  if (c == NULL) {
+    add(s, s + strlen(s), ss, ns);
+  } else {
+    add(s, c, ss, ns);
+    split(c + 1, ss, ns);
+  }
 }
 
-static void
-parse (const char *s)
-{
+static void parse(const char *s) {
   char **strings = NULL;
   size_t nstrings = 0;
   size_t i;
-  split (s, &strings, &nstrings);
+  split(s, &strings, &nstrings);
 
-  for (i = 0; i < nstrings; i++)
-    {
-      grpc_tracer_set_enabled (strings[i], 1);
-    }
+  for (i = 0; i < nstrings; i++) {
+    grpc_tracer_set_enabled(strings[i], 1);
+  }
 
-  for (i = 0; i < nstrings; i++)
-    {
-      gpr_free (strings[i]);
-    }
-  gpr_free (strings);
+  for (i = 0; i < nstrings; i++) {
+    gpr_free(strings[i]);
+  }
+  gpr_free(strings);
 }
 
-void
-grpc_tracer_init (const char *env_var)
-{
-  char *e = gpr_getenv (env_var);
-  if (e != NULL)
-    {
-      parse (e);
-      gpr_free (e);
-    }
+void grpc_tracer_init(const char *env_var) {
+  char *e = gpr_getenv(env_var);
+  if (e != NULL) {
+    parse(e);
+    gpr_free(e);
+  }
 }
 
-void
-grpc_tracer_shutdown (void)
-{
-  while (tracers)
-    {
-      tracer *t = tracers;
-      tracers = t->next;
-      gpr_free (t);
-    }
+void grpc_tracer_shutdown(void) {
+  while (tracers) {
+    tracer *t = tracers;
+    tracers = t->next;
+    gpr_free(t);
+  }
 }
 
-int
-grpc_tracer_set_enabled (const char *name, int enabled)
-{
+int grpc_tracer_set_enabled(const char *name, int enabled) {
   tracer *t;
-  if (0 == strcmp (name, "all"))
-    {
-      for (t = tracers; t; t = t->next)
-	{
-	  *t->flag = 1;
-	}
+  if (0 == strcmp(name, "all")) {
+    for (t = tracers; t; t = t->next) {
+      *t->flag = 1;
+    }
+  } else {
+    int found = 0;
+    for (t = tracers; t; t = t->next) {
+      if (0 == strcmp(name, t->name)) {
+        *t->flag = enabled;
+        found = 1;
+      }
     }
-  else
-    {
-      int found = 0;
-      for (t = tracers; t; t = t->next)
-	{
-	  if (0 == strcmp (name, t->name))
-	    {
-	      *t->flag = enabled;
-	      found = 1;
-	    }
-	}
-      if (!found)
-	{
-	  gpr_log (GPR_ERROR, "Unknown trace var: '%s'", name);
-	  return 0;		/* early return */
-	}
+    if (!found) {
+      gpr_log(GPR_ERROR, "Unknown trace var: '%s'", name);
+      return 0; /* early return */
     }
+  }
   return 1;
 }

src/core/debug/trace.h

@@ -36,8 +36,8 @@
 
 #include <grpc/support/port_platform.h>
 
-void grpc_register_tracer (const char *name, int *flag);
-void grpc_tracer_init (const char *env_var_name);
-void grpc_tracer_shutdown (void);
+void grpc_register_tracer(const char *name, int *flag);
+void grpc_tracer_init(const char *env_var_name);
+void grpc_tracer_shutdown(void);
 
 #endif /* GRPC_INTERNAL_CORE_DEBUG_TRACE_H */

src/core/httpcli/format_request.c

@@ -43,86 +43,78 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/useful.h>
 
-static void
-fill_common_header (const grpc_httpcli_request * request, gpr_strvec * buf)
-{
+static void fill_common_header(const grpc_httpcli_request *request,
+                               gpr_strvec *buf) {
   size_t i;
-  gpr_strvec_add (buf, gpr_strdup (request->path));
-  gpr_strvec_add (buf, gpr_strdup (" HTTP/1.0\r\n"));
+  gpr_strvec_add(buf, gpr_strdup(request->path));
+  gpr_strvec_add(buf, gpr_strdup(" HTTP/1.0\r\n"));
   /* just in case some crazy server really expects HTTP/1.1 */
-  gpr_strvec_add (buf, gpr_strdup ("Host: "));
-  gpr_strvec_add (buf, gpr_strdup (request->host));
-  gpr_strvec_add (buf, gpr_strdup ("\r\n"));
-  gpr_strvec_add (buf, gpr_strdup ("Connection: close\r\n"));
-  gpr_strvec_add (buf, gpr_strdup ("User-Agent: " GRPC_HTTPCLI_USER_AGENT "\r\n"));
+  gpr_strvec_add(buf, gpr_strdup("Host: "));
+  gpr_strvec_add(buf, gpr_strdup(request->host));
+  gpr_strvec_add(buf, gpr_strdup("\r\n"));
+  gpr_strvec_add(buf, gpr_strdup("Connection: close\r\n"));
+  gpr_strvec_add(buf,
+                 gpr_strdup("User-Agent: " GRPC_HTTPCLI_USER_AGENT "\r\n"));
   /* user supplied headers */
-  for (i = 0; i < request->hdr_count; i++)
-    {
-      gpr_strvec_add (buf, gpr_strdup (request->hdrs[i].key));
-      gpr_strvec_add (buf, gpr_strdup (": "));
-      gpr_strvec_add (buf, gpr_strdup (request->hdrs[i].value));
-      gpr_strvec_add (buf, gpr_strdup ("\r\n"));
-    }
+  for (i = 0; i < request->hdr_count; i++) {
+    gpr_strvec_add(buf, gpr_strdup(request->hdrs[i].key));
+    gpr_strvec_add(buf, gpr_strdup(": "));
+    gpr_strvec_add(buf, gpr_strdup(request->hdrs[i].value));
+    gpr_strvec_add(buf, gpr_strdup("\r\n"));
+  }
 }
 
-gpr_slice
-grpc_httpcli_format_get_request (const grpc_httpcli_request * request)
-{
+gpr_slice grpc_httpcli_format_get_request(const grpc_httpcli_request *request) {
   gpr_strvec out;
   char *flat;
   size_t flat_len;
 
-  gpr_strvec_init (&out);
-  gpr_strvec_add (&out, gpr_strdup ("GET "));
-  fill_common_header (request, &out);
-  gpr_strvec_add (&out, gpr_strdup ("\r\n"));
+  gpr_strvec_init(&out);
+  gpr_strvec_add(&out, gpr_strdup("GET "));
+  fill_common_header(request, &out);
+  gpr_strvec_add(&out, gpr_strdup("\r\n"));
 
-  flat = gpr_strvec_flatten (&out, &flat_len);
-  gpr_strvec_destroy (&out);
+  flat = gpr_strvec_flatten(&out, &flat_len);
+  gpr_strvec_destroy(&out);
 
-  return gpr_slice_new (flat, flat_len, gpr_free);
+  return gpr_slice_new(flat, flat_len, gpr_free);
 }
 
-gpr_slice
-grpc_httpcli_format_post_request (const grpc_httpcli_request * request, const char *body_bytes, size_t body_size)
-{
+gpr_slice grpc_httpcli_format_post_request(const grpc_httpcli_request *request,
+                                           const char *body_bytes,
+                                           size_t body_size) {
   gpr_strvec out;
   char *tmp;
   size_t out_len;
   size_t i;
 
-  gpr_strvec_init (&out);
+  gpr_strvec_init(&out);
 
-  gpr_strvec_add (&out, gpr_strdup ("POST "));
-  fill_common_header (request, &out);
-  if (body_bytes)
-    {
-      gpr_uint8 has_content_type = 0;
-      for (i = 0; i < request->hdr_count; i++)
-	{
-	  if (strcmp (request->hdrs[i].key, "Content-Type") == 0)
-	    {
-	      has_content_type = 1;
-	      break;
-	    }
-	}
-      if (!has_content_type)
-	{
-	  gpr_strvec_add (&out, gpr_strdup ("Content-Type: text/plain\r\n"));
-	}
-      gpr_asprintf (&tmp, "Content-Length: %lu\r\n", (unsigned long) body_size);
-      gpr_strvec_add (&out, tmp);
+  gpr_strvec_add(&out, gpr_strdup("POST "));
+  fill_common_header(request, &out);
+  if (body_bytes) {
+    gpr_uint8 has_content_type = 0;
+    for (i = 0; i < request->hdr_count; i++) {
+      if (strcmp(request->hdrs[i].key, "Content-Type") == 0) {
+        has_content_type = 1;
+        break;
+      }
     }
-  gpr_strvec_add (&out, gpr_strdup ("\r\n"));
-  tmp = gpr_strvec_flatten (&out, &out_len);
-  gpr_strvec_destroy (&out);
-
-  if (body_bytes)
-    {
-      tmp = gpr_realloc (tmp, out_len + body_size);
-      memcpy (tmp + out_len, body_bytes, body_size);
-      out_len += body_size;
+    if (!has_content_type) {
+      gpr_strvec_add(&out, gpr_strdup("Content-Type: text/plain\r\n"));
     }
+    gpr_asprintf(&tmp, "Content-Length: %lu\r\n", (unsigned long)body_size);
+    gpr_strvec_add(&out, tmp);
+  }
+  gpr_strvec_add(&out, gpr_strdup("\r\n"));
+  tmp = gpr_strvec_flatten(&out, &out_len);
+  gpr_strvec_destroy(&out);
+
+  if (body_bytes) {
+    tmp = gpr_realloc(tmp, out_len + body_size);
+    memcpy(tmp + out_len, body_bytes, body_size);
+    out_len += body_size;
+  }
 
-  return gpr_slice_new (tmp, out_len, gpr_free);
+  return gpr_slice_new(tmp, out_len, gpr_free);
 }

src/core/httpcli/format_request.h

@@ -37,7 +37,9 @@
 #include "src/core/httpcli/httpcli.h"
 #include <grpc/support/slice.h>
 
-gpr_slice grpc_httpcli_format_get_request (const grpc_httpcli_request * request);
-gpr_slice grpc_httpcli_format_post_request (const grpc_httpcli_request * request, const char *body_bytes, size_t body_size);
+gpr_slice grpc_httpcli_format_get_request(const grpc_httpcli_request *request);
+gpr_slice grpc_httpcli_format_post_request(const grpc_httpcli_request *request,
+                                           const char *body_bytes,
+                                           size_t body_size);
 
 #endif /* GRPC_INTERNAL_CORE_HTTPCLI_FORMAT_REQUEST_H */

src/core/httpcli/httpcli.c

@@ -46,8 +46,7 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-typedef struct
-{
+typedef struct {
   gpr_slice request_text;
   grpc_httpcli_parser parser;
   grpc_resolved_addresses *addresses;
@@ -72,230 +71,211 @@ typedef struct
 static grpc_httpcli_get_override g_get_override = NULL;
 static grpc_httpcli_post_override g_post_override = NULL;
 
-static void
-plaintext_handshake (grpc_exec_ctx * exec_ctx, void *arg, grpc_endpoint * endpoint, const char *host, void (*on_done) (grpc_exec_ctx * exec_ctx, void *arg, grpc_endpoint * endpoint))
-{
-  on_done (exec_ctx, arg, endpoint);
+static void plaintext_handshake(grpc_exec_ctx *exec_ctx, void *arg,
+                                grpc_endpoint *endpoint, const char *host,
+                                void (*on_done)(grpc_exec_ctx *exec_ctx,
+                                                void *arg,
+                                                grpc_endpoint *endpoint)) {
+  on_done(exec_ctx, arg, endpoint);
 }
 
-const grpc_httpcli_handshaker grpc_httpcli_plaintext = { "http",
-  plaintext_handshake
-};
+const grpc_httpcli_handshaker grpc_httpcli_plaintext = {"http",
+                                                        plaintext_handshake};
 
-void
-grpc_httpcli_context_init (grpc_httpcli_context * context)
-{
-  grpc_pollset_set_init (&context->pollset_set);
+void grpc_httpcli_context_init(grpc_httpcli_context *context) {
+  grpc_pollset_set_init(&context->pollset_set);
 }
 
-void
-grpc_httpcli_context_destroy (grpc_httpcli_context * context)
-{
-  grpc_pollset_set_destroy (&context->pollset_set);
+void grpc_httpcli_context_destroy(grpc_httpcli_context *context) {
+  grpc_pollset_set_destroy(&context->pollset_set);
 }
 
-static void next_address (grpc_exec_ctx * exec_ctx, internal_request * req);
+static void next_address(grpc_exec_ctx *exec_ctx, internal_request *req);
 
-static void
-finish (grpc_exec_ctx * exec_ctx, internal_request * req, int success)
-{
-  grpc_pollset_set_del_pollset (exec_ctx, &req->context->pollset_set, req->pollset);
-  req->on_response (exec_ctx, req->user_data, success ? &req->parser.r : NULL);
-  grpc_httpcli_parser_destroy (&req->parser);
-  if (req->addresses != NULL)
-    {
-      grpc_resolved_addresses_destroy (req->addresses);
-    }
-  if (req->ep != NULL)
-    {
-      grpc_endpoint_destroy (exec_ctx, req->ep);
-    }
-  gpr_slice_unref (req->request_text);
-  gpr_free (req->host);
-  grpc_iomgr_unregister_object (&req->iomgr_obj);
-  gpr_slice_buffer_destroy (&req->incoming);
-  gpr_slice_buffer_destroy (&req->outgoing);
-  gpr_free (req);
+static void finish(grpc_exec_ctx *exec_ctx, internal_request *req,
+                   int success) {
+  grpc_pollset_set_del_pollset(exec_ctx, &req->context->pollset_set,
+                               req->pollset);
+  req->on_response(exec_ctx, req->user_data, success ? &req->parser.r : NULL);
+  grpc_httpcli_parser_destroy(&req->parser);
+  if (req->addresses != NULL) {
+    grpc_resolved_addresses_destroy(req->addresses);
+  }
+  if (req->ep != NULL) {
+    grpc_endpoint_destroy(exec_ctx, req->ep);
+  }
+  gpr_slice_unref(req->request_text);
+  gpr_free(req->host);
+  grpc_iomgr_unregister_object(&req->iomgr_obj);
+  gpr_slice_buffer_destroy(&req->incoming);
+  gpr_slice_buffer_destroy(&req->outgoing);
+  gpr_free(req);
 }
 
-static void on_read (grpc_exec_ctx * exec_ctx, void *user_data, int success);
+static void on_read(grpc_exec_ctx *exec_ctx, void *user_data, int success);
 
-static void
-do_read (grpc_exec_ctx * exec_ctx, internal_request * req)
-{
-  grpc_endpoint_read (exec_ctx, req->ep, &req->incoming, &req->on_read);
+static void do_read(grpc_exec_ctx *exec_ctx, internal_request *req) {
+  grpc_endpoint_read(exec_ctx, req->ep, &req->incoming, &req->on_read);
 }
 
-static void
-on_read (grpc_exec_ctx * exec_ctx, void *user_data, int success)
-{
+static void on_read(grpc_exec_ctx *exec_ctx, void *user_data, int success) {
   internal_request *req = user_data;
   size_t i;
 
-  for (i = 0; i < req->incoming.count; i++)
-    {
-      if (GPR_SLICE_LENGTH (req->incoming.slices[i]))
-	{
-	  req->have_read_byte = 1;
-	  if (!grpc_httpcli_parser_parse (&req->parser, req->incoming.slices[i]))
-	    {
-	      finish (exec_ctx, req, 0);
-	      return;
-	    }
-	}
+  for (i = 0; i < req->incoming.count; i++) {
+    if (GPR_SLICE_LENGTH(req->incoming.slices[i])) {
+      req->have_read_byte = 1;
+      if (!grpc_httpcli_parser_parse(&req->parser, req->incoming.slices[i])) {
+        finish(exec_ctx, req, 0);
+        return;
+      }
     }
+  }
 
-  if (success)
-    {
-      do_read (exec_ctx, req);
-    }
-  else if (!req->have_read_byte)
-    {
-      next_address (exec_ctx, req);
-    }
-  else
-    {
-      finish (exec_ctx, req, grpc_httpcli_parser_eof (&req->parser));
-    }
+  if (success) {
+    do_read(exec_ctx, req);
+  } else if (!req->have_read_byte) {
+    next_address(exec_ctx, req);
+  } else {
+    finish(exec_ctx, req, grpc_httpcli_parser_eof(&req->parser));
+  }
 }
 
-static void
-on_written (grpc_exec_ctx * exec_ctx, internal_request * req)
-{
-  do_read (exec_ctx, req);
+static void on_written(grpc_exec_ctx *exec_ctx, internal_request *req) {
+  do_read(exec_ctx, req);
 }
 
-static void
-done_write (grpc_exec_ctx * exec_ctx, void *arg, int success)
-{
+static void done_write(grpc_exec_ctx *exec_ctx, void *arg, int success) {
   internal_request *req = arg;
-  if (success)
-    {
-      on_written (exec_ctx, req);
-    }
-  else
-    {
-      next_address (exec_ctx, req);
-    }
+  if (success) {
+    on_written(exec_ctx, req);
+  } else {
+    next_address(exec_ctx, req);
+  }
 }
 
-static void
-start_write (grpc_exec_ctx * exec_ctx, internal_request * req)
-{
-  gpr_slice_ref (req->request_text);
-  gpr_slice_buffer_add (&req->outgoing, req->request_text);
-  grpc_endpoint_write (exec_ctx, req->ep, &req->outgoing, &req->done_write);
+static void start_write(grpc_exec_ctx *exec_ctx, internal_request *req) {
+  gpr_slice_ref(req->request_text);
+  gpr_slice_buffer_add(&req->outgoing, req->request_text);
+  grpc_endpoint_write(exec_ctx, req->ep, &req->outgoing, &req->done_write);
 }
 
-static void
-on_handshake_done (grpc_exec_ctx * exec_ctx, void *arg, grpc_endpoint * ep)
-{
+static void on_handshake_done(grpc_exec_ctx *exec_ctx, void *arg,
+                              grpc_endpoint *ep) {
   internal_request *req = arg;
 
-  if (!ep)
-    {
-      next_address (exec_ctx, req);
-      return;
-    }
+  if (!ep) {
+    next_address(exec_ctx, req);
+    return;
+  }
 
   req->ep = ep;
-  start_write (exec_ctx, req);
+  start_write(exec_ctx, req);
 }
 
-static void
-on_connected (grpc_exec_ctx * exec_ctx, void *arg, int success)
-{
+static void on_connected(grpc_exec_ctx *exec_ctx, void *arg, int success) {
   internal_request *req = arg;
 
-  if (!req->ep)
-    {
-      next_address (exec_ctx, req);
-      return;
-    }
-  req->handshaker->handshake (exec_ctx, req, req->ep, req->host, on_handshake_done);
+  if (!req->ep) {
+    next_address(exec_ctx, req);
+    return;
+  }
+  req->handshaker->handshake(exec_ctx, req, req->ep, req->host,
+                             on_handshake_done);
 }
 
-static void
-next_address (grpc_exec_ctx * exec_ctx, internal_request * req)
-{
+static void next_address(grpc_exec_ctx *exec_ctx, internal_request *req) {
   grpc_resolved_address *addr;
-  if (req->next_address == req->addresses->naddrs)
-    {
-      finish (exec_ctx, req, 0);
-      return;
-    }
+  if (req->next_address == req->addresses->naddrs) {
+    finish(exec_ctx, req, 0);
+    return;
+  }
   addr = &req->addresses->addrs[req->next_address++];
-  grpc_closure_init (&req->connected, on_connected, req);
-  grpc_tcp_client_connect (exec_ctx, &req->connected, &req->ep, &req->context->pollset_set, (struct sockaddr *) &addr->addr, addr->len, req->deadline);
+  grpc_closure_init(&req->connected, on_connected, req);
+  grpc_tcp_client_connect(
+      exec_ctx, &req->connected, &req->ep, &req->context->pollset_set,
+      (struct sockaddr *)&addr->addr, addr->len, req->deadline);
 }
 
-static void
-on_resolved (grpc_exec_ctx * exec_ctx, void *arg, grpc_resolved_addresses * addresses)
-{
+static void on_resolved(grpc_exec_ctx *exec_ctx, void *arg,
+                        grpc_resolved_addresses *addresses) {
   internal_request *req = arg;
-  if (!addresses)
-    {
-      finish (exec_ctx, req, 0);
-      return;
-    }
+  if (!addresses) {
+    finish(exec_ctx, req, 0);
+    return;
+  }
   req->addresses = addresses;
   req->next_address = 0;
-  next_address (exec_ctx, req);
+  next_address(exec_ctx, req);
 }
 
-static void
-internal_request_begin (grpc_exec_ctx * exec_ctx, grpc_httpcli_context * context, grpc_pollset * pollset, const grpc_httpcli_request * request, gpr_timespec deadline, grpc_httpcli_response_cb on_response, void *user_data, const char *name, gpr_slice request_text)
-{
-  internal_request *req = gpr_malloc (sizeof (internal_request));
-  memset (req, 0, sizeof (*req));
+static void internal_request_begin(
+    grpc_exec_ctx *exec_ctx, grpc_httpcli_context *context,
+    grpc_pollset *pollset, const grpc_httpcli_request *request,
+    gpr_timespec deadline, grpc_httpcli_response_cb on_response,
+    void *user_data, const char *name, gpr_slice request_text) {
+  internal_request *req = gpr_malloc(sizeof(internal_request));
+  memset(req, 0, sizeof(*req));
   req->request_text = request_text;
-  grpc_httpcli_parser_init (&req->parser);
+  grpc_httpcli_parser_init(&req->parser);
   req->on_response = on_response;
   req->user_data = user_data;
   req->deadline = deadline;
-  req->handshaker = request->handshaker ? request->handshaker : &grpc_httpcli_plaintext;
+  req->handshaker =
+      request->handshaker ? request->handshaker : &grpc_httpcli_plaintext;
   req->context = context;
   req->pollset = pollset;
-  grpc_closure_init (&req->on_read, on_read, req);
-  grpc_closure_init (&req->done_write, done_write, req);
-  gpr_slice_buffer_init (&req->incoming);
-  gpr_slice_buffer_init (&req->outgoing);
-  grpc_iomgr_register_object (&req->iomgr_obj, name);
-  req->host = gpr_strdup (request->host);
+  grpc_closure_init(&req->on_read, on_read, req);
+  grpc_closure_init(&req->done_write, done_write, req);
+  gpr_slice_buffer_init(&req->incoming);
+  gpr_slice_buffer_init(&req->outgoing);
+  grpc_iomgr_register_object(&req->iomgr_obj, name);
+  req->host = gpr_strdup(request->host);
 
-  grpc_pollset_set_add_pollset (exec_ctx, &req->context->pollset_set, req->pollset);
-  grpc_resolve_address (request->host, req->handshaker->default_port, on_resolved, req);
+  grpc_pollset_set_add_pollset(exec_ctx, &req->context->pollset_set,
+                               req->pollset);
+  grpc_resolve_address(request->host, req->handshaker->default_port,
+                       on_resolved, req);
 }
 
-void
-grpc_httpcli_get (grpc_exec_ctx * exec_ctx, grpc_httpcli_context * context, grpc_pollset * pollset, const grpc_httpcli_request * request, gpr_timespec deadline, grpc_httpcli_response_cb on_response, void *user_data)
-{
+void grpc_httpcli_get(grpc_exec_ctx *exec_ctx, grpc_httpcli_context *context,
+                      grpc_pollset *pollset,
+                      const grpc_httpcli_request *request,
+                      gpr_timespec deadline,
+                      grpc_httpcli_response_cb on_response, void *user_data) {
   char *name;
-  if (g_get_override && g_get_override (exec_ctx, request, deadline, on_response, user_data))
-    {
-      return;
-    }
-  gpr_asprintf (&name, "HTTP:GET:%s:%s", request->host, request->path);
-  internal_request_begin (exec_ctx, context, pollset, request, deadline, on_response, user_data, name, grpc_httpcli_format_get_request (request));
-  gpr_free (name);
+  if (g_get_override &&
+      g_get_override(exec_ctx, request, deadline, on_response, user_data)) {
+    return;
+  }
+  gpr_asprintf(&name, "HTTP:GET:%s:%s", request->host, request->path);
+  internal_request_begin(exec_ctx, context, pollset, request, deadline,
+                         on_response, user_data, name,
+                         grpc_httpcli_format_get_request(request));
+  gpr_free(name);
 }
 
-void
-grpc_httpcli_post (grpc_exec_ctx * exec_ctx, grpc_httpcli_context * context, grpc_pollset * pollset, const grpc_httpcli_request * request, const char *body_bytes, size_t body_size, gpr_timespec deadline, grpc_httpcli_response_cb on_response, void *user_data)
-{
+void grpc_httpcli_post(grpc_exec_ctx *exec_ctx, grpc_httpcli_context *context,
+                       grpc_pollset *pollset,
+                       const grpc_httpcli_request *request,
+                       const char *body_bytes, size_t body_size,
+                       gpr_timespec deadline,
+                       grpc_httpcli_response_cb on_response, void *user_data) {
   char *name;
-  if (g_post_override && g_post_override (exec_ctx, request, body_bytes, body_size, deadline, on_response, user_data))
-    {
-      return;
-    }
-  gpr_asprintf (&name, "HTTP:POST:%s:%s", request->host, request->path);
-  internal_request_begin (exec_ctx, context, pollset, request, deadline, on_response, user_data, name, grpc_httpcli_format_post_request (request, body_bytes, body_size));
-  gpr_free (name);
+  if (g_post_override &&
+      g_post_override(exec_ctx, request, body_bytes, body_size, deadline,
+                      on_response, user_data)) {
+    return;
+  }
+  gpr_asprintf(&name, "HTTP:POST:%s:%s", request->host, request->path);
+  internal_request_begin(
+      exec_ctx, context, pollset, request, deadline, on_response, user_data,
+      name, grpc_httpcli_format_post_request(request, body_bytes, body_size));
+  gpr_free(name);
 }
 
-void
-grpc_httpcli_set_override (grpc_httpcli_get_override get, grpc_httpcli_post_override post)
-{
+void grpc_httpcli_set_override(grpc_httpcli_get_override get,
+                               grpc_httpcli_post_override post) {
   g_get_override = get;
   g_post_override = post;
 }

src/core/httpcli/httpcli.h

@@ -47,8 +47,7 @@
 #define GRPC_HTTPCLI_MAX_HEADER_LENGTH 4096
 
 /* A single header to be passed in a request */
-typedef struct grpc_httpcli_header
-{
+typedef struct grpc_httpcli_header {
   char *key;
   char *value;
 } grpc_httpcli_header;
@@ -56,23 +55,23 @@ typedef struct grpc_httpcli_header
 /* Tracks in-progress http requests
    TODO(ctiller): allow caching and capturing multiple requests for the
                   same content and combining them */
-typedef struct grpc_httpcli_context
-{
+typedef struct grpc_httpcli_context {
   grpc_pollset_set pollset_set;
 } grpc_httpcli_context;
 
-typedef struct
-{
+typedef struct {
   const char *default_port;
-  void (*handshake) (grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint * endpoint, const char *host, void (*on_done) (grpc_exec_ctx * exec_ctx, void *arg, grpc_endpoint * endpoint));
+  void (*handshake)(grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint *endpoint,
+                    const char *host,
+                    void (*on_done)(grpc_exec_ctx *exec_ctx, void *arg,
+                                    grpc_endpoint *endpoint));
 } grpc_httpcli_handshaker;
 
 extern const grpc_httpcli_handshaker grpc_httpcli_plaintext;
 extern const grpc_httpcli_handshaker grpc_httpcli_ssl;
 
 /* A request */
-typedef struct grpc_httpcli_request
-{
+typedef struct grpc_httpcli_request {
   /* The host name to connect to */
   char *host;
   /* The path of the resource to fetch */
@@ -87,8 +86,7 @@ typedef struct grpc_httpcli_request
 } grpc_httpcli_request;
 
 /* A response */
-typedef struct grpc_httpcli_response
-{
+typedef struct grpc_httpcli_response {
   /* HTTP status code */
   int status;
   /* Headers: count and key/values */
@@ -100,10 +98,12 @@ typedef struct grpc_httpcli_response
 } grpc_httpcli_response;
 
 /* Callback for grpc_httpcli_get and grpc_httpcli_post. */
-typedef void (*grpc_httpcli_response_cb) (grpc_exec_ctx * exec_ctx, void *user_data, const grpc_httpcli_response * response);
+typedef void (*grpc_httpcli_response_cb)(grpc_exec_ctx *exec_ctx,
+                                         void *user_data,
+                                         const grpc_httpcli_response *response);
 
-void grpc_httpcli_context_init (grpc_httpcli_context * context);
-void grpc_httpcli_context_destroy (grpc_httpcli_context * context);
+void grpc_httpcli_context_init(grpc_httpcli_context *context);
+void grpc_httpcli_context_destroy(grpc_httpcli_context *context);
 
 /* Asynchronously perform a HTTP GET.
    'context' specifies the http context under which to do the get
@@ -115,7 +115,11 @@ void grpc_httpcli_context_destroy (grpc_httpcli_context * context);
    'deadline' contains a deadline for the request (or gpr_inf_future)
    'on_response' is a callback to report results to (and 'user_data' is a user
      supplied pointer to pass to said call) */
-void grpc_httpcli_get (grpc_exec_ctx * exec_ctx, grpc_httpcli_context * context, grpc_pollset * pollset, const grpc_httpcli_request * request, gpr_timespec deadline, grpc_httpcli_response_cb on_response, void *user_data);
+void grpc_httpcli_get(grpc_exec_ctx *exec_ctx, grpc_httpcli_context *context,
+                      grpc_pollset *pollset,
+                      const grpc_httpcli_request *request,
+                      gpr_timespec deadline,
+                      grpc_httpcli_response_cb on_response, void *user_data);
 
 /* Asynchronously perform a HTTP POST.
    'context' specifies the http context under which to do the post
@@ -132,12 +136,25 @@ void grpc_httpcli_get (grpc_exec_ctx * exec_ctx, grpc_httpcli_context * context,
    'on_response' is a callback to report results to (and 'user_data' is a user
      supplied pointer to pass to said call)
    Does not support ?var1=val1&var2=val2 in the path. */
-void grpc_httpcli_post (grpc_exec_ctx * exec_ctx, grpc_httpcli_context * context, grpc_pollset * pollset, const grpc_httpcli_request * request, const char *body_bytes, size_t body_size, gpr_timespec deadline, grpc_httpcli_response_cb on_response, void *user_data);
+void grpc_httpcli_post(grpc_exec_ctx *exec_ctx, grpc_httpcli_context *context,
+                       grpc_pollset *pollset,
+                       const grpc_httpcli_request *request,
+                       const char *body_bytes, size_t body_size,
+                       gpr_timespec deadline,
+                       grpc_httpcli_response_cb on_response, void *user_data);
 
 /* override functions return 1 if they handled the request, 0 otherwise */
-typedef int (*grpc_httpcli_get_override) (grpc_exec_ctx * exec_ctx, const grpc_httpcli_request * request, gpr_timespec deadline, grpc_httpcli_response_cb on_response, void *user_data);
-typedef int (*grpc_httpcli_post_override) (grpc_exec_ctx * exec_ctx, const grpc_httpcli_request * request, const char *body_bytes, size_t body_size, gpr_timespec deadline, grpc_httpcli_response_cb on_response, void *user_data);
-
-void grpc_httpcli_set_override (grpc_httpcli_get_override get, grpc_httpcli_post_override post);
+typedef int (*grpc_httpcli_get_override)(grpc_exec_ctx *exec_ctx,
+                                         const grpc_httpcli_request *request,
+                                         gpr_timespec deadline,
+                                         grpc_httpcli_response_cb on_response,
+                                         void *user_data);
+typedef int (*grpc_httpcli_post_override)(
+    grpc_exec_ctx *exec_ctx, const grpc_httpcli_request *request,
+    const char *body_bytes, size_t body_size, gpr_timespec deadline,
+    grpc_httpcli_response_cb on_response, void *user_data);
+
+void grpc_httpcli_set_override(grpc_httpcli_get_override get,
+                               grpc_httpcli_post_override post);
 
 #endif /* GRPC_INTERNAL_CORE_HTTPCLI_HTTPCLI_H */

src/core/httpcli/httpcli_security_connector.c

@@ -42,146 +42,147 @@
 #include <grpc/support/string_util.h>
 #include "src/core/tsi/ssl_transport_security.h"
 
-typedef struct
-{
+typedef struct {
   grpc_channel_security_connector base;
   tsi_ssl_handshaker_factory *handshaker_factory;
   char *secure_peer_name;
 } grpc_httpcli_ssl_channel_security_connector;
 
-static void
-httpcli_ssl_destroy (grpc_security_connector * sc)
-{
-  grpc_httpcli_ssl_channel_security_connector *c = (grpc_httpcli_ssl_channel_security_connector *) sc;
-  if (c->handshaker_factory != NULL)
-    {
-      tsi_ssl_handshaker_factory_destroy (c->handshaker_factory);
-    }
-  if (c->secure_peer_name != NULL)
-    gpr_free (c->secure_peer_name);
-  gpr_free (sc);
+static void httpcli_ssl_destroy(grpc_security_connector *sc) {
+  grpc_httpcli_ssl_channel_security_connector *c =
+      (grpc_httpcli_ssl_channel_security_connector *)sc;
+  if (c->handshaker_factory != NULL) {
+    tsi_ssl_handshaker_factory_destroy(c->handshaker_factory);
+  }
+  if (c->secure_peer_name != NULL) gpr_free(c->secure_peer_name);
+  gpr_free(sc);
 }
 
-static void
-httpcli_ssl_do_handshake (grpc_exec_ctx * exec_ctx, grpc_security_connector * sc, grpc_endpoint * nonsecure_endpoint, grpc_security_handshake_done_cb cb, void *user_data)
-{
-  grpc_httpcli_ssl_channel_security_connector *c = (grpc_httpcli_ssl_channel_security_connector *) sc;
+static void httpcli_ssl_do_handshake(grpc_exec_ctx *exec_ctx,
+                                     grpc_security_connector *sc,
+                                     grpc_endpoint *nonsecure_endpoint,
+                                     grpc_security_handshake_done_cb cb,
+                                     void *user_data) {
+  grpc_httpcli_ssl_channel_security_connector *c =
+      (grpc_httpcli_ssl_channel_security_connector *)sc;
   tsi_result result = TSI_OK;
   tsi_handshaker *handshaker;
-  if (c->handshaker_factory == NULL)
-    {
-      cb (exec_ctx, user_data, GRPC_SECURITY_ERROR, nonsecure_endpoint, NULL);
-      return;
-    }
-  result = tsi_ssl_handshaker_factory_create_handshaker (c->handshaker_factory, c->secure_peer_name, &handshaker);
-  if (result != TSI_OK)
-    {
-      gpr_log (GPR_ERROR, "Handshaker creation failed with error %s.", tsi_result_to_string (result));
-      cb (exec_ctx, user_data, GRPC_SECURITY_ERROR, nonsecure_endpoint, NULL);
-    }
-  else
-    {
-      grpc_do_security_handshake (exec_ctx, handshaker, sc, nonsecure_endpoint, cb, user_data);
-    }
+  if (c->handshaker_factory == NULL) {
+    cb(exec_ctx, user_data, GRPC_SECURITY_ERROR, nonsecure_endpoint, NULL);
+    return;
+  }
+  result = tsi_ssl_handshaker_factory_create_handshaker(
+      c->handshaker_factory, c->secure_peer_name, &handshaker);
+  if (result != TSI_OK) {
+    gpr_log(GPR_ERROR, "Handshaker creation failed with error %s.",
+            tsi_result_to_string(result));
+    cb(exec_ctx, user_data, GRPC_SECURITY_ERROR, nonsecure_endpoint, NULL);
+  } else {
+    grpc_do_security_handshake(exec_ctx, handshaker, sc, nonsecure_endpoint, cb,
+                               user_data);
+  }
 }
 
-static grpc_security_status
-httpcli_ssl_check_peer (grpc_security_connector * sc, tsi_peer peer, grpc_security_check_cb cb, void *user_data)
-{
-  grpc_httpcli_ssl_channel_security_connector *c = (grpc_httpcli_ssl_channel_security_connector *) sc;
+static grpc_security_status httpcli_ssl_check_peer(grpc_security_connector *sc,
+                                                   tsi_peer peer,
+                                                   grpc_security_check_cb cb,
+                                                   void *user_data) {
+  grpc_httpcli_ssl_channel_security_connector *c =
+      (grpc_httpcli_ssl_channel_security_connector *)sc;
   grpc_security_status status = GRPC_SECURITY_OK;
 
   /* Check the peer name. */
-  if (c->secure_peer_name != NULL && !tsi_ssl_peer_matches_name (&peer, c->secure_peer_name))
-    {
-      gpr_log (GPR_ERROR, "Peer name %s is not in peer certificate", c->secure_peer_name);
-      status = GRPC_SECURITY_ERROR;
-    }
-  tsi_peer_destruct (&peer);
+  if (c->secure_peer_name != NULL &&
+      !tsi_ssl_peer_matches_name(&peer, c->secure_peer_name)) {
+    gpr_log(GPR_ERROR, "Peer name %s is not in peer certificate",
+            c->secure_peer_name);
+    status = GRPC_SECURITY_ERROR;
+  }
+  tsi_peer_destruct(&peer);
   return status;
 }
 
 static grpc_security_connector_vtable httpcli_ssl_vtable = {
-  httpcli_ssl_destroy, httpcli_ssl_do_handshake, httpcli_ssl_check_peer
-};
+    httpcli_ssl_destroy, httpcli_ssl_do_handshake, httpcli_ssl_check_peer};
 
-static grpc_security_status
-httpcli_ssl_channel_security_connector_create (const unsigned char *pem_root_certs, size_t pem_root_certs_size, const char *secure_peer_name, grpc_channel_security_connector ** sc)
-{
+static grpc_security_status httpcli_ssl_channel_security_connector_create(
+    const unsigned char *pem_root_certs, size_t pem_root_certs_size,
+    const char *secure_peer_name, grpc_channel_security_connector **sc) {
   tsi_result result = TSI_OK;
   grpc_httpcli_ssl_channel_security_connector *c;
 
-  if (secure_peer_name != NULL && pem_root_certs == NULL)
-    {
-      gpr_log (GPR_ERROR, "Cannot assert a secure peer name without a trust root.");
-      return GRPC_SECURITY_ERROR;
-    }
+  if (secure_peer_name != NULL && pem_root_certs == NULL) {
+    gpr_log(GPR_ERROR,
+            "Cannot assert a secure peer name without a trust root.");
+    return GRPC_SECURITY_ERROR;
+  }
 
-  c = gpr_malloc (sizeof (grpc_httpcli_ssl_channel_security_connector));
-  memset (c, 0, sizeof (grpc_httpcli_ssl_channel_security_connector));
+  c = gpr_malloc(sizeof(grpc_httpcli_ssl_channel_security_connector));
+  memset(c, 0, sizeof(grpc_httpcli_ssl_channel_security_connector));
 
-  gpr_ref_init (&c->base.base.refcount, 1);
+  gpr_ref_init(&c->base.base.refcount, 1);
   c->base.base.is_client_side = 1;
   c->base.base.vtable = &httpcli_ssl_vtable;
-  if (secure_peer_name != NULL)
-    {
-      c->secure_peer_name = gpr_strdup (secure_peer_name);
-    }
-  result = tsi_create_ssl_client_handshaker_factory (NULL, 0, NULL, 0, pem_root_certs, pem_root_certs_size, NULL, NULL, NULL, 0, &c->handshaker_factory);
-  if (result != TSI_OK)
-    {
-      gpr_log (GPR_ERROR, "Handshaker factory creation failed with %s.", tsi_result_to_string (result));
-      httpcli_ssl_destroy (&c->base.base);
-      *sc = NULL;
-      return GRPC_SECURITY_ERROR;
-    }
+  if (secure_peer_name != NULL) {
+    c->secure_peer_name = gpr_strdup(secure_peer_name);
+  }
+  result = tsi_create_ssl_client_handshaker_factory(
+      NULL, 0, NULL, 0, pem_root_certs, pem_root_certs_size, NULL, NULL, NULL,
+      0, &c->handshaker_factory);
+  if (result != TSI_OK) {
+    gpr_log(GPR_ERROR, "Handshaker factory creation failed with %s.",
+            tsi_result_to_string(result));
+    httpcli_ssl_destroy(&c->base.base);
+    *sc = NULL;
+    return GRPC_SECURITY_ERROR;
+  }
   *sc = &c->base;
   return GRPC_SECURITY_OK;
 }
 
 /* handshaker */
 
-typedef struct
-{
-  void (*func) (grpc_exec_ctx * exec_ctx, void *arg, grpc_endpoint * endpoint);
+typedef struct {
+  void (*func)(grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint *endpoint);
   void *arg;
 } on_done_closure;
 
-static void
-on_secure_transport_setup_done (grpc_exec_ctx * exec_ctx, void *rp, grpc_security_status status, grpc_endpoint * wrapped_endpoint, grpc_endpoint * secure_endpoint)
-{
+static void on_secure_transport_setup_done(grpc_exec_ctx *exec_ctx, void *rp,
+                                           grpc_security_status status,
+                                           grpc_endpoint *wrapped_endpoint,
+                                           grpc_endpoint *secure_endpoint) {
   on_done_closure *c = rp;
-  if (status != GRPC_SECURITY_OK)
-    {
-      gpr_log (GPR_ERROR, "Secure transport setup failed with error %d.", status);
-      c->func (exec_ctx, c->arg, NULL);
-    }
-  else
-    {
-      c->func (exec_ctx, c->arg, secure_endpoint);
-    }
-  gpr_free (c);
+  if (status != GRPC_SECURITY_OK) {
+    gpr_log(GPR_ERROR, "Secure transport setup failed with error %d.", status);
+    c->func(exec_ctx, c->arg, NULL);
+  } else {
+    c->func(exec_ctx, c->arg, secure_endpoint);
+  }
+  gpr_free(c);
 }
 
-static void
-ssl_handshake (grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint * tcp, const char *host, void (*on_done) (grpc_exec_ctx * exec_ctx, void *arg, grpc_endpoint * endpoint))
-{
+static void ssl_handshake(grpc_exec_ctx *exec_ctx, void *arg,
+                          grpc_endpoint *tcp, const char *host,
+                          void (*on_done)(grpc_exec_ctx *exec_ctx, void *arg,
+                                          grpc_endpoint *endpoint)) {
   grpc_channel_security_connector *sc = NULL;
   const unsigned char *pem_root_certs = NULL;
-  on_done_closure *c = gpr_malloc (sizeof (*c));
-  size_t pem_root_certs_size = grpc_get_default_ssl_roots (&pem_root_certs);
-  if (pem_root_certs == NULL || pem_root_certs_size == 0)
-    {
-      gpr_log (GPR_ERROR, "Could not get default pem root certs.");
-      on_done (exec_ctx, arg, NULL);
-      gpr_free (c);
-      return;
-    }
+  on_done_closure *c = gpr_malloc(sizeof(*c));
+  size_t pem_root_certs_size = grpc_get_default_ssl_roots(&pem_root_certs);
+  if (pem_root_certs == NULL || pem_root_certs_size == 0) {
+    gpr_log(GPR_ERROR, "Could not get default pem root certs.");
+    on_done(exec_ctx, arg, NULL);
+    gpr_free(c);
+    return;
+  }
   c->func = on_done;
   c->arg = arg;
-  GPR_ASSERT (httpcli_ssl_channel_security_connector_create (pem_root_certs, pem_root_certs_size, host, &sc) == GRPC_SECURITY_OK);
-  grpc_security_connector_do_handshake (exec_ctx, &sc->base, tcp, on_secure_transport_setup_done, c);
-  GRPC_SECURITY_CONNECTOR_UNREF (&sc->base, "httpcli");
+  GPR_ASSERT(httpcli_ssl_channel_security_connector_create(
+                 pem_root_certs, pem_root_certs_size, host, &sc) ==
+             GRPC_SECURITY_OK);
+  grpc_security_connector_do_handshake(exec_ctx, &sc->base, tcp,
+                                       on_secure_transport_setup_done, c);
+  GRPC_SECURITY_CONNECTOR_UNREF(&sc->base, "httpcli");
 }
 
-const grpc_httpcli_handshaker grpc_httpcli_ssl = { "https", ssl_handshake };
+const grpc_httpcli_handshaker grpc_httpcli_ssl = {"https", ssl_handshake};

src/core/httpcli/parser.c

@@ -39,220 +39,178 @@
 #include <grpc/support/log.h>
 #include <grpc/support/useful.h>
 
-static int
-handle_response_line (grpc_httpcli_parser * parser)
-{
+static int handle_response_line(grpc_httpcli_parser *parser) {
   gpr_uint8 *beg = parser->cur_line;
   gpr_uint8 *cur = beg;
   gpr_uint8 *end = beg + parser->cur_line_length;
 
-  if (cur == end || *cur++ != 'H')
-    goto error;
-  if (cur == end || *cur++ != 'T')
-    goto error;
-  if (cur == end || *cur++ != 'T')
-    goto error;
-  if (cur == end || *cur++ != 'P')
-    goto error;
-  if (cur == end || *cur++ != '/')
-    goto error;
-  if (cur == end || *cur++ != '1')
-    goto error;
-  if (cur == end || *cur++ != '.')
-    goto error;
-  if (cur == end || *cur < '0' || *cur++ > '1')
-    goto error;
-  if (cur == end || *cur++ != ' ')
-    goto error;
-  if (cur == end || *cur < '1' || *cur++ > '9')
-    goto error;
-  if (cur == end || *cur < '0' || *cur++ > '9')
-    goto error;
-  if (cur == end || *cur < '0' || *cur++ > '9')
-    goto error;
-  parser->r.status = (cur[-3] - '0') * 100 + (cur[-2] - '0') * 10 + (cur[-1] - '0');
-  if (cur == end || *cur++ != ' ')
-    goto error;
+  if (cur == end || *cur++ != 'H') goto error;
+  if (cur == end || *cur++ != 'T') goto error;
+  if (cur == end || *cur++ != 'T') goto error;
+  if (cur == end || *cur++ != 'P') goto error;
+  if (cur == end || *cur++ != '/') goto error;
+  if (cur == end || *cur++ != '1') goto error;
+  if (cur == end || *cur++ != '.') goto error;
+  if (cur == end || *cur < '0' || *cur++ > '1') goto error;
+  if (cur == end || *cur++ != ' ') goto error;
+  if (cur == end || *cur < '1' || *cur++ > '9') goto error;
+  if (cur == end || *cur < '0' || *cur++ > '9') goto error;
+  if (cur == end || *cur < '0' || *cur++ > '9') goto error;
+  parser->r.status =
+      (cur[-3] - '0') * 100 + (cur[-2] - '0') * 10 + (cur[-1] - '0');
+  if (cur == end || *cur++ != ' ') goto error;
 
   /* we don't really care about the status code message */
 
   return 1;
 
 error:
-  gpr_log (GPR_ERROR, "Failed parsing response line");
+  gpr_log(GPR_ERROR, "Failed parsing response line");
   return 0;
 }
 
-static char *
-buf2str (void *buffer, size_t length)
-{
-  char *out = gpr_malloc (length + 1);
-  memcpy (out, buffer, length);
+static char *buf2str(void *buffer, size_t length) {
+  char *out = gpr_malloc(length + 1);
+  memcpy(out, buffer, length);
   out[length] = 0;
   return out;
 }
 
-static int
-add_header (grpc_httpcli_parser * parser)
-{
+static int add_header(grpc_httpcli_parser *parser) {
   gpr_uint8 *beg = parser->cur_line;
   gpr_uint8 *cur = beg;
   gpr_uint8 *end = beg + parser->cur_line_length;
-  grpc_httpcli_header hdr = { NULL, NULL };
+  grpc_httpcli_header hdr = {NULL, NULL};
 
-  GPR_ASSERT (cur != end);
+  GPR_ASSERT(cur != end);
 
-  if (*cur == ' ' || *cur == '\t')
-    {
-      gpr_log (GPR_ERROR, "Continued header lines not supported yet");
-      goto error;
-    }
-
-  while (cur != end && *cur != ':')
-    {
-      cur++;
-    }
-  if (cur == end)
-    {
-      gpr_log (GPR_ERROR, "Didn't find ':' in header string");
-      goto error;
-    }
-  GPR_ASSERT (cur >= beg);
-  hdr.key = buf2str (beg, (size_t) (cur - beg));
-  cur++;			/* skip : */
-
-  while (cur != end && (*cur == ' ' || *cur == '\t'))
-    {
-      cur++;
-    }
-  GPR_ASSERT (end - cur >= 2);
-  hdr.value = buf2str (cur, (size_t) (end - cur) - 2);
+  if (*cur == ' ' || *cur == '\t') {
+    gpr_log(GPR_ERROR, "Continued header lines not supported yet");
+    goto error;
+  }
 
-  if (parser->r.hdr_count == parser->hdr_capacity)
-    {
-      parser->hdr_capacity = GPR_MAX (parser->hdr_capacity + 1, parser->hdr_capacity * 3 / 2);
-      parser->r.hdrs = gpr_realloc (parser->r.hdrs, parser->hdr_capacity * sizeof (*parser->r.hdrs));
-    }
+  while (cur != end && *cur != ':') {
+    cur++;
+  }
+  if (cur == end) {
+    gpr_log(GPR_ERROR, "Didn't find ':' in header string");
+    goto error;
+  }
+  GPR_ASSERT(cur >= beg);
+  hdr.key = buf2str(beg, (size_t)(cur - beg));
+  cur++; /* skip : */
+
+  while (cur != end && (*cur == ' ' || *cur == '\t')) {
+    cur++;
+  }
+  GPR_ASSERT(end - cur >= 2);
+  hdr.value = buf2str(cur, (size_t)(end - cur) - 2);
+
+  if (parser->r.hdr_count == parser->hdr_capacity) {
+    parser->hdr_capacity =
+        GPR_MAX(parser->hdr_capacity + 1, parser->hdr_capacity * 3 / 2);
+    parser->r.hdrs = gpr_realloc(
+        parser->r.hdrs, parser->hdr_capacity * sizeof(*parser->r.hdrs));
+  }
   parser->r.hdrs[parser->r.hdr_count++] = hdr;
   return 1;
 
 error:
-  gpr_free (hdr.key);
-  gpr_free (hdr.value);
+  gpr_free(hdr.key);
+  gpr_free(hdr.value);
   return 0;
 }
 
-static int
-finish_line (grpc_httpcli_parser * parser)
-{
-  switch (parser->state)
-    {
+static int finish_line(grpc_httpcli_parser *parser) {
+  switch (parser->state) {
     case GRPC_HTTPCLI_INITIAL_RESPONSE:
-      if (!handle_response_line (parser))
-	{
-	  return 0;
-	}
+      if (!handle_response_line(parser)) {
+        return 0;
+      }
       parser->state = GRPC_HTTPCLI_HEADERS;
       break;
     case GRPC_HTTPCLI_HEADERS:
-      if (parser->cur_line_length == 2)
-	{
-	  parser->state = GRPC_HTTPCLI_BODY;
-	  break;
-	}
-      if (!add_header (parser))
-	{
-	  return 0;
-	}
+      if (parser->cur_line_length == 2) {
+        parser->state = GRPC_HTTPCLI_BODY;
+        break;
+      }
+      if (!add_header(parser)) {
+        return 0;
+      }
       break;
     case GRPC_HTTPCLI_BODY:
-      gpr_log (GPR_ERROR, "should never reach here");
-      abort ();
-    }
+      gpr_log(GPR_ERROR, "should never reach here");
+      abort();
+  }
 
   parser->cur_line_length = 0;
   return 1;
 }
 
-static int
-addbyte (grpc_httpcli_parser * parser, gpr_uint8 byte)
-{
-  switch (parser->state)
-    {
+static int addbyte(grpc_httpcli_parser *parser, gpr_uint8 byte) {
+  switch (parser->state) {
     case GRPC_HTTPCLI_INITIAL_RESPONSE:
     case GRPC_HTTPCLI_HEADERS:
-      if (parser->cur_line_length >= GRPC_HTTPCLI_MAX_HEADER_LENGTH)
-	{
-	  gpr_log (GPR_ERROR, "HTTP client max line length (%d) exceeded", GRPC_HTTPCLI_MAX_HEADER_LENGTH);
-	  return 0;
-	}
+      if (parser->cur_line_length >= GRPC_HTTPCLI_MAX_HEADER_LENGTH) {
+        gpr_log(GPR_ERROR, "HTTP client max line length (%d) exceeded",
+                GRPC_HTTPCLI_MAX_HEADER_LENGTH);
+        return 0;
+      }
       parser->cur_line[parser->cur_line_length] = byte;
       parser->cur_line_length++;
-      if (parser->cur_line_length >= 2 && parser->cur_line[parser->cur_line_length - 2] == '\r' && parser->cur_line[parser->cur_line_length - 1] == '\n')
-	{
-	  return finish_line (parser);
-	}
-      else
-	{
-	  return 1;
-	}
-      gpr_log (GPR_ERROR, "should never reach here");
-      abort ();
+      if (parser->cur_line_length >= 2 &&
+          parser->cur_line[parser->cur_line_length - 2] == '\r' &&
+          parser->cur_line[parser->cur_line_length - 1] == '\n') {
+        return finish_line(parser);
+      } else {
+        return 1;
+      }
+      gpr_log(GPR_ERROR, "should never reach here");
+      abort();
     case GRPC_HTTPCLI_BODY:
-      if (parser->r.body_length == parser->body_capacity)
-	{
-	  parser->body_capacity = GPR_MAX (8, parser->body_capacity * 3 / 2);
-	  parser->r.body = gpr_realloc ((void *) parser->r.body, parser->body_capacity);
-	}
-      parser->r.body[parser->r.body_length] = (char) byte;
+      if (parser->r.body_length == parser->body_capacity) {
+        parser->body_capacity = GPR_MAX(8, parser->body_capacity * 3 / 2);
+        parser->r.body =
+            gpr_realloc((void *)parser->r.body, parser->body_capacity);
+      }
+      parser->r.body[parser->r.body_length] = (char)byte;
       parser->r.body_length++;
       return 1;
-    }
-  gpr_log (GPR_ERROR, "should never reach here");
-  abort ();
+  }
+  gpr_log(GPR_ERROR, "should never reach here");
+  abort();
 
   return 0;
 }
 
-void
-grpc_httpcli_parser_init (grpc_httpcli_parser * parser)
-{
-  memset (parser, 0, sizeof (*parser));
+void grpc_httpcli_parser_init(grpc_httpcli_parser *parser) {
+  memset(parser, 0, sizeof(*parser));
   parser->state = GRPC_HTTPCLI_INITIAL_RESPONSE;
   parser->r.status = 500;
 }
 
-void
-grpc_httpcli_parser_destroy (grpc_httpcli_parser * parser)
-{
+void grpc_httpcli_parser_destroy(grpc_httpcli_parser *parser) {
   size_t i;
-  gpr_free (parser->r.body);
-  for (i = 0; i < parser->r.hdr_count; i++)
-    {
-      gpr_free (parser->r.hdrs[i].key);
-      gpr_free (parser->r.hdrs[i].value);
-    }
-  gpr_free (parser->r.hdrs);
+  gpr_free(parser->r.body);
+  for (i = 0; i < parser->r.hdr_count; i++) {
+    gpr_free(parser->r.hdrs[i].key);
+    gpr_free(parser->r.hdrs[i].value);
+  }
+  gpr_free(parser->r.hdrs);
 }
 
-int
-grpc_httpcli_parser_parse (grpc_httpcli_parser * parser, gpr_slice slice)
-{
+int grpc_httpcli_parser_parse(grpc_httpcli_parser *parser, gpr_slice slice) {
   size_t i;
 
-  for (i = 0; i < GPR_SLICE_LENGTH (slice); i++)
-    {
-      if (!addbyte (parser, GPR_SLICE_START_PTR (slice)[i]))
-	{
-	  return 0;
-	}
+  for (i = 0; i < GPR_SLICE_LENGTH(slice); i++) {
+    if (!addbyte(parser, GPR_SLICE_START_PTR(slice)[i])) {
+      return 0;
     }
+  }
 
   return 1;
 }
 
-int
-grpc_httpcli_parser_eof (grpc_httpcli_parser * parser)
-{
+int grpc_httpcli_parser_eof(grpc_httpcli_parser *parser) {
   return parser->state == GRPC_HTTPCLI_BODY;
 }

src/core/httpcli/parser.h

@@ -38,15 +38,13 @@
 #include <grpc/support/port_platform.h>
 #include <grpc/support/slice.h>
 
-typedef enum
-{
+typedef enum {
   GRPC_HTTPCLI_INITIAL_RESPONSE,
   GRPC_HTTPCLI_HEADERS,
   GRPC_HTTPCLI_BODY
 } grpc_httpcli_parser_state;
 
-typedef struct
-{
+typedef struct {
   grpc_httpcli_parser_state state;
 
   grpc_httpcli_response r;
@@ -57,10 +55,10 @@ typedef struct
   size_t cur_line_length;
 } grpc_httpcli_parser;
 
-void grpc_httpcli_parser_init (grpc_httpcli_parser * parser);
-void grpc_httpcli_parser_destroy (grpc_httpcli_parser * parser);
+void grpc_httpcli_parser_init(grpc_httpcli_parser* parser);
+void grpc_httpcli_parser_destroy(grpc_httpcli_parser* parser);
 
-int grpc_httpcli_parser_parse (grpc_httpcli_parser * parser, gpr_slice slice);
-int grpc_httpcli_parser_eof (grpc_httpcli_parser * parser);
+int grpc_httpcli_parser_parse(grpc_httpcli_parser* parser, gpr_slice slice);
+int grpc_httpcli_parser_eof(grpc_httpcli_parser* parser);
 
 #endif /* GRPC_INTERNAL_CORE_HTTPCLI_PARSER_H */

src/core/iomgr/alarm.c

@@ -48,8 +48,7 @@
 #define MIN_QUEUE_WINDOW_DURATION 0.01
 #define MAX_QUEUE_WINDOW_DURATION 1
 
-typedef struct
-{
+typedef struct {
   gpr_mu mu;
   grpc_time_averaged_stats stats;
   /* All and only alarms with deadlines <= this will be in the heap. */
@@ -73,140 +72,127 @@ static shard_type g_shards[NUM_SHARDS];
 /* Protected by g_mu */
 static shard_type *g_shard_queue[NUM_SHARDS];
 
-static int run_some_expired_alarms (grpc_exec_ctx * exec_ctx, gpr_timespec now, gpr_timespec * next, int success);
+static int run_some_expired_alarms(grpc_exec_ctx *exec_ctx, gpr_timespec now,
+                                   gpr_timespec *next, int success);
 
-static gpr_timespec
-compute_min_deadline (shard_type * shard)
-{
-  return grpc_alarm_heap_is_empty (&shard->heap) ? shard->queue_deadline_cap : grpc_alarm_heap_top (&shard->heap)->deadline;
+static gpr_timespec compute_min_deadline(shard_type *shard) {
+  return grpc_alarm_heap_is_empty(&shard->heap)
+             ? shard->queue_deadline_cap
+             : grpc_alarm_heap_top(&shard->heap)->deadline;
 }
 
-void
-grpc_alarm_list_init (gpr_timespec now)
-{
+void grpc_alarm_list_init(gpr_timespec now) {
   gpr_uint32 i;
 
-  gpr_mu_init (&g_mu);
-  gpr_mu_init (&g_checker_mu);
+  gpr_mu_init(&g_mu);
+  gpr_mu_init(&g_checker_mu);
   g_clock_type = now.clock_type;
 
-  for (i = 0; i < NUM_SHARDS; i++)
-    {
-      shard_type *shard = &g_shards[i];
-      gpr_mu_init (&shard->mu);
-      grpc_time_averaged_stats_init (&shard->stats, 1.0 / ADD_DEADLINE_SCALE, 0.1, 0.5);
-      shard->queue_deadline_cap = now;
-      shard->shard_queue_index = i;
-      grpc_alarm_heap_init (&shard->heap);
-      shard->list.next = shard->list.prev = &shard->list;
-      shard->min_deadline = compute_min_deadline (shard);
-      g_shard_queue[i] = shard;
-    }
+  for (i = 0; i < NUM_SHARDS; i++) {
+    shard_type *shard = &g_shards[i];
+    gpr_mu_init(&shard->mu);
+    grpc_time_averaged_stats_init(&shard->stats, 1.0 / ADD_DEADLINE_SCALE, 0.1,
+                                  0.5);
+    shard->queue_deadline_cap = now;
+    shard->shard_queue_index = i;
+    grpc_alarm_heap_init(&shard->heap);
+    shard->list.next = shard->list.prev = &shard->list;
+    shard->min_deadline = compute_min_deadline(shard);
+    g_shard_queue[i] = shard;
+  }
 }
 
-void
-grpc_alarm_list_shutdown (grpc_exec_ctx *exec_ctx)
-{
+void grpc_alarm_list_shutdown(grpc_exec_ctx *exec_ctx) {
   int i;
-  run_some_expired_alarms (exec_ctx, gpr_inf_future (g_clock_type), NULL, 0);
-  for (i = 0; i < NUM_SHARDS; i++)
-    {
-      shard_type *shard = &g_shards[i];
-      gpr_mu_destroy (&shard->mu);
-      grpc_alarm_heap_destroy (&shard->heap);
-    }
-  gpr_mu_destroy (&g_mu);
-  gpr_mu_destroy (&g_checker_mu);
+  run_some_expired_alarms(exec_ctx, gpr_inf_future(g_clock_type), NULL, 0);
+  for (i = 0; i < NUM_SHARDS; i++) {
+    shard_type *shard = &g_shards[i];
+    gpr_mu_destroy(&shard->mu);
+    grpc_alarm_heap_destroy(&shard->heap);
+  }
+  gpr_mu_destroy(&g_mu);
+  gpr_mu_destroy(&g_checker_mu);
 }
 
 /* This is a cheap, but good enough, pointer hash for sharding the tasks: */
-static size_t
-shard_idx (const grpc_alarm * info)
-{
-  size_t x = (size_t) info;
+static size_t shard_idx(const grpc_alarm *info) {
+  size_t x = (size_t)info;
   return ((x >> 4) ^ (x >> 9) ^ (x >> 14)) & (NUM_SHARDS - 1);
 }
 
-static double
-ts_to_dbl (gpr_timespec ts)
-{
-  return (double) ts.tv_sec + 1e-9 * ts.tv_nsec;
+static double ts_to_dbl(gpr_timespec ts) {
+  return (double)ts.tv_sec + 1e-9 * ts.tv_nsec;
 }
 
-static gpr_timespec
-dbl_to_ts (double d)
-{
+static gpr_timespec dbl_to_ts(double d) {
   gpr_timespec ts;
-  ts.tv_sec = (time_t) d;
-  ts.tv_nsec = (int) (1e9 * (d - (double) ts.tv_sec));
+  ts.tv_sec = (time_t)d;
+  ts.tv_nsec = (int)(1e9 * (d - (double)ts.tv_sec));
   ts.clock_type = GPR_TIMESPAN;
   return ts;
 }
 
-static void
-list_join (grpc_alarm * head, grpc_alarm * alarm)
-{
+static void list_join(grpc_alarm *head, grpc_alarm *alarm) {
   alarm->next = head;
   alarm->prev = head->prev;
   alarm->next->prev = alarm->prev->next = alarm;
 }
 
-static void
-list_remove (grpc_alarm * alarm)
-{
+static void list_remove(grpc_alarm *alarm) {
   alarm->next->prev = alarm->prev;
   alarm->prev->next = alarm->next;
 }
 
-static void
-swap_adjacent_shards_in_queue (gpr_uint32 first_shard_queue_index)
-{
+static void swap_adjacent_shards_in_queue(gpr_uint32 first_shard_queue_index) {
   shard_type *temp;
   temp = g_shard_queue[first_shard_queue_index];
-  g_shard_queue[first_shard_queue_index] = g_shard_queue[first_shard_queue_index + 1];
+  g_shard_queue[first_shard_queue_index] =
+      g_shard_queue[first_shard_queue_index + 1];
   g_shard_queue[first_shard_queue_index + 1] = temp;
-  g_shard_queue[first_shard_queue_index]->shard_queue_index = first_shard_queue_index;
-  g_shard_queue[first_shard_queue_index + 1]->shard_queue_index = first_shard_queue_index + 1;
+  g_shard_queue[first_shard_queue_index]->shard_queue_index =
+      first_shard_queue_index;
+  g_shard_queue[first_shard_queue_index + 1]->shard_queue_index =
+      first_shard_queue_index + 1;
 }
 
-static void
-note_deadline_change (shard_type * shard)
-{
-  while (shard->shard_queue_index > 0 && gpr_time_cmp (shard->min_deadline, g_shard_queue[shard->shard_queue_index - 1]->min_deadline) < 0)
-    {
-      swap_adjacent_shards_in_queue (shard->shard_queue_index - 1);
-    }
-  while (shard->shard_queue_index < NUM_SHARDS - 1 && gpr_time_cmp (shard->min_deadline, g_shard_queue[shard->shard_queue_index + 1]->min_deadline) > 0)
-    {
-      swap_adjacent_shards_in_queue (shard->shard_queue_index);
-    }
+static void note_deadline_change(shard_type *shard) {
+  while (shard->shard_queue_index > 0 &&
+         gpr_time_cmp(
+             shard->min_deadline,
+             g_shard_queue[shard->shard_queue_index - 1]->min_deadline) < 0) {
+    swap_adjacent_shards_in_queue(shard->shard_queue_index - 1);
+  }
+  while (shard->shard_queue_index < NUM_SHARDS - 1 &&
+         gpr_time_cmp(
+             shard->min_deadline,
+             g_shard_queue[shard->shard_queue_index + 1]->min_deadline) > 0) {
+    swap_adjacent_shards_in_queue(shard->shard_queue_index);
+  }
 }
 
-void
-grpc_alarm_init (grpc_exec_ctx * exec_ctx, grpc_alarm * alarm, gpr_timespec deadline, grpc_iomgr_cb_func alarm_cb, void *alarm_cb_arg, gpr_timespec now)
-{
+void grpc_alarm_init(grpc_exec_ctx *exec_ctx, grpc_alarm *alarm,
+                     gpr_timespec deadline, grpc_iomgr_cb_func alarm_cb,
+                     void *alarm_cb_arg, gpr_timespec now) {
   int is_first_alarm = 0;
-  shard_type *shard = &g_shards[shard_idx (alarm)];
-  GPR_ASSERT (deadline.clock_type == g_clock_type);
-  GPR_ASSERT (now.clock_type == g_clock_type);
-  grpc_closure_init (&alarm->closure, alarm_cb, alarm_cb_arg);
+  shard_type *shard = &g_shards[shard_idx(alarm)];
+  GPR_ASSERT(deadline.clock_type == g_clock_type);
+  GPR_ASSERT(now.clock_type == g_clock_type);
+  grpc_closure_init(&alarm->closure, alarm_cb, alarm_cb_arg);
   alarm->deadline = deadline;
   alarm->triggered = 0;
 
   /* TODO(ctiller): check deadline expired */
 
-  gpr_mu_lock (&shard->mu);
-  grpc_time_averaged_stats_add_sample (&shard->stats, ts_to_dbl (gpr_time_sub (deadline, now)));
-  if (gpr_time_cmp (deadline, shard->queue_deadline_cap) < 0)
-    {
-      is_first_alarm = grpc_alarm_heap_add (&shard->heap, alarm);
-    }
-  else
-    {
-      alarm->heap_index = INVALID_HEAP_INDEX;
-      list_join (&shard->list, alarm);
-    }
-  gpr_mu_unlock (&shard->mu);
+  gpr_mu_lock(&shard->mu);
+  grpc_time_averaged_stats_add_sample(&shard->stats,
+                                      ts_to_dbl(gpr_time_sub(deadline, now)));
+  if (gpr_time_cmp(deadline, shard->queue_deadline_cap) < 0) {
+    is_first_alarm = grpc_alarm_heap_add(&shard->heap, alarm);
+  } else {
+    alarm->heap_index = INVALID_HEAP_INDEX;
+    list_join(&shard->list, alarm);
+  }
+  gpr_mu_unlock(&shard->mu);
 
   /* Deadline may have decreased, we need to adjust the master queue.  Note
      that there is a potential racy unlocked region here.  There could be a
@@ -219,42 +205,34 @@ grpc_alarm_init (grpc_exec_ctx * exec_ctx, grpc_alarm * alarm, gpr_timespec dead
      trigger the new alarm because the min_deadline hadn't yet been reduced.
      In that case, the alarm will simply have to wait for the next
      grpc_alarm_check. */
-  if (is_first_alarm)
-    {
-      gpr_mu_lock (&g_mu);
-      if (gpr_time_cmp (deadline, shard->min_deadline) < 0)
-	{
-	  gpr_timespec old_min_deadline = g_shard_queue[0]->min_deadline;
-	  shard->min_deadline = deadline;
-	  note_deadline_change (shard);
-	  if (shard->shard_queue_index == 0 && gpr_time_cmp (deadline, old_min_deadline) < 0)
-	    {
-	      grpc_kick_poller ();
-	    }
-	}
-      gpr_mu_unlock (&g_mu);
+  if (is_first_alarm) {
+    gpr_mu_lock(&g_mu);
+    if (gpr_time_cmp(deadline, shard->min_deadline) < 0) {
+      gpr_timespec old_min_deadline = g_shard_queue[0]->min_deadline;
+      shard->min_deadline = deadline;
+      note_deadline_change(shard);
+      if (shard->shard_queue_index == 0 &&
+          gpr_time_cmp(deadline, old_min_deadline) < 0) {
+        grpc_kick_poller();
+      }
     }
+    gpr_mu_unlock(&g_mu);
+  }
 }
 
-void
-grpc_alarm_cancel (grpc_exec_ctx * exec_ctx, grpc_alarm * alarm)
-{
-  shard_type *shard = &g_shards[shard_idx (alarm)];
-  gpr_mu_lock (&shard->mu);
-  if (!alarm->triggered)
-    {
-      grpc_exec_ctx_enqueue (exec_ctx, &alarm->closure, 0);
-      alarm->triggered = 1;
-      if (alarm->heap_index == INVALID_HEAP_INDEX)
-	{
-	  list_remove (alarm);
-	}
-      else
-	{
-	  grpc_alarm_heap_remove (&shard->heap, alarm);
-	}
+void grpc_alarm_cancel(grpc_exec_ctx *exec_ctx, grpc_alarm *alarm) {
+  shard_type *shard = &g_shards[shard_idx(alarm)];
+  gpr_mu_lock(&shard->mu);
+  if (!alarm->triggered) {
+    grpc_exec_ctx_enqueue(exec_ctx, &alarm->closure, 0);
+    alarm->triggered = 1;
+    if (alarm->heap_index == INVALID_HEAP_INDEX) {
+      list_remove(alarm);
+    } else {
+      grpc_alarm_heap_remove(&shard->heap, alarm);
     }
-  gpr_mu_unlock (&shard->mu);
+  }
+  gpr_mu_unlock(&shard->mu);
 }
 
 /* This is called when the queue is empty and "now" has reached the
@@ -262,126 +240,114 @@ grpc_alarm_cancel (grpc_exec_ctx * exec_ctx, grpc_alarm * alarm)
    for alarms that fall at or under it.  Returns true if the queue is no
    longer empty.
    REQUIRES: shard->mu locked */
-static int
-refill_queue (shard_type * shard, gpr_timespec now)
-{
+static int refill_queue(shard_type *shard, gpr_timespec now) {
   /* Compute the new queue window width and bound by the limits: */
-  double computed_deadline_delta = grpc_time_averaged_stats_update_average (&shard->stats) * ADD_DEADLINE_SCALE;
-  double deadline_delta = GPR_CLAMP (computed_deadline_delta, MIN_QUEUE_WINDOW_DURATION,
-				     MAX_QUEUE_WINDOW_DURATION);
+  double computed_deadline_delta =
+      grpc_time_averaged_stats_update_average(&shard->stats) *
+      ADD_DEADLINE_SCALE;
+  double deadline_delta =
+      GPR_CLAMP(computed_deadline_delta, MIN_QUEUE_WINDOW_DURATION,
+                MAX_QUEUE_WINDOW_DURATION);
   grpc_alarm *alarm, *next;
 
   /* Compute the new cap and put all alarms under it into the queue: */
-  shard->queue_deadline_cap = gpr_time_add (gpr_time_max (now, shard->queue_deadline_cap), dbl_to_ts (deadline_delta));
-  for (alarm = shard->list.next; alarm != &shard->list; alarm = next)
-    {
-      next = alarm->next;
-
-      if (gpr_time_cmp (alarm->deadline, shard->queue_deadline_cap) < 0)
-	{
-	  list_remove (alarm);
-	  grpc_alarm_heap_add (&shard->heap, alarm);
-	}
+  shard->queue_deadline_cap = gpr_time_add(
+      gpr_time_max(now, shard->queue_deadline_cap), dbl_to_ts(deadline_delta));
+  for (alarm = shard->list.next; alarm != &shard->list; alarm = next) {
+    next = alarm->next;
+
+    if (gpr_time_cmp(alarm->deadline, shard->queue_deadline_cap) < 0) {
+      list_remove(alarm);
+      grpc_alarm_heap_add(&shard->heap, alarm);
     }
-  return !grpc_alarm_heap_is_empty (&shard->heap);
+  }
+  return !grpc_alarm_heap_is_empty(&shard->heap);
 }
 
 /* This pops the next non-cancelled alarm with deadline <= now from the queue,
    or returns NULL if there isn't one.
    REQUIRES: shard->mu locked */
-static grpc_alarm *
-pop_one (shard_type * shard, gpr_timespec now)
-{
+static grpc_alarm *pop_one(shard_type *shard, gpr_timespec now) {
   grpc_alarm *alarm;
-  for (;;)
-    {
-      if (grpc_alarm_heap_is_empty (&shard->heap))
-	{
-	  if (gpr_time_cmp (now, shard->queue_deadline_cap) < 0)
-	    return NULL;
-	  if (!refill_queue (shard, now))
-	    return NULL;
-	}
-      alarm = grpc_alarm_heap_top (&shard->heap);
-      if (gpr_time_cmp (alarm->deadline, now) > 0)
-	return NULL;
-      alarm->triggered = 1;
-      grpc_alarm_heap_pop (&shard->heap);
-      return alarm;
+  for (;;) {
+    if (grpc_alarm_heap_is_empty(&shard->heap)) {
+      if (gpr_time_cmp(now, shard->queue_deadline_cap) < 0) return NULL;
+      if (!refill_queue(shard, now)) return NULL;
     }
+    alarm = grpc_alarm_heap_top(&shard->heap);
+    if (gpr_time_cmp(alarm->deadline, now) > 0) return NULL;
+    alarm->triggered = 1;
+    grpc_alarm_heap_pop(&shard->heap);
+    return alarm;
+  }
 }
 
 /* REQUIRES: shard->mu unlocked */
-static size_t
-pop_alarms (grpc_exec_ctx * exec_ctx, shard_type * shard, gpr_timespec now, gpr_timespec * new_min_deadline, int success)
-{
+static size_t pop_alarms(grpc_exec_ctx *exec_ctx, shard_type *shard,
+                         gpr_timespec now, gpr_timespec *new_min_deadline,
+                         int success) {
   size_t n = 0;
   grpc_alarm *alarm;
-  gpr_mu_lock (&shard->mu);
-  while ((alarm = pop_one (shard, now)))
-    {
-      grpc_exec_ctx_enqueue (exec_ctx, &alarm->closure, success);
-      n++;
-    }
-  *new_min_deadline = compute_min_deadline (shard);
-  gpr_mu_unlock (&shard->mu);
+  gpr_mu_lock(&shard->mu);
+  while ((alarm = pop_one(shard, now))) {
+    grpc_exec_ctx_enqueue(exec_ctx, &alarm->closure, success);
+    n++;
+  }
+  *new_min_deadline = compute_min_deadline(shard);
+  gpr_mu_unlock(&shard->mu);
   return n;
 }
 
-static int
-run_some_expired_alarms (grpc_exec_ctx * exec_ctx, gpr_timespec now, gpr_timespec * next, int success)
-{
+static int run_some_expired_alarms(grpc_exec_ctx *exec_ctx, gpr_timespec now,
+                                   gpr_timespec *next, int success) {
   size_t n = 0;
 
   /* TODO(ctiller): verify that there are any alarms (atomically) here */
 
-  if (gpr_mu_trylock (&g_checker_mu))
-    {
-      gpr_mu_lock (&g_mu);
-
-      while (gpr_time_cmp (g_shard_queue[0]->min_deadline, now) < 0)
-	{
-	  gpr_timespec new_min_deadline;
-
-	  /* For efficiency, we pop as many available alarms as we can from the
-	     shard.  This may violate perfect alarm deadline ordering, but that
-	     shouldn't be a big deal because we don't make ordering guarantees. */
-	  n += pop_alarms (exec_ctx, g_shard_queue[0], now, &new_min_deadline, success);
-
-	  /* An grpc_alarm_init() on the shard could intervene here, adding a new
-	     alarm that is earlier than new_min_deadline.  However,
-	     grpc_alarm_init() will block on the master_lock before it can call
-	     set_min_deadline, so this one will complete first and then the AddAlarm
-	     will reduce the min_deadline (perhaps unnecessarily). */
-	  g_shard_queue[0]->min_deadline = new_min_deadline;
-	  note_deadline_change (g_shard_queue[0]);
-	}
-
-      if (next)
-	{
-	  *next = gpr_time_min (*next, g_shard_queue[0]->min_deadline);
-	}
-
-      gpr_mu_unlock (&g_mu);
-      gpr_mu_unlock (&g_checker_mu);
+  if (gpr_mu_trylock(&g_checker_mu)) {
+    gpr_mu_lock(&g_mu);
+
+    while (gpr_time_cmp(g_shard_queue[0]->min_deadline, now) < 0) {
+      gpr_timespec new_min_deadline;
+
+      /* For efficiency, we pop as many available alarms as we can from the
+         shard.  This may violate perfect alarm deadline ordering, but that
+         shouldn't be a big deal because we don't make ordering guarantees. */
+      n += pop_alarms(exec_ctx, g_shard_queue[0], now, &new_min_deadline,
+                      success);
+
+      /* An grpc_alarm_init() on the shard could intervene here, adding a new
+         alarm that is earlier than new_min_deadline.  However,
+         grpc_alarm_init() will block on the master_lock before it can call
+         set_min_deadline, so this one will complete first and then the AddAlarm
+         will reduce the min_deadline (perhaps unnecessarily). */
+      g_shard_queue[0]->min_deadline = new_min_deadline;
+      note_deadline_change(g_shard_queue[0]);
     }
 
-  return (int) n;
+    if (next) {
+      *next = gpr_time_min(*next, g_shard_queue[0]->min_deadline);
+    }
+
+    gpr_mu_unlock(&g_mu);
+    gpr_mu_unlock(&g_checker_mu);
+  }
+
+  return (int)n;
 }
 
-int
-grpc_alarm_check (grpc_exec_ctx * exec_ctx, gpr_timespec now, gpr_timespec * next)
-{
-  GPR_ASSERT (now.clock_type == g_clock_type);
-  return run_some_expired_alarms (exec_ctx, now, next, gpr_time_cmp (now, gpr_inf_future (now.clock_type)) != 0);
+int grpc_alarm_check(grpc_exec_ctx *exec_ctx, gpr_timespec now,
+                     gpr_timespec *next) {
+  GPR_ASSERT(now.clock_type == g_clock_type);
+  return run_some_expired_alarms(
+      exec_ctx, now, next,
+      gpr_time_cmp(now, gpr_inf_future(now.clock_type)) != 0);
 }
 
-gpr_timespec
-grpc_alarm_list_next_timeout (void)
-{
+gpr_timespec grpc_alarm_list_next_timeout(void) {
   gpr_timespec out;
-  gpr_mu_lock (&g_mu);
+  gpr_mu_lock(&g_mu);
   out = g_shard_queue[0]->min_deadline;
-  gpr_mu_unlock (&g_mu);
+  gpr_mu_unlock(&g_mu);
   return out;
 }

src/core/iomgr/alarm.h

@@ -39,10 +39,9 @@
 #include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
-typedef struct grpc_alarm
-{
+typedef struct grpc_alarm {
   gpr_timespec deadline;
-  gpr_uint32 heap_index;	/* INVALID_HEAP_INDEX if not in heap */
+  gpr_uint32 heap_index; /* INVALID_HEAP_INDEX if not in heap */
   int triggered;
   struct grpc_alarm *next;
   struct grpc_alarm *prev;
@@ -55,7 +54,9 @@ typedef struct grpc_alarm
    and application code should check the status to determine how it was
    invoked. The application callback is also responsible for maintaining
    information about when to free up any user-level state. */
-void grpc_alarm_init (grpc_exec_ctx * exec_ctx, grpc_alarm * alarm, gpr_timespec deadline, grpc_iomgr_cb_func alarm_cb, void *alarm_cb_arg, gpr_timespec now);
+void grpc_alarm_init(grpc_exec_ctx *exec_ctx, grpc_alarm *alarm,
+                     gpr_timespec deadline, grpc_iomgr_cb_func alarm_cb,
+                     void *alarm_cb_arg, gpr_timespec now);
 
 /* Note that there is no alarm destroy function. This is because the
    alarm is a one-time occurrence with a guarantee that the callback will
@@ -83,6 +84,6 @@ void grpc_alarm_init (grpc_exec_ctx * exec_ctx, grpc_alarm * alarm, gpr_timespec
    matches this aim.
 
    Requires:  cancel() must happen after add() on a given alarm */
-void grpc_alarm_cancel (grpc_exec_ctx * exec_ctx, grpc_alarm * alarm);
+void grpc_alarm_cancel(grpc_exec_ctx *exec_ctx, grpc_alarm *alarm);
 
 #endif /* GRPC_INTERNAL_CORE_IOMGR_ALARM_H */

src/core/iomgr/alarm_heap.c

@@ -43,18 +43,14 @@
    position. This functor is called each time immediately after modifying a
    value in the underlying container, with the offset of the modified element as
    its argument. */
-static void
-adjust_upwards (grpc_alarm ** first, gpr_uint32 i, grpc_alarm * t)
-{
-  while (i > 0)
-    {
-      gpr_uint32 parent = (gpr_uint32) (((int) i - 1) / 2);
-      if (gpr_time_cmp (first[parent]->deadline, t->deadline) >= 0)
-	break;
-      first[i] = first[parent];
-      first[i]->heap_index = i;
-      i = parent;
-    }
+static void adjust_upwards(grpc_alarm **first, gpr_uint32 i, grpc_alarm *t) {
+  while (i > 0) {
+    gpr_uint32 parent = (gpr_uint32)(((int)i - 1) / 2);
+    if (gpr_time_cmp(first[parent]->deadline, t->deadline) >= 0) break;
+    first[i] = first[parent];
+    first[i]->heap_index = i;
+    i = parent;
+  }
   first[i] = t;
   t->heap_index = i;
 }
@@ -62,24 +58,24 @@ adjust_upwards (grpc_alarm ** first, gpr_uint32 i, grpc_alarm * t)
 /* Adjusts a heap so as to move a hole at position i farther away from the root,
    until a suitable position is found for element t.  Then, copies t into that
    position. */
-static void
-adjust_downwards (grpc_alarm ** first, gpr_uint32 i, gpr_uint32 length, grpc_alarm * t)
-{
-  for (;;)
-    {
-      gpr_uint32 left_child = 1u + 2u * i;
-      gpr_uint32 right_child;
-      gpr_uint32 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;
-      if (gpr_time_cmp (t->deadline, first[next_i]->deadline) >= 0)
-	break;
-      first[i] = first[next_i];
-      first[i]->heap_index = i;
-      i = next_i;
-    }
+static void adjust_downwards(grpc_alarm **first, gpr_uint32 i,
+                             gpr_uint32 length, grpc_alarm *t) {
+  for (;;) {
+    gpr_uint32 left_child = 1u + 2u * i;
+    gpr_uint32 right_child;
+    gpr_uint32 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;
+    if (gpr_time_cmp(t->deadline, first[next_i]->deadline) >= 0) break;
+    first[i] = first[next_i];
+    first[i]->heap_index = i;
+    i = next_i;
+  }
   first[i] = t;
   t->heap_index = i;
 }
@@ -87,88 +83,66 @@ adjust_downwards (grpc_alarm ** first, gpr_uint32 i, gpr_uint32 length, grpc_ala
 #define SHRINK_MIN_ELEMS 8
 #define SHRINK_FULLNESS_FACTOR 2
 
-static void
-maybe_shrink (grpc_alarm_heap * heap)
-{
-  if (heap->alarm_count >= 8 && heap->alarm_count <= heap->alarm_capacity / SHRINK_FULLNESS_FACTOR / 2)
-    {
-      heap->alarm_capacity = heap->alarm_count * SHRINK_FULLNESS_FACTOR;
-      heap->alarms = gpr_realloc (heap->alarms, heap->alarm_capacity * sizeof (grpc_alarm *));
-    }
+static void maybe_shrink(grpc_alarm_heap *heap) {
+  if (heap->alarm_count >= 8 &&
+      heap->alarm_count <= heap->alarm_capacity / SHRINK_FULLNESS_FACTOR / 2) {
+    heap->alarm_capacity = heap->alarm_count * SHRINK_FULLNESS_FACTOR;
+    heap->alarms =
+        gpr_realloc(heap->alarms, heap->alarm_capacity * sizeof(grpc_alarm *));
+  }
 }
 
-static void
-note_changed_priority (grpc_alarm_heap * heap, grpc_alarm * alarm)
-{
+static void note_changed_priority(grpc_alarm_heap *heap, grpc_alarm *alarm) {
   gpr_uint32 i = alarm->heap_index;
-  gpr_uint32 parent = (gpr_uint32) (((int) i - 1) / 2);
-  if (gpr_time_cmp (heap->alarms[parent]->deadline, alarm->deadline) < 0)
-    {
-      adjust_upwards (heap->alarms, i, alarm);
-    }
-  else
-    {
-      adjust_downwards (heap->alarms, i, heap->alarm_count, alarm);
-    }
+  gpr_uint32 parent = (gpr_uint32)(((int)i - 1) / 2);
+  if (gpr_time_cmp(heap->alarms[parent]->deadline, alarm->deadline) < 0) {
+    adjust_upwards(heap->alarms, i, alarm);
+  } else {
+    adjust_downwards(heap->alarms, i, heap->alarm_count, alarm);
+  }
 }
 
-void
-grpc_alarm_heap_init (grpc_alarm_heap * heap)
-{
-  memset (heap, 0, sizeof (*heap));
+void grpc_alarm_heap_init(grpc_alarm_heap *heap) {
+  memset(heap, 0, sizeof(*heap));
 }
 
-void
-grpc_alarm_heap_destroy (grpc_alarm_heap * heap)
-{
-  gpr_free (heap->alarms);
-}
+void grpc_alarm_heap_destroy(grpc_alarm_heap *heap) { gpr_free(heap->alarms); }
 
-int
-grpc_alarm_heap_add (grpc_alarm_heap * heap, grpc_alarm * alarm)
-{
-  if (heap->alarm_count == heap->alarm_capacity)
-    {
-      heap->alarm_capacity = GPR_MAX (heap->alarm_capacity + 1, heap->alarm_capacity * 3 / 2);
-      heap->alarms = gpr_realloc (heap->alarms, heap->alarm_capacity * sizeof (grpc_alarm *));
-    }
+int grpc_alarm_heap_add(grpc_alarm_heap *heap, grpc_alarm *alarm) {
+  if (heap->alarm_count == heap->alarm_capacity) {
+    heap->alarm_capacity =
+        GPR_MAX(heap->alarm_capacity + 1, heap->alarm_capacity * 3 / 2);
+    heap->alarms =
+        gpr_realloc(heap->alarms, heap->alarm_capacity * sizeof(grpc_alarm *));
+  }
   alarm->heap_index = heap->alarm_count;
-  adjust_upwards (heap->alarms, heap->alarm_count, alarm);
+  adjust_upwards(heap->alarms, heap->alarm_count, alarm);
   heap->alarm_count++;
   return alarm->heap_index == 0;
 }
 
-void
-grpc_alarm_heap_remove (grpc_alarm_heap * heap, grpc_alarm * alarm)
-{
+void grpc_alarm_heap_remove(grpc_alarm_heap *heap, grpc_alarm *alarm) {
   gpr_uint32 i = alarm->heap_index;
-  if (i == heap->alarm_count - 1)
-    {
-      heap->alarm_count--;
-      maybe_shrink (heap);
-      return;
-    }
+  if (i == heap->alarm_count - 1) {
+    heap->alarm_count--;
+    maybe_shrink(heap);
+    return;
+  }
   heap->alarms[i] = heap->alarms[heap->alarm_count - 1];
   heap->alarms[i]->heap_index = i;
   heap->alarm_count--;
-  maybe_shrink (heap);
-  note_changed_priority (heap, heap->alarms[i]);
+  maybe_shrink(heap);
+  note_changed_priority(heap, heap->alarms[i]);
 }
 
-int
-grpc_alarm_heap_is_empty (grpc_alarm_heap * heap)
-{
+int grpc_alarm_heap_is_empty(grpc_alarm_heap *heap) {
   return heap->alarm_count == 0;
 }
 
-grpc_alarm *
-grpc_alarm_heap_top (grpc_alarm_heap * heap)
-{
+grpc_alarm *grpc_alarm_heap_top(grpc_alarm_heap *heap) {
   return heap->alarms[0];
 }
 
-void
-grpc_alarm_heap_pop (grpc_alarm_heap * heap)
-{
-  grpc_alarm_heap_remove (heap, grpc_alarm_heap_top (heap));
+void grpc_alarm_heap_pop(grpc_alarm_heap *heap) {
+  grpc_alarm_heap_remove(heap, grpc_alarm_heap_top(heap));
 }

src/core/iomgr/alarm_heap.h

@@ -36,23 +36,22 @@
 
 #include "src/core/iomgr/alarm.h"
 
-typedef struct
-{
+typedef struct {
   grpc_alarm **alarms;
   gpr_uint32 alarm_count;
   gpr_uint32 alarm_capacity;
 } grpc_alarm_heap;
 
 /* return 1 if the new alarm is the first alarm in the heap */
-int grpc_alarm_heap_add (grpc_alarm_heap * heap, grpc_alarm * alarm);
+int grpc_alarm_heap_add(grpc_alarm_heap *heap, grpc_alarm *alarm);
 
-void grpc_alarm_heap_init (grpc_alarm_heap * heap);
-void grpc_alarm_heap_destroy (grpc_alarm_heap * heap);
+void grpc_alarm_heap_init(grpc_alarm_heap *heap);
+void grpc_alarm_heap_destroy(grpc_alarm_heap *heap);
 
-void grpc_alarm_heap_remove (grpc_alarm_heap * heap, grpc_alarm * alarm);
-grpc_alarm *grpc_alarm_heap_top (grpc_alarm_heap * heap);
-void grpc_alarm_heap_pop (grpc_alarm_heap * heap);
+void grpc_alarm_heap_remove(grpc_alarm_heap *heap, grpc_alarm *alarm);
+grpc_alarm *grpc_alarm_heap_top(grpc_alarm_heap *heap);
+void grpc_alarm_heap_pop(grpc_alarm_heap *heap);
 
-int grpc_alarm_heap_is_empty (grpc_alarm_heap * heap);
+int grpc_alarm_heap_is_empty(grpc_alarm_heap *heap);
 
 #endif /* GRPC_INTERNAL_CORE_IOMGR_ALARM_HEAP_H */

src/core/iomgr/alarm_internal.h

@@ -49,14 +49,15 @@
    with high probability at least one thread in the system will see an update
    at any time slice. */
 
-int grpc_alarm_check (grpc_exec_ctx * exec_ctx, gpr_timespec now, gpr_timespec * next);
-void grpc_alarm_list_init (gpr_timespec now);
-void grpc_alarm_list_shutdown (grpc_exec_ctx * exec_ctx);
+int grpc_alarm_check(grpc_exec_ctx* exec_ctx, gpr_timespec now,
+                     gpr_timespec* next);
+void grpc_alarm_list_init(gpr_timespec now);
+void grpc_alarm_list_shutdown(grpc_exec_ctx* exec_ctx);
 
-gpr_timespec grpc_alarm_list_next_timeout (void);
+gpr_timespec grpc_alarm_list_next_timeout(void);
 
 /* the following must be implemented by each iomgr implementation */
 
-void grpc_kick_poller (void);
+void grpc_kick_poller(void);
 
 #endif /* GRPC_INTERNAL_CORE_IOMGR_ALARM_INTERNAL_H */

src/core/iomgr/closure.c

@@ -33,53 +33,39 @@
 
 #include "src/core/iomgr/closure.h"
 
-void
-grpc_closure_init (grpc_closure * closure, grpc_iomgr_cb_func cb, void *cb_arg)
-{
+void grpc_closure_init(grpc_closure *closure, grpc_iomgr_cb_func cb,
+                       void *cb_arg) {
   closure->cb = cb;
   closure->cb_arg = cb_arg;
   closure->next = NULL;
 }
 
-void
-grpc_closure_list_add (grpc_closure_list * closure_list, grpc_closure * closure, int success)
-{
-  if (closure == NULL)
-    return;
+void grpc_closure_list_add(grpc_closure_list *closure_list,
+                           grpc_closure *closure, int success) {
+  if (closure == NULL) return;
   closure->next = NULL;
   closure->success = success;
-  if (closure_list->head == NULL)
-    {
-      closure_list->head = closure;
-    }
-  else
-    {
-      closure_list->tail->next = closure;
-    }
+  if (closure_list->head == NULL) {
+    closure_list->head = closure;
+  } else {
+    closure_list->tail->next = closure;
+  }
   closure_list->tail = closure;
 }
 
-int
-grpc_closure_list_empty (grpc_closure_list closure_list)
-{
+int grpc_closure_list_empty(grpc_closure_list closure_list) {
   return closure_list.head == NULL;
 }
 
-void
-grpc_closure_list_move (grpc_closure_list * src, grpc_closure_list * dst)
-{
-  if (src->head == NULL)
-    {
-      return;
-    }
-  if (dst->head == NULL)
-    {
-      *dst = *src;
-    }
-  else
-    {
-      dst->tail->next = src->head;
-      dst->tail = src->tail;
-    }
+void grpc_closure_list_move(grpc_closure_list *src, grpc_closure_list *dst) {
+  if (src->head == NULL) {
+    return;
+  }
+  if (dst->head == NULL) {
+    *dst = *src;
+  } else {
+    dst->tail->next = src->head;
+    dst->tail = src->tail;
+  }
   src->head = src->tail = NULL;
 }

src/core/iomgr/closure.h

@@ -43,8 +43,7 @@ typedef struct grpc_closure grpc_closure;
 struct grpc_exec_ctx;
 typedef struct grpc_exec_ctx grpc_exec_ctx;
 
-typedef struct grpc_closure_list
-{
+typedef struct grpc_closure_list {
   grpc_closure *head;
   grpc_closure *tail;
 } grpc_closure_list;
@@ -54,11 +53,11 @@ typedef struct grpc_closure_list
  * \param arg Arbitrary input.
  * \param success An indication on the state of the iomgr. On false, cleanup
  * actions should be taken (eg, shutdown). */
-typedef void (*grpc_iomgr_cb_func) (grpc_exec_ctx * exec_ctx, void *arg, int success);
+typedef void (*grpc_iomgr_cb_func)(grpc_exec_ctx *exec_ctx, void *arg,
+                                   int success);
 
 /** A closure over a grpc_iomgr_cb_func. */
-struct grpc_closure
-{
+struct grpc_closure {
   /** Bound callback. */
   grpc_iomgr_cb_func cb;
 
@@ -75,13 +74,15 @@ struct grpc_closure
 };
 
 /** Initializes \a closure with \a cb and \a cb_arg. */
-void grpc_closure_init (grpc_closure * closure, grpc_iomgr_cb_func cb, void *cb_arg);
+void grpc_closure_init(grpc_closure *closure, grpc_iomgr_cb_func cb,
+                       void *cb_arg);
 
 #define GRPC_CLOSURE_LIST_INIT \
   { NULL, NULL }
 
-void grpc_closure_list_add (grpc_closure_list * list, grpc_closure * closure, int success);
-void grpc_closure_list_move (grpc_closure_list * src, grpc_closure_list * dst);
-int grpc_closure_list_empty (grpc_closure_list list);
+void grpc_closure_list_add(grpc_closure_list *list, grpc_closure *closure,
+                           int success);
+void grpc_closure_list_move(grpc_closure_list *src, grpc_closure_list *dst);
+int grpc_closure_list_empty(grpc_closure_list list);
 
 #endif /* GRPC_INTERNAL_CORE_IOMGR_CLOSURE_H */

src/core/iomgr/endpoint.c

@@ -33,44 +33,35 @@
 
 #include "src/core/iomgr/endpoint.h"
 
-void
-grpc_endpoint_read (grpc_exec_ctx * exec_ctx, grpc_endpoint * ep, gpr_slice_buffer * slices, grpc_closure * cb)
-{
-  ep->vtable->read (exec_ctx, ep, slices, cb);
+void grpc_endpoint_read(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
+                        gpr_slice_buffer* slices, grpc_closure* cb) {
+  ep->vtable->read(exec_ctx, ep, slices, cb);
 }
 
-void
-grpc_endpoint_write (grpc_exec_ctx * exec_ctx, grpc_endpoint * ep, gpr_slice_buffer * slices, grpc_closure * cb)
-{
-  ep->vtable->write (exec_ctx, ep, slices, cb);
+void grpc_endpoint_write(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
+                         gpr_slice_buffer* slices, grpc_closure* cb) {
+  ep->vtable->write(exec_ctx, ep, slices, cb);
 }
 
-void
-grpc_endpoint_add_to_pollset (grpc_exec_ctx * exec_ctx, grpc_endpoint * ep, grpc_pollset * pollset)
-{
-  ep->vtable->add_to_pollset (exec_ctx, ep, pollset);
+void grpc_endpoint_add_to_pollset(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep,
+                                  grpc_pollset* pollset) {
+  ep->vtable->add_to_pollset(exec_ctx, ep, pollset);
 }
 
-void
-grpc_endpoint_add_to_pollset_set (grpc_exec_ctx * exec_ctx, grpc_endpoint * ep, grpc_pollset_set * pollset_set)
-{
-  ep->vtable->add_to_pollset_set (exec_ctx, ep, pollset_set);
+void grpc_endpoint_add_to_pollset_set(grpc_exec_ctx* exec_ctx,
+                                      grpc_endpoint* ep,
+                                      grpc_pollset_set* pollset_set) {
+  ep->vtable->add_to_pollset_set(exec_ctx, ep, pollset_set);
 }
 
-void
-grpc_endpoint_shutdown (grpc_exec_ctx * exec_ctx, grpc_endpoint * ep)
-{
-  ep->vtable->shutdown (exec_ctx, ep);
+void grpc_endpoint_shutdown(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep) {
+  ep->vtable->shutdown(exec_ctx, ep);
 }
 
-void
-grpc_endpoint_destroy (grpc_exec_ctx * exec_ctx, grpc_endpoint * ep)
-{
-  ep->vtable->destroy (exec_ctx, ep);
+void grpc_endpoint_destroy(grpc_exec_ctx* exec_ctx, grpc_endpoint* ep) {
+  ep->vtable->destroy(exec_ctx, ep);
 }
 
-char *
-grpc_endpoint_get_peer (grpc_endpoint * ep)
-{
-  return ep->vtable->get_peer (ep);
+char* grpc_endpoint_get_peer(grpc_endpoint* ep) {
+  return ep->vtable->get_peer(ep);
 }

src/core/iomgr/endpoint.h

@@ -46,24 +46,28 @@
 typedef struct grpc_endpoint grpc_endpoint;
 typedef struct grpc_endpoint_vtable grpc_endpoint_vtable;
 
-struct grpc_endpoint_vtable
-{
-  void (*read) (grpc_exec_ctx * exec_ctx, grpc_endpoint * ep, gpr_slice_buffer * slices, grpc_closure * cb);
-  void (*write) (grpc_exec_ctx * exec_ctx, grpc_endpoint * ep, gpr_slice_buffer * slices, grpc_closure * cb);
-  void (*add_to_pollset) (grpc_exec_ctx * exec_ctx, grpc_endpoint * ep, grpc_pollset * pollset);
-  void (*add_to_pollset_set) (grpc_exec_ctx * exec_ctx, grpc_endpoint * ep, grpc_pollset_set * pollset);
-  void (*shutdown) (grpc_exec_ctx * exec_ctx, grpc_endpoint * ep);
-  void (*destroy) (grpc_exec_ctx * exec_ctx, grpc_endpoint * ep);
-  char *(*get_peer) (grpc_endpoint * ep);
+struct grpc_endpoint_vtable {
+  void (*read)(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
+               gpr_slice_buffer *slices, grpc_closure *cb);
+  void (*write)(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
+                gpr_slice_buffer *slices, grpc_closure *cb);
+  void (*add_to_pollset)(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
+                         grpc_pollset *pollset);
+  void (*add_to_pollset_set)(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
+                             grpc_pollset_set *pollset);
+  void (*shutdown)(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep);
+  void (*destroy)(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep);
+  char *(*get_peer)(grpc_endpoint *ep);
 };
 
 /* When data is available on the connection, calls the callback with slices.
    Callback success indicates that the endpoint can accept more reads, failure
    indicates the endpoint is closed.
    Valid slices may be placed into \a slices even on callback success == 0. */
-void grpc_endpoint_read (grpc_exec_ctx * exec_ctx, grpc_endpoint * ep, gpr_slice_buffer * slices, grpc_closure * cb);
+void grpc_endpoint_read(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
+                        gpr_slice_buffer *slices, grpc_closure *cb);
 
-char *grpc_endpoint_get_peer (grpc_endpoint * ep);
+char *grpc_endpoint_get_peer(grpc_endpoint *ep);
 
 /* Write slices out to the socket.
 
@@ -75,20 +79,23 @@ char *grpc_endpoint_get_peer (grpc_endpoint * ep);
    No guarantee is made to the content of slices after a write EXCEPT that
    it is a valid slice buffer.
    */
-void grpc_endpoint_write (grpc_exec_ctx * exec_ctx, grpc_endpoint * ep, gpr_slice_buffer * slices, grpc_closure * cb);
+void grpc_endpoint_write(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
+                         gpr_slice_buffer *slices, grpc_closure *cb);
 
 /* Causes any pending read/write callbacks to run immediately with
    success==0 */
-void grpc_endpoint_shutdown (grpc_exec_ctx * exec_ctx, grpc_endpoint * ep);
-void grpc_endpoint_destroy (grpc_exec_ctx * exec_ctx, grpc_endpoint * ep);
+void grpc_endpoint_shutdown(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep);
+void grpc_endpoint_destroy(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep);
 
 /* Add an endpoint to a pollset, so that when the pollset is polled, events from
    this endpoint are considered */
-void grpc_endpoint_add_to_pollset (grpc_exec_ctx * exec_ctx, grpc_endpoint * ep, grpc_pollset * pollset);
-void grpc_endpoint_add_to_pollset_set (grpc_exec_ctx * exec_ctx, grpc_endpoint * ep, grpc_pollset_set * pollset_set);
+void grpc_endpoint_add_to_pollset(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
+                                  grpc_pollset *pollset);
+void grpc_endpoint_add_to_pollset_set(grpc_exec_ctx *exec_ctx,
+                                      grpc_endpoint *ep,
+                                      grpc_pollset_set *pollset_set);
 
-struct grpc_endpoint
-{
+struct grpc_endpoint {
   const grpc_endpoint_vtable *vtable;
 };
 

src/core/iomgr/endpoint_pair.h

@@ -36,12 +36,12 @@
 
 #include "src/core/iomgr/endpoint.h"
 
-typedef struct
-{
+typedef struct {
   grpc_endpoint *client;
   grpc_endpoint *server;
 } grpc_endpoint_pair;
 
-grpc_endpoint_pair grpc_iomgr_create_endpoint_pair (const char *name, size_t read_slice_size);
+grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(const char *name,
+                                                   size_t read_slice_size);
 
 #endif /* GRPC_INTERNAL_CORE_IOMGR_ENDPOINT_PAIR_H */

src/core/iomgr/endpoint_pair_posix.c

@@ -49,31 +49,30 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-static void
-create_sockets (int sv[2])
-{
+static void create_sockets(int sv[2]) {
   int flags;
-  GPR_ASSERT (socketpair (AF_UNIX, SOCK_STREAM, 0, sv) == 0);
-  flags = fcntl (sv[0], F_GETFL, 0);
-  GPR_ASSERT (fcntl (sv[0], F_SETFL, flags | O_NONBLOCK) == 0);
-  flags = fcntl (sv[1], F_GETFL, 0);
-  GPR_ASSERT (fcntl (sv[1], F_SETFL, flags | O_NONBLOCK) == 0);
+  GPR_ASSERT(socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == 0);
+  flags = fcntl(sv[0], F_GETFL, 0);
+  GPR_ASSERT(fcntl(sv[0], F_SETFL, flags | O_NONBLOCK) == 0);
+  flags = fcntl(sv[1], F_GETFL, 0);
+  GPR_ASSERT(fcntl(sv[1], F_SETFL, flags | O_NONBLOCK) == 0);
 }
 
-grpc_endpoint_pair
-grpc_iomgr_create_endpoint_pair (const char *name, size_t read_slice_size)
-{
+grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(const char *name,
+                                                   size_t read_slice_size) {
   int sv[2];
   grpc_endpoint_pair p;
   char *final_name;
-  create_sockets (sv);
+  create_sockets(sv);
 
-  gpr_asprintf (&final_name, "%s:client", name);
-  p.client = grpc_tcp_create (grpc_fd_create (sv[1], final_name), read_slice_size, "socketpair-server");
-  gpr_free (final_name);
-  gpr_asprintf (&final_name, "%s:server", name);
-  p.server = grpc_tcp_create (grpc_fd_create (sv[0], final_name), read_slice_size, "socketpair-client");
-  gpr_free (final_name);
+  gpr_asprintf(&final_name, "%s:client", name);
+  p.client = grpc_tcp_create(grpc_fd_create(sv[1], final_name), read_slice_size,
+                             "socketpair-server");
+  gpr_free(final_name);
+  gpr_asprintf(&final_name, "%s:server", name);
+  p.server = grpc_tcp_create(grpc_fd_create(sv[0], final_name), read_slice_size,
+                             "socketpair-client");
+  gpr_free(final_name);
   return p;
 }
 

src/core/iomgr/endpoint_pair_windows.c

@@ -45,48 +45,52 @@
 #include "src/core/iomgr/socket_windows.h"
 #include <grpc/support/log.h>
 
-static void
-create_sockets (SOCKET sv[2])
-{
+static void create_sockets(SOCKET sv[2]) {
   SOCKET svr_sock = INVALID_SOCKET;
   SOCKET lst_sock = INVALID_SOCKET;
   SOCKET cli_sock = INVALID_SOCKET;
   SOCKADDR_IN addr;
-  int addr_len = sizeof (addr);
+  int addr_len = sizeof(addr);
 
-  lst_sock = WSASocket (AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
-  GPR_ASSERT (lst_sock != INVALID_SOCKET);
+  lst_sock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
+                       WSA_FLAG_OVERLAPPED);
+  GPR_ASSERT(lst_sock != INVALID_SOCKET);
 
-  memset (&addr, 0, sizeof (addr));
-  addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
+  memset(&addr, 0, sizeof(addr));
+  addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
   addr.sin_family = AF_INET;
-  GPR_ASSERT (bind (lst_sock, (struct sockaddr *) &addr, sizeof (addr)) != SOCKET_ERROR);
-  GPR_ASSERT (listen (lst_sock, SOMAXCONN) != SOCKET_ERROR);
-  GPR_ASSERT (getsockname (lst_sock, (struct sockaddr *) &addr, &addr_len) != SOCKET_ERROR);
+  GPR_ASSERT(bind(lst_sock, (struct sockaddr *)&addr, sizeof(addr)) !=
+             SOCKET_ERROR);
+  GPR_ASSERT(listen(lst_sock, SOMAXCONN) != SOCKET_ERROR);
+  GPR_ASSERT(getsockname(lst_sock, (struct sockaddr *)&addr, &addr_len) !=
+             SOCKET_ERROR);
 
-  cli_sock = WSASocket (AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
-  GPR_ASSERT (cli_sock != INVALID_SOCKET);
+  cli_sock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
+                       WSA_FLAG_OVERLAPPED);
+  GPR_ASSERT(cli_sock != INVALID_SOCKET);
 
-  GPR_ASSERT (WSAConnect (cli_sock, (struct sockaddr *) &addr, addr_len, NULL, NULL, NULL, NULL) == 0);
-  svr_sock = accept (lst_sock, (struct sockaddr *) &addr, &addr_len);
-  GPR_ASSERT (svr_sock != INVALID_SOCKET);
+  GPR_ASSERT(WSAConnect(cli_sock, (struct sockaddr *)&addr, addr_len, NULL,
+                        NULL, NULL, NULL) == 0);
+  svr_sock = accept(lst_sock, (struct sockaddr *)&addr, &addr_len);
+  GPR_ASSERT(svr_sock != INVALID_SOCKET);
 
-  closesocket (lst_sock);
-  grpc_tcp_prepare_socket (cli_sock);
-  grpc_tcp_prepare_socket (svr_sock);
+  closesocket(lst_sock);
+  grpc_tcp_prepare_socket(cli_sock);
+  grpc_tcp_prepare_socket(svr_sock);
 
   sv[1] = cli_sock;
   sv[0] = svr_sock;
 }
 
-grpc_endpoint_pair
-grpc_iomgr_create_endpoint_pair (const char *name, size_t read_slice_size)
-{
+grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(const char *name,
+                                                   size_t read_slice_size) {
   SOCKET sv[2];
   grpc_endpoint_pair p;
-  create_sockets (sv);
-  p.client = grpc_tcp_create (grpc_winsocket_create (sv[1], "endpoint:client"), "endpoint:server");
-  p.server = grpc_tcp_create (grpc_winsocket_create (sv[0], "endpoint:server"), "endpoint:client");
+  create_sockets(sv);
+  p.client = grpc_tcp_create(grpc_winsocket_create(sv[1], "endpoint:client"),
+                             "endpoint:server");
+  p.server = grpc_tcp_create(grpc_winsocket_create(sv[0], "endpoint:server"),
+                             "endpoint:client");
   return p;
 }
 

src/core/iomgr/exec_ctx.c

@@ -33,30 +33,28 @@
 
 #include "src/core/iomgr/exec_ctx.h"
 
-void
-grpc_exec_ctx_flush (grpc_exec_ctx *exec_ctx)
-{
-  while (!grpc_closure_list_empty (exec_ctx->closure_list))
-    {
-      grpc_closure *c = closure_list->head;
-      closure_list->head = closure_list->tail = NULL;
-      while (c != NULL)
-	{
-	  grpc_closure *next = c->next;
-	  c->cb (exec_ctx, c->cb_arg, c->success);
-	  c = next;
-	}
+void grpc_exec_ctx_flush(grpc_exec_ctx *exec_ctx) {
+  while (!grpc_closure_list_empty(exec_ctx->closure_list)) {
+    grpc_closure *c = closure_list->head;
+    closure_list->head = closure_list->tail = NULL;
+    while (c != NULL) {
+      grpc_closure *next = c->next;
+      c->cb(exec_ctx, c->cb_arg, c->success);
+      c = next;
     }
+  }
 }
 
 void grpc_exec_ctx_finish(grpc_exec_ctx *exec_ctx) {
   grpc_exec_ctx_flush(exec_ctx);
 }
 
-void grpc_exec_ctx_enqueue(grpc_exec_ctx *exec_ctx, grpc_closure *closure, int success) {
+void grpc_exec_ctx_enqueue(grpc_exec_ctx *exec_ctx, grpc_closure *closure,
+                           int success) {
   grpc_closure_list_add(&exec_ctx->closure_list, closure, success);
 }
 
-void grpc_exec_ctx_enqueue_list(grpc_exec_ctx *exec_ctx, grpc_closure_list *list) {
+void grpc_exec_ctx_enqueue_list(grpc_exec_ctx *exec_ctx,
+                                grpc_closure_list *list) {
   grpc_closure_list_move(list, &exec_ctx->closure_list);
 }

src/core/iomgr/exec_ctx.h

@@ -40,11 +40,14 @@ struct grpc_exec_ctx {
   grpc_closure_list closure_list;
 };
 
-#define GRPC_EXEC_CTX_INIT { GRPC_CLOSURE_LIST_INIT }
+#define GRPC_EXEC_CTX_INIT \
+  { GRPC_CLOSURE_LIST_INIT }
 
 void grpc_exec_ctx_finish(grpc_exec_ctx *exec_ctx);
 void grpc_exec_ctx_flush(grpc_exec_ctx *exec_ctx);
-void grpc_exec_ctx_enqueue(grpc_exec_ctx *exec_ctx, grpc_closure *closure, int success);
-void grpc_exec_ctx_enqueue_list(grpc_exec_ctx *exec_ctx, grpc_closure_list *list);
+void grpc_exec_ctx_enqueue(grpc_exec_ctx *exec_ctx, grpc_closure *closure,
+                           int success);
+void grpc_exec_ctx_enqueue_list(grpc_exec_ctx *exec_ctx,
+                                grpc_closure_list *list);
 
 #endif

src/core/iomgr/fd_posix.c

@@ -45,11 +45,10 @@
 #include <grpc/support/log.h>
 #include <grpc/support/useful.h>
 
-enum descriptor_state
-{
+enum descriptor_state {
   NOT_READY = 0,
   READY = 1
-};				/* or a pointer to a closure to call */
+}; /* or a pointer to a closure to call */
 
 /* We need to keep a freelist not because of any concerns of malloc performance
  * but instead so that implementations with multiple threads in (for example)
@@ -71,40 +70,35 @@ enum descriptor_state
 static grpc_fd *fd_freelist = NULL;
 static gpr_mu fd_freelist_mu;
 
-static void
-freelist_fd (grpc_fd * fd)
-{
-  gpr_mu_lock (&fd_freelist_mu);
+static void freelist_fd(grpc_fd *fd) {
+  gpr_mu_lock(&fd_freelist_mu);
   fd->freelist_next = fd_freelist;
   fd_freelist = fd;
-  grpc_iomgr_unregister_object (&fd->iomgr_object);
-  gpr_mu_unlock (&fd_freelist_mu);
+  grpc_iomgr_unregister_object(&fd->iomgr_object);
+  gpr_mu_unlock(&fd_freelist_mu);
 }
 
-static grpc_fd *
-alloc_fd (int fd)
-{
+static grpc_fd *alloc_fd(int fd) {
   grpc_fd *r = NULL;
-  gpr_mu_lock (&fd_freelist_mu);
-  if (fd_freelist != NULL)
-    {
-      r = fd_freelist;
-      fd_freelist = fd_freelist->freelist_next;
-    }
-  gpr_mu_unlock (&fd_freelist_mu);
-  if (r == NULL)
-    {
-      r = gpr_malloc (sizeof (grpc_fd));
-      gpr_mu_init (&r->set_state_mu);
-      gpr_mu_init (&r->watcher_mu);
-    }
-
-  gpr_atm_rel_store (&r->refst, 1);
-  gpr_atm_rel_store (&r->readst, NOT_READY);
-  gpr_atm_rel_store (&r->writest, NOT_READY);
-  gpr_atm_rel_store (&r->shutdown, 0);
+  gpr_mu_lock(&fd_freelist_mu);
+  if (fd_freelist != NULL) {
+    r = fd_freelist;
+    fd_freelist = fd_freelist->freelist_next;
+  }
+  gpr_mu_unlock(&fd_freelist_mu);
+  if (r == NULL) {
+    r = gpr_malloc(sizeof(grpc_fd));
+    gpr_mu_init(&r->set_state_mu);
+    gpr_mu_init(&r->watcher_mu);
+  }
+
+  gpr_atm_rel_store(&r->refst, 1);
+  gpr_atm_rel_store(&r->readst, NOT_READY);
+  gpr_atm_rel_store(&r->writest, NOT_READY);
+  gpr_atm_rel_store(&r->shutdown, 0);
   r->fd = fd;
-  r->inactive_watcher_root.next = r->inactive_watcher_root.prev = &r->inactive_watcher_root;
+  r->inactive_watcher_root.next = r->inactive_watcher_root.prev =
+      &r->inactive_watcher_root;
   r->freelist_next = NULL;
   r->read_watcher = r->write_watcher = NULL;
   r->on_done_closure = NULL;
@@ -112,198 +106,147 @@ alloc_fd (int fd)
   return r;
 }
 
-static void
-destroy (grpc_fd * fd)
-{
-  gpr_mu_destroy (&fd->set_state_mu);
-  gpr_mu_destroy (&fd->watcher_mu);
-  gpr_free (fd);
+static void destroy(grpc_fd *fd) {
+  gpr_mu_destroy(&fd->set_state_mu);
+  gpr_mu_destroy(&fd->watcher_mu);
+  gpr_free(fd);
 }
 
 #ifdef GRPC_FD_REF_COUNT_DEBUG
 #define REF_BY(fd, n, reason) ref_by(fd, n, reason, __FILE__, __LINE__)
 #define UNREF_BY(fd, n, reason) unref_by(fd, n, reason, __FILE__, __LINE__)
-static void
-ref_by (grpc_fd * fd, int n, const char *reason, const char *file, int line)
-{
-  gpr_log (GPR_DEBUG, "FD %d %p   ref %d %d -> %d [%s; %s:%d]", fd->fd, fd, n, gpr_atm_no_barrier_load (&fd->refst), gpr_atm_no_barrier_load (&fd->refst) + n, reason, file, line);
+static void ref_by(grpc_fd *fd, int n, const char *reason, const char *file,
+                   int line) {
+  gpr_log(GPR_DEBUG, "FD %d %p   ref %d %d -> %d [%s; %s:%d]", fd->fd, fd, n,
+          gpr_atm_no_barrier_load(&fd->refst),
+          gpr_atm_no_barrier_load(&fd->refst) + n, reason, file, line);
 #else
 #define REF_BY(fd, n, reason) ref_by(fd, n)
 #define UNREF_BY(fd, n, reason) unref_by(fd, n)
-static void
-ref_by (grpc_fd * fd, int n)
-{
+static void ref_by(grpc_fd *fd, int n) {
 #endif
-  GPR_ASSERT (gpr_atm_no_barrier_fetch_add (&fd->refst, n) > 0);
+  GPR_ASSERT(gpr_atm_no_barrier_fetch_add(&fd->refst, n) > 0);
 }
 
 #ifdef GRPC_FD_REF_COUNT_DEBUG
-static void
-unref_by (grpc_fd * fd, int n, const char *reason, const char *file, int line)
-{
+static void unref_by(grpc_fd *fd, int n, const char *reason, const char *file,
+                     int line) {
   gpr_atm old;
-  gpr_log (GPR_DEBUG, "FD %d %p unref %d %d -> %d [%s; %s:%d]", fd->fd, fd, n, gpr_atm_no_barrier_load (&fd->refst), gpr_atm_no_barrier_load (&fd->refst) - n, reason, file, line);
+  gpr_log(GPR_DEBUG, "FD %d %p unref %d %d -> %d [%s; %s:%d]", fd->fd, fd, n,
+          gpr_atm_no_barrier_load(&fd->refst),
+          gpr_atm_no_barrier_load(&fd->refst) - n, reason, file, line);
 #else
-static void
-unref_by (grpc_fd * fd, int n)
-{
+static void unref_by(grpc_fd *fd, int n) {
   gpr_atm old;
 #endif
-  old = gpr_atm_full_fetch_add (&fd->refst, -n);
-  if (old == n)
-    {
-      freelist_fd (fd);
-    }
-  else
-    {
-      GPR_ASSERT (old > n);
-    }
+  old = gpr_atm_full_fetch_add(&fd->refst, -n);
+  if (old == n) {
+    freelist_fd(fd);
+  } else {
+    GPR_ASSERT(old > n);
+  }
 }
 
-void
-grpc_fd_global_init (void)
-{
-  gpr_mu_init (&fd_freelist_mu);
+void grpc_fd_global_init(void) { gpr_mu_init(&fd_freelist_mu); }
+
+void grpc_fd_global_shutdown(void) {
+  gpr_mu_lock(&fd_freelist_mu);
+  gpr_mu_unlock(&fd_freelist_mu);
+  while (fd_freelist != NULL) {
+    grpc_fd *fd = fd_freelist;
+    fd_freelist = fd_freelist->freelist_next;
+    destroy(fd);
+  }
+  gpr_mu_destroy(&fd_freelist_mu);
 }
 
-void
-grpc_fd_global_shutdown (void)
-{
-  gpr_mu_lock (&fd_freelist_mu);
-  gpr_mu_unlock (&fd_freelist_mu);
-  while (fd_freelist != NULL)
-    {
-      grpc_fd *fd = fd_freelist;
-      fd_freelist = fd_freelist->freelist_next;
-      destroy (fd);
-    }
-  gpr_mu_destroy (&fd_freelist_mu);
-}
-
-grpc_fd *
-grpc_fd_create (int fd, const char *name)
-{
-  grpc_fd *r = alloc_fd (fd);
-  grpc_iomgr_register_object (&r->iomgr_object, name);
+grpc_fd *grpc_fd_create(int fd, const char *name) {
+  grpc_fd *r = alloc_fd(fd);
+  grpc_iomgr_register_object(&r->iomgr_object, name);
   return r;
 }
 
-int
-grpc_fd_is_orphaned (grpc_fd * fd)
-{
-  return (gpr_atm_acq_load (&fd->refst) & 1) == 0;
+int grpc_fd_is_orphaned(grpc_fd *fd) {
+  return (gpr_atm_acq_load(&fd->refst) & 1) == 0;
 }
 
-static void
-pollset_kick_locked (grpc_pollset * pollset)
-{
-  gpr_mu_lock (GRPC_POLLSET_MU (pollset));
-  grpc_pollset_kick (pollset, NULL);
-  gpr_mu_unlock (GRPC_POLLSET_MU (pollset));
+static void pollset_kick_locked(grpc_pollset *pollset) {
+  gpr_mu_lock(GRPC_POLLSET_MU(pollset));
+  grpc_pollset_kick(pollset, NULL);
+  gpr_mu_unlock(GRPC_POLLSET_MU(pollset));
 }
 
-static void
-maybe_wake_one_watcher_locked (grpc_fd * fd)
-{
-  if (fd->inactive_watcher_root.next != &fd->inactive_watcher_root)
-    {
-      pollset_kick_locked (fd->inactive_watcher_root.next->pollset);
-    }
-  else if (fd->read_watcher)
-    {
-      pollset_kick_locked (fd->read_watcher->pollset);
-    }
-  else if (fd->write_watcher)
-    {
-      pollset_kick_locked (fd->write_watcher->pollset);
-    }
+static void maybe_wake_one_watcher_locked(grpc_fd *fd) {
+  if (fd->inactive_watcher_root.next != &fd->inactive_watcher_root) {
+    pollset_kick_locked(fd->inactive_watcher_root.next->pollset);
+  } else if (fd->read_watcher) {
+    pollset_kick_locked(fd->read_watcher->pollset);
+  } else if (fd->write_watcher) {
+    pollset_kick_locked(fd->write_watcher->pollset);
+  }
 }
 
-static void
-maybe_wake_one_watcher (grpc_fd * fd)
-{
-  gpr_mu_lock (&fd->watcher_mu);
-  maybe_wake_one_watcher_locked (fd);
-  gpr_mu_unlock (&fd->watcher_mu);
+static void maybe_wake_one_watcher(grpc_fd *fd) {
+  gpr_mu_lock(&fd->watcher_mu);
+  maybe_wake_one_watcher_locked(fd);
+  gpr_mu_unlock(&fd->watcher_mu);
 }
 
-static void
-wake_all_watchers_locked (grpc_fd * fd)
-{
+static void wake_all_watchers_locked(grpc_fd *fd) {
   grpc_fd_watcher *watcher;
-  for (watcher = fd->inactive_watcher_root.next; watcher != &fd->inactive_watcher_root; watcher = watcher->next)
-    {
-      pollset_kick_locked (watcher->pollset);
-    }
-  if (fd->read_watcher)
-    {
-      pollset_kick_locked (fd->read_watcher->pollset);
-    }
-  if (fd->write_watcher && fd->write_watcher != fd->read_watcher)
-    {
-      pollset_kick_locked (fd->write_watcher->pollset);
-    }
+  for (watcher = fd->inactive_watcher_root.next;
+       watcher != &fd->inactive_watcher_root; watcher = watcher->next) {
+    pollset_kick_locked(watcher->pollset);
+  }
+  if (fd->read_watcher) {
+    pollset_kick_locked(fd->read_watcher->pollset);
+  }
+  if (fd->write_watcher && fd->write_watcher != fd->read_watcher) {
+    pollset_kick_locked(fd->write_watcher->pollset);
+  }
 }
 
-static int
-has_watchers (grpc_fd * fd)
-{
-  return fd->read_watcher != NULL || fd->write_watcher != NULL || fd->inactive_watcher_root.next != &fd->inactive_watcher_root;
+static int has_watchers(grpc_fd *fd) {
+  return fd->read_watcher != NULL || fd->write_watcher != NULL ||
+         fd->inactive_watcher_root.next != &fd->inactive_watcher_root;
 }
 
-void
-grpc_fd_orphan (grpc_exec_ctx * exec_ctx, grpc_fd * fd, grpc_closure * on_done, const char *reason)
-{
+void grpc_fd_orphan(grpc_exec_ctx *exec_ctx, grpc_fd *fd, grpc_closure *on_done,
+                    const char *reason) {
   fd->on_done_closure = on_done;
-  shutdown (fd->fd, SHUT_RDWR);
-  gpr_mu_lock (&fd->watcher_mu);
-  REF_BY (fd, 1, reason);	/* remove active status, but keep referenced */
-  if (!has_watchers (fd))
-    {
-      fd->closed = 1;
-      close (fd->fd);
-      grpc_exec_ctx_enqueue (exec_ctx, fd->on_done_closure, 1);
-    }
-  else
-    {
-      wake_all_watchers_locked (fd);
-    }
-  gpr_mu_unlock (&fd->watcher_mu);
-  UNREF_BY (fd, 2, reason);	/* drop the reference */
+  shutdown(fd->fd, SHUT_RDWR);
+  gpr_mu_lock(&fd->watcher_mu);
+  REF_BY(fd, 1, reason); /* remove active status, but keep referenced */
+  if (!has_watchers(fd)) {
+    fd->closed = 1;
+    close(fd->fd);
+    grpc_exec_ctx_enqueue(exec_ctx, fd->on_done_closure, 1);
+  } else {
+    wake_all_watchers_locked(fd);
+  }
+  gpr_mu_unlock(&fd->watcher_mu);
+  UNREF_BY(fd, 2, reason); /* drop the reference */
 }
 
 /* increment refcount by two to avoid changing the orphan bit */
 #ifdef GRPC_FD_REF_COUNT_DEBUG
-void
-grpc_fd_ref (grpc_fd * fd, const char *reason, const char *file, int line)
-{
-  ref_by (fd, 2, reason, file, line);
+void grpc_fd_ref(grpc_fd *fd, const char *reason, const char *file, int line) {
+  ref_by(fd, 2, reason, file, line);
 }
 
-void
-grpc_fd_unref (grpc_fd * fd, const char *reason, const char *file, int line)
-{
-  unref_by (fd, 2, reason, file, line);
+void grpc_fd_unref(grpc_fd *fd, const char *reason, const char *file,
+                   int line) {
+  unref_by(fd, 2, reason, file, line);
 }
 #else
-void
-grpc_fd_ref (grpc_fd * fd)
-{
-  ref_by (fd, 2);
-}
+void grpc_fd_ref(grpc_fd *fd) { ref_by(fd, 2); }
 
-void
-grpc_fd_unref (grpc_fd * fd)
-{
-  unref_by (fd, 2);
-}
+void grpc_fd_unref(grpc_fd *fd) { unref_by(fd, 2); }
 #endif
 
-static void
-notify_on (grpc_exec_ctx * exec_ctx, grpc_fd * fd, gpr_atm * st, grpc_closure * closure)
-{
-  switch (gpr_atm_acq_load (st))
-    {
+static void notify_on(grpc_exec_ctx *exec_ctx, grpc_fd *fd, gpr_atm *st,
+                      grpc_closure *closure) {
+  switch (gpr_atm_acq_load(st)) {
     case NOT_READY:
       /* There is no race if the descriptor is already ready, so we skip
          the interlocked op in that case.  As long as the app doesn't
@@ -311,195 +254,177 @@ notify_on (grpc_exec_ctx * exec_ctx, grpc_fd * fd, gpr_atm * st, grpc_closure *
          oldval should never be anything other than READY or NOT_READY.  We
          don't
          check for user error on the fast path. */
-      if (gpr_atm_rel_cas (st, NOT_READY, (gpr_intptr) closure))
-	{
-	  /* swap was successful -- the closure will run after the next
-	     set_ready call.  NOTE: we don't have an ABA problem here,
-	     since we should never have concurrent calls to the same
-	     notify_on function. */
-	  maybe_wake_one_watcher (fd);
-	  return;
-	}
-      /* swap was unsuccessful due to an intervening set_ready call.
-         Fall through to the READY code below */
+      if (gpr_atm_rel_cas(st, NOT_READY, (gpr_intptr)closure)) {
+        /* swap was successful -- the closure will run after the next
+           set_ready call.  NOTE: we don't have an ABA problem here,
+           since we should never have concurrent calls to the same
+           notify_on function. */
+        maybe_wake_one_watcher(fd);
+        return;
+      }
+    /* swap was unsuccessful due to an intervening set_ready call.
+       Fall through to the READY code below */
     case READY:
-      GPR_ASSERT (gpr_atm_no_barrier_load (st) == READY);
-      gpr_atm_rel_store (st, NOT_READY);
-      grpc_exec_ctx_enqueue (exec_ctx, closure, !gpr_atm_acq_load (&fd->shutdown));
+      GPR_ASSERT(gpr_atm_no_barrier_load(st) == READY);
+      gpr_atm_rel_store(st, NOT_READY);
+      grpc_exec_ctx_enqueue(exec_ctx, closure,
+                            !gpr_atm_acq_load(&fd->shutdown));
       return;
-    default:			/* WAITING */
+    default: /* WAITING */
       /* upcallptr was set to a different closure.  This is an error! */
-      gpr_log (GPR_ERROR, "User called a notify_on function with a previous callback still " "pending");
-      abort ();
-    }
-  gpr_log (GPR_ERROR, "Corrupt memory in &st->state");
-  abort ();
+      gpr_log(GPR_ERROR,
+              "User called a notify_on function with a previous callback still "
+              "pending");
+      abort();
+  }
+  gpr_log(GPR_ERROR, "Corrupt memory in &st->state");
+  abort();
 }
 
-static void
-set_ready_locked (grpc_exec_ctx * exec_ctx, grpc_fd * fd, gpr_atm * st)
-{
-  gpr_intptr state = gpr_atm_acq_load (st);
+static void set_ready_locked(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
+                             gpr_atm *st) {
+  gpr_intptr state = gpr_atm_acq_load(st);
 
-  switch (state)
-    {
+  switch (state) {
     case READY:
       /* duplicate ready, ignore */
       return;
     case NOT_READY:
-      if (gpr_atm_rel_cas (st, NOT_READY, READY))
-	{
-	  /* swap was successful -- the closure will run after the next
-	     notify_on call. */
-	  return;
-	}
+      if (gpr_atm_rel_cas(st, NOT_READY, READY)) {
+        /* swap was successful -- the closure will run after the next
+           notify_on call. */
+        return;
+      }
       /* swap was unsuccessful due to an intervening set_ready call.
          Fall through to the WAITING code below */
-      state = gpr_atm_acq_load (st);
-    default:			/* waiting */
-      GPR_ASSERT (gpr_atm_no_barrier_load (st) != READY && gpr_atm_no_barrier_load (st) != NOT_READY);
-      grpc_exec_ctx_enqueue (exec_ctx, (grpc_closure *) state, !gpr_atm_acq_load (&fd->shutdown));
-      gpr_atm_rel_store (st, NOT_READY);
+      state = gpr_atm_acq_load(st);
+    default: /* waiting */
+      GPR_ASSERT(gpr_atm_no_barrier_load(st) != READY &&
+                 gpr_atm_no_barrier_load(st) != NOT_READY);
+      grpc_exec_ctx_enqueue(exec_ctx, (grpc_closure *)state,
+                            !gpr_atm_acq_load(&fd->shutdown));
+      gpr_atm_rel_store(st, NOT_READY);
       return;
-    }
+  }
 }
 
-static void
-set_ready (grpc_exec_ctx * exec_ctx, grpc_fd * fd, gpr_atm * st)
-{
+static void set_ready(grpc_exec_ctx *exec_ctx, grpc_fd *fd, gpr_atm *st) {
   /* only one set_ready can be active at once (but there may be a racing
      notify_on) */
-  gpr_mu_lock (&fd->set_state_mu);
-  set_ready_locked (exec_ctx, fd, st);
-  gpr_mu_unlock (&fd->set_state_mu);
+  gpr_mu_lock(&fd->set_state_mu);
+  set_ready_locked(exec_ctx, fd, st);
+  gpr_mu_unlock(&fd->set_state_mu);
 }
 
-void
-grpc_fd_shutdown (grpc_exec_ctx * exec_ctx, grpc_fd * fd)
-{
-  gpr_mu_lock (&fd->set_state_mu);
-  GPR_ASSERT (!gpr_atm_no_barrier_load (&fd->shutdown));
-  gpr_atm_rel_store (&fd->shutdown, 1);
-  set_ready_locked (exec_ctx, fd, &fd->readst);
-  set_ready_locked (exec_ctx, fd, &fd->writest);
-  gpr_mu_unlock (&fd->set_state_mu);
+void grpc_fd_shutdown(grpc_exec_ctx *exec_ctx, grpc_fd *fd) {
+  gpr_mu_lock(&fd->set_state_mu);
+  GPR_ASSERT(!gpr_atm_no_barrier_load(&fd->shutdown));
+  gpr_atm_rel_store(&fd->shutdown, 1);
+  set_ready_locked(exec_ctx, fd, &fd->readst);
+  set_ready_locked(exec_ctx, fd, &fd->writest);
+  gpr_mu_unlock(&fd->set_state_mu);
 }
 
-void
-grpc_fd_notify_on_read (grpc_exec_ctx * exec_ctx, grpc_fd * fd, grpc_closure * closure)
-{
-  notify_on (exec_ctx, fd, &fd->readst, closure);
+void grpc_fd_notify_on_read(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
+                            grpc_closure *closure) {
+  notify_on(exec_ctx, fd, &fd->readst, closure);
 }
 
-void
-grpc_fd_notify_on_write (grpc_exec_ctx * exec_ctx, grpc_fd * fd, grpc_closure * closure)
-{
-  notify_on (exec_ctx, fd, &fd->writest, closure);
+void grpc_fd_notify_on_write(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
+                             grpc_closure *closure) {
+  notify_on(exec_ctx, fd, &fd->writest, closure);
 }
 
-gpr_uint32
-grpc_fd_begin_poll (grpc_fd * fd, grpc_pollset * pollset, gpr_uint32 read_mask, gpr_uint32 write_mask, grpc_fd_watcher * watcher)
-{
+gpr_uint32 grpc_fd_begin_poll(grpc_fd *fd, grpc_pollset *pollset,
+                              gpr_uint32 read_mask, gpr_uint32 write_mask,
+                              grpc_fd_watcher *watcher) {
   gpr_uint32 mask = 0;
   /* keep track of pollers that have requested our events, in case they change
    */
-  GRPC_FD_REF (fd, "poll");
+  GRPC_FD_REF(fd, "poll");
 
-  gpr_mu_lock (&fd->watcher_mu);
+  gpr_mu_lock(&fd->watcher_mu);
   /* if we are shutdown, then don't add to the watcher set */
-  if (gpr_atm_no_barrier_load (&fd->shutdown))
-    {
-      watcher->fd = NULL;
-      watcher->pollset = NULL;
-      gpr_mu_unlock (&fd->watcher_mu);
-      GRPC_FD_UNREF (fd, "poll");
-      return 0;
-    }
+  if (gpr_atm_no_barrier_load(&fd->shutdown)) {
+    watcher->fd = NULL;
+    watcher->pollset = NULL;
+    gpr_mu_unlock(&fd->watcher_mu);
+    GRPC_FD_UNREF(fd, "poll");
+    return 0;
+  }
   /* if there is nobody polling for read, but we need to, then start doing so */
-  if (read_mask && !fd->read_watcher && (gpr_uintptr) gpr_atm_acq_load (&fd->readst) > READY)
-    {
-      fd->read_watcher = watcher;
-      mask |= read_mask;
-    }
+  if (read_mask && !fd->read_watcher &&
+      (gpr_uintptr)gpr_atm_acq_load(&fd->readst) > READY) {
+    fd->read_watcher = watcher;
+    mask |= read_mask;
+  }
   /* if there is nobody polling for write, but we need to, then start doing so
    */
-  if (write_mask && !fd->write_watcher && (gpr_uintptr) gpr_atm_acq_load (&fd->writest) > READY)
-    {
-      fd->write_watcher = watcher;
-      mask |= write_mask;
-    }
+  if (write_mask && !fd->write_watcher &&
+      (gpr_uintptr)gpr_atm_acq_load(&fd->writest) > READY) {
+    fd->write_watcher = watcher;
+    mask |= write_mask;
+  }
   /* if not polling, remember this watcher in case we need someone to later */
-  if (mask == 0)
-    {
-      watcher->next = &fd->inactive_watcher_root;
-      watcher->prev = watcher->next->prev;
-      watcher->next->prev = watcher->prev->next = watcher;
-    }
+  if (mask == 0) {
+    watcher->next = &fd->inactive_watcher_root;
+    watcher->prev = watcher->next->prev;
+    watcher->next->prev = watcher->prev->next = watcher;
+  }
   watcher->pollset = pollset;
   watcher->fd = fd;
-  gpr_mu_unlock (&fd->watcher_mu);
+  gpr_mu_unlock(&fd->watcher_mu);
 
   return mask;
 }
 
-void
-grpc_fd_end_poll (grpc_exec_ctx * exec_ctx, grpc_fd_watcher * watcher, int got_read, int got_write)
-{
+void grpc_fd_end_poll(grpc_exec_ctx *exec_ctx, grpc_fd_watcher *watcher,
+                      int got_read, int got_write) {
   int was_polling = 0;
   int kick = 0;
   grpc_fd *fd = watcher->fd;
 
-  if (fd == NULL)
-    {
-      return;
-    }
-
-  gpr_mu_lock (&fd->watcher_mu);
-  if (watcher == fd->read_watcher)
-    {
-      /* remove read watcher, kick if we still need a read */
-      was_polling = 1;
-      kick = kick || !got_read;
-      fd->read_watcher = NULL;
-    }
-  if (watcher == fd->write_watcher)
-    {
-      /* remove write watcher, kick if we still need a write */
-      was_polling = 1;
-      kick = kick || !got_write;
-      fd->write_watcher = NULL;
-    }
-  if (!was_polling)
-    {
-      /* remove from inactive list */
-      watcher->next->prev = watcher->prev;
-      watcher->prev->next = watcher->next;
-    }
-  if (kick)
-    {
-      maybe_wake_one_watcher_locked (fd);
-    }
-  if (grpc_fd_is_orphaned (fd) && !has_watchers (fd) && !fd->closed)
-    {
-      fd->closed = 1;
-      close (fd->fd);
-      grpc_exec_ctx_enqueue (exec_ctx, fd->on_done_closure, 1);
-    }
-  gpr_mu_unlock (&fd->watcher_mu);
-
-  GRPC_FD_UNREF (fd, "poll");
+  if (fd == NULL) {
+    return;
+  }
+
+  gpr_mu_lock(&fd->watcher_mu);
+  if (watcher == fd->read_watcher) {
+    /* remove read watcher, kick if we still need a read */
+    was_polling = 1;
+    kick = kick || !got_read;
+    fd->read_watcher = NULL;
+  }
+  if (watcher == fd->write_watcher) {
+    /* remove write watcher, kick if we still need a write */
+    was_polling = 1;
+    kick = kick || !got_write;
+    fd->write_watcher = NULL;
+  }
+  if (!was_polling) {
+    /* remove from inactive list */
+    watcher->next->prev = watcher->prev;
+    watcher->prev->next = watcher->next;
+  }
+  if (kick) {
+    maybe_wake_one_watcher_locked(fd);
+  }
+  if (grpc_fd_is_orphaned(fd) && !has_watchers(fd) && !fd->closed) {
+    fd->closed = 1;
+    close(fd->fd);
+    grpc_exec_ctx_enqueue(exec_ctx, fd->on_done_closure, 1);
+  }
+  gpr_mu_unlock(&fd->watcher_mu);
+
+  GRPC_FD_UNREF(fd, "poll");
 }
 
-void
-grpc_fd_become_readable (grpc_exec_ctx * exec_ctx, grpc_fd * fd)
-{
-  set_ready (exec_ctx, fd, &fd->readst);
+void grpc_fd_become_readable(grpc_exec_ctx *exec_ctx, grpc_fd *fd) {
+  set_ready(exec_ctx, fd, &fd->readst);
 }
 
-void
-grpc_fd_become_writable (grpc_exec_ctx * exec_ctx, grpc_fd * fd)
-{
-  set_ready (exec_ctx, fd, &fd->writest);
+void grpc_fd_become_writable(grpc_exec_ctx *exec_ctx, grpc_fd *fd) {
+  set_ready(exec_ctx, fd, &fd->writest);
 }
 
 #endif

src/core/iomgr/fd_posix.h

@@ -42,16 +42,14 @@
 
 typedef struct grpc_fd grpc_fd;
 
-typedef struct grpc_fd_watcher
-{
+typedef struct grpc_fd_watcher {
   struct grpc_fd_watcher *next;
   struct grpc_fd_watcher *prev;
   grpc_pollset *pollset;
   grpc_fd *fd;
 } grpc_fd_watcher;
 
-struct grpc_fd
-{
+struct grpc_fd {
   int fd;
   /* refst format:
      bit0:   1=active/0=orphaned
@@ -105,7 +103,7 @@ struct grpc_fd
 /* Create a wrapped file descriptor.
    Requires fd is a non-blocking file descriptor.
    This takes ownership of closing fd. */
-grpc_fd *grpc_fd_create (int fd, const char *name);
+grpc_fd *grpc_fd_create(int fd, const char *name);
 
 /* Releases fd to be asynchronously destroyed.
    on_done is called when the underlying file descriptor is definitely close()d.
@@ -113,7 +111,8 @@ grpc_fd *grpc_fd_create (int fd, const char *name);
    Requires: *fd initialized; no outstanding notify_on_read or
    notify_on_write.
    MUST NOT be called with a pollset lock taken */
-void grpc_fd_orphan (grpc_exec_ctx * exec_ctx, grpc_fd * fd, grpc_closure * on_done, const char *reason);
+void grpc_fd_orphan(grpc_exec_ctx *exec_ctx, grpc_fd *fd, grpc_closure *on_done,
+                    const char *reason);
 
 /* Begin polling on an fd.
    Registers that the given pollset is interested in this fd - so that if read
@@ -126,16 +125,19 @@ void grpc_fd_orphan (grpc_exec_ctx * exec_ctx, grpc_fd * fd, grpc_closure * on_d
    Polling strategies that do not need to alter their behavior depending on the
    fd's current interest (such as epoll) do not need to call this function.
    MUST NOT be called with a pollset lock taken */
-gpr_uint32 grpc_fd_begin_poll (grpc_fd * fd, grpc_pollset * pollset, gpr_uint32 read_mask, gpr_uint32 write_mask, grpc_fd_watcher * rec);
+gpr_uint32 grpc_fd_begin_poll(grpc_fd *fd, grpc_pollset *pollset,
+                              gpr_uint32 read_mask, gpr_uint32 write_mask,
+                              grpc_fd_watcher *rec);
 /* Complete polling previously started with grpc_fd_begin_poll
    MUST NOT be called with a pollset lock taken */
-void grpc_fd_end_poll (grpc_exec_ctx * exec_ctx, grpc_fd_watcher * rec, int got_read, int got_write);
+void grpc_fd_end_poll(grpc_exec_ctx *exec_ctx, grpc_fd_watcher *rec,
+                      int got_read, int got_write);
 
 /* Return 1 if this fd is orphaned, 0 otherwise */
-int grpc_fd_is_orphaned (grpc_fd * fd);
+int grpc_fd_is_orphaned(grpc_fd *fd);
 
 /* Cause any current callbacks to error out with GRPC_CALLBACK_CANCELLED. */
-void grpc_fd_shutdown (grpc_exec_ctx * exec_ctx, grpc_fd * fd);
+void grpc_fd_shutdown(grpc_exec_ctx *exec_ctx, grpc_fd *fd);
 
 /* Register read interest, causing read_cb to be called once when fd becomes
    readable, on deadline specified by deadline, or on shutdown triggered by
@@ -150,32 +152,34 @@ void grpc_fd_shutdown (grpc_exec_ctx * exec_ctx, grpc_fd * fd);
    underlying platform. This means that users must drain fd in read_cb before
    calling notify_on_read again. Users are also expected to handle spurious
    events, i.e read_cb is called while nothing can be readable from fd  */
-void grpc_fd_notify_on_read (grpc_exec_ctx * exec_ctx, grpc_fd * fd, grpc_closure * closure);
+void grpc_fd_notify_on_read(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
+                            grpc_closure *closure);
 
 /* Exactly the same semantics as above, except based on writable events.  */
-void grpc_fd_notify_on_write (grpc_exec_ctx * exec_ctx, grpc_fd * fd, grpc_closure * closure);
+void grpc_fd_notify_on_write(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
+                             grpc_closure *closure);
 
 /* Notification from the poller to an fd that it has become readable or
    writable.
    If allow_synchronous_callback is 1, allow running the fd callback inline
    in this callstack, otherwise register an asynchronous callback and return */
-void grpc_fd_become_readable (grpc_exec_ctx * exec_ctx, grpc_fd * fd);
-void grpc_fd_become_writable (grpc_exec_ctx * exec_ctx, grpc_fd * fd);
+void grpc_fd_become_readable(grpc_exec_ctx *exec_ctx, grpc_fd *fd);
+void grpc_fd_become_writable(grpc_exec_ctx *exec_ctx, grpc_fd *fd);
 
 /* Reference counting for fds */
 #ifdef GRPC_FD_REF_COUNT_DEBUG
-void grpc_fd_ref (grpc_fd * fd, const char *reason, const char *file, int line);
-void grpc_fd_unref (grpc_fd * fd, const char *reason, const char *file, int line);
+void grpc_fd_ref(grpc_fd *fd, const char *reason, const char *file, int line);
+void grpc_fd_unref(grpc_fd *fd, const char *reason, const char *file, int line);
 #define GRPC_FD_REF(fd, reason) grpc_fd_ref(fd, reason, __FILE__, __LINE__)
 #define GRPC_FD_UNREF(fd, reason) grpc_fd_unref(fd, reason, __FILE__, __LINE__)
 #else
-void grpc_fd_ref (grpc_fd * fd);
-void grpc_fd_unref (grpc_fd * fd);
+void grpc_fd_ref(grpc_fd *fd);
+void grpc_fd_unref(grpc_fd *fd);
 #define GRPC_FD_REF(fd, reason) grpc_fd_ref(fd)
 #define GRPC_FD_UNREF(fd, reason) grpc_fd_unref(fd)
 #endif
 
-void grpc_fd_global_init (void);
-void grpc_fd_global_shutdown (void);
+void grpc_fd_global_init(void);
+void grpc_fd_global_shutdown(void);
 
 #endif /* GRPC_INTERNAL_CORE_IOMGR_FD_POSIX_H */

src/core/iomgr/iocp_windows.c

@@ -56,9 +56,7 @@ static gpr_atm g_custom_events = 0;
 
 static HANDLE g_iocp;
 
-static void
-do_iocp_work ()
-{
+static void do_iocp_work() {
   BOOL success;
   DWORD bytes = 0;
   DWORD flags = 0;
@@ -66,159 +64,135 @@ do_iocp_work ()
   LPOVERLAPPED overlapped;
   grpc_winsocket *socket;
   grpc_winsocket_callback_info *info;
-  void (*f) (void *, int) = NULL;
+  void (*f)(void *, int) = NULL;
   void *opaque = NULL;
-  success = GetQueuedCompletionStatus (g_iocp, &bytes, &completion_key, &overlapped, INFINITE);
+  success = GetQueuedCompletionStatus(g_iocp, &bytes, &completion_key,
+                                      &overlapped, INFINITE);
   /* success = 0 and overlapped = NULL means the deadline got attained.
      Which is impossible. since our wait time is +inf */
-  GPR_ASSERT (success || overlapped);
-  GPR_ASSERT (completion_key && overlapped);
-  if (overlapped == &g_iocp_custom_overlap)
-    {
-      gpr_atm_full_fetch_add (&g_custom_events, -1);
-      if (completion_key == (ULONG_PTR) & g_iocp_kick_token)
-	{
-	  /* We were awoken from a kick. */
-	  return;
-	}
-      gpr_log (GPR_ERROR, "Unknown custom completion key.");
-      abort ();
+  GPR_ASSERT(success || overlapped);
+  GPR_ASSERT(completion_key && overlapped);
+  if (overlapped == &g_iocp_custom_overlap) {
+    gpr_atm_full_fetch_add(&g_custom_events, -1);
+    if (completion_key == (ULONG_PTR)&g_iocp_kick_token) {
+      /* We were awoken from a kick. */
+      return;
     }
-
-  socket = (grpc_winsocket *) completion_key;
-  if (overlapped == &socket->write_info.overlapped)
-    {
-      info = &socket->write_info;
-    }
-  else if (overlapped == &socket->read_info.overlapped)
-    {
-      info = &socket->read_info;
-    }
-  else
-    {
-      gpr_log (GPR_ERROR, "Unknown IOCP operation");
-      abort ();
-    }
-  success = WSAGetOverlappedResult (socket->socket, &info->overlapped, &bytes, FALSE, &flags);
+    gpr_log(GPR_ERROR, "Unknown custom completion key.");
+    abort();
+  }
+
+  socket = (grpc_winsocket *)completion_key;
+  if (overlapped == &socket->write_info.overlapped) {
+    info = &socket->write_info;
+  } else if (overlapped == &socket->read_info.overlapped) {
+    info = &socket->read_info;
+  } else {
+    gpr_log(GPR_ERROR, "Unknown IOCP operation");
+    abort();
+  }
+  success = WSAGetOverlappedResult(socket->socket, &info->overlapped, &bytes,
+                                   FALSE, &flags);
   info->bytes_transfered = bytes;
-  info->wsa_error = success ? 0 : WSAGetLastError ();
-  GPR_ASSERT (overlapped == &info->overlapped);
-  GPR_ASSERT (!info->has_pending_iocp);
-  gpr_mu_lock (&socket->state_mu);
-  if (info->cb)
-    {
-      f = info->cb;
-      opaque = info->opaque;
-      info->cb = NULL;
-    }
-  else
-    {
-      info->has_pending_iocp = 1;
-    }
-  gpr_mu_unlock (&socket->state_mu);
-  if (f)
-    f (opaque, 1);
+  info->wsa_error = success ? 0 : WSAGetLastError();
+  GPR_ASSERT(overlapped == &info->overlapped);
+  GPR_ASSERT(!info->has_pending_iocp);
+  gpr_mu_lock(&socket->state_mu);
+  if (info->cb) {
+    f = info->cb;
+    opaque = info->opaque;
+    info->cb = NULL;
+  } else {
+    info->has_pending_iocp = 1;
+  }
+  gpr_mu_unlock(&socket->state_mu);
+  if (f) f(opaque, 1);
 }
 
-static void
-iocp_loop (void *p)
-{
-  while (gpr_atm_acq_load (&g_custom_events) || !gpr_event_get (&g_shutdown_iocp))
-    {
-      do_iocp_work ();
-    }
+static void iocp_loop(void *p) {
+  while (gpr_atm_acq_load(&g_custom_events) ||
+         !gpr_event_get(&g_shutdown_iocp)) {
+    do_iocp_work();
+  }
 
-  gpr_event_set (&g_iocp_done, (void *) 1);
+  gpr_event_set(&g_iocp_done, (void *)1);
 }
 
-void
-grpc_iocp_init (void)
-{
+void grpc_iocp_init(void) {
   gpr_thd_id id;
 
-  g_iocp = CreateIoCompletionPort (INVALID_HANDLE_VALUE, NULL, (ULONG_PTR) NULL, 0);
-  GPR_ASSERT (g_iocp);
+  g_iocp =
+      CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, (ULONG_PTR)NULL, 0);
+  GPR_ASSERT(g_iocp);
 
-  gpr_event_init (&g_iocp_done);
-  gpr_event_init (&g_shutdown_iocp);
-  gpr_thd_new (&id, iocp_loop, NULL, NULL);
+  gpr_event_init(&g_iocp_done);
+  gpr_event_init(&g_shutdown_iocp);
+  gpr_thd_new(&id, iocp_loop, NULL, NULL);
 }
 
-void
-grpc_iocp_kick (void)
-{
+void grpc_iocp_kick(void) {
   BOOL success;
 
-  gpr_atm_full_fetch_add (&g_custom_events, 1);
-  success = PostQueuedCompletionStatus (g_iocp, 0, (ULONG_PTR) & g_iocp_kick_token, &g_iocp_custom_overlap);
-  GPR_ASSERT (success);
+  gpr_atm_full_fetch_add(&g_custom_events, 1);
+  success = PostQueuedCompletionStatus(g_iocp, 0, (ULONG_PTR)&g_iocp_kick_token,
+                                       &g_iocp_custom_overlap);
+  GPR_ASSERT(success);
 }
 
-void
-grpc_iocp_shutdown (void)
-{
+void grpc_iocp_shutdown(void) {
   BOOL success;
-  gpr_event_set (&g_shutdown_iocp, (void *) 1);
-  grpc_iocp_kick ();
-  gpr_event_wait (&g_iocp_done, gpr_inf_future (GPR_CLOCK_REALTIME));
-  success = CloseHandle (g_iocp);
-  GPR_ASSERT (success);
+  gpr_event_set(&g_shutdown_iocp, (void *)1);
+  grpc_iocp_kick();
+  gpr_event_wait(&g_iocp_done, gpr_inf_future(GPR_CLOCK_REALTIME));
+  success = CloseHandle(g_iocp);
+  GPR_ASSERT(success);
 }
 
-void
-grpc_iocp_add_socket (grpc_winsocket * socket)
-{
+void grpc_iocp_add_socket(grpc_winsocket *socket) {
   HANDLE ret;
-  if (socket->added_to_iocp)
-    return;
-  ret = CreateIoCompletionPort ((HANDLE) socket->socket, g_iocp, (gpr_uintptr) socket, 0);
-  if (!ret)
-    {
-      char *utf8_message = gpr_format_message (WSAGetLastError ());
-      gpr_log (GPR_ERROR, "Unable to add socket to iocp: %s", utf8_message);
-      gpr_free (utf8_message);
-      __debugbreak ();
-      abort ();
-    }
+  if (socket->added_to_iocp) return;
+  ret = CreateIoCompletionPort((HANDLE)socket->socket, g_iocp,
+                               (gpr_uintptr)socket, 0);
+  if (!ret) {
+    char *utf8_message = gpr_format_message(WSAGetLastError());
+    gpr_log(GPR_ERROR, "Unable to add socket to iocp: %s", utf8_message);
+    gpr_free(utf8_message);
+    __debugbreak();
+    abort();
+  }
   socket->added_to_iocp = 1;
-  GPR_ASSERT (ret == g_iocp);
+  GPR_ASSERT(ret == g_iocp);
 }
 
 /* Calling notify_on_read or write means either of two things:
    -) The IOCP already completed in the background, and we need to call
    the callback now.
    -) The IOCP hasn't completed yet, and we're queuing it for later. */
-static void
-socket_notify_on_iocp (grpc_winsocket * socket, void (*cb) (void *, int), void *opaque, grpc_winsocket_callback_info * info)
-{
+static void socket_notify_on_iocp(grpc_winsocket *socket,
+                                  void (*cb)(void *, int), void *opaque,
+                                  grpc_winsocket_callback_info *info) {
   int run_now = 0;
-  GPR_ASSERT (!info->cb);
-  gpr_mu_lock (&socket->state_mu);
-  if (info->has_pending_iocp)
-    {
-      run_now = 1;
-      info->has_pending_iocp = 0;
-    }
-  else
-    {
-      info->cb = cb;
-      info->opaque = opaque;
-    }
-  gpr_mu_unlock (&socket->state_mu);
-  if (run_now)
-    cb (opaque, 1);
+  GPR_ASSERT(!info->cb);
+  gpr_mu_lock(&socket->state_mu);
+  if (info->has_pending_iocp) {
+    run_now = 1;
+    info->has_pending_iocp = 0;
+  } else {
+    info->cb = cb;
+    info->opaque = opaque;
+  }
+  gpr_mu_unlock(&socket->state_mu);
+  if (run_now) cb(opaque, 1);
 }
 
-void
-grpc_socket_notify_on_write (grpc_winsocket * socket, void (*cb) (void *, int), void *opaque)
-{
-  socket_notify_on_iocp (socket, cb, opaque, &socket->write_info);
+void grpc_socket_notify_on_write(grpc_winsocket *socket,
+                                 void (*cb)(void *, int), void *opaque) {
+  socket_notify_on_iocp(socket, cb, opaque, &socket->write_info);
 }
 
-void
-grpc_socket_notify_on_read (grpc_winsocket * socket, void (*cb) (void *, int), void *opaque)
-{
-  socket_notify_on_iocp (socket, cb, opaque, &socket->read_info);
+void grpc_socket_notify_on_read(grpc_winsocket *socket, void (*cb)(void *, int),
+                                void *opaque) {
+  socket_notify_on_iocp(socket, cb, opaque, &socket->read_info);
 }
 
 #endif /* GPR_WINSOCK_SOCKET */

src/core/iomgr/iocp_windows.h

@@ -38,13 +38,15 @@
 
 #include "src/core/iomgr/socket_windows.h"
 
-void grpc_iocp_init (void);
-void grpc_iocp_kick (void);
-void grpc_iocp_shutdown (void);
-void grpc_iocp_add_socket (grpc_winsocket *);
+void grpc_iocp_init(void);
+void grpc_iocp_kick(void);
+void grpc_iocp_shutdown(void);
+void grpc_iocp_add_socket(grpc_winsocket *);
 
-void grpc_socket_notify_on_write (grpc_winsocket *, void (*cb) (void *, int success), void *opaque);
+void grpc_socket_notify_on_write(grpc_winsocket *,
+                                 void (*cb)(void *, int success), void *opaque);
 
-void grpc_socket_notify_on_read (grpc_winsocket *, void (*cb) (void *, int success), void *opaque);
+void grpc_socket_notify_on_read(grpc_winsocket *,
+                                void (*cb)(void *, int success), void *opaque);
 
 #endif /* GRPC_INTERNAL_CORE_IOMGR_IOCP_WINDOWS_H */

src/core/iomgr/iomgr.c

@@ -51,127 +51,112 @@ static gpr_cv g_rcv;
 static int g_shutdown;
 static grpc_iomgr_object g_root_object;
 
-void
-grpc_kick_poller (void)
-{
+void grpc_kick_poller(void) {
   /* Empty. The background callback executor polls periodically. The activity
    * the kicker is trying to draw the executor's attention to will be picked up
    * either by one of the periodic wakeups or by one of the polling application
    * threads. */
 }
 
-void
-grpc_iomgr_init (void)
-{
+void grpc_iomgr_init(void) {
   g_shutdown = 0;
-  gpr_mu_init (&g_mu);
-  gpr_cv_init (&g_rcv);
-  grpc_alarm_list_init (gpr_now (GPR_CLOCK_MONOTONIC));
+  gpr_mu_init(&g_mu);
+  gpr_cv_init(&g_rcv);
+  grpc_alarm_list_init(gpr_now(GPR_CLOCK_MONOTONIC));
   g_root_object.next = g_root_object.prev = &g_root_object;
   g_root_object.name = "root";
-  grpc_iomgr_platform_init ();
+  grpc_iomgr_platform_init();
 }
 
-static size_t
-count_objects (void)
-{
+static size_t count_objects(void) {
   grpc_iomgr_object *obj;
   size_t n = 0;
-  for (obj = g_root_object.next; obj != &g_root_object; obj = obj->next)
-    {
-      n++;
-    }
+  for (obj = g_root_object.next; obj != &g_root_object; obj = obj->next) {
+    n++;
+  }
   return n;
 }
 
-static void
-dump_objects (const char *kind)
-{
+static void dump_objects(const char *kind) {
   grpc_iomgr_object *obj;
-  for (obj = g_root_object.next; obj != &g_root_object; obj = obj->next)
-    {
-      gpr_log (GPR_DEBUG, "%s OBJECT: %s %p", kind, obj->name, obj);
-    }
+  for (obj = g_root_object.next; obj != &g_root_object; obj = obj->next) {
+    gpr_log(GPR_DEBUG, "%s OBJECT: %s %p", kind, obj->name, obj);
+  }
 }
 
-void
-grpc_iomgr_shutdown (void)
-{
-  gpr_timespec shutdown_deadline = gpr_time_add (gpr_now (GPR_CLOCK_REALTIME), gpr_time_from_seconds (10, GPR_TIMESPAN));
-  gpr_timespec last_warning_time = gpr_now (GPR_CLOCK_REALTIME);
+void grpc_iomgr_shutdown(void) {
+  gpr_timespec shutdown_deadline = gpr_time_add(
+      gpr_now(GPR_CLOCK_REALTIME), gpr_time_from_seconds(10, GPR_TIMESPAN));
+  gpr_timespec last_warning_time = gpr_now(GPR_CLOCK_REALTIME);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
-  gpr_mu_lock (&g_mu);
+  gpr_mu_lock(&g_mu);
   g_shutdown = 1;
-  while (g_root_object.next != &g_root_object)
-    {
-      if (gpr_time_cmp (gpr_time_sub (gpr_now (GPR_CLOCK_REALTIME), last_warning_time), gpr_time_from_seconds (1, GPR_TIMESPAN)) >= 0)
-	{
-	  if (g_root_object.next != &g_root_object)
-	    {
-	      gpr_log (GPR_DEBUG, "Waiting for %d iomgr objects to be destroyed", count_objects ());
-	    }
-	  last_warning_time = gpr_now (GPR_CLOCK_REALTIME);
-	}
-      if (grpc_alarm_check (&exec_ctx, gpr_inf_future (GPR_CLOCK_MONOTONIC), NULL))
-	{
-	  gpr_mu_unlock (&g_mu);
-	  grpc_exec_ctx_finish (&exec_ctx);
-	  gpr_mu_lock (&g_mu);
-	  continue;
-	}
-      if (g_root_object.next != &g_root_object)
-	{
-	  int timeout = 0;
-	  gpr_timespec short_deadline = gpr_time_add (gpr_now (GPR_CLOCK_REALTIME), gpr_time_from_millis (100, GPR_TIMESPAN));
-	  if (gpr_cv_wait (&g_rcv, &g_mu, short_deadline))
-	    {
-	      if (gpr_time_cmp (gpr_now (GPR_CLOCK_REALTIME), shutdown_deadline) > 0)
-		{
-		  timeout = 1;
-		  break;
-		}
-	    }
-	  if (timeout && g_root_object.next != &g_root_object)
-	    {
-	      gpr_log (GPR_DEBUG, "Failed to free %d iomgr objects before shutdown deadline: " "memory leaks are likely", count_objects ());
-	      dump_objects ("LEAKED");
-	      break;
-	    }
-	}
+  while (g_root_object.next != &g_root_object) {
+    if (gpr_time_cmp(
+            gpr_time_sub(gpr_now(GPR_CLOCK_REALTIME), last_warning_time),
+            gpr_time_from_seconds(1, GPR_TIMESPAN)) >= 0) {
+      if (g_root_object.next != &g_root_object) {
+        gpr_log(GPR_DEBUG, "Waiting for %d iomgr objects to be destroyed",
+                count_objects());
+      }
+      last_warning_time = gpr_now(GPR_CLOCK_REALTIME);
+    }
+    if (grpc_alarm_check(&exec_ctx, gpr_inf_future(GPR_CLOCK_MONOTONIC),
+                         NULL)) {
+      gpr_mu_unlock(&g_mu);
+      grpc_exec_ctx_finish(&exec_ctx);
+      gpr_mu_lock(&g_mu);
+      continue;
+    }
+    if (g_root_object.next != &g_root_object) {
+      int timeout = 0;
+      gpr_timespec short_deadline = gpr_time_add(
+          gpr_now(GPR_CLOCK_REALTIME), gpr_time_from_millis(100, GPR_TIMESPAN));
+      if (gpr_cv_wait(&g_rcv, &g_mu, short_deadline)) {
+        if (gpr_time_cmp(gpr_now(GPR_CLOCK_REALTIME), shutdown_deadline) > 0) {
+          timeout = 1;
+          break;
+        }
+      }
+      if (timeout && g_root_object.next != &g_root_object) {
+        gpr_log(GPR_DEBUG,
+                "Failed to free %d iomgr objects before shutdown deadline: "
+                "memory leaks are likely",
+                count_objects());
+        dump_objects("LEAKED");
+        break;
+      }
     }
-  gpr_mu_unlock (&g_mu);
+  }
+  gpr_mu_unlock(&g_mu);
 
-  grpc_alarm_list_shutdown (&exec_ctx);
-  grpc_exec_ctx_finish (&exec_ctx);
+  grpc_alarm_list_shutdown(&exec_ctx);
+  grpc_exec_ctx_finish(&exec_ctx);
 
   /* ensure all threads have left g_mu */
-  gpr_mu_lock (&g_mu);
-  gpr_mu_unlock (&g_mu);
+  gpr_mu_lock(&g_mu);
+  gpr_mu_unlock(&g_mu);
 
-  grpc_iomgr_platform_shutdown ();
-  gpr_mu_destroy (&g_mu);
-  gpr_cv_destroy (&g_rcv);
+  grpc_iomgr_platform_shutdown();
+  gpr_mu_destroy(&g_mu);
+  gpr_cv_destroy(&g_rcv);
 }
 
-void
-grpc_iomgr_register_object (grpc_iomgr_object * obj, const char *name)
-{
-  obj->name = gpr_strdup (name);
-  gpr_mu_lock (&g_mu);
+void grpc_iomgr_register_object(grpc_iomgr_object *obj, const char *name) {
+  obj->name = gpr_strdup(name);
+  gpr_mu_lock(&g_mu);
   obj->next = &g_root_object;
   obj->prev = g_root_object.prev;
   obj->next->prev = obj->prev->next = obj;
-  gpr_mu_unlock (&g_mu);
+  gpr_mu_unlock(&g_mu);
 }
 
-void
-grpc_iomgr_unregister_object (grpc_iomgr_object * obj)
-{
-  gpr_mu_lock (&g_mu);
+void grpc_iomgr_unregister_object(grpc_iomgr_object *obj) {
+  gpr_mu_lock(&g_mu);
   obj->next->prev = obj->prev;
   obj->prev->next = obj->next;
-  gpr_cv_signal (&g_rcv);
-  gpr_mu_unlock (&g_mu);
-  gpr_free (obj->name);
+  gpr_cv_signal(&g_rcv);
+  gpr_mu_unlock(&g_mu);
+  gpr_free(obj->name);
 }

src/core/iomgr/iomgr.h

@@ -35,9 +35,9 @@
 #define GRPC_INTERNAL_CORE_IOMGR_IOMGR_H
 
 /** Initializes the iomgr. */
-void grpc_iomgr_init (void);
+void grpc_iomgr_init(void);
 
 /** Signals the intention to shutdown the iomgr. */
-void grpc_iomgr_shutdown (void);
+void grpc_iomgr_shutdown(void);
 
 #endif /* GRPC_INTERNAL_CORE_IOMGR_IOMGR_H */

src/core/iomgr/iomgr_internal.h

@@ -37,17 +37,16 @@
 #include "src/core/iomgr/iomgr.h"
 #include <grpc/support/sync.h>
 
-typedef struct grpc_iomgr_object
-{
+typedef struct grpc_iomgr_object {
   char *name;
   struct grpc_iomgr_object *next;
   struct grpc_iomgr_object *prev;
 } grpc_iomgr_object;
 
-void grpc_iomgr_register_object (grpc_iomgr_object * obj, const char *name);
-void grpc_iomgr_unregister_object (grpc_iomgr_object * obj);
+void grpc_iomgr_register_object(grpc_iomgr_object *obj, const char *name);
+void grpc_iomgr_unregister_object(grpc_iomgr_object *obj);
 
-void grpc_iomgr_platform_init (void);
-void grpc_iomgr_platform_shutdown (void);
+void grpc_iomgr_platform_init(void);
+void grpc_iomgr_platform_shutdown(void);
 
 #endif /* GRPC_INTERNAL_CORE_IOMGR_IOMGR_INTERNAL_H */

src/core/iomgr/iomgr_posix.c

@@ -40,19 +40,15 @@
 #include "src/core/iomgr/fd_posix.h"
 #include "src/core/iomgr/tcp_posix.h"
 
-void
-grpc_iomgr_platform_init (void)
-{
-  grpc_fd_global_init ();
-  grpc_pollset_global_init ();
-  grpc_register_tracer ("tcp", &grpc_tcp_trace);
+void grpc_iomgr_platform_init(void) {
+  grpc_fd_global_init();
+  grpc_pollset_global_init();
+  grpc_register_tracer("tcp", &grpc_tcp_trace);
 }
 
-void
-grpc_iomgr_platform_shutdown (void)
-{
-  grpc_pollset_global_shutdown ();
-  grpc_fd_global_shutdown ();
+void grpc_iomgr_platform_shutdown(void) {
+  grpc_pollset_global_shutdown();
+  grpc_fd_global_shutdown();
 }
 
 #endif /* GRPC_POSIX_SOCKET */

src/core/iomgr/iomgr_posix.h

@@ -36,7 +36,7 @@
 
 #include "src/core/iomgr/iomgr_internal.h"
 
-void grpc_pollset_global_init (void);
-void grpc_pollset_global_shutdown (void);
+void grpc_pollset_global_init(void);
+void grpc_pollset_global_shutdown(void);
 
 #endif /* GRPC_INTERNAL_CORE_IOMGR_IOMGR_POSIX_H */

src/core/iomgr/iomgr_windows.c

@@ -47,33 +47,25 @@
    ports. All of what we're doing here is basically make sure that
    Windows sockets are initialized in and out. */
 
-static void
-winsock_init (void)
-{
+static void winsock_init(void) {
   WSADATA wsaData;
-  int status = WSAStartup (MAKEWORD (2, 0), &wsaData);
-  GPR_ASSERT (status == 0);
+  int status = WSAStartup(MAKEWORD(2, 0), &wsaData);
+  GPR_ASSERT(status == 0);
 }
 
-static void
-winsock_shutdown (void)
-{
-  int status = WSACleanup ();
-  GPR_ASSERT (status == 0);
+static void winsock_shutdown(void) {
+  int status = WSACleanup();
+  GPR_ASSERT(status == 0);
 }
 
-void
-grpc_iomgr_platform_init (void)
-{
-  winsock_init ();
-  grpc_iocp_init ();
+void grpc_iomgr_platform_init(void) {
+  winsock_init();
+  grpc_iocp_init();
 }
 
-void
-grpc_iomgr_platform_shutdown (void)
-{
-  grpc_iocp_shutdown ();
-  winsock_shutdown ();
+void grpc_iomgr_platform_shutdown(void) {
+  grpc_iocp_shutdown();
+  winsock_shutdown();
 }
 
 #endif /* GRPC_WINSOCK_SOCKET */

src/core/iomgr/pollset.h

@@ -54,9 +54,10 @@
 #include "src/core/iomgr/pollset_windows.h"
 #endif
 
-void grpc_pollset_init (grpc_pollset * pollset);
-void grpc_pollset_shutdown (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_closure * closure);
-void grpc_pollset_destroy (grpc_pollset * pollset);
+void grpc_pollset_init(grpc_pollset *pollset);
+void grpc_pollset_shutdown(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
+                           grpc_closure *closure);
+void grpc_pollset_destroy(grpc_pollset *pollset);
 
 /* Do some work on a pollset.
    May involve invoking asynchronous callbacks, or actually polling file
@@ -76,11 +77,14 @@ void grpc_pollset_destroy (grpc_pollset * pollset);
    May call grpc_closure_list_run on grpc_closure_list, without holding the
    pollset
    lock */
-void grpc_pollset_work (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_pollset_worker * worker, gpr_timespec now, gpr_timespec deadline);
+void grpc_pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
+                       grpc_pollset_worker *worker, gpr_timespec now,
+                       gpr_timespec deadline);
 
 /* Break one polling thread out of polling work for this pollset.
    If specific_worker is GRPC_POLLSET_KICK_BROADCAST, kick ALL the workers.
    Otherwise, if specific_worker is non-NULL, then kick that worker. */
-void grpc_pollset_kick (grpc_pollset * pollset, grpc_pollset_worker * specific_worker);
+void grpc_pollset_kick(grpc_pollset *pollset,
+                       grpc_pollset_worker *specific_worker);
 
 #endif /* GRPC_INTERNAL_CORE_IOMGR_POLLSET_H */

src/core/iomgr/pollset_multipoller_with_epoll.c

@@ -45,28 +45,24 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-typedef struct wakeup_fd_hdl
-{
+typedef struct wakeup_fd_hdl {
   grpc_wakeup_fd wakeup_fd;
   struct wakeup_fd_hdl *next;
 } wakeup_fd_hdl;
 
-typedef struct
-{
+typedef struct {
   grpc_pollset *pollset;
   grpc_fd *fd;
   grpc_closure closure;
 } delayed_add;
 
-typedef struct
-{
+typedef struct {
   int epoll_fd;
   wakeup_fd_hdl *free_wakeup_fds;
 } pollset_hdr;
 
-static void
-finally_add_fd (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_fd * fd)
-{
+static void finally_add_fd(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
+                           grpc_fd *fd) {
   pollset_hdr *h = pollset->data.ptr;
   struct epoll_event ev;
   int err;
@@ -75,98 +71,90 @@ finally_add_fd (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_fd * fd)
   /* We pretend to be polling whilst adding an fd to keep the fd from being
      closed during the add. This may result in a spurious wakeup being assigned
      to this pollset whilst adding, but that should be benign. */
-  GPR_ASSERT (grpc_fd_begin_poll (fd, pollset, 0, 0, &watcher) == 0);
-  if (watcher.fd != NULL)
-    {
-      ev.events = (uint32_t) (EPOLLIN | EPOLLOUT | EPOLLET);
-      ev.data.ptr = fd;
-      err = epoll_ctl (h->epoll_fd, EPOLL_CTL_ADD, fd->fd, &ev);
-      if (err < 0)
-	{
-	  /* FDs may be added to a pollset multiple times, so EEXIST is normal. */
-	  if (errno != EEXIST)
-	    {
-	      gpr_log (GPR_ERROR, "epoll_ctl add for %d failed: %s", fd->fd, strerror (errno));
-	    }
-	}
+  GPR_ASSERT(grpc_fd_begin_poll(fd, pollset, 0, 0, &watcher) == 0);
+  if (watcher.fd != NULL) {
+    ev.events = (uint32_t)(EPOLLIN | EPOLLOUT | EPOLLET);
+    ev.data.ptr = fd;
+    err = epoll_ctl(h->epoll_fd, EPOLL_CTL_ADD, fd->fd, &ev);
+    if (err < 0) {
+      /* FDs may be added to a pollset multiple times, so EEXIST is normal. */
+      if (errno != EEXIST) {
+        gpr_log(GPR_ERROR, "epoll_ctl add for %d failed: %s", fd->fd,
+                strerror(errno));
+      }
     }
-  grpc_fd_end_poll (exec_ctx, &watcher, 0, 0);
+  }
+  grpc_fd_end_poll(exec_ctx, &watcher, 0, 0);
 }
 
-static void
-perform_delayed_add (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_status)
-{
+static void perform_delayed_add(grpc_exec_ctx *exec_ctx, void *arg,
+                                int iomgr_status) {
   delayed_add *da = arg;
 
-  if (!grpc_fd_is_orphaned (da->fd))
-    {
-      finally_add_fd (exec_ctx, da->pollset, da->fd);
-    }
+  if (!grpc_fd_is_orphaned(da->fd)) {
+    finally_add_fd(exec_ctx, da->pollset, da->fd);
+  }
 
-  gpr_mu_lock (&da->pollset->mu);
+  gpr_mu_lock(&da->pollset->mu);
   da->pollset->in_flight_cbs--;
-  if (da->pollset->shutting_down)
-    {
-      /* We don't care about this pollset anymore. */
-      if (da->pollset->in_flight_cbs == 0 && !da->pollset->called_shutdown)
-	{
-	  da->pollset->called_shutdown = 1;
-	  grpc_exec_ctx_enqueue (exec_ctx, da->pollset->shutdown_done, 1);
-	}
+  if (da->pollset->shutting_down) {
+    /* We don't care about this pollset anymore. */
+    if (da->pollset->in_flight_cbs == 0 && !da->pollset->called_shutdown) {
+      da->pollset->called_shutdown = 1;
+      grpc_exec_ctx_enqueue(exec_ctx, da->pollset->shutdown_done, 1);
     }
-  gpr_mu_unlock (&da->pollset->mu);
+  }
+  gpr_mu_unlock(&da->pollset->mu);
 
-  GRPC_FD_UNREF (da->fd, "delayed_add");
+  GRPC_FD_UNREF(da->fd, "delayed_add");
 
-  gpr_free (da);
+  gpr_free(da);
 }
 
-static void
-multipoll_with_epoll_pollset_add_fd (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_fd * fd, int and_unlock_pollset)
-{
-  if (and_unlock_pollset)
-    {
-      gpr_mu_unlock (&pollset->mu);
-      finally_add_fd (exec_ctx, pollset, fd);
-    }
-  else
-    {
-      delayed_add *da = gpr_malloc (sizeof (*da));
-      da->pollset = pollset;
-      da->fd = fd;
-      GRPC_FD_REF (fd, "delayed_add");
-      grpc_closure_init (&da->closure, perform_delayed_add, da);
-      pollset->in_flight_cbs++;
-      grpc_exec_ctx_enqueue (exec_ctx, &da->closure, 1);
-    }
+static void multipoll_with_epoll_pollset_add_fd(grpc_exec_ctx *exec_ctx,
+                                                grpc_pollset *pollset,
+                                                grpc_fd *fd,
+                                                int and_unlock_pollset) {
+  if (and_unlock_pollset) {
+    gpr_mu_unlock(&pollset->mu);
+    finally_add_fd(exec_ctx, pollset, fd);
+  } else {
+    delayed_add *da = gpr_malloc(sizeof(*da));
+    da->pollset = pollset;
+    da->fd = fd;
+    GRPC_FD_REF(fd, "delayed_add");
+    grpc_closure_init(&da->closure, perform_delayed_add, da);
+    pollset->in_flight_cbs++;
+    grpc_exec_ctx_enqueue(exec_ctx, &da->closure, 1);
+  }
 }
 
-static void
-multipoll_with_epoll_pollset_del_fd (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_fd * fd, int and_unlock_pollset)
-{
+static void multipoll_with_epoll_pollset_del_fd(grpc_exec_ctx *exec_ctx,
+                                                grpc_pollset *pollset,
+                                                grpc_fd *fd,
+                                                int and_unlock_pollset) {
   pollset_hdr *h = pollset->data.ptr;
   int err;
 
-  if (and_unlock_pollset)
-    {
-      gpr_mu_unlock (&pollset->mu);
-    }
+  if (and_unlock_pollset) {
+    gpr_mu_unlock(&pollset->mu);
+  }
 
   /* Note that this can race with concurrent poll, but that should be fine since
    * at worst it creates a spurious read event on a reused grpc_fd object. */
-  err = epoll_ctl (h->epoll_fd, EPOLL_CTL_DEL, fd->fd, NULL);
-  if (err < 0)
-    {
-      gpr_log (GPR_ERROR, "epoll_ctl del for %d failed: %s", fd->fd, strerror (errno));
-    }
+  err = epoll_ctl(h->epoll_fd, EPOLL_CTL_DEL, fd->fd, NULL);
+  if (err < 0) {
+    gpr_log(GPR_ERROR, "epoll_ctl del for %d failed: %s", fd->fd,
+            strerror(errno));
+  }
 }
 
 /* TODO(klempner): We probably want to turn this down a bit */
 #define GRPC_EPOLL_MAX_EVENTS 1000
 
-static void
-multipoll_with_epoll_pollset_maybe_work_and_unlock (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_pollset_worker * worker, gpr_timespec deadline, gpr_timespec now)
-{
+static void multipoll_with_epoll_pollset_maybe_work_and_unlock(
+    grpc_exec_ctx *exec_ctx, grpc_pollset *pollset, grpc_pollset_worker *worker,
+    gpr_timespec deadline, gpr_timespec now) {
   struct epoll_event ep_ev[GRPC_EPOLL_MAX_EVENTS];
   int ep_rv;
   int poll_rv;
@@ -180,116 +168,93 @@ multipoll_with_epoll_pollset_maybe_work_and_unlock (grpc_exec_ctx * exec_ctx, gr
    * here.
    */
 
-  gpr_mu_unlock (&pollset->mu);
+  gpr_mu_unlock(&pollset->mu);
 
-  timeout_ms = grpc_poll_deadline_to_millis_timeout (deadline, now);
+  timeout_ms = grpc_poll_deadline_to_millis_timeout(deadline, now);
 
-  pfds[0].fd = GRPC_WAKEUP_FD_GET_READ_FD (&worker->wakeup_fd);
+  pfds[0].fd = GRPC_WAKEUP_FD_GET_READ_FD(&worker->wakeup_fd);
   pfds[0].events = POLLIN;
   pfds[0].revents = 0;
   pfds[1].fd = h->epoll_fd;
   pfds[1].events = POLLIN;
   pfds[1].revents = 0;
 
-  poll_rv = grpc_poll_function (pfds, 2, timeout_ms);
+  poll_rv = grpc_poll_function(pfds, 2, timeout_ms);
 
-  if (poll_rv < 0)
-    {
-      if (errno != EINTR)
-	{
-	  gpr_log (GPR_ERROR, "poll() failed: %s", strerror (errno));
-	}
+  if (poll_rv < 0) {
+    if (errno != EINTR) {
+      gpr_log(GPR_ERROR, "poll() failed: %s", strerror(errno));
     }
-  else if (poll_rv == 0)
-    {
-      /* do nothing */
+  } else if (poll_rv == 0) {
+    /* do nothing */
+  } else {
+    if (pfds[0].revents) {
+      grpc_wakeup_fd_consume_wakeup(&worker->wakeup_fd);
     }
-  else
-    {
-      if (pfds[0].revents)
-	{
-	  grpc_wakeup_fd_consume_wakeup (&worker->wakeup_fd);
-	}
-      if (pfds[1].revents)
-	{
-	  do
-	    {
-	      ep_rv = epoll_wait (h->epoll_fd, ep_ev, GRPC_EPOLL_MAX_EVENTS, 0);
-	      if (ep_rv < 0)
-		{
-		  if (errno != EINTR)
-		    {
-		      gpr_log (GPR_ERROR, "epoll_wait() failed: %s", strerror (errno));
-		    }
-		}
-	      else
-		{
-		  int i;
-		  for (i = 0; i < ep_rv; ++i)
-		    {
-		      grpc_fd *fd = ep_ev[i].data.ptr;
-		      /* TODO(klempner): We might want to consider making err and pri
-		       * separate events */
-		      int cancel = ep_ev[i].events & (EPOLLERR | EPOLLHUP);
-		      int read = ep_ev[i].events & (EPOLLIN | EPOLLPRI);
-		      int write = ep_ev[i].events & EPOLLOUT;
-		      if (read || cancel)
-			{
-			  grpc_fd_become_readable (exec_ctx, fd);
-			}
-		      if (write || cancel)
-			{
-			  grpc_fd_become_writable (exec_ctx, fd);
-			}
-		    }
-		}
-	    }
-	  while (ep_rv == GRPC_EPOLL_MAX_EVENTS);
-	}
+    if (pfds[1].revents) {
+      do {
+        ep_rv = epoll_wait(h->epoll_fd, ep_ev, GRPC_EPOLL_MAX_EVENTS, 0);
+        if (ep_rv < 0) {
+          if (errno != EINTR) {
+            gpr_log(GPR_ERROR, "epoll_wait() failed: %s", strerror(errno));
+          }
+        } else {
+          int i;
+          for (i = 0; i < ep_rv; ++i) {
+            grpc_fd *fd = ep_ev[i].data.ptr;
+            /* TODO(klempner): We might want to consider making err and pri
+             * separate events */
+            int cancel = ep_ev[i].events & (EPOLLERR | EPOLLHUP);
+            int read = ep_ev[i].events & (EPOLLIN | EPOLLPRI);
+            int write = ep_ev[i].events & EPOLLOUT;
+            if (read || cancel) {
+              grpc_fd_become_readable(exec_ctx, fd);
+            }
+            if (write || cancel) {
+              grpc_fd_become_writable(exec_ctx, fd);
+            }
+          }
+        }
+      } while (ep_rv == GRPC_EPOLL_MAX_EVENTS);
     }
+  }
 }
 
-static void
-multipoll_with_epoll_pollset_finish_shutdown (grpc_pollset * pollset)
-{
-}
+static void multipoll_with_epoll_pollset_finish_shutdown(
+    grpc_pollset *pollset) {}
 
-static void
-multipoll_with_epoll_pollset_destroy (grpc_pollset * pollset)
-{
+static void multipoll_with_epoll_pollset_destroy(grpc_pollset *pollset) {
   pollset_hdr *h = pollset->data.ptr;
-  close (h->epoll_fd);
-  gpr_free (h);
+  close(h->epoll_fd);
+  gpr_free(h);
 }
 
 static const grpc_pollset_vtable multipoll_with_epoll_pollset = {
-  multipoll_with_epoll_pollset_add_fd, multipoll_with_epoll_pollset_del_fd,
-  multipoll_with_epoll_pollset_maybe_work_and_unlock,
-  multipoll_with_epoll_pollset_finish_shutdown,
-  multipoll_with_epoll_pollset_destroy
-};
-
-static void
-epoll_become_multipoller (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_fd ** fds, size_t nfds)
-{
+    multipoll_with_epoll_pollset_add_fd, multipoll_with_epoll_pollset_del_fd,
+    multipoll_with_epoll_pollset_maybe_work_and_unlock,
+    multipoll_with_epoll_pollset_finish_shutdown,
+    multipoll_with_epoll_pollset_destroy};
+
+static void epoll_become_multipoller(grpc_exec_ctx *exec_ctx,
+                                     grpc_pollset *pollset, grpc_fd **fds,
+                                     size_t nfds) {
   size_t i;
-  pollset_hdr *h = gpr_malloc (sizeof (pollset_hdr));
+  pollset_hdr *h = gpr_malloc(sizeof(pollset_hdr));
 
   pollset->vtable = &multipoll_with_epoll_pollset;
   pollset->data.ptr = h;
-  h->epoll_fd = epoll_create1 (EPOLL_CLOEXEC);
-  if (h->epoll_fd < 0)
-    {
-      /* TODO(klempner): Fall back to poll here, especially on ENOSYS */
-      gpr_log (GPR_ERROR, "epoll_create1 failed: %s", strerror (errno));
-      abort ();
-    }
-  for (i = 0; i < nfds; i++)
-    {
-      multipoll_with_epoll_pollset_add_fd (exec_ctx, pollset, fds[i], 0);
-    }
+  h->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
+  if (h->epoll_fd < 0) {
+    /* TODO(klempner): Fall back to poll here, especially on ENOSYS */
+    gpr_log(GPR_ERROR, "epoll_create1 failed: %s", strerror(errno));
+    abort();
+  }
+  for (i = 0; i < nfds; i++) {
+    multipoll_with_epoll_pollset_add_fd(exec_ctx, pollset, fds[i], 0);
+  }
 }
 
-grpc_platform_become_multipoller_type grpc_platform_become_multipoller = epoll_become_multipoller;
+grpc_platform_become_multipoller_type grpc_platform_become_multipoller =
+    epoll_become_multipoller;
 
 #endif /* GPR_LINUX_MULTIPOLL_WITH_EPOLL */

src/core/iomgr/pollset_multipoller_with_poll_posix.c

@@ -48,8 +48,7 @@
 #include <grpc/support/log.h>
 #include <grpc/support/useful.h>
 
-typedef struct
-{
+typedef struct {
   /* all polled fds */
   size_t fd_count;
   size_t fd_capacity;
@@ -60,52 +59,48 @@ typedef struct
   grpc_fd **dels;
 } pollset_hdr;
 
-static void
-multipoll_with_poll_pollset_add_fd (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_fd * fd, int and_unlock_pollset)
-{
+static void multipoll_with_poll_pollset_add_fd(grpc_exec_ctx *exec_ctx,
+                                               grpc_pollset *pollset,
+                                               grpc_fd *fd,
+                                               int and_unlock_pollset) {
   size_t i;
   pollset_hdr *h = pollset->data.ptr;
   /* TODO(ctiller): this is O(num_fds^2); maybe switch to a hash set here */
-  for (i = 0; i < h->fd_count; i++)
-    {
-      if (h->fds[i] == fd)
-	goto exit;
-    }
-  if (h->fd_count == h->fd_capacity)
-    {
-      h->fd_capacity = GPR_MAX (h->fd_capacity + 8, h->fd_count * 3 / 2);
-      h->fds = gpr_realloc (h->fds, sizeof (grpc_fd *) * h->fd_capacity);
-    }
+  for (i = 0; i < h->fd_count; i++) {
+    if (h->fds[i] == fd) goto exit;
+  }
+  if (h->fd_count == h->fd_capacity) {
+    h->fd_capacity = GPR_MAX(h->fd_capacity + 8, h->fd_count * 3 / 2);
+    h->fds = gpr_realloc(h->fds, sizeof(grpc_fd *) * h->fd_capacity);
+  }
   h->fds[h->fd_count++] = fd;
-  GRPC_FD_REF (fd, "multipoller");
+  GRPC_FD_REF(fd, "multipoller");
 exit:
-  if (and_unlock_pollset)
-    {
-      gpr_mu_unlock (&pollset->mu);
-    }
+  if (and_unlock_pollset) {
+    gpr_mu_unlock(&pollset->mu);
+  }
 }
 
-static void
-multipoll_with_poll_pollset_del_fd (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_fd * fd, int and_unlock_pollset)
-{
+static void multipoll_with_poll_pollset_del_fd(grpc_exec_ctx *exec_ctx,
+                                               grpc_pollset *pollset,
+                                               grpc_fd *fd,
+                                               int and_unlock_pollset) {
   /* will get removed next poll cycle */
   pollset_hdr *h = pollset->data.ptr;
-  if (h->del_count == h->del_capacity)
-    {
-      h->del_capacity = GPR_MAX (h->del_capacity + 8, h->del_count * 3 / 2);
-      h->dels = gpr_realloc (h->dels, sizeof (grpc_fd *) * h->del_capacity);
-    }
+  if (h->del_count == h->del_capacity) {
+    h->del_capacity = GPR_MAX(h->del_capacity + 8, h->del_count * 3 / 2);
+    h->dels = gpr_realloc(h->dels, sizeof(grpc_fd *) * h->del_capacity);
+  }
   h->dels[h->del_count++] = fd;
-  GRPC_FD_REF (fd, "multipoller_del");
-  if (and_unlock_pollset)
-    {
-      gpr_mu_unlock (&pollset->mu);
-    }
+  GRPC_FD_REF(fd, "multipoller_del");
+  if (and_unlock_pollset) {
+    gpr_mu_unlock(&pollset->mu);
+  }
 }
 
-static void
-multipoll_with_poll_pollset_maybe_work_and_unlock (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_pollset_worker * worker, gpr_timespec deadline, gpr_timespec now)
-{
+static void multipoll_with_poll_pollset_maybe_work_and_unlock(
+    grpc_exec_ctx *exec_ctx, grpc_pollset *pollset, grpc_pollset_worker *worker,
+    gpr_timespec deadline, gpr_timespec now) {
   int timeout;
   int r;
   size_t i, j, fd_count;
@@ -116,150 +111,125 @@ multipoll_with_poll_pollset_maybe_work_and_unlock (grpc_exec_ctx * exec_ctx, grp
   struct pollfd *pfds;
 
   h = pollset->data.ptr;
-  timeout = grpc_poll_deadline_to_millis_timeout (deadline, now);
+  timeout = grpc_poll_deadline_to_millis_timeout(deadline, now);
   /* TODO(ctiller): perform just one malloc here if we exceed the inline case */
-  pfds = gpr_malloc (sizeof (*pfds) * (h->fd_count + 1));
-  watchers = gpr_malloc (sizeof (*watchers) * (h->fd_count + 1));
+  pfds = gpr_malloc(sizeof(*pfds) * (h->fd_count + 1));
+  watchers = gpr_malloc(sizeof(*watchers) * (h->fd_count + 1));
   fd_count = 0;
   pfd_count = 1;
-  pfds[0].fd = GRPC_WAKEUP_FD_GET_READ_FD (&worker->wakeup_fd);
+  pfds[0].fd = GRPC_WAKEUP_FD_GET_READ_FD(&worker->wakeup_fd);
   pfds[0].events = POLLIN;
   pfds[0].revents = POLLOUT;
-  for (i = 0; i < h->fd_count; i++)
-    {
-      int remove = grpc_fd_is_orphaned (h->fds[i]);
-      for (j = 0; !remove && j < h->del_count; j++)
-	{
-	  if (h->fds[i] == h->dels[j])
-	    remove = 1;
-	}
-      if (remove)
-	{
-	  GRPC_FD_UNREF (h->fds[i], "multipoller");
-	}
-      else
-	{
-	  h->fds[fd_count++] = h->fds[i];
-	  watchers[pfd_count].fd = h->fds[i];
-	  pfds[pfd_count].fd = h->fds[i]->fd;
-	  pfds[pfd_count].revents = 0;
-	  pfd_count++;
-	}
+  for (i = 0; i < h->fd_count; i++) {
+    int remove = grpc_fd_is_orphaned(h->fds[i]);
+    for (j = 0; !remove && j < h->del_count; j++) {
+      if (h->fds[i] == h->dels[j]) remove = 1;
     }
-  for (j = 0; j < h->del_count; j++)
-    {
-      GRPC_FD_UNREF (h->dels[j], "multipoller_del");
+    if (remove) {
+      GRPC_FD_UNREF(h->fds[i], "multipoller");
+    } else {
+      h->fds[fd_count++] = h->fds[i];
+      watchers[pfd_count].fd = h->fds[i];
+      pfds[pfd_count].fd = h->fds[i]->fd;
+      pfds[pfd_count].revents = 0;
+      pfd_count++;
     }
+  }
+  for (j = 0; j < h->del_count; j++) {
+    GRPC_FD_UNREF(h->dels[j], "multipoller_del");
+  }
   h->del_count = 0;
   h->fd_count = fd_count;
-  gpr_mu_unlock (&pollset->mu);
+  gpr_mu_unlock(&pollset->mu);
 
-  for (i = 1; i < pfd_count; i++)
-    {
-      pfds[i].events = (short) grpc_fd_begin_poll (watchers[i].fd, pollset, POLLIN, POLLOUT, &watchers[i]);
-    }
+  for (i = 1; i < pfd_count; i++) {
+    pfds[i].events = (short)grpc_fd_begin_poll(watchers[i].fd, pollset, POLLIN,
+                                               POLLOUT, &watchers[i]);
+  }
 
-  r = grpc_poll_function (pfds, pfd_count, timeout);
+  r = grpc_poll_function(pfds, pfd_count, timeout);
 
-  for (i = 1; i < pfd_count; i++)
-    {
-      grpc_fd_end_poll (exec_ctx, &watchers[i], pfds[i].revents & POLLIN, pfds[i].revents & POLLOUT);
-    }
+  for (i = 1; i < pfd_count; i++) {
+    grpc_fd_end_poll(exec_ctx, &watchers[i], pfds[i].revents & POLLIN,
+                     pfds[i].revents & POLLOUT);
+  }
 
-  if (r < 0)
-    {
-      if (errno != EINTR)
-	{
-	  gpr_log (GPR_ERROR, "poll() failed: %s", strerror (errno));
-	}
+  if (r < 0) {
+    if (errno != EINTR) {
+      gpr_log(GPR_ERROR, "poll() failed: %s", strerror(errno));
     }
-  else if (r == 0)
-    {
-      /* do nothing */
+  } else if (r == 0) {
+    /* do nothing */
+  } else {
+    if (pfds[0].revents & POLLIN) {
+      grpc_wakeup_fd_consume_wakeup(&worker->wakeup_fd);
     }
-  else
-    {
-      if (pfds[0].revents & POLLIN)
-	{
-	  grpc_wakeup_fd_consume_wakeup (&worker->wakeup_fd);
-	}
-      for (i = 1; i < pfd_count; i++)
-	{
-	  if (watchers[i].fd == NULL)
-	    {
-	      continue;
-	    }
-	  if (pfds[i].revents & (POLLIN | POLLHUP | POLLERR))
-	    {
-	      grpc_fd_become_readable (exec_ctx, watchers[i].fd);
-	    }
-	  if (pfds[i].revents & (POLLOUT | POLLHUP | POLLERR))
-	    {
-	      grpc_fd_become_writable (exec_ctx, watchers[i].fd);
-	    }
-	}
+    for (i = 1; i < pfd_count; i++) {
+      if (watchers[i].fd == NULL) {
+        continue;
+      }
+      if (pfds[i].revents & (POLLIN | POLLHUP | POLLERR)) {
+        grpc_fd_become_readable(exec_ctx, watchers[i].fd);
+      }
+      if (pfds[i].revents & (POLLOUT | POLLHUP | POLLERR)) {
+        grpc_fd_become_writable(exec_ctx, watchers[i].fd);
+      }
     }
+  }
 
-  gpr_free (pfds);
-  gpr_free (watchers);
+  gpr_free(pfds);
+  gpr_free(watchers);
 }
 
-static void
-multipoll_with_poll_pollset_finish_shutdown (grpc_pollset * pollset)
-{
+static void multipoll_with_poll_pollset_finish_shutdown(grpc_pollset *pollset) {
   size_t i;
   pollset_hdr *h = pollset->data.ptr;
-  for (i = 0; i < h->fd_count; i++)
-    {
-      GRPC_FD_UNREF (h->fds[i], "multipoller");
-    }
-  for (i = 0; i < h->del_count; i++)
-    {
-      GRPC_FD_UNREF (h->dels[i], "multipoller_del");
-    }
+  for (i = 0; i < h->fd_count; i++) {
+    GRPC_FD_UNREF(h->fds[i], "multipoller");
+  }
+  for (i = 0; i < h->del_count; i++) {
+    GRPC_FD_UNREF(h->dels[i], "multipoller_del");
+  }
   h->fd_count = 0;
   h->del_count = 0;
 }
 
-static void
-multipoll_with_poll_pollset_destroy (grpc_pollset * pollset)
-{
+static void multipoll_with_poll_pollset_destroy(grpc_pollset *pollset) {
   pollset_hdr *h = pollset->data.ptr;
-  multipoll_with_poll_pollset_finish_shutdown (pollset);
-  gpr_free (h->fds);
-  gpr_free (h->dels);
-  gpr_free (h);
+  multipoll_with_poll_pollset_finish_shutdown(pollset);
+  gpr_free(h->fds);
+  gpr_free(h->dels);
+  gpr_free(h);
 }
 
 static const grpc_pollset_vtable multipoll_with_poll_pollset = {
-  multipoll_with_poll_pollset_add_fd, multipoll_with_poll_pollset_del_fd,
-  multipoll_with_poll_pollset_maybe_work_and_unlock,
-  multipoll_with_poll_pollset_finish_shutdown,
-  multipoll_with_poll_pollset_destroy
-};
-
-void
-grpc_poll_become_multipoller (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_fd ** fds, size_t nfds)
-{
+    multipoll_with_poll_pollset_add_fd, multipoll_with_poll_pollset_del_fd,
+    multipoll_with_poll_pollset_maybe_work_and_unlock,
+    multipoll_with_poll_pollset_finish_shutdown,
+    multipoll_with_poll_pollset_destroy};
+
+void grpc_poll_become_multipoller(grpc_exec_ctx *exec_ctx,
+                                  grpc_pollset *pollset, grpc_fd **fds,
+                                  size_t nfds) {
   size_t i;
-  pollset_hdr *h = gpr_malloc (sizeof (pollset_hdr));
+  pollset_hdr *h = gpr_malloc(sizeof(pollset_hdr));
   pollset->vtable = &multipoll_with_poll_pollset;
   pollset->data.ptr = h;
   h->fd_count = nfds;
   h->fd_capacity = nfds;
-  h->fds = gpr_malloc (nfds * sizeof (grpc_fd *));
+  h->fds = gpr_malloc(nfds * sizeof(grpc_fd *));
   h->del_count = 0;
   h->del_capacity = 0;
   h->dels = NULL;
-  for (i = 0; i < nfds; i++)
-    {
-      h->fds[i] = fds[i];
-      GRPC_FD_REF (fds[i], "multipoller");
-    }
+  for (i = 0; i < nfds; i++) {
+    h->fds[i] = fds[i];
+    GRPC_FD_REF(fds[i], "multipoller");
+  }
 }
 
 #endif /* GPR_POSIX_SOCKET */
 
 #ifdef GPR_POSIX_MULTIPOLL_WITH_POLL
-grpc_platform_become_multipoller_type grpc_platform_become_multipoller = grpc_poll_become_multipoller;
+grpc_platform_become_multipoller_type grpc_platform_become_multipoller =
+    grpc_poll_become_multipoller;
 #endif

src/core/iomgr/pollset_posix.c

@@ -53,281 +53,234 @@
 #include <grpc/support/tls.h>
 #include <grpc/support/useful.h>
 
-GPR_TLS_DECL (g_current_thread_poller);
-GPR_TLS_DECL (g_current_thread_worker);
+GPR_TLS_DECL(g_current_thread_poller);
+GPR_TLS_DECL(g_current_thread_worker);
 
 grpc_poll_function_type grpc_poll_function = poll;
 
-static void
-remove_worker (grpc_pollset * p, grpc_pollset_worker * worker)
-{
+static void remove_worker(grpc_pollset *p, grpc_pollset_worker *worker) {
   worker->prev->next = worker->next;
   worker->next->prev = worker->prev;
 }
 
-int
-grpc_pollset_has_workers (grpc_pollset * p)
-{
+int grpc_pollset_has_workers(grpc_pollset *p) {
   return p->root_worker.next != &p->root_worker;
 }
 
-static grpc_pollset_worker *
-pop_front_worker (grpc_pollset * p)
-{
-  if (grpc_pollset_has_workers (p))
-    {
-      grpc_pollset_worker *w = p->root_worker.next;
-      remove_worker (p, w);
-      return w;
-    }
-  else
-    {
-      return NULL;
-    }
+static grpc_pollset_worker *pop_front_worker(grpc_pollset *p) {
+  if (grpc_pollset_has_workers(p)) {
+    grpc_pollset_worker *w = p->root_worker.next;
+    remove_worker(p, w);
+    return w;
+  } else {
+    return NULL;
+  }
 }
 
-static void
-push_back_worker (grpc_pollset * p, grpc_pollset_worker * worker)
-{
+static void push_back_worker(grpc_pollset *p, grpc_pollset_worker *worker) {
   worker->next = &p->root_worker;
   worker->prev = worker->next->prev;
   worker->prev->next = worker->next->prev = worker;
 }
 
-static void
-push_front_worker (grpc_pollset * p, grpc_pollset_worker * worker)
-{
+static void push_front_worker(grpc_pollset *p, grpc_pollset_worker *worker) {
   worker->prev = &p->root_worker;
   worker->next = worker->prev->next;
   worker->prev->next = worker->next->prev = worker;
 }
 
-void
-grpc_pollset_kick (grpc_pollset * p, grpc_pollset_worker * specific_worker)
-{
+void grpc_pollset_kick(grpc_pollset *p, grpc_pollset_worker *specific_worker) {
   /* pollset->mu already held */
-  if (specific_worker != NULL)
-    {
-      if (specific_worker == GRPC_POLLSET_KICK_BROADCAST)
-	{
-	  for (specific_worker = p->root_worker.next; specific_worker != &p->root_worker; specific_worker = specific_worker->next)
-	    {
-	      grpc_wakeup_fd_wakeup (&specific_worker->wakeup_fd);
-	    }
-	  p->kicked_without_pollers = 1;
-	}
-      else if (gpr_tls_get (&g_current_thread_worker) != (gpr_intptr) specific_worker)
-	{
-	  grpc_wakeup_fd_wakeup (&specific_worker->wakeup_fd);
-	}
-    }
-  else if (gpr_tls_get (&g_current_thread_poller) != (gpr_intptr) p)
-    {
-      specific_worker = pop_front_worker (p);
-      if (specific_worker != NULL)
-	{
-	  push_back_worker (p, specific_worker);
-	  grpc_wakeup_fd_wakeup (&specific_worker->wakeup_fd);
-	}
-      else
-	{
-	  p->kicked_without_pollers = 1;
-	}
-    }
+  if (specific_worker != NULL) {
+    if (specific_worker == GRPC_POLLSET_KICK_BROADCAST) {
+      for (specific_worker = p->root_worker.next;
+           specific_worker != &p->root_worker;
+           specific_worker = specific_worker->next) {
+        grpc_wakeup_fd_wakeup(&specific_worker->wakeup_fd);
+      }
+      p->kicked_without_pollers = 1;
+    } else if (gpr_tls_get(&g_current_thread_worker) !=
+               (gpr_intptr)specific_worker) {
+      grpc_wakeup_fd_wakeup(&specific_worker->wakeup_fd);
+    }
+  } else if (gpr_tls_get(&g_current_thread_poller) != (gpr_intptr)p) {
+    specific_worker = pop_front_worker(p);
+    if (specific_worker != NULL) {
+      push_back_worker(p, specific_worker);
+      grpc_wakeup_fd_wakeup(&specific_worker->wakeup_fd);
+    } else {
+      p->kicked_without_pollers = 1;
+    }
+  }
 }
 
 /* global state management */
 
-void
-grpc_pollset_global_init (void)
-{
-  gpr_tls_init (&g_current_thread_poller);
-  grpc_wakeup_fd_global_init ();
+void grpc_pollset_global_init(void) {
+  gpr_tls_init(&g_current_thread_poller);
+  grpc_wakeup_fd_global_init();
 }
 
-void
-grpc_pollset_global_shutdown (void)
-{
-  gpr_tls_destroy (&g_current_thread_poller);
-  grpc_wakeup_fd_global_destroy ();
+void grpc_pollset_global_shutdown(void) {
+  gpr_tls_destroy(&g_current_thread_poller);
+  grpc_wakeup_fd_global_destroy();
 }
 
 /* main interface */
 
-static void become_basic_pollset (grpc_pollset * pollset, grpc_fd * fd_or_null);
+static void become_basic_pollset(grpc_pollset *pollset, grpc_fd *fd_or_null);
 
-void
-grpc_pollset_init (grpc_pollset * pollset)
-{
-  gpr_mu_init (&pollset->mu);
+void grpc_pollset_init(grpc_pollset *pollset) {
+  gpr_mu_init(&pollset->mu);
   pollset->root_worker.next = pollset->root_worker.prev = &pollset->root_worker;
   pollset->in_flight_cbs = 0;
   pollset->shutting_down = 0;
   pollset->called_shutdown = 0;
   pollset->idle_jobs.head = pollset->idle_jobs.tail = NULL;
-  become_basic_pollset (pollset, NULL);
+  become_basic_pollset(pollset, NULL);
 }
 
-void
-grpc_pollset_add_fd (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_fd * fd)
-{
-  gpr_mu_lock (&pollset->mu);
-  pollset->vtable->add_fd (exec_ctx, pollset, fd, 1);
+void grpc_pollset_add_fd(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
+                         grpc_fd *fd) {
+  gpr_mu_lock(&pollset->mu);
+  pollset->vtable->add_fd(exec_ctx, pollset, fd, 1);
 /* the following (enabled only in debug) will reacquire and then release
    our lock - meaning that if the unlocking flag passed to del_fd above is
    not respected, the code will deadlock (in a way that we have a chance of
    debugging) */
 #ifndef NDEBUG
-  gpr_mu_lock (&pollset->mu);
-  gpr_mu_unlock (&pollset->mu);
+  gpr_mu_lock(&pollset->mu);
+  gpr_mu_unlock(&pollset->mu);
 #endif
 }
 
-void
-grpc_pollset_del_fd (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_fd * fd)
-{
-  gpr_mu_lock (&pollset->mu);
-  pollset->vtable->del_fd (exec_ctx, pollset, fd, 1);
+void grpc_pollset_del_fd(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
+                         grpc_fd *fd) {
+  gpr_mu_lock(&pollset->mu);
+  pollset->vtable->del_fd(exec_ctx, pollset, fd, 1);
 /* the following (enabled only in debug) will reacquire and then release
    our lock - meaning that if the unlocking flag passed to del_fd above is
    not respected, the code will deadlock (in a way that we have a chance of
    debugging) */
 #ifndef NDEBUG
-  gpr_mu_lock (&pollset->mu);
-  gpr_mu_unlock (&pollset->mu);
+  gpr_mu_lock(&pollset->mu);
+  gpr_mu_unlock(&pollset->mu);
 #endif
 }
 
-static void
-finish_shutdown (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset)
-{
-  pollset->vtable->finish_shutdown (pollset);
-  grpc_exec_ctx_enqueue (exec_ctx, pollset->shutdown_done, 1);
+static void finish_shutdown(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset) {
+  pollset->vtable->finish_shutdown(pollset);
+  grpc_exec_ctx_enqueue(exec_ctx, pollset->shutdown_done, 1);
 }
 
-void
-grpc_pollset_work (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_pollset_worker * worker, gpr_timespec now, gpr_timespec deadline)
-{
+void grpc_pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
+                       grpc_pollset_worker *worker, gpr_timespec now,
+                       gpr_timespec deadline) {
   /* pollset->mu already held */
   int added_worker = 0;
   int locked = 1;
   /* this must happen before we (potentially) drop pollset->mu */
   worker->next = worker->prev = NULL;
   /* TODO(ctiller): pool these */
-  grpc_wakeup_fd_init (&worker->wakeup_fd);
-  if (!grpc_pollset_has_workers (pollset) && !grpc_closure_list_empty (pollset->idle_jobs))
-    {
-      grpc_exec_ctx_enqueue_list (exec_ctx, &pollset->idle_jobs);
-      goto done;
-    }
-  if (grpc_alarm_check (exec_ctx, now, &deadline))
-    {
-      goto done;
-    }
-  if (pollset->shutting_down)
-    {
-      goto done;
-    }
-  if (pollset->in_flight_cbs)
-    {
-      /* Give do_promote priority so we don't starve it out */
-      gpr_mu_unlock (&pollset->mu);
-      locked = 0;
-      goto done;
-    }
-  if (!pollset->kicked_without_pollers)
-    {
-      push_front_worker (pollset, worker);
-      added_worker = 1;
-      gpr_tls_set (&g_current_thread_poller, (gpr_intptr) pollset);
-      pollset->vtable->maybe_work_and_unlock (exec_ctx, pollset, worker, deadline, now);
-      locked = 0;
-      gpr_tls_set (&g_current_thread_poller, 0);
-    }
-  else
-    {
-      pollset->kicked_without_pollers = 0;
-    }
+  grpc_wakeup_fd_init(&worker->wakeup_fd);
+  if (!grpc_pollset_has_workers(pollset) &&
+      !grpc_closure_list_empty(pollset->idle_jobs)) {
+    grpc_exec_ctx_enqueue_list(exec_ctx, &pollset->idle_jobs);
+    goto done;
+  }
+  if (grpc_alarm_check(exec_ctx, now, &deadline)) {
+    goto done;
+  }
+  if (pollset->shutting_down) {
+    goto done;
+  }
+  if (pollset->in_flight_cbs) {
+    /* Give do_promote priority so we don't starve it out */
+    gpr_mu_unlock(&pollset->mu);
+    locked = 0;
+    goto done;
+  }
+  if (!pollset->kicked_without_pollers) {
+    push_front_worker(pollset, worker);
+    added_worker = 1;
+    gpr_tls_set(&g_current_thread_poller, (gpr_intptr)pollset);
+    pollset->vtable->maybe_work_and_unlock(exec_ctx, pollset, worker, deadline,
+                                           now);
+    locked = 0;
+    gpr_tls_set(&g_current_thread_poller, 0);
+  } else {
+    pollset->kicked_without_pollers = 0;
+  }
 done:
-  if (!locked)
-    {
-      grpc_exec_ctx_flush (exec_ctx);
-      gpr_mu_lock (&pollset->mu);
-      locked = 1;
-    }
-  grpc_wakeup_fd_destroy (&worker->wakeup_fd);
-  if (added_worker)
-    {
-      remove_worker (pollset, worker);
-    }
-  if (pollset->shutting_down)
-    {
-      if (grpc_pollset_has_workers (pollset))
-	{
-	  grpc_pollset_kick (pollset, NULL);
-	}
-      else if (!pollset->called_shutdown && pollset->in_flight_cbs == 0)
-	{
-	  pollset->called_shutdown = 1;
-	  gpr_mu_unlock (&pollset->mu);
-	  finish_shutdown (exec_ctx, pollset);
-	  grpc_exec_ctx_flush (exec_ctx);
-	  /* Continuing to access pollset here is safe -- it is the caller's
-	   * responsibility to not destroy when it has outstanding calls to
-	   * grpc_pollset_work.
-	   * TODO(dklempner): Can we refactor the shutdown logic to avoid this? */
-	  gpr_mu_lock (&pollset->mu);
-	}
-    }
+  if (!locked) {
+    grpc_exec_ctx_flush(exec_ctx);
+    gpr_mu_lock(&pollset->mu);
+    locked = 1;
+  }
+  grpc_wakeup_fd_destroy(&worker->wakeup_fd);
+  if (added_worker) {
+    remove_worker(pollset, worker);
+  }
+  if (pollset->shutting_down) {
+    if (grpc_pollset_has_workers(pollset)) {
+      grpc_pollset_kick(pollset, NULL);
+    } else if (!pollset->called_shutdown && pollset->in_flight_cbs == 0) {
+      pollset->called_shutdown = 1;
+      gpr_mu_unlock(&pollset->mu);
+      finish_shutdown(exec_ctx, pollset);
+      grpc_exec_ctx_flush(exec_ctx);
+      /* Continuing to access pollset here is safe -- it is the caller's
+       * responsibility to not destroy when it has outstanding calls to
+       * grpc_pollset_work.
+       * TODO(dklempner): Can we refactor the shutdown logic to avoid this? */
+      gpr_mu_lock(&pollset->mu);
+    }
+  }
 }
 
-void
-grpc_pollset_shutdown (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_closure * closure)
-{
+void grpc_pollset_shutdown(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
+                           grpc_closure *closure) {
   int call_shutdown = 0;
-  gpr_mu_lock (&pollset->mu);
-  GPR_ASSERT (!pollset->shutting_down);
+  gpr_mu_lock(&pollset->mu);
+  GPR_ASSERT(!pollset->shutting_down);
   pollset->shutting_down = 1;
-  if (!pollset->called_shutdown && pollset->in_flight_cbs == 0 && !grpc_pollset_has_workers (pollset))
-    {
-      pollset->called_shutdown = 1;
-      call_shutdown = 1;
-    }
+  if (!pollset->called_shutdown && pollset->in_flight_cbs == 0 &&
+      !grpc_pollset_has_workers(pollset)) {
+    pollset->called_shutdown = 1;
+    call_shutdown = 1;
+  }
   pollset->shutdown_done = closure;
-  grpc_pollset_kick (pollset, GRPC_POLLSET_KICK_BROADCAST);
-  gpr_mu_unlock (&pollset->mu);
+  grpc_pollset_kick(pollset, GRPC_POLLSET_KICK_BROADCAST);
+  gpr_mu_unlock(&pollset->mu);
 
-  if (call_shutdown)
-    {
-      finish_shutdown (exec_ctx, pollset);
-    }
+  if (call_shutdown) {
+    finish_shutdown(exec_ctx, pollset);
+  }
 }
 
-void
-grpc_pollset_destroy (grpc_pollset * pollset)
-{
-  GPR_ASSERT (pollset->shutting_down);
-  GPR_ASSERT (pollset->in_flight_cbs == 0);
-  GPR_ASSERT (!grpc_pollset_has_workers (pollset));
-  pollset->vtable->destroy (pollset);
-  gpr_mu_destroy (&pollset->mu);
+void grpc_pollset_destroy(grpc_pollset *pollset) {
+  GPR_ASSERT(pollset->shutting_down);
+  GPR_ASSERT(pollset->in_flight_cbs == 0);
+  GPR_ASSERT(!grpc_pollset_has_workers(pollset));
+  pollset->vtable->destroy(pollset);
+  gpr_mu_destroy(&pollset->mu);
 }
 
-int
-grpc_poll_deadline_to_millis_timeout (gpr_timespec deadline, gpr_timespec now)
-{
+int grpc_poll_deadline_to_millis_timeout(gpr_timespec deadline,
+                                         gpr_timespec now) {
   gpr_timespec timeout;
   static const int max_spin_polling_us = 10;
-  if (gpr_time_cmp (deadline, gpr_inf_future (deadline.clock_type)) == 0)
-    {
-      return -1;
-    }
-  if (gpr_time_cmp (deadline, gpr_time_add (now, gpr_time_from_micros (max_spin_polling_us, GPR_TIMESPAN))) <= 0)
-    {
-      return 0;
-    }
-  timeout = gpr_time_sub (deadline, now);
-  return gpr_time_to_millis (gpr_time_add (timeout, gpr_time_from_nanos (GPR_NS_PER_SEC - 1, GPR_TIMESPAN)));
+  if (gpr_time_cmp(deadline, gpr_inf_future(deadline.clock_type)) == 0) {
+    return -1;
+  }
+  if (gpr_time_cmp(deadline, gpr_time_add(now, gpr_time_from_micros(
+                                                   max_spin_polling_us,
+                                                   GPR_TIMESPAN))) <= 0) {
+    return 0;
+  }
+  timeout = gpr_time_sub(deadline, now);
+  return gpr_time_to_millis(gpr_time_add(
+      timeout, gpr_time_from_nanos(GPR_NS_PER_SEC - 1, GPR_TIMESPAN)));
 }
 
 /*
@@ -335,17 +288,14 @@ grpc_poll_deadline_to_millis_timeout (gpr_timespec deadline, gpr_timespec now)
  *                 descriptor via poll()
  */
 
-typedef struct grpc_unary_promote_args
-{
+typedef struct grpc_unary_promote_args {
   const grpc_pollset_vtable *original_vtable;
   grpc_pollset *pollset;
   grpc_fd *fd;
   grpc_closure promotion_closure;
 } grpc_unary_promote_args;
 
-static void
-basic_do_promote (grpc_exec_ctx * exec_ctx, void *args, int success)
-{
+static void basic_do_promote(grpc_exec_ctx *exec_ctx, void *args, int success) {
   grpc_unary_promote_args *up_args = args;
   const grpc_pollset_vtable *original_vtable = up_args->original_vtable;
   grpc_pollset *pollset = up_args->pollset;
@@ -360,143 +310,123 @@ basic_do_promote (grpc_exec_ctx * exec_ctx, void *args, int success)
    * 4. The pollset may be shutting down.
    */
 
-  gpr_mu_lock (&pollset->mu);
+  gpr_mu_lock(&pollset->mu);
   /* First we need to ensure that nobody is polling concurrently */
-  GPR_ASSERT (!grpc_pollset_has_workers (pollset));
+  GPR_ASSERT(!grpc_pollset_has_workers(pollset));
 
-  gpr_free (up_args);
+  gpr_free(up_args);
   /* At this point the pollset may no longer be a unary poller. In that case
    * we should just call the right add function and be done. */
   /* TODO(klempner): If we're not careful this could cause infinite recursion.
    * That's not a problem for now because empty_pollset has a trivial poller
    * and we don't have any mechanism to unbecome multipoller. */
   pollset->in_flight_cbs--;
-  if (pollset->shutting_down)
-    {
-      /* We don't care about this pollset anymore. */
-      if (pollset->in_flight_cbs == 0 && !pollset->called_shutdown)
-	{
-	  GPR_ASSERT (!grpc_pollset_has_workers (pollset));
-	  pollset->called_shutdown = 1;
-	  grpc_exec_ctx_enqueue (exec_ctx, pollset->shutdown_done, 1);
-	}
-    }
-  else if (grpc_fd_is_orphaned (fd))
-    {
-      /* Don't try to add it to anything, we'll drop our ref on it below */
-    }
-  else if (pollset->vtable != original_vtable)
-    {
-      pollset->vtable->add_fd (exec_ctx, pollset, fd, 0);
-    }
-  else if (fd != pollset->data.ptr)
-    {
-      grpc_fd *fds[2];
-      fds[0] = pollset->data.ptr;
-      fds[1] = fd;
-
-      if (fds[0] && !grpc_fd_is_orphaned (fds[0]))
-	{
-	  grpc_platform_become_multipoller (exec_ctx, pollset, fds, GPR_ARRAY_SIZE (fds));
-	  GRPC_FD_UNREF (fds[0], "basicpoll");
-	}
-      else
-	{
-	  /* old fd is orphaned and we haven't cleaned it up until now, so remain a
-	   * unary poller */
-	  /* Note that it is possible that fds[1] is also orphaned at this point.
-	   * That's okay, we'll correct it at the next add or poll. */
-	  if (fds[0])
-	    GRPC_FD_UNREF (fds[0], "basicpoll");
-	  pollset->data.ptr = fd;
-	  GRPC_FD_REF (fd, "basicpoll");
-	}
-    }
-
-  gpr_mu_unlock (&pollset->mu);
+  if (pollset->shutting_down) {
+    /* We don't care about this pollset anymore. */
+    if (pollset->in_flight_cbs == 0 && !pollset->called_shutdown) {
+      GPR_ASSERT(!grpc_pollset_has_workers(pollset));
+      pollset->called_shutdown = 1;
+      grpc_exec_ctx_enqueue(exec_ctx, pollset->shutdown_done, 1);
+    }
+  } else if (grpc_fd_is_orphaned(fd)) {
+    /* Don't try to add it to anything, we'll drop our ref on it below */
+  } else if (pollset->vtable != original_vtable) {
+    pollset->vtable->add_fd(exec_ctx, pollset, fd, 0);
+  } else if (fd != pollset->data.ptr) {
+    grpc_fd *fds[2];
+    fds[0] = pollset->data.ptr;
+    fds[1] = fd;
+
+    if (fds[0] && !grpc_fd_is_orphaned(fds[0])) {
+      grpc_platform_become_multipoller(exec_ctx, pollset, fds,
+                                       GPR_ARRAY_SIZE(fds));
+      GRPC_FD_UNREF(fds[0], "basicpoll");
+    } else {
+      /* old fd is orphaned and we haven't cleaned it up until now, so remain a
+       * unary poller */
+      /* Note that it is possible that fds[1] is also orphaned at this point.
+       * That's okay, we'll correct it at the next add or poll. */
+      if (fds[0]) GRPC_FD_UNREF(fds[0], "basicpoll");
+      pollset->data.ptr = fd;
+      GRPC_FD_REF(fd, "basicpoll");
+    }
+  }
+
+  gpr_mu_unlock(&pollset->mu);
 
   /* Matching ref in basic_pollset_add_fd */
-  GRPC_FD_UNREF (fd, "basicpoll_add");
+  GRPC_FD_UNREF(fd, "basicpoll_add");
 }
 
-static void
-basic_pollset_add_fd (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_fd * fd, int and_unlock_pollset)
-{
+static void basic_pollset_add_fd(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
+                                 grpc_fd *fd, int and_unlock_pollset) {
   grpc_unary_promote_args *up_args;
-  GPR_ASSERT (fd);
-  if (fd == pollset->data.ptr)
-    goto exit;
-
-  if (!grpc_pollset_has_workers (pollset))
-    {
-      /* Fast path -- no in flight cbs */
-      /* TODO(klempner): Comment this out and fix any test failures or establish
-       * they are due to timing issues */
-      grpc_fd *fds[2];
-      fds[0] = pollset->data.ptr;
-      fds[1] = fd;
-
-      if (fds[0] == NULL)
-	{
-	  pollset->data.ptr = fd;
-	  GRPC_FD_REF (fd, "basicpoll");
-	}
-      else if (!grpc_fd_is_orphaned (fds[0]))
-	{
-	  grpc_platform_become_multipoller (exec_ctx, pollset, fds, GPR_ARRAY_SIZE (fds));
-	  GRPC_FD_UNREF (fds[0], "basicpoll");
-	}
-      else
-	{
-	  /* old fd is orphaned and we haven't cleaned it up until now, so remain a
-	   * unary poller */
-	  GRPC_FD_UNREF (fds[0], "basicpoll");
-	  pollset->data.ptr = fd;
-	  GRPC_FD_REF (fd, "basicpoll");
-	}
-      goto exit;
+  GPR_ASSERT(fd);
+  if (fd == pollset->data.ptr) goto exit;
+
+  if (!grpc_pollset_has_workers(pollset)) {
+    /* Fast path -- no in flight cbs */
+    /* TODO(klempner): Comment this out and fix any test failures or establish
+     * they are due to timing issues */
+    grpc_fd *fds[2];
+    fds[0] = pollset->data.ptr;
+    fds[1] = fd;
+
+    if (fds[0] == NULL) {
+      pollset->data.ptr = fd;
+      GRPC_FD_REF(fd, "basicpoll");
+    } else if (!grpc_fd_is_orphaned(fds[0])) {
+      grpc_platform_become_multipoller(exec_ctx, pollset, fds,
+                                       GPR_ARRAY_SIZE(fds));
+      GRPC_FD_UNREF(fds[0], "basicpoll");
+    } else {
+      /* old fd is orphaned and we haven't cleaned it up until now, so remain a
+       * unary poller */
+      GRPC_FD_UNREF(fds[0], "basicpoll");
+      pollset->data.ptr = fd;
+      GRPC_FD_REF(fd, "basicpoll");
     }
+    goto exit;
+  }
 
   /* Now we need to promote. This needs to happen when we're not polling. Since
    * this may be called from poll, the wait needs to happen asynchronously. */
-  GRPC_FD_REF (fd, "basicpoll_add");
+  GRPC_FD_REF(fd, "basicpoll_add");
   pollset->in_flight_cbs++;
-  up_args = gpr_malloc (sizeof (*up_args));
+  up_args = gpr_malloc(sizeof(*up_args));
   up_args->fd = fd;
   up_args->original_vtable = pollset->vtable;
   up_args->pollset = pollset;
   up_args->promotion_closure.cb = basic_do_promote;
   up_args->promotion_closure.cb_arg = up_args;
 
-  grpc_closure_list_add (&pollset->idle_jobs, &up_args->promotion_closure, 1);
-  grpc_pollset_kick (pollset, GRPC_POLLSET_KICK_BROADCAST);
+  grpc_closure_list_add(&pollset->idle_jobs, &up_args->promotion_closure, 1);
+  grpc_pollset_kick(pollset, GRPC_POLLSET_KICK_BROADCAST);
 
 exit:
-  if (and_unlock_pollset)
-    {
-      gpr_mu_unlock (&pollset->mu);
-    }
+  if (and_unlock_pollset) {
+    gpr_mu_unlock(&pollset->mu);
+  }
 }
 
-static void
-basic_pollset_del_fd (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_fd * fd, int and_unlock_pollset)
-{
-  GPR_ASSERT (fd);
-  if (fd == pollset->data.ptr)
-    {
-      GRPC_FD_UNREF (pollset->data.ptr, "basicpoll");
-      pollset->data.ptr = NULL;
-    }
-
-  if (and_unlock_pollset)
-    {
-      gpr_mu_unlock (&pollset->mu);
-    }
+static void basic_pollset_del_fd(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
+                                 grpc_fd *fd, int and_unlock_pollset) {
+  GPR_ASSERT(fd);
+  if (fd == pollset->data.ptr) {
+    GRPC_FD_UNREF(pollset->data.ptr, "basicpoll");
+    pollset->data.ptr = NULL;
+  }
+
+  if (and_unlock_pollset) {
+    gpr_mu_unlock(&pollset->mu);
+  }
 }
 
-static void
-basic_pollset_maybe_work_and_unlock (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_pollset_worker * worker, gpr_timespec deadline, gpr_timespec now)
-{
+static void basic_pollset_maybe_work_and_unlock(grpc_exec_ctx *exec_ctx,
+                                                grpc_pollset *pollset,
+                                                grpc_pollset_worker *worker,
+                                                gpr_timespec deadline,
+                                                gpr_timespec now) {
   struct pollfd pfd[2];
   grpc_fd *fd;
   grpc_fd_watcher fd_watcher;
@@ -505,98 +435,77 @@ basic_pollset_maybe_work_and_unlock (grpc_exec_ctx * exec_ctx, grpc_pollset * po
   nfds_t nfds;
 
   fd = pollset->data.ptr;
-  if (fd && grpc_fd_is_orphaned (fd))
-    {
-      GRPC_FD_UNREF (fd, "basicpoll");
-      fd = pollset->data.ptr = NULL;
-    }
-  timeout = grpc_poll_deadline_to_millis_timeout (deadline, now);
-  pfd[0].fd = GRPC_WAKEUP_FD_GET_READ_FD (&worker->wakeup_fd);
+  if (fd && grpc_fd_is_orphaned(fd)) {
+    GRPC_FD_UNREF(fd, "basicpoll");
+    fd = pollset->data.ptr = NULL;
+  }
+  timeout = grpc_poll_deadline_to_millis_timeout(deadline, now);
+  pfd[0].fd = GRPC_WAKEUP_FD_GET_READ_FD(&worker->wakeup_fd);
   pfd[0].events = POLLIN;
   pfd[0].revents = 0;
   nfds = 1;
-  if (fd)
-    {
-      pfd[1].fd = fd->fd;
-      pfd[1].revents = 0;
-      gpr_mu_unlock (&pollset->mu);
-      pfd[1].events = (short) grpc_fd_begin_poll (fd, pollset, POLLIN, POLLOUT, &fd_watcher);
-      if (pfd[1].events != 0)
-	{
-	  nfds++;
-	}
-    }
-  else
-    {
-      gpr_mu_unlock (&pollset->mu);
-    }
+  if (fd) {
+    pfd[1].fd = fd->fd;
+    pfd[1].revents = 0;
+    gpr_mu_unlock(&pollset->mu);
+    pfd[1].events =
+        (short)grpc_fd_begin_poll(fd, pollset, POLLIN, POLLOUT, &fd_watcher);
+    if (pfd[1].events != 0) {
+      nfds++;
+    }
+  } else {
+    gpr_mu_unlock(&pollset->mu);
+  }
 
   /* poll fd count (argument 2) is shortened by one if we have no events
      to poll on - such that it only includes the kicker */
-  r = grpc_poll_function (pfd, nfds, timeout);
-  GRPC_TIMER_MARK (GRPC_PTAG_POLL_FINISHED, r);
-
-  if (fd)
-    {
-      grpc_fd_end_poll (exec_ctx, &fd_watcher, pfd[1].revents & POLLIN, pfd[1].revents & POLLOUT);
-    }
-
-  if (r < 0)
-    {
-      if (errno != EINTR)
-	{
-	  gpr_log (GPR_ERROR, "poll() failed: %s", strerror (errno));
-	}
-    }
-  else if (r == 0)
-    {
-      /* do nothing */
-    }
-  else
-    {
-      if (pfd[0].revents & POLLIN)
-	{
-	  grpc_wakeup_fd_consume_wakeup (&worker->wakeup_fd);
-	}
-      if (nfds > 1)
-	{
-	  if (pfd[1].revents & (POLLIN | POLLHUP | POLLERR))
-	    {
-	      grpc_fd_become_readable (exec_ctx, fd);
-	    }
-	  if (pfd[1].revents & (POLLOUT | POLLHUP | POLLERR))
-	    {
-	      grpc_fd_become_writable (exec_ctx, fd);
-	    }
-	}
-    }
+  r = grpc_poll_function(pfd, nfds, timeout);
+  GRPC_TIMER_MARK(GRPC_PTAG_POLL_FINISHED, r);
+
+  if (fd) {
+    grpc_fd_end_poll(exec_ctx, &fd_watcher, pfd[1].revents & POLLIN,
+                     pfd[1].revents & POLLOUT);
+  }
+
+  if (r < 0) {
+    if (errno != EINTR) {
+      gpr_log(GPR_ERROR, "poll() failed: %s", strerror(errno));
+    }
+  } else if (r == 0) {
+    /* do nothing */
+  } else {
+    if (pfd[0].revents & POLLIN) {
+      grpc_wakeup_fd_consume_wakeup(&worker->wakeup_fd);
+    }
+    if (nfds > 1) {
+      if (pfd[1].revents & (POLLIN | POLLHUP | POLLERR)) {
+        grpc_fd_become_readable(exec_ctx, fd);
+      }
+      if (pfd[1].revents & (POLLOUT | POLLHUP | POLLERR)) {
+        grpc_fd_become_writable(exec_ctx, fd);
+      }
+    }
+  }
 }
 
-static void
-basic_pollset_destroy (grpc_pollset * pollset)
-{
-  if (pollset->data.ptr != NULL)
-    {
-      GRPC_FD_UNREF (pollset->data.ptr, "basicpoll");
-      pollset->data.ptr = NULL;
-    }
+static void basic_pollset_destroy(grpc_pollset *pollset) {
+  if (pollset->data.ptr != NULL) {
+    GRPC_FD_UNREF(pollset->data.ptr, "basicpoll");
+    pollset->data.ptr = NULL;
+  }
 }
 
 static const grpc_pollset_vtable basic_pollset = {
-  basic_pollset_add_fd, basic_pollset_del_fd,
-  basic_pollset_maybe_work_and_unlock, basic_pollset_destroy,
-  basic_pollset_destroy
-};
-
-static void
-become_basic_pollset (grpc_pollset * pollset, grpc_fd * fd_or_null)
-{
+    basic_pollset_add_fd, basic_pollset_del_fd,
+    basic_pollset_maybe_work_and_unlock, basic_pollset_destroy,
+    basic_pollset_destroy};
+
+static void become_basic_pollset(grpc_pollset *pollset, grpc_fd *fd_or_null) {
   pollset->vtable = &basic_pollset;
   pollset->data.ptr = fd_or_null;
-  if (fd_or_null != NULL)
-    {
-      GRPC_FD_REF (fd_or_null, "basicpoll");
-    }
+  if (fd_or_null != NULL) {
+    GRPC_FD_REF(fd_or_null, "basicpoll");
+  }
 }
 
 #endif /* GPR_POSIX_POLLSET */

src/core/iomgr/pollset_posix.h

@@ -48,15 +48,13 @@ typedef struct grpc_pollset_vtable grpc_pollset_vtable;
    use the struct tag */
 struct grpc_fd;
 
-typedef struct grpc_pollset_worker
-{
+typedef struct grpc_pollset_worker {
   grpc_wakeup_fd wakeup_fd;
   struct grpc_pollset_worker *next;
   struct grpc_pollset_worker *prev;
 } grpc_pollset_worker;
 
-typedef struct grpc_pollset
-{
+typedef struct grpc_pollset {
   /* pollsets under posix can mutate representation as fds are added and
      removed.
      For example, we may choose a poll() based implementation on linux for
@@ -70,34 +68,38 @@ typedef struct grpc_pollset
   int kicked_without_pollers;
   grpc_closure *shutdown_done;
   grpc_closure_list idle_jobs;
-  union
-  {
+  union {
     int fd;
     void *ptr;
   } data;
 } grpc_pollset;
 
-struct grpc_pollset_vtable
-{
-  void (*add_fd) (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, struct grpc_fd * fd, int and_unlock_pollset);
-  void (*del_fd) (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, struct grpc_fd * fd, int and_unlock_pollset);
-  void (*maybe_work_and_unlock) (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, grpc_pollset_worker * worker, gpr_timespec deadline, gpr_timespec now);
-  void (*finish_shutdown) (grpc_pollset * pollset);
-  void (*destroy) (grpc_pollset * pollset);
+struct grpc_pollset_vtable {
+  void (*add_fd)(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
+                 struct grpc_fd *fd, int and_unlock_pollset);
+  void (*del_fd)(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
+                 struct grpc_fd *fd, int and_unlock_pollset);
+  void (*maybe_work_and_unlock)(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
+                                grpc_pollset_worker *worker,
+                                gpr_timespec deadline, gpr_timespec now);
+  void (*finish_shutdown)(grpc_pollset *pollset);
+  void (*destroy)(grpc_pollset *pollset);
 };
 
 #define GRPC_POLLSET_MU(pollset) (&(pollset)->mu)
 
 /* Add an fd to a pollset */
-void grpc_pollset_add_fd (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, struct grpc_fd *fd);
+void grpc_pollset_add_fd(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
+                         struct grpc_fd *fd);
 /* Force remove an fd from a pollset (normally they are removed on the next
    poll after an fd is orphaned) */
-void grpc_pollset_del_fd (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, struct grpc_fd *fd);
+void grpc_pollset_del_fd(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
+                         struct grpc_fd *fd);
 
 /* Returns the fd to listen on for kicks */
-int grpc_kick_read_fd (grpc_pollset * p);
+int grpc_kick_read_fd(grpc_pollset *p);
 /* Call after polling has been kicked to leave the kicked state */
-void grpc_kick_drain (grpc_pollset * p);
+void grpc_kick_drain(grpc_pollset *p);
 
 /* Convert a timespec to milliseconds:
    - very small or negative poll times are clamped to zero to do a
@@ -106,20 +108,26 @@ void grpc_kick_drain (grpc_pollset * p);
    - longer than a millisecond polls are rounded up to the next nearest
      millisecond to avoid spinning
    - infinite timeouts are converted to -1 */
-int grpc_poll_deadline_to_millis_timeout (gpr_timespec deadline, gpr_timespec now);
+int grpc_poll_deadline_to_millis_timeout(gpr_timespec deadline,
+                                         gpr_timespec now);
 
 /* turn a pollset into a multipoller: platform specific */
-typedef void (*grpc_platform_become_multipoller_type) (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, struct grpc_fd ** fds, size_t fd_count);
+typedef void (*grpc_platform_become_multipoller_type)(grpc_exec_ctx *exec_ctx,
+                                                      grpc_pollset *pollset,
+                                                      struct grpc_fd **fds,
+                                                      size_t fd_count);
 extern grpc_platform_become_multipoller_type grpc_platform_become_multipoller;
 
-void grpc_poll_become_multipoller (grpc_exec_ctx * exec_ctx, grpc_pollset * pollset, struct grpc_fd **fds, size_t fd_count);
+void grpc_poll_become_multipoller(grpc_exec_ctx *exec_ctx,
+                                  grpc_pollset *pollset, struct grpc_fd **fds,
+                                  size_t fd_count);
 
 /* Return 1 if the pollset has active threads in grpc_pollset_work (pollset must
  * be locked) */
-int grpc_pollset_has_workers (grpc_pollset * pollset);
+int grpc_pollset_has_workers(grpc_pollset *pollset);
 
 /* override to allow tests to hook poll() usage */
-typedef int (*grpc_poll_function_type) (struct pollfd *, nfds_t, int);
+typedef int (*grpc_poll_function_type)(struct pollfd *, nfds_t, int);
 extern grpc_poll_function_type grpc_poll_function;
 
 #endif /* GRPC_INTERNAL_CORE_IOMGR_POLLSET_POSIX_H */

src/core/iomgr/pollset_set.h

@@ -49,9 +49,13 @@
 #include "src/core/iomgr/pollset_set_windows.h"
 #endif
 
-void grpc_pollset_set_init (grpc_pollset_set * pollset_set);
-void grpc_pollset_set_destroy (grpc_pollset_set * pollset_set);
-void grpc_pollset_set_add_pollset (grpc_exec_ctx * exec_ctx, grpc_pollset_set * pollset_set, grpc_pollset * pollset);
-void grpc_pollset_set_del_pollset (grpc_exec_ctx * exec_ctx, grpc_pollset_set * pollset_set, grpc_pollset * pollset);
+void grpc_pollset_set_init(grpc_pollset_set* pollset_set);
+void grpc_pollset_set_destroy(grpc_pollset_set* pollset_set);
+void grpc_pollset_set_add_pollset(grpc_exec_ctx* exec_ctx,
+                                  grpc_pollset_set* pollset_set,
+                                  grpc_pollset* pollset);
+void grpc_pollset_set_del_pollset(grpc_exec_ctx* exec_ctx,
+                                  grpc_pollset_set* pollset_set,
+                                  grpc_pollset* pollset);
 
 #endif /* GRPC_INTERNAL_CORE_IOMGR_POLLSET_H */

src/core/iomgr/pollset_set_posix.c

@@ -43,105 +43,93 @@
 
 #include "src/core/iomgr/pollset_set.h"
 
-void
-grpc_pollset_set_init (grpc_pollset_set * pollset_set)
-{
-  memset (pollset_set, 0, sizeof (*pollset_set));
-  gpr_mu_init (&pollset_set->mu);
+void grpc_pollset_set_init(grpc_pollset_set *pollset_set) {
+  memset(pollset_set, 0, sizeof(*pollset_set));
+  gpr_mu_init(&pollset_set->mu);
 }
 
-void
-grpc_pollset_set_destroy (grpc_pollset_set * pollset_set)
-{
+void grpc_pollset_set_destroy(grpc_pollset_set *pollset_set) {
   size_t i;
-  gpr_mu_destroy (&pollset_set->mu);
-  for (i = 0; i < pollset_set->fd_count; i++)
-    {
-      GRPC_FD_UNREF (pollset_set->fds[i], "pollset");
-    }
-  gpr_free (pollset_set->pollsets);
-  gpr_free (pollset_set->fds);
+  gpr_mu_destroy(&pollset_set->mu);
+  for (i = 0; i < pollset_set->fd_count; i++) {
+    GRPC_FD_UNREF(pollset_set->fds[i], "pollset");
+  }
+  gpr_free(pollset_set->pollsets);
+  gpr_free(pollset_set->fds);
 }
 
-void
-grpc_pollset_set_add_pollset (grpc_exec_ctx * exec_ctx, grpc_pollset_set * pollset_set, grpc_pollset * pollset)
-{
+void grpc_pollset_set_add_pollset(grpc_exec_ctx *exec_ctx,
+                                  grpc_pollset_set *pollset_set,
+                                  grpc_pollset *pollset) {
   size_t i, j;
-  gpr_mu_lock (&pollset_set->mu);
-  if (pollset_set->pollset_count == pollset_set->pollset_capacity)
-    {
-      pollset_set->pollset_capacity = GPR_MAX (8, 2 * pollset_set->pollset_capacity);
-      pollset_set->pollsets = gpr_realloc (pollset_set->pollsets, pollset_set->pollset_capacity * sizeof (*pollset_set->pollsets));
-    }
+  gpr_mu_lock(&pollset_set->mu);
+  if (pollset_set->pollset_count == pollset_set->pollset_capacity) {
+    pollset_set->pollset_capacity =
+        GPR_MAX(8, 2 * pollset_set->pollset_capacity);
+    pollset_set->pollsets =
+        gpr_realloc(pollset_set->pollsets, pollset_set->pollset_capacity *
+                                               sizeof(*pollset_set->pollsets));
+  }
   pollset_set->pollsets[pollset_set->pollset_count++] = pollset;
-  for (i = 0, j = 0; i < pollset_set->fd_count; i++)
-    {
-      if (grpc_fd_is_orphaned (pollset_set->fds[i]))
-	{
-	  GRPC_FD_UNREF (pollset_set->fds[i], "pollset");
-	}
-      else
-	{
-	  grpc_pollset_add_fd (exec_ctx, pollset, pollset_set->fds[i]);
-	  pollset_set->fds[j++] = pollset_set->fds[i];
-	}
+  for (i = 0, j = 0; i < pollset_set->fd_count; i++) {
+    if (grpc_fd_is_orphaned(pollset_set->fds[i])) {
+      GRPC_FD_UNREF(pollset_set->fds[i], "pollset");
+    } else {
+      grpc_pollset_add_fd(exec_ctx, pollset, pollset_set->fds[i]);
+      pollset_set->fds[j++] = pollset_set->fds[i];
     }
+  }
   pollset_set->fd_count = j;
-  gpr_mu_unlock (&pollset_set->mu);
+  gpr_mu_unlock(&pollset_set->mu);
 }
 
-void
-grpc_pollset_set_del_pollset (grpc_exec_ctx * exec_ctx, grpc_pollset_set * pollset_set, grpc_pollset * pollset)
-{
+void grpc_pollset_set_del_pollset(grpc_exec_ctx *exec_ctx,
+                                  grpc_pollset_set *pollset_set,
+                                  grpc_pollset *pollset) {
   size_t i;
-  gpr_mu_lock (&pollset_set->mu);
-  for (i = 0; i < pollset_set->pollset_count; i++)
-    {
-      if (pollset_set->pollsets[i] == pollset)
-	{
-	  pollset_set->pollset_count--;
-	  GPR_SWAP (grpc_pollset *, pollset_set->pollsets[i], pollset_set->pollsets[pollset_set->pollset_count]);
-	  break;
-	}
+  gpr_mu_lock(&pollset_set->mu);
+  for (i = 0; i < pollset_set->pollset_count; i++) {
+    if (pollset_set->pollsets[i] == pollset) {
+      pollset_set->pollset_count--;
+      GPR_SWAP(grpc_pollset *, pollset_set->pollsets[i],
+               pollset_set->pollsets[pollset_set->pollset_count]);
+      break;
     }
-  gpr_mu_unlock (&pollset_set->mu);
+  }
+  gpr_mu_unlock(&pollset_set->mu);
 }
 
-void
-grpc_pollset_set_add_fd (grpc_exec_ctx * exec_ctx, grpc_pollset_set * pollset_set, grpc_fd * fd)
-{
+void grpc_pollset_set_add_fd(grpc_exec_ctx *exec_ctx,
+                             grpc_pollset_set *pollset_set, grpc_fd *fd) {
   size_t i;
-  gpr_mu_lock (&pollset_set->mu);
-  if (pollset_set->fd_count == pollset_set->fd_capacity)
-    {
-      pollset_set->fd_capacity = GPR_MAX (8, 2 * pollset_set->fd_capacity);
-      pollset_set->fds = gpr_realloc (pollset_set->fds, pollset_set->fd_capacity * sizeof (*pollset_set->fds));
-    }
-  GRPC_FD_REF (fd, "pollset_set");
+  gpr_mu_lock(&pollset_set->mu);
+  if (pollset_set->fd_count == pollset_set->fd_capacity) {
+    pollset_set->fd_capacity = GPR_MAX(8, 2 * pollset_set->fd_capacity);
+    pollset_set->fds = gpr_realloc(
+        pollset_set->fds, pollset_set->fd_capacity * sizeof(*pollset_set->fds));
+  }
+  GRPC_FD_REF(fd, "pollset_set");
   pollset_set->fds[pollset_set->fd_count++] = fd;
-  for (i = 0; i < pollset_set->pollset_count; i++)
-    {
-      grpc_pollset_add_fd (exec_ctx, pollset_set->pollsets[i], fd);
-    }
-  gpr_mu_unlock (&pollset_set->mu);
+  for (i = 0; i < pollset_set->pollset_count; i++) {
+    grpc_pollset_add_fd(exec_ctx, pollset_set->pollsets[i], fd);
+  }
+  gpr_mu_unlock(&pollset_set->mu);
 }
 
-void
-grpc_pollset_set_del_fd (grpc_exec_ctx * exec_ctx, grpc_pollset_set * pollset_set, grpc_fd * fd)
-{
+void grpc_pollset_set_del_fd(grpc_exec_ctx *exec_ctx,
+                             grpc_pollset_set *pollset_set, grpc_fd *fd) {
   size_t i;
-  gpr_mu_lock (&pollset_set->mu);
-  for (i = 0; i < pollset_set->fd_count; i++)
-    {
-      if (pollset_set->fds[i] == fd)
-	{
-	  pollset_set->fd_count--;
-	  GPR_SWAP (grpc_fd *, pollset_set->fds[i], pollset_set->fds[pollset_set->fd_count]);
-	  GRPC_FD_UNREF (fd, "pollset_set");
-	  break;
-	}
+  gpr_mu_lock(&pollset_set->mu);
+  for (i = 0; i < pollset_set->fd_count; i++) {
+    if (pollset_set->fds[i] == fd) {
+      pollset_set->fd_count--;
+      GPR_SWAP(grpc_fd *, pollset_set->fds[i],
+               pollset_set->fds[pollset_set->fd_count]);
+      GRPC_FD_UNREF(fd, "pollset_set");
+      break;
     }
-  gpr_mu_unlock (&pollset_set->mu);
+  }
+  gpr_mu_unlock(&pollset_set->mu);
 }
 
 #endif /* GPR_POSIX_SOCKET */