clang-format all core files

28 files changed, 3260 insertions, 3701 deletions

diff --git a/src/core/surface/byte_buffer.c b/src/core/surface/byte_buffer.c
index c26e3e1317..a930949f2d 100644
--- a/src/core/surface/byte_buffer.c
+++ b/src/core/surface/byte_buffer.c
@@ -35,79 +35,66 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-grpc_byte_buffer *
-grpc_raw_byte_buffer_create (gpr_slice * slices, size_t nslices)
-{
-  return grpc_raw_compressed_byte_buffer_create (slices, nslices, GRPC_COMPRESS_NONE);
+grpc_byte_buffer *grpc_raw_byte_buffer_create(gpr_slice *slices,
+                                              size_t nslices) {
+  return grpc_raw_compressed_byte_buffer_create(slices, nslices,
+                                                GRPC_COMPRESS_NONE);
 }
 
-grpc_byte_buffer *
-grpc_raw_compressed_byte_buffer_create (gpr_slice * slices, size_t nslices, grpc_compression_algorithm compression)
-{
+grpc_byte_buffer *grpc_raw_compressed_byte_buffer_create(
+    gpr_slice *slices, size_t nslices, grpc_compression_algorithm compression) {
   size_t i;
-  grpc_byte_buffer *bb = malloc (sizeof (grpc_byte_buffer));
+  grpc_byte_buffer *bb = malloc(sizeof(grpc_byte_buffer));
   bb->type = GRPC_BB_RAW;
   bb->data.raw.compression = compression;
-  gpr_slice_buffer_init (&bb->data.raw.slice_buffer);
-  for (i = 0; i < nslices; i++)
-    {
-      gpr_slice_ref (slices[i]);
-      gpr_slice_buffer_add (&bb->data.raw.slice_buffer, slices[i]);
-    }
+  gpr_slice_buffer_init(&bb->data.raw.slice_buffer);
+  for (i = 0; i < nslices; i++) {
+    gpr_slice_ref(slices[i]);
+    gpr_slice_buffer_add(&bb->data.raw.slice_buffer, slices[i]);
+  }
   return bb;
 }
 
-grpc_byte_buffer *
-grpc_raw_byte_buffer_from_reader (grpc_byte_buffer_reader * reader)
-{
-  grpc_byte_buffer *bb = malloc (sizeof (grpc_byte_buffer));
+grpc_byte_buffer *grpc_raw_byte_buffer_from_reader(
+    grpc_byte_buffer_reader *reader) {
+  grpc_byte_buffer *bb = malloc(sizeof(grpc_byte_buffer));
   gpr_slice slice;
   bb->type = GRPC_BB_RAW;
   bb->data.raw.compression = GRPC_COMPRESS_NONE;
-  gpr_slice_buffer_init (&bb->data.raw.slice_buffer);
+  gpr_slice_buffer_init(&bb->data.raw.slice_buffer);
 
-  while (grpc_byte_buffer_reader_next (reader, &slice))
-    {
-      gpr_slice_buffer_add (&bb->data.raw.slice_buffer, slice);
-    }
+  while (grpc_byte_buffer_reader_next(reader, &slice)) {
+    gpr_slice_buffer_add(&bb->data.raw.slice_buffer, slice);
+  }
   return bb;
 }
 
-grpc_byte_buffer *
-grpc_byte_buffer_copy (grpc_byte_buffer * bb)
-{
-  switch (bb->type)
-    {
+grpc_byte_buffer *grpc_byte_buffer_copy(grpc_byte_buffer *bb) {
+  switch (bb->type) {
     case GRPC_BB_RAW:
-      return grpc_raw_byte_buffer_create (bb->data.raw.slice_buffer.slices, bb->data.raw.slice_buffer.count);
-    }
-  gpr_log (GPR_INFO, "should never get here");
-  abort ();
+      return grpc_raw_byte_buffer_create(bb->data.raw.slice_buffer.slices,
+                                         bb->data.raw.slice_buffer.count);
+  }
+  gpr_log(GPR_INFO, "should never get here");
+  abort();
   return NULL;
 }
 
-void
-grpc_byte_buffer_destroy (grpc_byte_buffer * bb)
-{
-  if (!bb)
-    return;
-  switch (bb->type)
-    {
+void grpc_byte_buffer_destroy(grpc_byte_buffer *bb) {
+  if (!bb) return;
+  switch (bb->type) {
     case GRPC_BB_RAW:
-      gpr_slice_buffer_destroy (&bb->data.raw.slice_buffer);
+      gpr_slice_buffer_destroy(&bb->data.raw.slice_buffer);
       break;
-    }
-  free (bb);
+  }
+  free(bb);
 }
 
-size_t
-grpc_byte_buffer_length (grpc_byte_buffer * bb)
-{
-  switch (bb->type)
-    {
+size_t grpc_byte_buffer_length(grpc_byte_buffer *bb) {
+  switch (bb->type) {
     case GRPC_BB_RAW:
       return bb->data.raw.slice_buffer.length;
-    }
-  gpr_log (GPR_ERROR, "should never reach here");
-  abort ();
+  }
+  gpr_log(GPR_ERROR, "should never reach here");
+  abort();
 }
diff --git a/src/core/surface/byte_buffer_queue.c b/src/core/surface/byte_buffer_queue.c
index 543da6a000..e47dc4f4ce 100644
--- a/src/core/surface/byte_buffer_queue.c
+++ b/src/core/surface/byte_buffer_queue.c
@@ -35,86 +35,63 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/useful.h>
 
-static void
-bba_destroy (grpc_bbq_array * array, size_t start_pos)
-{
+static void bba_destroy(grpc_bbq_array *array, size_t start_pos) {
   size_t i;
-  for (i = start_pos; i < array->count; i++)
-    {
-      grpc_byte_buffer_destroy (array->data[i]);
-    }
-  gpr_free (array->data);
+  for (i = start_pos; i < array->count; i++) {
+    grpc_byte_buffer_destroy(array->data[i]);
+  }
+  gpr_free(array->data);
 }
 
 /* Append an operation to an array, expanding as needed */
-static void
-bba_push (grpc_bbq_array * a, grpc_byte_buffer * buffer)
-{
-  if (a->count == a->capacity)
-    {
-      a->capacity = GPR_MAX (a->capacity * 2, 8);
-      a->data = gpr_realloc (a->data, sizeof (grpc_byte_buffer *) * a->capacity);
-    }
+static void bba_push(grpc_bbq_array *a, grpc_byte_buffer *buffer) {
+  if (a->count == a->capacity) {
+    a->capacity = GPR_MAX(a->capacity * 2, 8);
+    a->data = gpr_realloc(a->data, sizeof(grpc_byte_buffer *) * a->capacity);
+  }
   a->data[a->count++] = buffer;
 }
 
-void
-grpc_bbq_destroy (grpc_byte_buffer_queue * q)
-{
-  bba_destroy (&q->filling, 0);
-  bba_destroy (&q->draining, q->drain_pos);
+void grpc_bbq_destroy(grpc_byte_buffer_queue *q) {
+  bba_destroy(&q->filling, 0);
+  bba_destroy(&q->draining, q->drain_pos);
 }
 
-int
-grpc_bbq_empty (grpc_byte_buffer_queue * q)
-{
+int grpc_bbq_empty(grpc_byte_buffer_queue *q) {
   return (q->drain_pos == q->draining.count && q->filling.count == 0);
 }
 
-void
-grpc_bbq_push (grpc_byte_buffer_queue * q, grpc_byte_buffer * buffer)
-{
-  q->bytes += grpc_byte_buffer_length (buffer);
-  bba_push (&q->filling, buffer);
+void grpc_bbq_push(grpc_byte_buffer_queue *q, grpc_byte_buffer *buffer) {
+  q->bytes += grpc_byte_buffer_length(buffer);
+  bba_push(&q->filling, buffer);
 }
 
-void
-grpc_bbq_flush (grpc_byte_buffer_queue * q)
-{
+void grpc_bbq_flush(grpc_byte_buffer_queue *q) {
   grpc_byte_buffer *bb;
-  while ((bb = grpc_bbq_pop (q)))
-    {
-      grpc_byte_buffer_destroy (bb);
-    }
+  while ((bb = grpc_bbq_pop(q))) {
+    grpc_byte_buffer_destroy(bb);
+  }
 }
 
-size_t
-grpc_bbq_bytes (grpc_byte_buffer_queue * q)
-{
-  return q->bytes;
-}
+size_t grpc_bbq_bytes(grpc_byte_buffer_queue *q) { return q->bytes; }
 
-grpc_byte_buffer *
-grpc_bbq_pop (grpc_byte_buffer_queue * q)
-{
+grpc_byte_buffer *grpc_bbq_pop(grpc_byte_buffer_queue *q) {
   grpc_bbq_array temp_array;
   grpc_byte_buffer *out;
 
-  if (q->drain_pos == q->draining.count)
-    {
-      if (q->filling.count == 0)
-	{
-	  return NULL;
-	}
-      q->draining.count = 0;
-      q->drain_pos = 0;
-      /* swap arrays */
-      temp_array = q->filling;
-      q->filling = q->draining;
-      q->draining = temp_array;
+  if (q->drain_pos == q->draining.count) {
+    if (q->filling.count == 0) {
+      return NULL;
     }
+    q->draining.count = 0;
+    q->drain_pos = 0;
+    /* swap arrays */
+    temp_array = q->filling;
+    q->filling = q->draining;
+    q->draining = temp_array;
+  }
 
   out = q->draining.data[q->drain_pos++];
-  q->bytes -= grpc_byte_buffer_length (out);
+  q->bytes -= grpc_byte_buffer_length(out);
   return out;
 }
diff --git a/src/core/surface/byte_buffer_queue.h b/src/core/surface/byte_buffer_queue.h
index 3e344c1e54..2c3b22d24e 100644
--- a/src/core/surface/byte_buffer_queue.h
+++ b/src/core/surface/byte_buffer_queue.h
@@ -38,27 +38,25 @@
 
 /* TODO(ctiller): inline an element or two into this struct to avoid per-call
                   allocations */
-typedef struct
-{
+typedef struct {
   grpc_byte_buffer **data;
   size_t count;
   size_t capacity;
 } grpc_bbq_array;
 
 /* should be initialized by zeroing memory */
-typedef struct
-{
+typedef struct {
   size_t drain_pos;
   grpc_bbq_array filling;
   grpc_bbq_array draining;
   size_t bytes;
 } grpc_byte_buffer_queue;
 
-void grpc_bbq_destroy (grpc_byte_buffer_queue * q);
-grpc_byte_buffer *grpc_bbq_pop (grpc_byte_buffer_queue * q);
-void grpc_bbq_flush (grpc_byte_buffer_queue * q);
-int grpc_bbq_empty (grpc_byte_buffer_queue * q);
-void grpc_bbq_push (grpc_byte_buffer_queue * q, grpc_byte_buffer * bb);
-size_t grpc_bbq_bytes (grpc_byte_buffer_queue * q);
+void grpc_bbq_destroy(grpc_byte_buffer_queue *q);
+grpc_byte_buffer *grpc_bbq_pop(grpc_byte_buffer_queue *q);
+void grpc_bbq_flush(grpc_byte_buffer_queue *q);
+int grpc_bbq_empty(grpc_byte_buffer_queue *q);
+void grpc_bbq_push(grpc_byte_buffer_queue *q, grpc_byte_buffer *bb);
+size_t grpc_bbq_bytes(grpc_byte_buffer_queue *q);
 
 #endif /* GRPC_INTERNAL_CORE_SURFACE_BYTE_BUFFER_QUEUE_H */
diff --git a/src/core/surface/byte_buffer_reader.c b/src/core/surface/byte_buffer_reader.c
index c4c9e43d7e..283db83833 100644
--- a/src/core/surface/byte_buffer_reader.c
+++ b/src/core/surface/byte_buffer_reader.c
@@ -42,77 +42,64 @@
 
 #include "src/core/compression/message_compress.h"
 
-static int
-is_compressed (grpc_byte_buffer * buffer)
-{
-  switch (buffer->type)
-    {
+static int is_compressed(grpc_byte_buffer *buffer) {
+  switch (buffer->type) {
     case GRPC_BB_RAW:
-      if (buffer->data.raw.compression == GRPC_COMPRESS_NONE)
-	{
-	  return 0 /* GPR_FALSE */ ;
-	}
+      if (buffer->data.raw.compression == GRPC_COMPRESS_NONE) {
+        return 0 /* GPR_FALSE */;
+      }
       break;
-    }
-  return 1 /* GPR_TRUE */ ;
+  }
+  return 1 /* GPR_TRUE */;
 }
 
-void
-grpc_byte_buffer_reader_init (grpc_byte_buffer_reader * reader, grpc_byte_buffer * buffer)
-{
+void grpc_byte_buffer_reader_init(grpc_byte_buffer_reader *reader,
+                                  grpc_byte_buffer *buffer) {
   gpr_slice_buffer decompressed_slices_buffer;
   reader->buffer_in = buffer;
-  switch (reader->buffer_in->type)
-    {
+  switch (reader->buffer_in->type) {
     case GRPC_BB_RAW:
-      gpr_slice_buffer_init (&decompressed_slices_buffer);
-      if (is_compressed (reader->buffer_in))
-	{
-	  grpc_msg_decompress (reader->buffer_in->data.raw.compression, &reader->buffer_in->data.raw.slice_buffer, &decompressed_slices_buffer);
-	  reader->buffer_out = grpc_raw_byte_buffer_create (decompressed_slices_buffer.slices, decompressed_slices_buffer.count);
-	  gpr_slice_buffer_destroy (&decompressed_slices_buffer);
-	}
-      else
-	{			/* not compressed, use the input buffer as output */
-	  reader->buffer_out = reader->buffer_in;
-	}
+      gpr_slice_buffer_init(&decompressed_slices_buffer);
+      if (is_compressed(reader->buffer_in)) {
+        grpc_msg_decompress(reader->buffer_in->data.raw.compression,
+                            &reader->buffer_in->data.raw.slice_buffer,
+                            &decompressed_slices_buffer);
+        reader->buffer_out =
+            grpc_raw_byte_buffer_create(decompressed_slices_buffer.slices,
+                                        decompressed_slices_buffer.count);
+        gpr_slice_buffer_destroy(&decompressed_slices_buffer);
+      } else { /* not compressed, use the input buffer as output */
+        reader->buffer_out = reader->buffer_in;
+      }
       reader->current.index = 0;
       break;
-    }
+  }
 }
 
-void
-grpc_byte_buffer_reader_destroy (grpc_byte_buffer_reader * reader)
-{
-  switch (reader->buffer_in->type)
-    {
+void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader *reader) {
+  switch (reader->buffer_in->type) {
     case GRPC_BB_RAW:
       /* keeping the same if-else structure as in the init function */
-      if (is_compressed (reader->buffer_in))
-	{
-	  grpc_byte_buffer_destroy (reader->buffer_out);
-	}
+      if (is_compressed(reader->buffer_in)) {
+        grpc_byte_buffer_destroy(reader->buffer_out);
+      }
       break;
-    }
+  }
 }
 
-int
-grpc_byte_buffer_reader_next (grpc_byte_buffer_reader * reader, gpr_slice * slice)
-{
-  switch (reader->buffer_in->type)
-    {
-    case GRPC_BB_RAW:
-      {
-	gpr_slice_buffer *slice_buffer;
-	slice_buffer = &reader->buffer_out->data.raw.slice_buffer;
-	if (reader->current.index < slice_buffer->count)
-	  {
-	    *slice = gpr_slice_ref (slice_buffer->slices[reader->current.index]);
-	    reader->current.index += 1;
-	    return 1;
-	  }
-	break;
+int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader *reader,
+                                 gpr_slice *slice) {
+  switch (reader->buffer_in->type) {
+    case GRPC_BB_RAW: {
+      gpr_slice_buffer *slice_buffer;
+      slice_buffer = &reader->buffer_out->data.raw.slice_buffer;
+      if (reader->current.index < slice_buffer->count) {
+        *slice = gpr_slice_ref(slice_buffer->slices[reader->current.index]);
+        reader->current.index += 1;
+        return 1;
       }
+      break;
     }
+  }
   return 0;
 }
diff --git a/src/core/surface/call.c b/src/core/surface/call.c
index 418c75efd2..d97bf53206 100644
--- a/src/core/surface/call.c
+++ b/src/core/surface/call.c
@@ -61,8 +61,7 @@
       - status/close recv (depending on client/server) */
 #define MAX_CONCURRENT_COMPLETIONS 6
 
-typedef struct
-{
+typedef struct {
   grpc_ioreq_completion_func on_complete;
   void *user_data;
   int success;
@@ -74,8 +73,7 @@ typedef struct
 
 #define MAX_SEND_INITIAL_METADATA_COUNT 3
 
-typedef struct
-{
+typedef struct {
   /* Overall status of the operation: starts OK, may degrade to
      non-OK */
   gpr_uint8 success;
@@ -92,8 +90,7 @@ typedef struct
    enumerates them all, and acts as a priority sorting for which
    status to return to the application - earlier entries override
    later ones */
-typedef enum
-{
+typedef enum {
   /* Status came from the application layer overriding whatever
      the wire says */
   STATUS_FROM_API_OVERRIDE = 0,
@@ -107,16 +104,14 @@ typedef enum
   STATUS_SOURCE_COUNT
 } status_source;
 
-typedef struct
-{
+typedef struct {
   gpr_uint8 is_set;
   grpc_status_code code;
   grpc_mdstr *details;
 } received_status;
 
 /* How far through the GRPC stream have we read? */
-typedef enum
-{
+typedef enum {
   /* We are still waiting for initial metadata to complete */
   READ_STATE_INITIAL = 0,
   /* We have gotten initial metadata, and are reading either
@@ -128,15 +123,13 @@ typedef enum
   READ_STATE_STREAM_CLOSED
 } read_state;
 
-typedef enum
-{
+typedef enum {
   WRITE_STATE_INITIAL = 0,
   WRITE_STATE_STARTED,
   WRITE_STATE_WRITE_CLOSED
 } write_state;
 
-struct grpc_call
-{
+struct grpc_call {
   grpc_completion_queue *cq;
   grpc_channel *channel;
   grpc_call *parent;
@@ -283,363 +276,328 @@ struct grpc_call
 #define CALL_FROM_TOP_ELEM(top_elem) \
   CALL_FROM_CALL_STACK(grpc_call_stack_from_top_element(top_elem))
 
-static void set_deadline_alarm (grpc_exec_ctx * exec_ctx, grpc_call * call, gpr_timespec deadline);
-static void call_on_done_recv (grpc_exec_ctx * exec_ctx, void *call, int success);
-static void call_on_done_send (grpc_exec_ctx * exec_ctx, void *call, int success);
-static int fill_send_ops (grpc_call * call, grpc_transport_stream_op * op);
-static void execute_op (grpc_exec_ctx * exec_ctx, grpc_call * call, grpc_transport_stream_op * op);
-static void recv_metadata (grpc_exec_ctx * exec_ctx, grpc_call * call, grpc_metadata_batch * metadata);
-static void finish_read_ops (grpc_call * call);
-static grpc_call_error cancel_with_status (grpc_call * c, grpc_status_code status, const char *description);
-static void finished_loose_op (grpc_exec_ctx * exec_ctx, void *call, int success);
-
-static void lock (grpc_call * call);
-static void unlock (grpc_exec_ctx * exec_ctx, grpc_call * call);
-
-grpc_call *
-grpc_call_create (grpc_channel * channel, grpc_call * parent_call, gpr_uint32 propagation_mask, grpc_completion_queue * cq, const void *server_transport_data, grpc_mdelem ** add_initial_metadata, size_t add_initial_metadata_count, gpr_timespec send_deadline)
-{
+static void set_deadline_alarm(grpc_exec_ctx *exec_ctx, grpc_call *call,
+                               gpr_timespec deadline);
+static void call_on_done_recv(grpc_exec_ctx *exec_ctx, void *call, int success);
+static void call_on_done_send(grpc_exec_ctx *exec_ctx, void *call, int success);
+static int fill_send_ops(grpc_call *call, grpc_transport_stream_op *op);
+static void execute_op(grpc_exec_ctx *exec_ctx, grpc_call *call,
+                       grpc_transport_stream_op *op);
+static void recv_metadata(grpc_exec_ctx *exec_ctx, grpc_call *call,
+                          grpc_metadata_batch *metadata);
+static void finish_read_ops(grpc_call *call);
+static grpc_call_error cancel_with_status(grpc_call *c, grpc_status_code status,
+                                          const char *description);
+static void finished_loose_op(grpc_exec_ctx *exec_ctx, void *call, int success);
+
+static void lock(grpc_call *call);
+static void unlock(grpc_exec_ctx *exec_ctx, grpc_call *call);
+
+grpc_call *grpc_call_create(grpc_channel *channel, grpc_call *parent_call,
+                            gpr_uint32 propagation_mask,
+                            grpc_completion_queue *cq,
+                            const void *server_transport_data,
+                            grpc_mdelem **add_initial_metadata,
+                            size_t add_initial_metadata_count,
+                            gpr_timespec send_deadline) {
   size_t i;
   grpc_transport_stream_op initial_op;
   grpc_transport_stream_op *initial_op_ptr = NULL;
-  grpc_channel_stack *channel_stack = grpc_channel_get_channel_stack (channel);
+  grpc_channel_stack *channel_stack = grpc_channel_get_channel_stack(channel);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_call *call = gpr_malloc (sizeof (grpc_call) + channel_stack->call_stack_size);
-  memset (call, 0, sizeof (grpc_call));
-  gpr_mu_init (&call->mu);
-  gpr_mu_init (&call->completion_mu);
+  grpc_call *call =
+      gpr_malloc(sizeof(grpc_call) + channel_stack->call_stack_size);
+  memset(call, 0, sizeof(grpc_call));
+  gpr_mu_init(&call->mu);
+  gpr_mu_init(&call->completion_mu);
   call->channel = channel;
   call->cq = cq;
-  if (cq != NULL)
-    {
-      GRPC_CQ_INTERNAL_REF (cq, "bind");
-    }
+  if (cq != NULL) {
+    GRPC_CQ_INTERNAL_REF(cq, "bind");
+  }
   call->parent = parent_call;
   call->is_client = server_transport_data == NULL;
-  for (i = 0; i < GRPC_IOREQ_OP_COUNT; i++)
-    {
-      call->request_set[i] = REQSET_EMPTY;
-    }
-  if (call->is_client)
-    {
-      call->request_set[GRPC_IOREQ_SEND_TRAILING_METADATA] = REQSET_DONE;
-      call->request_set[GRPC_IOREQ_SEND_STATUS] = REQSET_DONE;
-    }
-  GPR_ASSERT (add_initial_metadata_count < MAX_SEND_INITIAL_METADATA_COUNT);
-  for (i = 0; i < add_initial_metadata_count; i++)
-    {
-      call->send_initial_metadata[i].md = add_initial_metadata[i];
-    }
+  for (i = 0; i < GRPC_IOREQ_OP_COUNT; i++) {
+    call->request_set[i] = REQSET_EMPTY;
+  }
+  if (call->is_client) {
+    call->request_set[GRPC_IOREQ_SEND_TRAILING_METADATA] = REQSET_DONE;
+    call->request_set[GRPC_IOREQ_SEND_STATUS] = REQSET_DONE;
+  }
+  GPR_ASSERT(add_initial_metadata_count < MAX_SEND_INITIAL_METADATA_COUNT);
+  for (i = 0; i < add_initial_metadata_count; i++) {
+    call->send_initial_metadata[i].md = add_initial_metadata[i];
+  }
   call->send_initial_metadata_count = add_initial_metadata_count;
   call->send_deadline = send_deadline;
-  GRPC_CHANNEL_INTERNAL_REF (channel, "call");
-  call->metadata_context = grpc_channel_get_metadata_context (channel);
-  grpc_sopb_init (&call->send_ops);
-  grpc_sopb_init (&call->recv_ops);
-  gpr_slice_buffer_init (&call->incoming_message);
-  grpc_closure_init (&call->on_done_recv, call_on_done_recv, call);
-  grpc_closure_init (&call->on_done_send, call_on_done_send, call);
-  grpc_closure_init (&call->on_done_bind, finished_loose_op, call);
+  GRPC_CHANNEL_INTERNAL_REF(channel, "call");
+  call->metadata_context = grpc_channel_get_metadata_context(channel);
+  grpc_sopb_init(&call->send_ops);
+  grpc_sopb_init(&call->recv_ops);
+  gpr_slice_buffer_init(&call->incoming_message);
+  grpc_closure_init(&call->on_done_recv, call_on_done_recv, call);
+  grpc_closure_init(&call->on_done_send, call_on_done_send, call);
+  grpc_closure_init(&call->on_done_bind, finished_loose_op, call);
   /* dropped in destroy and when READ_STATE_STREAM_CLOSED received */
-  gpr_ref_init (&call->internal_refcount, 2);
+  gpr_ref_init(&call->internal_refcount, 2);
   /* server hack: start reads immediately so we can get initial metadata.
      TODO(ctiller): figure out a cleaner solution */
-  if (!call->is_client)
-    {
-      memset (&initial_op, 0, sizeof (initial_op));
-      initial_op.recv_ops = &call->recv_ops;
-      initial_op.recv_state = &call->recv_state;
-      initial_op.on_done_recv = &call->on_done_recv;
-      initial_op.context = call->context;
-      call->receiving = 1;
-      GRPC_CALL_INTERNAL_REF (call, "receiving");
-      initial_op_ptr = &initial_op;
-    }
-  grpc_call_stack_init (&exec_ctx, channel_stack, server_transport_data, initial_op_ptr, CALL_STACK_FROM_CALL (call));
-  if (parent_call != NULL)
-    {
-      GRPC_CALL_INTERNAL_REF (parent_call, "child");
-      GPR_ASSERT (call->is_client);
-      GPR_ASSERT (!parent_call->is_client);
-
-      gpr_mu_lock (&parent_call->mu);
-
-      if (propagation_mask & GRPC_PROPAGATE_DEADLINE)
-	{
-	  send_deadline = gpr_time_min (gpr_convert_clock_type (send_deadline, parent_call->send_deadline.clock_type), parent_call->send_deadline);
-	}
-      /* for now GRPC_PROPAGATE_TRACING_CONTEXT *MUST* be passed with
-       * GRPC_PROPAGATE_STATS_CONTEXT */
-      /* TODO(ctiller): This should change to use the appropriate census start_op
-       * call. */
-      if (propagation_mask & GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT)
-	{
-	  GPR_ASSERT (propagation_mask & GRPC_PROPAGATE_CENSUS_STATS_CONTEXT);
-	  grpc_call_context_set (call, GRPC_CONTEXT_TRACING, parent_call->context[GRPC_CONTEXT_TRACING].value, NULL);
-	}
-      else
-	{
-	  GPR_ASSERT (propagation_mask & GRPC_PROPAGATE_CENSUS_STATS_CONTEXT);
-	}
-      if (propagation_mask & GRPC_PROPAGATE_CANCELLATION)
-	{
-	  call->cancellation_is_inherited = 1;
-	}
-
-      if (parent_call->first_child == NULL)
-	{
-	  parent_call->first_child = call;
-	  call->sibling_next = call->sibling_prev = call;
-	}
-      else
-	{
-	  call->sibling_next = parent_call->first_child;
-	  call->sibling_prev = parent_call->first_child->sibling_prev;
-	  call->sibling_next->sibling_prev = call->sibling_prev->sibling_next = call;
-	}
-
-      gpr_mu_unlock (&parent_call->mu);
-    }
-  if (gpr_time_cmp (send_deadline, gpr_inf_future (send_deadline.clock_type)) != 0)
-    {
-      set_deadline_alarm (&exec_ctx, call, send_deadline);
-    }
-  grpc_exec_ctx_finish (&exec_ctx);
+  if (!call->is_client) {
+    memset(&initial_op, 0, sizeof(initial_op));
+    initial_op.recv_ops = &call->recv_ops;
+    initial_op.recv_state = &call->recv_state;
+    initial_op.on_done_recv = &call->on_done_recv;
+    initial_op.context = call->context;
+    call->receiving = 1;
+    GRPC_CALL_INTERNAL_REF(call, "receiving");
+    initial_op_ptr = &initial_op;
+  }
+  grpc_call_stack_init(&exec_ctx, channel_stack, server_transport_data,
+                       initial_op_ptr, CALL_STACK_FROM_CALL(call));
+  if (parent_call != NULL) {
+    GRPC_CALL_INTERNAL_REF(parent_call, "child");
+    GPR_ASSERT(call->is_client);
+    GPR_ASSERT(!parent_call->is_client);
+
+    gpr_mu_lock(&parent_call->mu);
+
+    if (propagation_mask & GRPC_PROPAGATE_DEADLINE) {
+      send_deadline = gpr_time_min(
+          gpr_convert_clock_type(send_deadline,
+                                 parent_call->send_deadline.clock_type),
+          parent_call->send_deadline);
+    }
+    /* for now GRPC_PROPAGATE_TRACING_CONTEXT *MUST* be passed with
+     * GRPC_PROPAGATE_STATS_CONTEXT */
+    /* TODO(ctiller): This should change to use the appropriate census start_op
+     * call. */
+    if (propagation_mask & GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT) {
+      GPR_ASSERT(propagation_mask & GRPC_PROPAGATE_CENSUS_STATS_CONTEXT);
+      grpc_call_context_set(call, GRPC_CONTEXT_TRACING,
+                            parent_call->context[GRPC_CONTEXT_TRACING].value,
+                            NULL);
+    } else {
+      GPR_ASSERT(propagation_mask & GRPC_PROPAGATE_CENSUS_STATS_CONTEXT);
+    }
+    if (propagation_mask & GRPC_PROPAGATE_CANCELLATION) {
+      call->cancellation_is_inherited = 1;
+    }
+
+    if (parent_call->first_child == NULL) {
+      parent_call->first_child = call;
+      call->sibling_next = call->sibling_prev = call;
+    } else {
+      call->sibling_next = parent_call->first_child;
+      call->sibling_prev = parent_call->first_child->sibling_prev;
+      call->sibling_next->sibling_prev = call->sibling_prev->sibling_next =
+          call;
+    }
+
+    gpr_mu_unlock(&parent_call->mu);
+  }
+  if (gpr_time_cmp(send_deadline, gpr_inf_future(send_deadline.clock_type)) !=
+      0) {
+    set_deadline_alarm(&exec_ctx, call, send_deadline);
+  }
+  grpc_exec_ctx_finish(&exec_ctx);
   return call;
 }
 
-void
-grpc_call_set_completion_queue (grpc_exec_ctx * exec_ctx, grpc_call * call, grpc_completion_queue * cq)
-{
-  lock (call);
+void grpc_call_set_completion_queue(grpc_exec_ctx *exec_ctx, grpc_call *call,
+                                    grpc_completion_queue *cq) {
+  lock(call);
   call->cq = cq;
-  if (cq)
-    {
-      GRPC_CQ_INTERNAL_REF (cq, "bind");
-    }
-  unlock (exec_ctx, call);
+  if (cq) {
+    GRPC_CQ_INTERNAL_REF(cq, "bind");
+  }
+  unlock(exec_ctx, call);
 }
 
-grpc_completion_queue *
-grpc_call_get_completion_queue (grpc_call * call)
-{
+grpc_completion_queue *grpc_call_get_completion_queue(grpc_call *call) {
   return call->cq;
 }
 
-static grpc_cq_completion *
-allocate_completion (grpc_call * call)
-{
+static grpc_cq_completion *allocate_completion(grpc_call *call) {
   gpr_uint8 i;
-  gpr_mu_lock (&call->completion_mu);
-  for (i = 0; i < GPR_ARRAY_SIZE (call->completions); i++)
-    {
-      if (call->allocated_completions & (1u << i))
-	{
-	  continue;
-	}
-      call->allocated_completions |= (gpr_uint8) (1u << i);
-      gpr_mu_unlock (&call->completion_mu);
-      return &call->completions[i];
-    }
-  gpr_log (GPR_ERROR, "should never reach here");
-  abort ();
+  gpr_mu_lock(&call->completion_mu);
+  for (i = 0; i < GPR_ARRAY_SIZE(call->completions); i++) {
+    if (call->allocated_completions & (1u << i)) {
+      continue;
+    }
+    call->allocated_completions |= (gpr_uint8)(1u << i);
+    gpr_mu_unlock(&call->completion_mu);
+    return &call->completions[i];
+  }
+  gpr_log(GPR_ERROR, "should never reach here");
+  abort();
 }
 
-static void
-done_completion (grpc_exec_ctx * exec_ctx, void *call, grpc_cq_completion * completion)
-{
+static void done_completion(grpc_exec_ctx *exec_ctx, void *call,
+                            grpc_cq_completion *completion) {
   grpc_call *c = call;
-  gpr_mu_lock (&c->completion_mu);
-  c->allocated_completions &= (gpr_uint8) ~ (1u << (completion - c->completions));
-  gpr_mu_unlock (&c->completion_mu);
-  GRPC_CALL_INTERNAL_UNREF (exec_ctx, c, "completion");
+  gpr_mu_lock(&c->completion_mu);
+  c->allocated_completions &=
+      (gpr_uint8) ~(1u << (completion - c->completions));
+  gpr_mu_unlock(&c->completion_mu);
+  GRPC_CALL_INTERNAL_UNREF(exec_ctx, c, "completion");
 }
 
 #ifdef GRPC_CALL_REF_COUNT_DEBUG
-void
-grpc_call_internal_ref (grpc_call * c, const char *reason)
-{
-  gpr_log (GPR_DEBUG, "CALL:   ref %p %d -> %d [%s]", c, c->internal_refcount.count, c->internal_refcount.count + 1, reason);
+void grpc_call_internal_ref(grpc_call *c, const char *reason) {
+  gpr_log(GPR_DEBUG, "CALL:   ref %p %d -> %d [%s]", c,
+          c->internal_refcount.count, c->internal_refcount.count + 1, reason);
 #else
-void
-grpc_call_internal_ref (grpc_call * c)
-{
+void grpc_call_internal_ref(grpc_call *c) {
 #endif
-  gpr_ref (&c->internal_refcount);
+  gpr_ref(&c->internal_refcount);
 }
 
-static void
-destroy_call (grpc_exec_ctx * exec_ctx, grpc_call * call)
-{
+static void destroy_call(grpc_exec_ctx *exec_ctx, grpc_call *call) {
   size_t i;
   grpc_call *c = call;
-  grpc_call_stack_destroy (exec_ctx, CALL_STACK_FROM_CALL (c));
-  GRPC_CHANNEL_INTERNAL_UNREF (exec_ctx, c->channel, "call");
-  gpr_mu_destroy (&c->mu);
-  gpr_mu_destroy (&c->completion_mu);
-  for (i = 0; i < STATUS_SOURCE_COUNT; i++)
-    {
-      if (c->status[i].details)
-	{
-	  GRPC_MDSTR_UNREF (c->status[i].details);
-	}
-    }
-  for (i = 0; i < c->owned_metadata_count; i++)
-    {
-      GRPC_MDELEM_UNREF (c->owned_metadata[i]);
-    }
-  gpr_free (c->owned_metadata);
-  for (i = 0; i < GPR_ARRAY_SIZE (c->buffered_metadata); i++)
-    {
-      gpr_free (c->buffered_metadata[i].metadata);
-    }
-  for (i = 0; i < c->send_initial_metadata_count; i++)
-    {
-      GRPC_MDELEM_UNREF (c->send_initial_metadata[i].md);
-    }
-  for (i = 0; i < GRPC_CONTEXT_COUNT; i++)
-    {
-      if (c->context[i].destroy)
-	{
-	  c->context[i].destroy (c->context[i].value);
-	}
-    }
-  grpc_sopb_destroy (&c->send_ops);
-  grpc_sopb_destroy (&c->recv_ops);
-  grpc_bbq_destroy (&c->incoming_queue);
-  gpr_slice_buffer_destroy (&c->incoming_message);
-  if (c->cq)
-    {
-      GRPC_CQ_INTERNAL_UNREF (c->cq, "bind");
-    }
-  gpr_free (c);
+  grpc_call_stack_destroy(exec_ctx, CALL_STACK_FROM_CALL(c));
+  GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, c->channel, "call");
+  gpr_mu_destroy(&c->mu);
+  gpr_mu_destroy(&c->completion_mu);
+  for (i = 0; i < STATUS_SOURCE_COUNT; i++) {
+    if (c->status[i].details) {
+      GRPC_MDSTR_UNREF(c->status[i].details);
+    }
+  }
+  for (i = 0; i < c->owned_metadata_count; i++) {
+    GRPC_MDELEM_UNREF(c->owned_metadata[i]);
+  }
+  gpr_free(c->owned_metadata);
+  for (i = 0; i < GPR_ARRAY_SIZE(c->buffered_metadata); i++) {
+    gpr_free(c->buffered_metadata[i].metadata);
+  }
+  for (i = 0; i < c->send_initial_metadata_count; i++) {
+    GRPC_MDELEM_UNREF(c->send_initial_metadata[i].md);
+  }
+  for (i = 0; i < GRPC_CONTEXT_COUNT; i++) {
+    if (c->context[i].destroy) {
+      c->context[i].destroy(c->context[i].value);
+    }
+  }
+  grpc_sopb_destroy(&c->send_ops);
+  grpc_sopb_destroy(&c->recv_ops);
+  grpc_bbq_destroy(&c->incoming_queue);
+  gpr_slice_buffer_destroy(&c->incoming_message);
+  if (c->cq) {
+    GRPC_CQ_INTERNAL_UNREF(c->cq, "bind");
+  }
+  gpr_free(c);
 }
 
 #ifdef GRPC_CALL_REF_COUNT_DEBUG
-void
-grpc_call_internal_unref (grpc_exec_ctx * exec_ctx, grpc_call * c, const char *reason)
-{
-  gpr_log (GPR_DEBUG, "CALL: unref %p %d -> %d [%s]", c, c->internal_refcount.count, c->internal_refcount.count - 1, reason);
+void grpc_call_internal_unref(grpc_exec_ctx *exec_ctx, grpc_call *c,
+                              const char *reason) {
+  gpr_log(GPR_DEBUG, "CALL: unref %p %d -> %d [%s]", c,
+          c->internal_refcount.count, c->internal_refcount.count - 1, reason);
 #else
-void
-grpc_call_internal_unref (grpc_exec_ctx * exec_ctx, grpc_call * c)
-{
+void grpc_call_internal_unref(grpc_exec_ctx *exec_ctx, grpc_call *c) {
 #endif
-  if (gpr_unref (&c->internal_refcount))
-    {
-      destroy_call (exec_ctx, c);
-    }
+  if (gpr_unref(&c->internal_refcount)) {
+    destroy_call(exec_ctx, c);
+  }
 }
 
-static void
-set_status_code (grpc_call * call, status_source source, gpr_uint32 status)
-{
-  if (call->status[source].is_set)
-    return;
+static void set_status_code(grpc_call *call, status_source source,
+                            gpr_uint32 status) {
+  if (call->status[source].is_set) return;
 
   call->status[source].is_set = 1;
-  call->status[source].code = (grpc_status_code) status;
+  call->status[source].code = (grpc_status_code)status;
   call->error_status_set = status != GRPC_STATUS_OK;
 
-  if (status != GRPC_STATUS_OK && !grpc_bbq_empty (&call->incoming_queue))
-    {
-      grpc_bbq_flush (&call->incoming_queue);
-    }
+  if (status != GRPC_STATUS_OK && !grpc_bbq_empty(&call->incoming_queue)) {
+    grpc_bbq_flush(&call->incoming_queue);
+  }
 }
 
-static void
-set_compression_algorithm (grpc_call * call, grpc_compression_algorithm algo)
-{
+static void set_compression_algorithm(grpc_call *call,
+                                      grpc_compression_algorithm algo) {
   call->compression_algorithm = algo;
 }
 
-grpc_compression_algorithm
-grpc_call_get_compression_algorithm (const grpc_call * call)
-{
+grpc_compression_algorithm grpc_call_get_compression_algorithm(
+    const grpc_call *call) {
   return call->compression_algorithm;
 }
 
-static void
-set_encodings_accepted_by_peer (grpc_call * call, const gpr_slice accept_encoding_slice)
-{
+static void set_encodings_accepted_by_peer(
+    grpc_call *call, const gpr_slice accept_encoding_slice) {
   size_t i;
   grpc_compression_algorithm algorithm;
   gpr_slice_buffer accept_encoding_parts;
 
-  gpr_slice_buffer_init (&accept_encoding_parts);
-  gpr_slice_split (accept_encoding_slice, ",", &accept_encoding_parts);
+  gpr_slice_buffer_init(&accept_encoding_parts);
+  gpr_slice_split(accept_encoding_slice, ",", &accept_encoding_parts);
 
   /* No need to zero call->encodings_accepted_by_peer: grpc_call_create already
    * zeroes the whole grpc_call */
   /* Always support no compression */
-  GPR_BITSET (&call->encodings_accepted_by_peer, GRPC_COMPRESS_NONE);
-  for (i = 0; i < accept_encoding_parts.count; i++)
-    {
-      const gpr_slice *accept_encoding_entry_slice = &accept_encoding_parts.slices[i];
-      if (grpc_compression_algorithm_parse ((const char *) GPR_SLICE_START_PTR (*accept_encoding_entry_slice), GPR_SLICE_LENGTH (*accept_encoding_entry_slice), &algorithm))
-	{
-	  GPR_BITSET (&call->encodings_accepted_by_peer, algorithm);
-	}
-      else
-	{
-	  char *accept_encoding_entry_str = gpr_dump_slice (*accept_encoding_entry_slice, GPR_DUMP_ASCII);
-	  gpr_log (GPR_ERROR, "Invalid entry in accept encoding metadata: '%s'. Ignoring.", accept_encoding_entry_str);
-	  gpr_free (accept_encoding_entry_str);
-	}
-    }
+  GPR_BITSET(&call->encodings_accepted_by_peer, GRPC_COMPRESS_NONE);
+  for (i = 0; i < accept_encoding_parts.count; i++) {
+    const gpr_slice *accept_encoding_entry_slice =
+        &accept_encoding_parts.slices[i];
+    if (grpc_compression_algorithm_parse(
+            (const char *)GPR_SLICE_START_PTR(*accept_encoding_entry_slice),
+            GPR_SLICE_LENGTH(*accept_encoding_entry_slice), &algorithm)) {
+      GPR_BITSET(&call->encodings_accepted_by_peer, algorithm);
+    } else {
+      char *accept_encoding_entry_str =
+          gpr_dump_slice(*accept_encoding_entry_slice, GPR_DUMP_ASCII);
+      gpr_log(GPR_ERROR,
+              "Invalid entry in accept encoding metadata: '%s'. Ignoring.",
+              accept_encoding_entry_str);
+      gpr_free(accept_encoding_entry_str);
+    }
+  }
 }
 
-gpr_uint32
-grpc_call_get_encodings_accepted_by_peer (grpc_call * call)
-{
+gpr_uint32 grpc_call_get_encodings_accepted_by_peer(grpc_call *call) {
   return call->encodings_accepted_by_peer;
 }
 
-gpr_uint32
-grpc_call_get_message_flags (const grpc_call * call)
-{
+gpr_uint32 grpc_call_get_message_flags(const grpc_call *call) {
   return call->incoming_message_flags;
 }
 
-static void
-set_status_details (grpc_call * call, status_source source, grpc_mdstr * status)
-{
-  if (call->status[source].details != NULL)
-    {
-      GRPC_MDSTR_UNREF (call->status[source].details);
-    }
+static void set_status_details(grpc_call *call, status_source source,
+                               grpc_mdstr *status) {
+  if (call->status[source].details != NULL) {
+    GRPC_MDSTR_UNREF(call->status[source].details);
+  }
   call->status[source].details = status;
 }
 
-static int
-is_op_live (grpc_call * call, grpc_ioreq_op op)
-{
+static int is_op_live(grpc_call *call, grpc_ioreq_op op) {
   gpr_uint8 set = call->request_set[op];
   reqinfo_master *master;
-  if (set >= GRPC_IOREQ_OP_COUNT)
-    return 0;
+  if (set >= GRPC_IOREQ_OP_COUNT) return 0;
   master = &call->masters[set];
   return (master->complete_mask & (1u << op)) == 0;
 }
 
-static void
-lock (grpc_call * call)
-{
-  gpr_mu_lock (&call->mu);
-}
+static void lock(grpc_call *call) { gpr_mu_lock(&call->mu); }
 
-static int
-need_more_data (grpc_call * call)
-{
-  if (call->read_state == READ_STATE_STREAM_CLOSED)
-    return 0;
+static int need_more_data(grpc_call *call) {
+  if (call->read_state == READ_STATE_STREAM_CLOSED) return 0;
   /* TODO(ctiller): this needs some serious cleanup */
-  return is_op_live (call, GRPC_IOREQ_RECV_INITIAL_METADATA) || (is_op_live (call, GRPC_IOREQ_RECV_MESSAGE) && grpc_bbq_empty (&call->incoming_queue)) || is_op_live (call, GRPC_IOREQ_RECV_TRAILING_METADATA) || is_op_live (call, GRPC_IOREQ_RECV_STATUS) || is_op_live (call, GRPC_IOREQ_RECV_STATUS_DETAILS) || (is_op_live (call, GRPC_IOREQ_RECV_CLOSE) && grpc_bbq_empty (&call->incoming_queue)) || (call->write_state == WRITE_STATE_INITIAL && !call->is_client) || (call->cancel_with_status != GRPC_STATUS_OK) || call->destroy_called;
+  return is_op_live(call, GRPC_IOREQ_RECV_INITIAL_METADATA) ||
+         (is_op_live(call, GRPC_IOREQ_RECV_MESSAGE) &&
+          grpc_bbq_empty(&call->incoming_queue)) ||
+         is_op_live(call, GRPC_IOREQ_RECV_TRAILING_METADATA) ||
+         is_op_live(call, GRPC_IOREQ_RECV_STATUS) ||
+         is_op_live(call, GRPC_IOREQ_RECV_STATUS_DETAILS) ||
+         (is_op_live(call, GRPC_IOREQ_RECV_CLOSE) &&
+          grpc_bbq_empty(&call->incoming_queue)) ||
+         (call->write_state == WRITE_STATE_INITIAL && !call->is_client) ||
+         (call->cancel_with_status != GRPC_STATUS_OK) || call->destroy_called;
 }
 
-static void
-unlock (grpc_exec_ctx * exec_ctx, grpc_call * call)
-{
+static void unlock(grpc_exec_ctx *exec_ctx, grpc_call *call) {
   grpc_transport_stream_op op;
   completed_request completed_requests[GRPC_IOREQ_OP_COUNT];
   int completing_requests = 0;
@@ -648,677 +606,607 @@ unlock (grpc_exec_ctx * exec_ctx, grpc_call * call)
   const size_t MAX_RECV_PEEK_AHEAD = 65536;
   size_t buffered_bytes;
 
-  memset (&op, 0, sizeof (op));
+  memset(&op, 0, sizeof(op));
 
   op.cancel_with_status = call->cancel_with_status;
   start_op = op.cancel_with_status != GRPC_STATUS_OK;
-  call->cancel_with_status = GRPC_STATUS_OK;	/* reset */
-
-  if (!call->receiving && need_more_data (call))
-    {
-      if (grpc_bbq_empty (&call->incoming_queue) && call->reading_message)
-	{
-	  op.max_recv_bytes = call->incoming_message_length - call->incoming_message.length + MAX_RECV_PEEK_AHEAD;
-	}
-      else
-	{
-	  buffered_bytes = grpc_bbq_bytes (&call->incoming_queue);
-	  if (buffered_bytes > MAX_RECV_PEEK_AHEAD)
-	    {
-	      op.max_recv_bytes = 0;
-	    }
-	  else
-	    {
-	      op.max_recv_bytes = MAX_RECV_PEEK_AHEAD - buffered_bytes;
-	    }
-	}
-      /* TODO(ctiller): 1024 is basically to cover a bug
-         I don't understand yet */
-      if (op.max_recv_bytes > 1024)
-	{
-	  op.recv_ops = &call->recv_ops;
-	  op.recv_state = &call->recv_state;
-	  op.on_done_recv = &call->on_done_recv;
-	  call->receiving = 1;
-	  GRPC_CALL_INTERNAL_REF (call, "receiving");
-	  start_op = 1;
-	}
-    }
-
-  if (!call->sending)
-    {
-      if (fill_send_ops (call, &op))
-	{
-	  call->sending = 1;
-	  GRPC_CALL_INTERNAL_REF (call, "sending");
-	  start_op = 1;
-	}
-    }
-
-  if (!call->bound_pollset && call->cq && (!call->is_client || start_op))
-    {
-      call->bound_pollset = 1;
-      op.bind_pollset = grpc_cq_pollset (call->cq);
+  call->cancel_with_status = GRPC_STATUS_OK; /* reset */
+
+  if (!call->receiving && need_more_data(call)) {
+    if (grpc_bbq_empty(&call->incoming_queue) && call->reading_message) {
+      op.max_recv_bytes = call->incoming_message_length -
+                          call->incoming_message.length + MAX_RECV_PEEK_AHEAD;
+    } else {
+      buffered_bytes = grpc_bbq_bytes(&call->incoming_queue);
+      if (buffered_bytes > MAX_RECV_PEEK_AHEAD) {
+        op.max_recv_bytes = 0;
+      } else {
+        op.max_recv_bytes = MAX_RECV_PEEK_AHEAD - buffered_bytes;
+      }
+    }
+    /* TODO(ctiller): 1024 is basically to cover a bug
+       I don't understand yet */
+    if (op.max_recv_bytes > 1024) {
+      op.recv_ops = &call->recv_ops;
+      op.recv_state = &call->recv_state;
+      op.on_done_recv = &call->on_done_recv;
+      call->receiving = 1;
+      GRPC_CALL_INTERNAL_REF(call, "receiving");
       start_op = 1;
     }
+  }
 
-  if (!call->completing && call->num_completed_requests != 0)
-    {
-      completing_requests = call->num_completed_requests;
-      memcpy (completed_requests, call->completed_requests, sizeof (completed_requests));
-      call->num_completed_requests = 0;
-      call->completing = 1;
-      GRPC_CALL_INTERNAL_REF (call, "completing");
-    }
-
-  gpr_mu_unlock (&call->mu);
-
-  if (start_op)
-    {
-      execute_op (exec_ctx, call, &op);
-    }
-
-  if (completing_requests > 0)
-    {
-      for (i = 0; i < completing_requests; i++)
-	{
-	  completed_requests[i].on_complete (exec_ctx, call, completed_requests[i].success, completed_requests[i].user_data);
-	}
-      lock (call);
-      call->completing = 0;
-      unlock (exec_ctx, call);
-      GRPC_CALL_INTERNAL_UNREF (exec_ctx, call, "completing");
+  if (!call->sending) {
+    if (fill_send_ops(call, &op)) {
+      call->sending = 1;
+      GRPC_CALL_INTERNAL_REF(call, "sending");
+      start_op = 1;
     }
+  }
+
+  if (!call->bound_pollset && call->cq && (!call->is_client || start_op)) {
+    call->bound_pollset = 1;
+    op.bind_pollset = grpc_cq_pollset(call->cq);
+    start_op = 1;
+  }
+
+  if (!call->completing && call->num_completed_requests != 0) {
+    completing_requests = call->num_completed_requests;
+    memcpy(completed_requests, call->completed_requests,
+           sizeof(completed_requests));
+    call->num_completed_requests = 0;
+    call->completing = 1;
+    GRPC_CALL_INTERNAL_REF(call, "completing");
+  }
+
+  gpr_mu_unlock(&call->mu);
+
+  if (start_op) {
+    execute_op(exec_ctx, call, &op);
+  }
+
+  if (completing_requests > 0) {
+    for (i = 0; i < completing_requests; i++) {
+      completed_requests[i].on_complete(exec_ctx, call,
+                                        completed_requests[i].success,
+                                        completed_requests[i].user_data);
+    }
+    lock(call);
+    call->completing = 0;
+    unlock(exec_ctx, call);
+    GRPC_CALL_INTERNAL_UNREF(exec_ctx, call, "completing");
+  }
 }
 
-static void
-get_final_status (grpc_call * call, grpc_ioreq_data out)
-{
+static void get_final_status(grpc_call *call, grpc_ioreq_data out) {
   int i;
-  for (i = 0; i < STATUS_SOURCE_COUNT; i++)
-    {
-      if (call->status[i].is_set)
-	{
-	  out.recv_status.set_value (call->status[i].code, out.recv_status.user_data);
-	  return;
-	}
-    }
-  if (call->is_client)
-    {
-      out.recv_status.set_value (GRPC_STATUS_UNKNOWN, out.recv_status.user_data);
-    }
-  else
-    {
-      out.recv_status.set_value (GRPC_STATUS_OK, out.recv_status.user_data);
+  for (i = 0; i < STATUS_SOURCE_COUNT; i++) {
+    if (call->status[i].is_set) {
+      out.recv_status.set_value(call->status[i].code,
+                                out.recv_status.user_data);
+      return;
     }
+  }
+  if (call->is_client) {
+    out.recv_status.set_value(GRPC_STATUS_UNKNOWN, out.recv_status.user_data);
+  } else {
+    out.recv_status.set_value(GRPC_STATUS_OK, out.recv_status.user_data);
+  }
 }
 
-static void
-get_final_details (grpc_call * call, grpc_ioreq_data out)
-{
+static void get_final_details(grpc_call *call, grpc_ioreq_data out) {
   int i;
-  for (i = 0; i < STATUS_SOURCE_COUNT; i++)
-    {
-      if (call->status[i].is_set)
-	{
-	  if (call->status[i].details)
-	    {
-	      gpr_slice details = call->status[i].details->slice;
-	      size_t len = GPR_SLICE_LENGTH (details);
-	      if (len + 1 > *out.recv_status_details.details_capacity)
-		{
-		  *out.recv_status_details.details_capacity = GPR_MAX (len + 1, *out.recv_status_details.details_capacity * 3 / 2);
-		  *out.recv_status_details.details = gpr_realloc (*out.recv_status_details.details, *out.recv_status_details.details_capacity);
-		}
-	      memcpy (*out.recv_status_details.details, GPR_SLICE_START_PTR (details), len);
-	      (*out.recv_status_details.details)[len] = 0;
-	    }
-	  else
-	    {
-	      goto no_details;
-	    }
-	  return;
-	}
+  for (i = 0; i < STATUS_SOURCE_COUNT; i++) {
+    if (call->status[i].is_set) {
+      if (call->status[i].details) {
+        gpr_slice details = call->status[i].details->slice;
+        size_t len = GPR_SLICE_LENGTH(details);
+        if (len + 1 > *out.recv_status_details.details_capacity) {
+          *out.recv_status_details.details_capacity = GPR_MAX(
+              len + 1, *out.recv_status_details.details_capacity * 3 / 2);
+          *out.recv_status_details.details =
+              gpr_realloc(*out.recv_status_details.details,
+                          *out.recv_status_details.details_capacity);
+        }
+        memcpy(*out.recv_status_details.details, GPR_SLICE_START_PTR(details),
+               len);
+        (*out.recv_status_details.details)[len] = 0;
+      } else {
+        goto no_details;
+      }
+      return;
     }
+  }
 
 no_details:
-  if (0 == *out.recv_status_details.details_capacity)
-    {
-      *out.recv_status_details.details_capacity = 8;
-      *out.recv_status_details.details = gpr_malloc (*out.recv_status_details.details_capacity);
-    }
+  if (0 == *out.recv_status_details.details_capacity) {
+    *out.recv_status_details.details_capacity = 8;
+    *out.recv_status_details.details =
+        gpr_malloc(*out.recv_status_details.details_capacity);
+  }
   **out.recv_status_details.details = 0;
 }
 
-static void
-finish_live_ioreq_op (grpc_call * call, grpc_ioreq_op op, int success)
-{
+static void finish_live_ioreq_op(grpc_call *call, grpc_ioreq_op op,
+                                 int success) {
   completed_request *cr;
   gpr_uint8 master_set = call->request_set[op];
   reqinfo_master *master;
   size_t i;
   /* ioreq is live: we need to do something */
   master = &call->masters[master_set];
-  master->complete_mask |= (gpr_uint16) (1u << op);
-  if (!success)
-    {
-      master->success = 0;
-    }
-  if (master->complete_mask == master->need_mask)
-    {
-      for (i = 0; i < GRPC_IOREQ_OP_COUNT; i++)
-	{
-	  if (call->request_set[i] != master_set)
-	    {
-	      continue;
-	    }
-	  call->request_set[i] = REQSET_DONE;
-	  switch ((grpc_ioreq_op) i)
-	    {
-	    case GRPC_IOREQ_RECV_MESSAGE:
-	    case GRPC_IOREQ_SEND_MESSAGE:
-	      call->request_set[i] = REQSET_EMPTY;
-	      if (!master->success)
-		{
-		  call->write_state = WRITE_STATE_WRITE_CLOSED;
-		}
-	      break;
-	    case GRPC_IOREQ_SEND_STATUS:
-	      if (call->request_data[GRPC_IOREQ_SEND_STATUS].send_status.details != NULL)
-		{
-		  GRPC_MDSTR_UNREF (call->request_data[GRPC_IOREQ_SEND_STATUS].send_status.details);
-		  call->request_data[GRPC_IOREQ_SEND_STATUS].send_status.details = NULL;
-		}
-	      break;
-	    case GRPC_IOREQ_RECV_CLOSE:
-	    case GRPC_IOREQ_SEND_INITIAL_METADATA:
-	    case GRPC_IOREQ_SEND_TRAILING_METADATA:
-	    case GRPC_IOREQ_SEND_CLOSE:
-	      break;
-	    case GRPC_IOREQ_RECV_STATUS:
-	      get_final_status (call, call->request_data[GRPC_IOREQ_RECV_STATUS]);
-	      break;
-	    case GRPC_IOREQ_RECV_STATUS_DETAILS:
-	      get_final_details (call, call->request_data[GRPC_IOREQ_RECV_STATUS_DETAILS]);
-	      break;
-	    case GRPC_IOREQ_RECV_INITIAL_METADATA:
-	      GPR_SWAP (grpc_metadata_array, call->buffered_metadata[0], *call->request_data[GRPC_IOREQ_RECV_INITIAL_METADATA].recv_metadata);
-	      break;
-	    case GRPC_IOREQ_RECV_TRAILING_METADATA:
-	      GPR_SWAP (grpc_metadata_array, call->buffered_metadata[1], *call->request_data[GRPC_IOREQ_RECV_TRAILING_METADATA].recv_metadata);
-	      break;
-	    case GRPC_IOREQ_OP_COUNT:
-	      abort ();
-	      break;
-	    }
-	}
-      cr = &call->completed_requests[call->num_completed_requests++];
-      cr->success = master->success;
-      cr->on_complete = master->on_complete;
-      cr->user_data = master->user_data;
-    }
+  master->complete_mask |= (gpr_uint16)(1u << op);
+  if (!success) {
+    master->success = 0;
+  }
+  if (master->complete_mask == master->need_mask) {
+    for (i = 0; i < GRPC_IOREQ_OP_COUNT; i++) {
+      if (call->request_set[i] != master_set) {
+        continue;
+      }
+      call->request_set[i] = REQSET_DONE;
+      switch ((grpc_ioreq_op)i) {
+        case GRPC_IOREQ_RECV_MESSAGE:
+        case GRPC_IOREQ_SEND_MESSAGE:
+          call->request_set[i] = REQSET_EMPTY;
+          if (!master->success) {
+            call->write_state = WRITE_STATE_WRITE_CLOSED;
+          }
+          break;
+        case GRPC_IOREQ_SEND_STATUS:
+          if (call->request_data[GRPC_IOREQ_SEND_STATUS].send_status.details !=
+              NULL) {
+            GRPC_MDSTR_UNREF(
+                call->request_data[GRPC_IOREQ_SEND_STATUS].send_status.details);
+            call->request_data[GRPC_IOREQ_SEND_STATUS].send_status.details =
+                NULL;
+          }
+          break;
+        case GRPC_IOREQ_RECV_CLOSE:
+        case GRPC_IOREQ_SEND_INITIAL_METADATA:
+        case GRPC_IOREQ_SEND_TRAILING_METADATA:
+        case GRPC_IOREQ_SEND_CLOSE:
+          break;
+        case GRPC_IOREQ_RECV_STATUS:
+          get_final_status(call, call->request_data[GRPC_IOREQ_RECV_STATUS]);
+          break;
+        case GRPC_IOREQ_RECV_STATUS_DETAILS:
+          get_final_details(call,
+                            call->request_data[GRPC_IOREQ_RECV_STATUS_DETAILS]);
+          break;
+        case GRPC_IOREQ_RECV_INITIAL_METADATA:
+          GPR_SWAP(grpc_metadata_array, call->buffered_metadata[0],
+                   *call->request_data[GRPC_IOREQ_RECV_INITIAL_METADATA]
+                        .recv_metadata);
+          break;
+        case GRPC_IOREQ_RECV_TRAILING_METADATA:
+          GPR_SWAP(grpc_metadata_array, call->buffered_metadata[1],
+                   *call->request_data[GRPC_IOREQ_RECV_TRAILING_METADATA]
+                        .recv_metadata);
+          break;
+        case GRPC_IOREQ_OP_COUNT:
+          abort();
+          break;
+      }
+    }
+    cr = &call->completed_requests[call->num_completed_requests++];
+    cr->success = master->success;
+    cr->on_complete = master->on_complete;
+    cr->user_data = master->user_data;
+  }
 }
 
-static void
-finish_ioreq_op (grpc_call * call, grpc_ioreq_op op, int success)
-{
-  if (is_op_live (call, op))
-    {
-      finish_live_ioreq_op (call, op, success);
-    }
+static void finish_ioreq_op(grpc_call *call, grpc_ioreq_op op, int success) {
+  if (is_op_live(call, op)) {
+    finish_live_ioreq_op(call, op, success);
+  }
 }
 
-static void
-early_out_write_ops (grpc_call * call)
-{
-  switch (call->write_state)
-    {
+static void early_out_write_ops(grpc_call *call) {
+  switch (call->write_state) {
     case WRITE_STATE_WRITE_CLOSED:
-      finish_ioreq_op (call, GRPC_IOREQ_SEND_MESSAGE, 0);
-      finish_ioreq_op (call, GRPC_IOREQ_SEND_STATUS, 0);
-      finish_ioreq_op (call, GRPC_IOREQ_SEND_TRAILING_METADATA, 0);
-      finish_ioreq_op (call, GRPC_IOREQ_SEND_CLOSE, 1);
-      /* fallthrough */
+      finish_ioreq_op(call, GRPC_IOREQ_SEND_MESSAGE, 0);
+      finish_ioreq_op(call, GRPC_IOREQ_SEND_STATUS, 0);
+      finish_ioreq_op(call, GRPC_IOREQ_SEND_TRAILING_METADATA, 0);
+      finish_ioreq_op(call, GRPC_IOREQ_SEND_CLOSE, 1);
+    /* fallthrough */
     case WRITE_STATE_STARTED:
-      finish_ioreq_op (call, GRPC_IOREQ_SEND_INITIAL_METADATA, 0);
-      /* fallthrough */
+      finish_ioreq_op(call, GRPC_IOREQ_SEND_INITIAL_METADATA, 0);
+    /* fallthrough */
     case WRITE_STATE_INITIAL:
       /* do nothing */
       break;
-    }
+  }
 }
 
-static void
-call_on_done_send (grpc_exec_ctx * exec_ctx, void *pc, int success)
-{
+static void call_on_done_send(grpc_exec_ctx *exec_ctx, void *pc, int success) {
   grpc_call *call = pc;
-  lock (call);
-  if (call->last_send_contains & (1 << GRPC_IOREQ_SEND_INITIAL_METADATA))
-    {
-      finish_ioreq_op (call, GRPC_IOREQ_SEND_INITIAL_METADATA, success);
-      call->write_state = WRITE_STATE_STARTED;
-    }
-  if (call->last_send_contains & (1 << GRPC_IOREQ_SEND_MESSAGE))
-    {
-      finish_ioreq_op (call, GRPC_IOREQ_SEND_MESSAGE, success);
-    }
-  if (call->last_send_contains & (1 << GRPC_IOREQ_SEND_CLOSE))
-    {
-      finish_ioreq_op (call, GRPC_IOREQ_SEND_TRAILING_METADATA, success);
-      finish_ioreq_op (call, GRPC_IOREQ_SEND_STATUS, success);
-      finish_ioreq_op (call, GRPC_IOREQ_SEND_CLOSE, 1);
-      call->write_state = WRITE_STATE_WRITE_CLOSED;
-    }
-  if (!success)
-    {
-      call->write_state = WRITE_STATE_WRITE_CLOSED;
-      early_out_write_ops (call);
-    }
+  lock(call);
+  if (call->last_send_contains & (1 << GRPC_IOREQ_SEND_INITIAL_METADATA)) {
+    finish_ioreq_op(call, GRPC_IOREQ_SEND_INITIAL_METADATA, success);
+    call->write_state = WRITE_STATE_STARTED;
+  }
+  if (call->last_send_contains & (1 << GRPC_IOREQ_SEND_MESSAGE)) {
+    finish_ioreq_op(call, GRPC_IOREQ_SEND_MESSAGE, success);
+  }
+  if (call->last_send_contains & (1 << GRPC_IOREQ_SEND_CLOSE)) {
+    finish_ioreq_op(call, GRPC_IOREQ_SEND_TRAILING_METADATA, success);
+    finish_ioreq_op(call, GRPC_IOREQ_SEND_STATUS, success);
+    finish_ioreq_op(call, GRPC_IOREQ_SEND_CLOSE, 1);
+    call->write_state = WRITE_STATE_WRITE_CLOSED;
+  }
+  if (!success) {
+    call->write_state = WRITE_STATE_WRITE_CLOSED;
+    early_out_write_ops(call);
+  }
   call->send_ops.nops = 0;
   call->last_send_contains = 0;
   call->sending = 0;
-  unlock (exec_ctx, call);
-  GRPC_CALL_INTERNAL_UNREF (exec_ctx, call, "sending");
+  unlock(exec_ctx, call);
+  GRPC_CALL_INTERNAL_UNREF(exec_ctx, call, "sending");
 }
 
-static void
-finish_message (grpc_call * call)
-{
-  if (call->error_status_set == 0)
-    {
-      /* TODO(ctiller): this could be a lot faster if coded directly */
-      grpc_byte_buffer *byte_buffer;
-      /* some aliases for readability */
-      gpr_slice *slices = call->incoming_message.slices;
-      const size_t nslices = call->incoming_message.count;
-
-      if ((call->incoming_message_flags & GRPC_WRITE_INTERNAL_COMPRESS) && (call->compression_algorithm > GRPC_COMPRESS_NONE))
-	{
-	  byte_buffer = grpc_raw_compressed_byte_buffer_create (slices, nslices, call->compression_algorithm);
-	}
-      else
-	{
-	  byte_buffer = grpc_raw_byte_buffer_create (slices, nslices);
-	}
-      grpc_bbq_push (&call->incoming_queue, byte_buffer);
-    }
-  gpr_slice_buffer_reset_and_unref (&call->incoming_message);
-  GPR_ASSERT (call->incoming_message.count == 0);
+static void finish_message(grpc_call *call) {
+  if (call->error_status_set == 0) {
+    /* TODO(ctiller): this could be a lot faster if coded directly */
+    grpc_byte_buffer *byte_buffer;
+    /* some aliases for readability */
+    gpr_slice *slices = call->incoming_message.slices;
+    const size_t nslices = call->incoming_message.count;
+
+    if ((call->incoming_message_flags & GRPC_WRITE_INTERNAL_COMPRESS) &&
+        (call->compression_algorithm > GRPC_COMPRESS_NONE)) {
+      byte_buffer = grpc_raw_compressed_byte_buffer_create(
+          slices, nslices, call->compression_algorithm);
+    } else {
+      byte_buffer = grpc_raw_byte_buffer_create(slices, nslices);
+    }
+    grpc_bbq_push(&call->incoming_queue, byte_buffer);
+  }
+  gpr_slice_buffer_reset_and_unref(&call->incoming_message);
+  GPR_ASSERT(call->incoming_message.count == 0);
   call->reading_message = 0;
 }
 
-static int
-begin_message (grpc_call * call, grpc_begin_message msg)
-{
+static int begin_message(grpc_call *call, grpc_begin_message msg) {
   /* can't begin a message when we're still reading a message */
-  if (call->reading_message)
-    {
-      char *message = NULL;
-      gpr_asprintf (&message, "Message terminated early; read %d bytes, expected %d", (int) call->incoming_message.length, (int) call->incoming_message_length);
-      cancel_with_status (call, GRPC_STATUS_INVALID_ARGUMENT, message);
-      gpr_free (message);
-      return 0;
-    }
+  if (call->reading_message) {
+    char *message = NULL;
+    gpr_asprintf(
+        &message, "Message terminated early; read %d bytes, expected %d",
+        (int)call->incoming_message.length, (int)call->incoming_message_length);
+    cancel_with_status(call, GRPC_STATUS_INVALID_ARGUMENT, message);
+    gpr_free(message);
+    return 0;
+  }
   /* sanity check: if message flags indicate a compressed message, the
    * compression level should already be present in the call, as parsed off its
    * corresponding metadata. */
-  if ((msg.flags & GRPC_WRITE_INTERNAL_COMPRESS) && (call->compression_algorithm == GRPC_COMPRESS_NONE))
-    {
-      char *message = NULL;
-      char *alg_name;
-      if (!grpc_compression_algorithm_name (call->compression_algorithm, &alg_name))
-	{
-	  /* This shouldn't happen, other than due to data corruption */
-	  alg_name = "<unknown>";
-	}
-      gpr_asprintf (&message, "Invalid compression algorithm (%s) for compressed message.", alg_name);
-      cancel_with_status (call, GRPC_STATUS_INTERNAL, message);
-      gpr_free (message);
-      return 0;
-    }
+  if ((msg.flags & GRPC_WRITE_INTERNAL_COMPRESS) &&
+      (call->compression_algorithm == GRPC_COMPRESS_NONE)) {
+    char *message = NULL;
+    char *alg_name;
+    if (!grpc_compression_algorithm_name(call->compression_algorithm,
+                                         &alg_name)) {
+      /* This shouldn't happen, other than due to data corruption */
+      alg_name = "<unknown>";
+    }
+    gpr_asprintf(&message,
+                 "Invalid compression algorithm (%s) for compressed message.",
+                 alg_name);
+    cancel_with_status(call, GRPC_STATUS_INTERNAL, message);
+    gpr_free(message);
+    return 0;
+  }
   /* stash away parameters, and prepare for incoming slices */
-  if (msg.length > grpc_channel_get_max_message_length (call->channel))
-    {
-      char *message = NULL;
-      gpr_asprintf (&message, "Maximum message length of %d exceeded by a message of length %d", grpc_channel_get_max_message_length (call->channel), msg.length);
-      cancel_with_status (call, GRPC_STATUS_INVALID_ARGUMENT, message);
-      gpr_free (message);
-      return 0;
-    }
-  else if (msg.length > 0)
-    {
-      call->reading_message = 1;
-      call->incoming_message_length = msg.length;
-      call->incoming_message_flags = msg.flags;
-      return 1;
-    }
-  else
-    {
-      finish_message (call);
-      return 1;
-    }
+  if (msg.length > grpc_channel_get_max_message_length(call->channel)) {
+    char *message = NULL;
+    gpr_asprintf(
+        &message,
+        "Maximum message length of %d exceeded by a message of length %d",
+        grpc_channel_get_max_message_length(call->channel), msg.length);
+    cancel_with_status(call, GRPC_STATUS_INVALID_ARGUMENT, message);
+    gpr_free(message);
+    return 0;
+  } else if (msg.length > 0) {
+    call->reading_message = 1;
+    call->incoming_message_length = msg.length;
+    call->incoming_message_flags = msg.flags;
+    return 1;
+  } else {
+    finish_message(call);
+    return 1;
+  }
 }
 
-static int
-add_slice_to_message (grpc_call * call, gpr_slice slice)
-{
-  if (GPR_SLICE_LENGTH (slice) == 0)
-    {
-      gpr_slice_unref (slice);
-      return 1;
-    }
+static int add_slice_to_message(grpc_call *call, gpr_slice slice) {
+  if (GPR_SLICE_LENGTH(slice) == 0) {
+    gpr_slice_unref(slice);
+    return 1;
+  }
   /* we have to be reading a message to know what to do here */
-  if (!call->reading_message)
-    {
-      cancel_with_status (call, GRPC_STATUS_INVALID_ARGUMENT, "Received payload data while not reading a message");
-      return 0;
-    }
+  if (!call->reading_message) {
+    cancel_with_status(call, GRPC_STATUS_INVALID_ARGUMENT,
+                       "Received payload data while not reading a message");
+    return 0;
+  }
   /* append the slice to the incoming buffer */
-  gpr_slice_buffer_add (&call->incoming_message, slice);
-  if (call->incoming_message.length > call->incoming_message_length)
-    {
-      /* if we got too many bytes, complain */
-      char *message = NULL;
-      gpr_asprintf (&message, "Receiving message overflow; read %d bytes, expected %d", (int) call->incoming_message.length, (int) call->incoming_message_length);
-      cancel_with_status (call, GRPC_STATUS_INVALID_ARGUMENT, message);
-      gpr_free (message);
-      return 0;
-    }
-  else if (call->incoming_message.length == call->incoming_message_length)
-    {
-      finish_message (call);
-      return 1;
-    }
-  else
-    {
-      return 1;
-    }
+  gpr_slice_buffer_add(&call->incoming_message, slice);
+  if (call->incoming_message.length > call->incoming_message_length) {
+    /* if we got too many bytes, complain */
+    char *message = NULL;
+    gpr_asprintf(
+        &message, "Receiving message overflow; read %d bytes, expected %d",
+        (int)call->incoming_message.length, (int)call->incoming_message_length);
+    cancel_with_status(call, GRPC_STATUS_INVALID_ARGUMENT, message);
+    gpr_free(message);
+    return 0;
+  } else if (call->incoming_message.length == call->incoming_message_length) {
+    finish_message(call);
+    return 1;
+  } else {
+    return 1;
+  }
 }
 
-static void
-call_on_done_recv (grpc_exec_ctx * exec_ctx, void *pc, int success)
-{
+static void call_on_done_recv(grpc_exec_ctx *exec_ctx, void *pc, int success) {
   grpc_call *call = pc;
   grpc_call *child_call;
   grpc_call *next_child_call;
   size_t i;
-  GRPC_TIMER_BEGIN (GRPC_PTAG_CALL_ON_DONE_RECV, 0);
-  lock (call);
+  GRPC_TIMER_BEGIN(GRPC_PTAG_CALL_ON_DONE_RECV, 0);
+  lock(call);
   call->receiving = 0;
-  if (success)
-    {
-      for (i = 0; success && i < call->recv_ops.nops; i++)
-	{
-	  grpc_stream_op *op = &call->recv_ops.ops[i];
-	  switch (op->type)
-	    {
-	    case GRPC_NO_OP:
-	      break;
-	    case GRPC_OP_METADATA:
-	      recv_metadata (exec_ctx, call, &op->data.metadata);
-	      break;
-	    case GRPC_OP_BEGIN_MESSAGE:
-	      success = begin_message (call, op->data.begin_message);
-	      break;
-	    case GRPC_OP_SLICE:
-	      success = add_slice_to_message (call, op->data.slice);
-	      break;
-	    }
-	}
-      if (!success)
-	{
-	  grpc_stream_ops_unref_owned_objects (&call->recv_ops.ops[i], call->recv_ops.nops - i);
-	}
-      if (call->recv_state == GRPC_STREAM_RECV_CLOSED)
-	{
-	  GPR_ASSERT (call->read_state <= READ_STATE_READ_CLOSED);
-	  call->read_state = READ_STATE_READ_CLOSED;
-	}
-      if (call->recv_state == GRPC_STREAM_CLOSED)
-	{
-	  GPR_ASSERT (call->read_state <= READ_STATE_STREAM_CLOSED);
-	  call->read_state = READ_STATE_STREAM_CLOSED;
-	  if (call->have_alarm)
-	    {
-	      grpc_alarm_cancel (exec_ctx, &call->alarm);
-	    }
-	  /* propagate cancellation to any interested children */
-	  child_call = call->first_child;
-	  if (child_call != NULL)
-	    {
-	      do
-		{
-		  next_child_call = child_call->sibling_next;
-		  if (child_call->cancellation_is_inherited)
-		    {
-		      GRPC_CALL_INTERNAL_REF (child_call, "propagate_cancel");
-		      grpc_call_cancel (child_call, NULL);
-		      GRPC_CALL_INTERNAL_UNREF (exec_ctx, child_call, "propagate_cancel");
-		    }
-		  child_call = next_child_call;
-		}
-	      while (child_call != call->first_child);
-	    }
-	  GRPC_CALL_INTERNAL_UNREF (exec_ctx, call, "closed");
-	}
-      finish_read_ops (call);
-    }
-  else
-    {
-      finish_ioreq_op (call, GRPC_IOREQ_RECV_MESSAGE, 0);
-      finish_ioreq_op (call, GRPC_IOREQ_RECV_STATUS, 0);
-      finish_ioreq_op (call, GRPC_IOREQ_RECV_CLOSE, 0);
-      finish_ioreq_op (call, GRPC_IOREQ_RECV_TRAILING_METADATA, 0);
-      finish_ioreq_op (call, GRPC_IOREQ_RECV_INITIAL_METADATA, 0);
-      finish_ioreq_op (call, GRPC_IOREQ_RECV_STATUS_DETAILS, 0);
-    }
+  if (success) {
+    for (i = 0; success && i < call->recv_ops.nops; i++) {
+      grpc_stream_op *op = &call->recv_ops.ops[i];
+      switch (op->type) {
+        case GRPC_NO_OP:
+          break;
+        case GRPC_OP_METADATA:
+          recv_metadata(exec_ctx, call, &op->data.metadata);
+          break;
+        case GRPC_OP_BEGIN_MESSAGE:
+          success = begin_message(call, op->data.begin_message);
+          break;
+        case GRPC_OP_SLICE:
+          success = add_slice_to_message(call, op->data.slice);
+          break;
+      }
+    }
+    if (!success) {
+      grpc_stream_ops_unref_owned_objects(&call->recv_ops.ops[i],
+                                          call->recv_ops.nops - i);
+    }
+    if (call->recv_state == GRPC_STREAM_RECV_CLOSED) {
+      GPR_ASSERT(call->read_state <= READ_STATE_READ_CLOSED);
+      call->read_state = READ_STATE_READ_CLOSED;
+    }
+    if (call->recv_state == GRPC_STREAM_CLOSED) {
+      GPR_ASSERT(call->read_state <= READ_STATE_STREAM_CLOSED);
+      call->read_state = READ_STATE_STREAM_CLOSED;
+      if (call->have_alarm) {
+        grpc_alarm_cancel(exec_ctx, &call->alarm);
+      }
+      /* propagate cancellation to any interested children */
+      child_call = call->first_child;
+      if (child_call != NULL) {
+        do {
+          next_child_call = child_call->sibling_next;
+          if (child_call->cancellation_is_inherited) {
+            GRPC_CALL_INTERNAL_REF(child_call, "propagate_cancel");
+            grpc_call_cancel(child_call, NULL);
+            GRPC_CALL_INTERNAL_UNREF(exec_ctx, child_call, "propagate_cancel");
+          }
+          child_call = next_child_call;
+        } while (child_call != call->first_child);
+      }
+      GRPC_CALL_INTERNAL_UNREF(exec_ctx, call, "closed");
+    }
+    finish_read_ops(call);
+  } else {
+    finish_ioreq_op(call, GRPC_IOREQ_RECV_MESSAGE, 0);
+    finish_ioreq_op(call, GRPC_IOREQ_RECV_STATUS, 0);
+    finish_ioreq_op(call, GRPC_IOREQ_RECV_CLOSE, 0);
+    finish_ioreq_op(call, GRPC_IOREQ_RECV_TRAILING_METADATA, 0);
+    finish_ioreq_op(call, GRPC_IOREQ_RECV_INITIAL_METADATA, 0);
+    finish_ioreq_op(call, GRPC_IOREQ_RECV_STATUS_DETAILS, 0);
+  }
   call->recv_ops.nops = 0;
-  unlock (exec_ctx, call);
+  unlock(exec_ctx, call);
 
-  GRPC_CALL_INTERNAL_UNREF (exec_ctx, call, "receiving");
-  GRPC_TIMER_END (GRPC_PTAG_CALL_ON_DONE_RECV, 0);
+  GRPC_CALL_INTERNAL_UNREF(exec_ctx, call, "receiving");
+  GRPC_TIMER_END(GRPC_PTAG_CALL_ON_DONE_RECV, 0);
 }
 
-static int
-prepare_application_metadata (grpc_call * call, size_t count, grpc_metadata * metadata)
-{
+static int prepare_application_metadata(grpc_call *call, size_t count,
+                                        grpc_metadata *metadata) {
   size_t i;
-  for (i = 0; i < count; i++)
-    {
-      grpc_metadata *md = &metadata[i];
-      grpc_metadata *next_md = (i == count - 1) ? NULL : &metadata[i + 1];
-      grpc_metadata *prev_md = (i == 0) ? NULL : &metadata[i - 1];
-      grpc_linked_mdelem *l = (grpc_linked_mdelem *) & md->internal_data;
-      GPR_ASSERT (sizeof (grpc_linked_mdelem) == sizeof (md->internal_data));
-      l->md = grpc_mdelem_from_string_and_buffer (call->metadata_context, md->key, (const gpr_uint8 *) md->value, md->value_length, 1);
-      if (!grpc_mdstr_is_legal_header (l->md->key))
-	{
-	  gpr_log (GPR_ERROR, "attempt to send invalid metadata key: %s", grpc_mdstr_as_c_string (l->md->key));
-	  return 0;
-	}
-      else if (!grpc_mdstr_is_bin_suffixed (l->md->key) && !grpc_mdstr_is_legal_nonbin_header (l->md->value))
-	{
-	  gpr_log (GPR_ERROR, "attempt to send invalid metadata value");
-	  return 0;
-	}
-      l->next = next_md ? (grpc_linked_mdelem *) & next_md->internal_data : NULL;
-      l->prev = prev_md ? (grpc_linked_mdelem *) & prev_md->internal_data : NULL;
+  for (i = 0; i < count; i++) {
+    grpc_metadata *md = &metadata[i];
+    grpc_metadata *next_md = (i == count - 1) ? NULL : &metadata[i + 1];
+    grpc_metadata *prev_md = (i == 0) ? NULL : &metadata[i - 1];
+    grpc_linked_mdelem *l = (grpc_linked_mdelem *)&md->internal_data;
+    GPR_ASSERT(sizeof(grpc_linked_mdelem) == sizeof(md->internal_data));
+    l->md = grpc_mdelem_from_string_and_buffer(call->metadata_context, md->key,
+                                               (const gpr_uint8 *)md->value,
+                                               md->value_length, 1);
+    if (!grpc_mdstr_is_legal_header(l->md->key)) {
+      gpr_log(GPR_ERROR, "attempt to send invalid metadata key: %s",
+              grpc_mdstr_as_c_string(l->md->key));
+      return 0;
+    } else if (!grpc_mdstr_is_bin_suffixed(l->md->key) &&
+               !grpc_mdstr_is_legal_nonbin_header(l->md->value)) {
+      gpr_log(GPR_ERROR, "attempt to send invalid metadata value");
+      return 0;
     }
+    l->next = next_md ? (grpc_linked_mdelem *)&next_md->internal_data : NULL;
+    l->prev = prev_md ? (grpc_linked_mdelem *)&prev_md->internal_data : NULL;
+  }
   return 1;
 }
 
-static grpc_mdelem_list
-chain_metadata_from_app (grpc_call * call, size_t count, grpc_metadata * metadata)
-{
+static grpc_mdelem_list chain_metadata_from_app(grpc_call *call, size_t count,
+                                                grpc_metadata *metadata) {
   grpc_mdelem_list out;
-  if (count == 0)
-    {
-      out.head = out.tail = NULL;
-      return out;
-    }
-  out.head = (grpc_linked_mdelem *) & (metadata[0].internal_data);
-  out.tail = (grpc_linked_mdelem *) & (metadata[count - 1].internal_data);
+  if (count == 0) {
+    out.head = out.tail = NULL;
+    return out;
+  }
+  out.head = (grpc_linked_mdelem *)&(metadata[0].internal_data);
+  out.tail = (grpc_linked_mdelem *)&(metadata[count - 1].internal_data);
   return out;
 }
 
 /* Copy the contents of a byte buffer into stream ops */
-static void
-copy_byte_buffer_to_stream_ops (grpc_byte_buffer * byte_buffer, grpc_stream_op_buffer * sopb)
-{
+static void copy_byte_buffer_to_stream_ops(grpc_byte_buffer *byte_buffer,
+                                           grpc_stream_op_buffer *sopb) {
   size_t i;
 
-  switch (byte_buffer->type)
-    {
+  switch (byte_buffer->type) {
     case GRPC_BB_RAW:
-      for (i = 0; i < byte_buffer->data.raw.slice_buffer.count; i++)
-	{
-	  gpr_slice slice = byte_buffer->data.raw.slice_buffer.slices[i];
-	  gpr_slice_ref (slice);
-	  grpc_sopb_add_slice (sopb, slice);
-	}
+      for (i = 0; i < byte_buffer->data.raw.slice_buffer.count; i++) {
+        gpr_slice slice = byte_buffer->data.raw.slice_buffer.slices[i];
+        gpr_slice_ref(slice);
+        grpc_sopb_add_slice(sopb, slice);
+      }
       break;
-    }
+  }
 }
 
-static int
-fill_send_ops (grpc_call * call, grpc_transport_stream_op * op)
-{
+static int fill_send_ops(grpc_call *call, grpc_transport_stream_op *op) {
   grpc_ioreq_data data;
   gpr_uint32 flags;
   grpc_metadata_batch mdb;
   size_t i;
-  GPR_ASSERT (op->send_ops == NULL);
+  GPR_ASSERT(op->send_ops == NULL);
 
-  switch (call->write_state)
-    {
+  switch (call->write_state) {
     case WRITE_STATE_INITIAL:
-      if (!is_op_live (call, GRPC_IOREQ_SEND_INITIAL_METADATA))
-	{
-	  break;
-	}
+      if (!is_op_live(call, GRPC_IOREQ_SEND_INITIAL_METADATA)) {
+        break;
+      }
       data = call->request_data[GRPC_IOREQ_SEND_INITIAL_METADATA];
-      mdb.list = chain_metadata_from_app (call, data.send_metadata.count, data.send_metadata.metadata);
+      mdb.list = chain_metadata_from_app(call, data.send_metadata.count,
+                                         data.send_metadata.metadata);
       mdb.garbage.head = mdb.garbage.tail = NULL;
       mdb.deadline = call->send_deadline;
-      for (i = 0; i < call->send_initial_metadata_count; i++)
-	{
-	  grpc_metadata_batch_link_head (&mdb, &call->send_initial_metadata[i]);
-	}
-      grpc_sopb_add_metadata (&call->send_ops, mdb);
+      for (i = 0; i < call->send_initial_metadata_count; i++) {
+        grpc_metadata_batch_link_head(&mdb, &call->send_initial_metadata[i]);
+      }
+      grpc_sopb_add_metadata(&call->send_ops, mdb);
       op->send_ops = &call->send_ops;
       call->last_send_contains |= 1 << GRPC_IOREQ_SEND_INITIAL_METADATA;
       call->send_initial_metadata_count = 0;
-      /* fall through intended */
+    /* fall through intended */
     case WRITE_STATE_STARTED:
-      if (is_op_live (call, GRPC_IOREQ_SEND_MESSAGE))
-	{
-	  size_t length;
-	  data = call->request_data[GRPC_IOREQ_SEND_MESSAGE];
-	  flags = call->request_flags[GRPC_IOREQ_SEND_MESSAGE];
-	  length = grpc_byte_buffer_length (data.send_message);
-	  GPR_ASSERT (length <= GPR_UINT32_MAX);
-	  grpc_sopb_add_begin_message (&call->send_ops, (gpr_uint32) length, flags);
-	  copy_byte_buffer_to_stream_ops (data.send_message, &call->send_ops);
-	  op->send_ops = &call->send_ops;
-	  call->last_send_contains |= 1 << GRPC_IOREQ_SEND_MESSAGE;
-	}
-      if (is_op_live (call, GRPC_IOREQ_SEND_CLOSE))
-	{
-	  op->is_last_send = 1;
-	  op->send_ops = &call->send_ops;
-	  call->last_send_contains |= 1 << GRPC_IOREQ_SEND_CLOSE;
-	  if (!call->is_client)
-	    {
-	      /* send trailing metadata */
-	      data = call->request_data[GRPC_IOREQ_SEND_TRAILING_METADATA];
-	      mdb.list = chain_metadata_from_app (call, data.send_metadata.count, data.send_metadata.metadata);
-	      mdb.garbage.head = mdb.garbage.tail = NULL;
-	      mdb.deadline = gpr_inf_future (GPR_CLOCK_REALTIME);
-	      /* send status */
-	      /* TODO(ctiller): cache common status values */
-	      data = call->request_data[GRPC_IOREQ_SEND_STATUS];
-	      grpc_metadata_batch_add_tail (&mdb, &call->status_link, grpc_channel_get_reffed_status_elem (call->channel, data.send_status.code));
-	      if (data.send_status.details)
-		{
-		  grpc_metadata_batch_add_tail (&mdb, &call->details_link, grpc_mdelem_from_metadata_strings (call->metadata_context, GRPC_MDSTR_REF (grpc_channel_get_message_string (call->channel)), data.send_status.details));
-		  call->request_data[GRPC_IOREQ_SEND_STATUS].send_status.details = NULL;
-		}
-	      grpc_sopb_add_metadata (&call->send_ops, mdb);
-	    }
-	}
+      if (is_op_live(call, GRPC_IOREQ_SEND_MESSAGE)) {
+        size_t length;
+        data = call->request_data[GRPC_IOREQ_SEND_MESSAGE];
+        flags = call->request_flags[GRPC_IOREQ_SEND_MESSAGE];
+        length = grpc_byte_buffer_length(data.send_message);
+        GPR_ASSERT(length <= GPR_UINT32_MAX);
+        grpc_sopb_add_begin_message(&call->send_ops, (gpr_uint32)length, flags);
+        copy_byte_buffer_to_stream_ops(data.send_message, &call->send_ops);
+        op->send_ops = &call->send_ops;
+        call->last_send_contains |= 1 << GRPC_IOREQ_SEND_MESSAGE;
+      }
+      if (is_op_live(call, GRPC_IOREQ_SEND_CLOSE)) {
+        op->is_last_send = 1;
+        op->send_ops = &call->send_ops;
+        call->last_send_contains |= 1 << GRPC_IOREQ_SEND_CLOSE;
+        if (!call->is_client) {
+          /* send trailing metadata */
+          data = call->request_data[GRPC_IOREQ_SEND_TRAILING_METADATA];
+          mdb.list = chain_metadata_from_app(call, data.send_metadata.count,
+                                             data.send_metadata.metadata);
+          mdb.garbage.head = mdb.garbage.tail = NULL;
+          mdb.deadline = gpr_inf_future(GPR_CLOCK_REALTIME);
+          /* send status */
+          /* TODO(ctiller): cache common status values */
+          data = call->request_data[GRPC_IOREQ_SEND_STATUS];
+          grpc_metadata_batch_add_tail(
+              &mdb, &call->status_link,
+              grpc_channel_get_reffed_status_elem(call->channel,
+                                                  data.send_status.code));
+          if (data.send_status.details) {
+            grpc_metadata_batch_add_tail(
+                &mdb, &call->details_link,
+                grpc_mdelem_from_metadata_strings(
+                    call->metadata_context,
+                    GRPC_MDSTR_REF(
+                        grpc_channel_get_message_string(call->channel)),
+                    data.send_status.details));
+            call->request_data[GRPC_IOREQ_SEND_STATUS].send_status.details =
+                NULL;
+          }
+          grpc_sopb_add_metadata(&call->send_ops, mdb);
+        }
+      }
       break;
     case WRITE_STATE_WRITE_CLOSED:
       break;
-    }
-  if (op->send_ops)
-    {
-      op->on_done_send = &call->on_done_send;
-    }
+  }
+  if (op->send_ops) {
+    op->on_done_send = &call->on_done_send;
+  }
   return op->send_ops != NULL;
 }
 
-static grpc_call_error
-start_ioreq_error (grpc_call * call, gpr_uint32 mutated_ops, grpc_call_error ret)
-{
+static grpc_call_error start_ioreq_error(grpc_call *call,
+                                         gpr_uint32 mutated_ops,
+                                         grpc_call_error ret) {
   size_t i;
-  for (i = 0; i < GRPC_IOREQ_OP_COUNT; i++)
-    {
-      if (mutated_ops & (1u << i))
-	{
-	  call->request_set[i] = REQSET_EMPTY;
-	}
+  for (i = 0; i < GRPC_IOREQ_OP_COUNT; i++) {
+    if (mutated_ops & (1u << i)) {
+      call->request_set[i] = REQSET_EMPTY;
     }
+  }
   return ret;
 }
 
-static void
-finish_read_ops (grpc_call * call)
-{
+static void finish_read_ops(grpc_call *call) {
   int empty;
 
-  if (is_op_live (call, GRPC_IOREQ_RECV_MESSAGE))
-    {
-      empty = (NULL == (*call->request_data[GRPC_IOREQ_RECV_MESSAGE].recv_message = grpc_bbq_pop (&call->incoming_queue)));
-      if (!empty)
-	{
-	  finish_live_ioreq_op (call, GRPC_IOREQ_RECV_MESSAGE, 1);
-	  empty = grpc_bbq_empty (&call->incoming_queue);
-	}
-    }
-  else
-    {
-      empty = grpc_bbq_empty (&call->incoming_queue);
+  if (is_op_live(call, GRPC_IOREQ_RECV_MESSAGE)) {
+    empty =
+        (NULL == (*call->request_data[GRPC_IOREQ_RECV_MESSAGE].recv_message =
+                      grpc_bbq_pop(&call->incoming_queue)));
+    if (!empty) {
+      finish_live_ioreq_op(call, GRPC_IOREQ_RECV_MESSAGE, 1);
+      empty = grpc_bbq_empty(&call->incoming_queue);
     }
+  } else {
+    empty = grpc_bbq_empty(&call->incoming_queue);
+  }
 
-  switch (call->read_state)
-    {
+  switch (call->read_state) {
     case READ_STATE_STREAM_CLOSED:
-      if (empty && !call->have_alarm)
-	{
-	  finish_ioreq_op (call, GRPC_IOREQ_RECV_CLOSE, 1);
-	}
-      /* fallthrough */
+      if (empty && !call->have_alarm) {
+        finish_ioreq_op(call, GRPC_IOREQ_RECV_CLOSE, 1);
+      }
+    /* fallthrough */
     case READ_STATE_READ_CLOSED:
-      if (empty)
-	{
-	  finish_ioreq_op (call, GRPC_IOREQ_RECV_MESSAGE, 1);
-	}
-      finish_ioreq_op (call, GRPC_IOREQ_RECV_STATUS, 1);
-      finish_ioreq_op (call, GRPC_IOREQ_RECV_STATUS_DETAILS, 1);
-      finish_ioreq_op (call, GRPC_IOREQ_RECV_TRAILING_METADATA, 1);
-      /* fallthrough */
+      if (empty) {
+        finish_ioreq_op(call, GRPC_IOREQ_RECV_MESSAGE, 1);
+      }
+      finish_ioreq_op(call, GRPC_IOREQ_RECV_STATUS, 1);
+      finish_ioreq_op(call, GRPC_IOREQ_RECV_STATUS_DETAILS, 1);
+      finish_ioreq_op(call, GRPC_IOREQ_RECV_TRAILING_METADATA, 1);
+    /* fallthrough */
     case READ_STATE_GOT_INITIAL_METADATA:
-      finish_ioreq_op (call, GRPC_IOREQ_RECV_INITIAL_METADATA, 1);
-      /* fallthrough */
+      finish_ioreq_op(call, GRPC_IOREQ_RECV_INITIAL_METADATA, 1);
+    /* fallthrough */
     case READ_STATE_INITIAL:
       /* do nothing */
       break;
-    }
+  }
 }
 
-static grpc_call_error
-start_ioreq (grpc_call * call, const grpc_ioreq * reqs, size_t nreqs, grpc_ioreq_completion_func completion, void *user_data)
-{
+static grpc_call_error start_ioreq(grpc_call *call, const grpc_ioreq *reqs,
+                                   size_t nreqs,
+                                   grpc_ioreq_completion_func completion,
+                                   void *user_data) {
   size_t i;
   gpr_uint16 have_ops = 0;
   grpc_ioreq_op op;
@@ -1326,46 +1214,43 @@ start_ioreq (grpc_call * call, const grpc_ioreq * reqs, size_t nreqs, grpc_ioreq
   grpc_ioreq_data data;
   gpr_uint8 set;
 
-  if (nreqs == 0)
-    {
-      return GRPC_CALL_OK;
-    }
+  if (nreqs == 0) {
+    return GRPC_CALL_OK;
+  }
 
   set = reqs[0].op;
 
-  for (i = 0; i < nreqs; i++)
-    {
-      op = reqs[i].op;
-      if (call->request_set[op] < GRPC_IOREQ_OP_COUNT)
-	{
-	  return start_ioreq_error (call, have_ops, GRPC_CALL_ERROR_TOO_MANY_OPERATIONS);
-	}
-      else if (call->request_set[op] == REQSET_DONE)
-	{
-	  return start_ioreq_error (call, have_ops, GRPC_CALL_ERROR_ALREADY_INVOKED);
-	}
-      data = reqs[i].data;
-      if (op == GRPC_IOREQ_SEND_INITIAL_METADATA || op == GRPC_IOREQ_SEND_TRAILING_METADATA)
-	{
-	  if (!prepare_application_metadata (call, data.send_metadata.count, data.send_metadata.metadata))
-	    {
-	      return start_ioreq_error (call, have_ops, GRPC_CALL_ERROR_INVALID_METADATA);
-	    }
-	}
-      if (op == GRPC_IOREQ_SEND_STATUS)
-	{
-	  set_status_code (call, STATUS_FROM_SERVER_STATUS, (gpr_uint32) reqs[i].data.send_status.code);
-	  if (reqs[i].data.send_status.details)
-	    {
-	      set_status_details (call, STATUS_FROM_SERVER_STATUS, GRPC_MDSTR_REF (reqs[i].data.send_status.details));
-	    }
-	}
-      have_ops |= (gpr_uint16) (1u << op);
-
-      call->request_data[op] = data;
-      call->request_flags[op] = reqs[i].flags;
-      call->request_set[op] = set;
-    }
+  for (i = 0; i < nreqs; i++) {
+    op = reqs[i].op;
+    if (call->request_set[op] < GRPC_IOREQ_OP_COUNT) {
+      return start_ioreq_error(call, have_ops,
+                               GRPC_CALL_ERROR_TOO_MANY_OPERATIONS);
+    } else if (call->request_set[op] == REQSET_DONE) {
+      return start_ioreq_error(call, have_ops, GRPC_CALL_ERROR_ALREADY_INVOKED);
+    }
+    data = reqs[i].data;
+    if (op == GRPC_IOREQ_SEND_INITIAL_METADATA ||
+        op == GRPC_IOREQ_SEND_TRAILING_METADATA) {
+      if (!prepare_application_metadata(call, data.send_metadata.count,
+                                        data.send_metadata.metadata)) {
+        return start_ioreq_error(call, have_ops,
+                                 GRPC_CALL_ERROR_INVALID_METADATA);
+      }
+    }
+    if (op == GRPC_IOREQ_SEND_STATUS) {
+      set_status_code(call, STATUS_FROM_SERVER_STATUS,
+                      (gpr_uint32)reqs[i].data.send_status.code);
+      if (reqs[i].data.send_status.details) {
+        set_status_details(call, STATUS_FROM_SERVER_STATUS,
+                           GRPC_MDSTR_REF(reqs[i].data.send_status.details));
+      }
+    }
+    have_ops |= (gpr_uint16)(1u << op);
+
+    call->request_data[op] = data;
+    call->request_flags[op] = reqs[i].flags;
+    call->request_set[op] = set;
+  }
 
   master = &call->masters[set];
   master->success = 1;
@@ -1374,251 +1259,218 @@ start_ioreq (grpc_call * call, const grpc_ioreq * reqs, size_t nreqs, grpc_ioreq
   master->on_complete = completion;
   master->user_data = user_data;
 
-  finish_read_ops (call);
-  early_out_write_ops (call);
+  finish_read_ops(call);
+  early_out_write_ops(call);
 
   return GRPC_CALL_OK;
 }
 
-grpc_call_error
-grpc_call_start_ioreq_and_call_back (grpc_exec_ctx * exec_ctx, grpc_call * call, const grpc_ioreq * reqs, size_t nreqs, grpc_ioreq_completion_func on_complete, void *user_data)
-{
+grpc_call_error grpc_call_start_ioreq_and_call_back(
+    grpc_exec_ctx *exec_ctx, grpc_call *call, const grpc_ioreq *reqs,
+    size_t nreqs, grpc_ioreq_completion_func on_complete, void *user_data) {
   grpc_call_error err;
-  lock (call);
-  err = start_ioreq (call, reqs, nreqs, on_complete, user_data);
-  unlock (exec_ctx, call);
+  lock(call);
+  err = start_ioreq(call, reqs, nreqs, on_complete, user_data);
+  unlock(exec_ctx, call);
   return err;
 }
 
-void
-grpc_call_destroy (grpc_call * c)
-{
+void grpc_call_destroy(grpc_call *c) {
   int cancel;
   grpc_call *parent = c->parent;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
-  if (parent)
-    {
-      gpr_mu_lock (&parent->mu);
-      if (c == parent->first_child)
-	{
-	  parent->first_child = c->sibling_next;
-	  if (c == parent->first_child)
-	    {
-	      parent->first_child = NULL;
-	    }
-	  c->sibling_prev->sibling_next = c->sibling_next;
-	  c->sibling_next->sibling_prev = c->sibling_prev;
-	}
-      gpr_mu_unlock (&parent->mu);
-      GRPC_CALL_INTERNAL_UNREF (&exec_ctx, parent, "child");
-    }
-
-  lock (c);
-  GPR_ASSERT (!c->destroy_called);
+  if (parent) {
+    gpr_mu_lock(&parent->mu);
+    if (c == parent->first_child) {
+      parent->first_child = c->sibling_next;
+      if (c == parent->first_child) {
+        parent->first_child = NULL;
+      }
+      c->sibling_prev->sibling_next = c->sibling_next;
+      c->sibling_next->sibling_prev = c->sibling_prev;
+    }
+    gpr_mu_unlock(&parent->mu);
+    GRPC_CALL_INTERNAL_UNREF(&exec_ctx, parent, "child");
+  }
+
+  lock(c);
+  GPR_ASSERT(!c->destroy_called);
   c->destroy_called = 1;
-  if (c->have_alarm)
-    {
-      grpc_alarm_cancel (&exec_ctx, &c->alarm);
-    }
+  if (c->have_alarm) {
+    grpc_alarm_cancel(&exec_ctx, &c->alarm);
+  }
   cancel = c->read_state != READ_STATE_STREAM_CLOSED;
-  unlock (&exec_ctx, c);
-  if (cancel)
-    grpc_call_cancel (c, NULL);
-  GRPC_CALL_INTERNAL_UNREF (&exec_ctx, c, "destroy");
-  grpc_exec_ctx_finish (&exec_ctx);
+  unlock(&exec_ctx, c);
+  if (cancel) grpc_call_cancel(c, NULL);
+  GRPC_CALL_INTERNAL_UNREF(&exec_ctx, c, "destroy");
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
-grpc_call_error
-grpc_call_cancel (grpc_call * call, void *reserved)
-{
-  GPR_ASSERT (!reserved);
-  return grpc_call_cancel_with_status (call, GRPC_STATUS_CANCELLED, "Cancelled", NULL);
+grpc_call_error grpc_call_cancel(grpc_call *call, void *reserved) {
+  GPR_ASSERT(!reserved);
+  return grpc_call_cancel_with_status(call, GRPC_STATUS_CANCELLED, "Cancelled",
+                                      NULL);
 }
 
-grpc_call_error
-grpc_call_cancel_with_status (grpc_call * c, grpc_status_code status, const char *description, void *reserved)
-{
+grpc_call_error grpc_call_cancel_with_status(grpc_call *c,
+                                             grpc_status_code status,
+                                             const char *description,
+                                             void *reserved) {
   grpc_call_error r;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  GPR_ASSERT (reserved == NULL);
-  lock (c);
-  r = cancel_with_status (c, status, description);
-  unlock (&exec_ctx, c);
-  grpc_exec_ctx_finish (&exec_ctx);
+  GPR_ASSERT(reserved == NULL);
+  lock(c);
+  r = cancel_with_status(c, status, description);
+  unlock(&exec_ctx, c);
+  grpc_exec_ctx_finish(&exec_ctx);
   return r;
 }
 
-static grpc_call_error
-cancel_with_status (grpc_call * c, grpc_status_code status, const char *description)
-{
-  grpc_mdstr *details = description ? grpc_mdstr_from_string (c->metadata_context, description, 0) : NULL;
+static grpc_call_error cancel_with_status(grpc_call *c, grpc_status_code status,
+                                          const char *description) {
+  grpc_mdstr *details =
+      description ? grpc_mdstr_from_string(c->metadata_context, description, 0)
+                  : NULL;
 
-  GPR_ASSERT (status != GRPC_STATUS_OK);
+  GPR_ASSERT(status != GRPC_STATUS_OK);
 
-  set_status_code (c, STATUS_FROM_API_OVERRIDE, (gpr_uint32) status);
-  set_status_details (c, STATUS_FROM_API_OVERRIDE, details);
+  set_status_code(c, STATUS_FROM_API_OVERRIDE, (gpr_uint32)status);
+  set_status_details(c, STATUS_FROM_API_OVERRIDE, details);
 
   c->cancel_with_status = status;
 
   return GRPC_CALL_OK;
 }
 
-static void
-finished_loose_op (grpc_exec_ctx * exec_ctx, void *call, int success_ignored)
-{
-  GRPC_CALL_INTERNAL_UNREF (exec_ctx, call, "loose-op");
+static void finished_loose_op(grpc_exec_ctx *exec_ctx, void *call,
+                              int success_ignored) {
+  GRPC_CALL_INTERNAL_UNREF(exec_ctx, call, "loose-op");
 }
 
-typedef struct
-{
+typedef struct {
   grpc_call *call;
   grpc_closure closure;
 } finished_loose_op_allocated_args;
 
-static void
-finished_loose_op_allocated (grpc_exec_ctx * exec_ctx, void *alloc, int success)
-{
+static void finished_loose_op_allocated(grpc_exec_ctx *exec_ctx, void *alloc,
+                                        int success) {
   finished_loose_op_allocated_args *args = alloc;
-  finished_loose_op (exec_ctx, args->call, success);
-  gpr_free (args);
+  finished_loose_op(exec_ctx, args->call, success);
+  gpr_free(args);
 }
 
-static void
-execute_op (grpc_exec_ctx * exec_ctx, grpc_call * call, grpc_transport_stream_op * op)
-{
+static void execute_op(grpc_exec_ctx *exec_ctx, grpc_call *call,
+                       grpc_transport_stream_op *op) {
   grpc_call_element *elem;
 
-  GPR_ASSERT (op->on_consumed == NULL);
-  if (op->cancel_with_status != GRPC_STATUS_OK || op->bind_pollset)
-    {
-      GRPC_CALL_INTERNAL_REF (call, "loose-op");
-      if (op->bind_pollset)
-	{
-	  op->on_consumed = &call->on_done_bind;
-	}
-      else
-	{
-	  finished_loose_op_allocated_args *args = gpr_malloc (sizeof (*args));
-	  args->call = call;
-	  grpc_closure_init (&args->closure, finished_loose_op_allocated, args);
-	  op->on_consumed = &args->closure;
-	}
+  GPR_ASSERT(op->on_consumed == NULL);
+  if (op->cancel_with_status != GRPC_STATUS_OK || op->bind_pollset) {
+    GRPC_CALL_INTERNAL_REF(call, "loose-op");
+    if (op->bind_pollset) {
+      op->on_consumed = &call->on_done_bind;
+    } else {
+      finished_loose_op_allocated_args *args = gpr_malloc(sizeof(*args));
+      args->call = call;
+      grpc_closure_init(&args->closure, finished_loose_op_allocated, args);
+      op->on_consumed = &args->closure;
     }
+  }
 
-  elem = CALL_ELEM_FROM_CALL (call, 0);
+  elem = CALL_ELEM_FROM_CALL(call, 0);
   op->context = call->context;
-  elem->filter->start_transport_stream_op (exec_ctx, elem, op);
+  elem->filter->start_transport_stream_op(exec_ctx, elem, op);
 }
 
-char *
-grpc_call_get_peer (grpc_call * call)
-{
-  grpc_call_element *elem = CALL_ELEM_FROM_CALL (call, 0);
+char *grpc_call_get_peer(grpc_call *call) {
+  grpc_call_element *elem = CALL_ELEM_FROM_CALL(call, 0);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  char *result = elem->filter->get_peer (&exec_ctx, elem);
-  grpc_exec_ctx_finish (&exec_ctx);
+  char *result = elem->filter->get_peer(&exec_ctx, elem);
+  grpc_exec_ctx_finish(&exec_ctx);
   return result;
 }
 
-grpc_call *
-grpc_call_from_top_element (grpc_call_element * elem)
-{
-  return CALL_FROM_TOP_ELEM (elem);
+grpc_call *grpc_call_from_top_element(grpc_call_element *elem) {
+  return CALL_FROM_TOP_ELEM(elem);
 }
 
-static void
-call_alarm (grpc_exec_ctx * exec_ctx, void *arg, int success)
-{
+static void call_alarm(grpc_exec_ctx *exec_ctx, void *arg, int success) {
   grpc_call *call = arg;
-  lock (call);
+  lock(call);
   call->have_alarm = 0;
-  if (success)
-    {
-      cancel_with_status (call, GRPC_STATUS_DEADLINE_EXCEEDED, "Deadline Exceeded");
-    }
-  finish_read_ops (call);
-  unlock (exec_ctx, call);
-  GRPC_CALL_INTERNAL_UNREF (exec_ctx, call, "alarm");
+  if (success) {
+    cancel_with_status(call, GRPC_STATUS_DEADLINE_EXCEEDED,
+                       "Deadline Exceeded");
+  }
+  finish_read_ops(call);
+  unlock(exec_ctx, call);
+  GRPC_CALL_INTERNAL_UNREF(exec_ctx, call, "alarm");
 }
 
-static void
-set_deadline_alarm (grpc_exec_ctx * exec_ctx, grpc_call * call, gpr_timespec deadline)
-{
-  if (call->have_alarm)
-    {
-      gpr_log (GPR_ERROR, "Attempt to set deadline alarm twice");
-      assert (0);
-      return;
-    }
-  GRPC_CALL_INTERNAL_REF (call, "alarm");
+static void set_deadline_alarm(grpc_exec_ctx *exec_ctx, grpc_call *call,
+                               gpr_timespec deadline) {
+  if (call->have_alarm) {
+    gpr_log(GPR_ERROR, "Attempt to set deadline alarm twice");
+    assert(0);
+    return;
+  }
+  GRPC_CALL_INTERNAL_REF(call, "alarm");
   call->have_alarm = 1;
-  call->send_deadline = gpr_convert_clock_type (deadline, GPR_CLOCK_MONOTONIC);
-  grpc_alarm_init (exec_ctx, &call->alarm, call->send_deadline, call_alarm, call, gpr_now (GPR_CLOCK_MONOTONIC));
+  call->send_deadline = gpr_convert_clock_type(deadline, GPR_CLOCK_MONOTONIC);
+  grpc_alarm_init(exec_ctx, &call->alarm, call->send_deadline, call_alarm, call,
+                  gpr_now(GPR_CLOCK_MONOTONIC));
 }
 
 /* we offset status by a small amount when storing it into transport metadata
    as metadata cannot store a 0 value (which is used as OK for grpc_status_codes
    */
 #define STATUS_OFFSET 1
-static void
-destroy_status (void *ignored)
-{
-}
+static void destroy_status(void *ignored) {}
 
-static gpr_uint32
-decode_status (grpc_mdelem * md)
-{
+static gpr_uint32 decode_status(grpc_mdelem *md) {
   gpr_uint32 status;
-  void *user_data = grpc_mdelem_get_user_data (md, destroy_status);
-  if (user_data)
-    {
-      status = ((gpr_uint32) (gpr_intptr) user_data) - STATUS_OFFSET;
-    }
-  else
-    {
-      if (!gpr_parse_bytes_to_uint32 (grpc_mdstr_as_c_string (md->value), GPR_SLICE_LENGTH (md->value->slice), &status))
-	{
-	  status = GRPC_STATUS_UNKNOWN;	/* could not parse status code */
-	}
-      grpc_mdelem_set_user_data (md, destroy_status, (void *) (gpr_intptr) (status + STATUS_OFFSET));
-    }
+  void *user_data = grpc_mdelem_get_user_data(md, destroy_status);
+  if (user_data) {
+    status = ((gpr_uint32)(gpr_intptr)user_data) - STATUS_OFFSET;
+  } else {
+    if (!gpr_parse_bytes_to_uint32(grpc_mdstr_as_c_string(md->value),
+                                   GPR_SLICE_LENGTH(md->value->slice),
+                                   &status)) {
+      status = GRPC_STATUS_UNKNOWN; /* could not parse status code */
+    }
+    grpc_mdelem_set_user_data(md, destroy_status,
+                              (void *)(gpr_intptr)(status + STATUS_OFFSET));
+  }
   return status;
 }
 
 /* just as for status above, we need to offset: metadata userdata can't hold a
  * zero (null), which in this case is used to signal no compression */
 #define COMPRESS_OFFSET 1
-static void
-destroy_compression (void *ignored)
-{
-}
+static void destroy_compression(void *ignored) {}
 
-static gpr_uint32
-decode_compression (grpc_mdelem * md)
-{
+static gpr_uint32 decode_compression(grpc_mdelem *md) {
   grpc_compression_algorithm algorithm;
-  void *user_data = grpc_mdelem_get_user_data (md, destroy_compression);
-  if (user_data)
-    {
-      algorithm = ((grpc_compression_algorithm) (gpr_intptr) user_data) - COMPRESS_OFFSET;
-    }
-  else
-    {
-      const char *md_c_str = grpc_mdstr_as_c_string (md->value);
-      if (!grpc_compression_algorithm_parse (md_c_str, strlen (md_c_str), &algorithm))
-	{
-	  gpr_log (GPR_ERROR, "Invalid compression algorithm: '%s'", md_c_str);
-	  assert (0);
-	}
-      grpc_mdelem_set_user_data (md, destroy_compression, (void *) (gpr_intptr) (algorithm + COMPRESS_OFFSET));
-    }
+  void *user_data = grpc_mdelem_get_user_data(md, destroy_compression);
+  if (user_data) {
+    algorithm =
+        ((grpc_compression_algorithm)(gpr_intptr)user_data) - COMPRESS_OFFSET;
+  } else {
+    const char *md_c_str = grpc_mdstr_as_c_string(md->value);
+    if (!grpc_compression_algorithm_parse(md_c_str, strlen(md_c_str),
+                                          &algorithm)) {
+      gpr_log(GPR_ERROR, "Invalid compression algorithm: '%s'", md_c_str);
+      assert(0);
+    }
+    grpc_mdelem_set_user_data(
+        md, destroy_compression,
+        (void *)(gpr_intptr)(algorithm + COMPRESS_OFFSET));
+  }
   return algorithm;
 }
 
-static void
-recv_metadata (grpc_exec_ctx * exec_ctx, grpc_call * call, grpc_metadata_batch * md)
-{
+static void recv_metadata(grpc_exec_ctx *exec_ctx, grpc_call *call,
+                          grpc_metadata_batch *md) {
   grpc_linked_mdelem *l;
   grpc_metadata_array *dest;
   grpc_metadata *mdusr;
@@ -1626,397 +1478,355 @@ recv_metadata (grpc_exec_ctx * exec_ctx, grpc_call * call, grpc_metadata_batch *
   grpc_mdctx *mdctx = call->metadata_context;
 
   is_trailing = call->read_state >= READ_STATE_GOT_INITIAL_METADATA;
-  for (l = md->list.head; l != NULL; l = l->next)
-    {
-      grpc_mdelem *md = l->md;
-      grpc_mdstr *key = md->key;
-      if (key == grpc_channel_get_status_string (call->channel))
-	{
-	  set_status_code (call, STATUS_FROM_WIRE, decode_status (md));
-	}
-      else if (key == grpc_channel_get_message_string (call->channel))
-	{
-	  set_status_details (call, STATUS_FROM_WIRE, GRPC_MDSTR_REF (md->value));
-	}
-      else if (key == grpc_channel_get_compression_algorithm_string (call->channel))
-	{
-	  set_compression_algorithm (call, decode_compression (md));
-	}
-      else if (key == grpc_channel_get_encodings_accepted_by_peer_string (call->channel))
-	{
-	  set_encodings_accepted_by_peer (call, md->value->slice);
-	}
-      else
-	{
-	  dest = &call->buffered_metadata[is_trailing];
-	  if (dest->count == dest->capacity)
-	    {
-	      dest->capacity = GPR_MAX (dest->capacity + 8, dest->capacity * 2);
-	      dest->metadata = gpr_realloc (dest->metadata, sizeof (grpc_metadata) * dest->capacity);
-	    }
-	  mdusr = &dest->metadata[dest->count++];
-	  mdusr->key = grpc_mdstr_as_c_string (md->key);
-	  mdusr->value = grpc_mdstr_as_c_string (md->value);
-	  mdusr->value_length = GPR_SLICE_LENGTH (md->value->slice);
-	  if (call->owned_metadata_count == call->owned_metadata_capacity)
-	    {
-	      call->owned_metadata_capacity = GPR_MAX (call->owned_metadata_capacity + 8, call->owned_metadata_capacity * 2);
-	      call->owned_metadata = gpr_realloc (call->owned_metadata, sizeof (grpc_mdelem *) * call->owned_metadata_capacity);
-	    }
-	  call->owned_metadata[call->owned_metadata_count++] = md;
-	  l->md = 0;
-	}
-    }
-  if (gpr_time_cmp (md->deadline, gpr_inf_future (md->deadline.clock_type)) != 0 && !call->is_client)
-    {
-      set_deadline_alarm (exec_ctx, call, md->deadline);
-    }
-  if (!is_trailing)
-    {
-      call->read_state = READ_STATE_GOT_INITIAL_METADATA;
-    }
-
-  grpc_mdctx_lock (mdctx);
-  for (l = md->list.head; l; l = l->next)
-    {
-      if (l->md)
-	GRPC_MDCTX_LOCKED_MDELEM_UNREF (mdctx, l->md);
-    }
-  for (l = md->garbage.head; l; l = l->next)
-    {
-      GRPC_MDCTX_LOCKED_MDELEM_UNREF (mdctx, l->md);
-    }
-  grpc_mdctx_unlock (mdctx);
+  for (l = md->list.head; l != NULL; l = l->next) {
+    grpc_mdelem *md = l->md;
+    grpc_mdstr *key = md->key;
+    if (key == grpc_channel_get_status_string(call->channel)) {
+      set_status_code(call, STATUS_FROM_WIRE, decode_status(md));
+    } else if (key == grpc_channel_get_message_string(call->channel)) {
+      set_status_details(call, STATUS_FROM_WIRE, GRPC_MDSTR_REF(md->value));
+    } else if (key ==
+               grpc_channel_get_compression_algorithm_string(call->channel)) {
+      set_compression_algorithm(call, decode_compression(md));
+    } else if (key == grpc_channel_get_encodings_accepted_by_peer_string(
+                          call->channel)) {
+      set_encodings_accepted_by_peer(call, md->value->slice);
+    } else {
+      dest = &call->buffered_metadata[is_trailing];
+      if (dest->count == dest->capacity) {
+        dest->capacity = GPR_MAX(dest->capacity + 8, dest->capacity * 2);
+        dest->metadata =
+            gpr_realloc(dest->metadata, sizeof(grpc_metadata) * dest->capacity);
+      }
+      mdusr = &dest->metadata[dest->count++];
+      mdusr->key = grpc_mdstr_as_c_string(md->key);
+      mdusr->value = grpc_mdstr_as_c_string(md->value);
+      mdusr->value_length = GPR_SLICE_LENGTH(md->value->slice);
+      if (call->owned_metadata_count == call->owned_metadata_capacity) {
+        call->owned_metadata_capacity =
+            GPR_MAX(call->owned_metadata_capacity + 8,
+                    call->owned_metadata_capacity * 2);
+        call->owned_metadata =
+            gpr_realloc(call->owned_metadata,
+                        sizeof(grpc_mdelem *) * call->owned_metadata_capacity);
+      }
+      call->owned_metadata[call->owned_metadata_count++] = md;
+      l->md = 0;
+    }
+  }
+  if (gpr_time_cmp(md->deadline, gpr_inf_future(md->deadline.clock_type)) !=
+          0 &&
+      !call->is_client) {
+    set_deadline_alarm(exec_ctx, call, md->deadline);
+  }
+  if (!is_trailing) {
+    call->read_state = READ_STATE_GOT_INITIAL_METADATA;
+  }
+
+  grpc_mdctx_lock(mdctx);
+  for (l = md->list.head; l; l = l->next) {
+    if (l->md) GRPC_MDCTX_LOCKED_MDELEM_UNREF(mdctx, l->md);
+  }
+  for (l = md->garbage.head; l; l = l->next) {
+    GRPC_MDCTX_LOCKED_MDELEM_UNREF(mdctx, l->md);
+  }
+  grpc_mdctx_unlock(mdctx);
 }
 
-grpc_call_stack *
-grpc_call_get_call_stack (grpc_call * call)
-{
-  return CALL_STACK_FROM_CALL (call);
+grpc_call_stack *grpc_call_get_call_stack(grpc_call *call) {
+  return CALL_STACK_FROM_CALL(call);
 }
 
 /*
  * BATCH API IMPLEMENTATION
  */
 
-static void
-set_status_value_directly (grpc_status_code status, void *dest)
-{
-  *(grpc_status_code *) dest = status;
+static void set_status_value_directly(grpc_status_code status, void *dest) {
+  *(grpc_status_code *)dest = status;
 }
 
-static void
-set_cancelled_value (grpc_status_code status, void *dest)
-{
-  *(grpc_status_code *) dest = (status != GRPC_STATUS_OK);
+static void set_cancelled_value(grpc_status_code status, void *dest) {
+  *(grpc_status_code *)dest = (status != GRPC_STATUS_OK);
 }
 
-static void
-finish_batch (grpc_exec_ctx * exec_ctx, grpc_call * call, int success, void *tag)
-{
-  grpc_cq_end_op (exec_ctx,call->cq, tag, success, done_completion, call, allocate_completion ( call));
+static void finish_batch(grpc_exec_ctx *exec_ctx, grpc_call *call, int success,
+                         void *tag) {
+  grpc_cq_end_op(exec_ctx, call->cq, tag, success, done_completion, call,
+                 allocate_completion(call));
 }
 
-static void
-finish_batch_with_close (grpc_exec_ctx * exec_ctx, grpc_call * call, int success, void *tag)
-{
-  grpc_cq_end_op (exec_ctx,call->cq, tag, 1, done_completion, call, allocate_completion ( call));
+static void finish_batch_with_close(grpc_exec_ctx *exec_ctx, grpc_call *call,
+                                    int success, void *tag) {
+  grpc_cq_end_op(exec_ctx, call->cq, tag, 1, done_completion, call,
+                 allocate_completion(call));
 }
 
-static int
-are_write_flags_valid (gpr_uint32 flags)
-{
+static int are_write_flags_valid(gpr_uint32 flags) {
   /* check that only bits in GRPC_WRITE_(INTERNAL?)_USED_MASK are set */
-  const gpr_uint32 allowed_write_positions = (GRPC_WRITE_USED_MASK | GRPC_WRITE_INTERNAL_USED_MASK);
+  const gpr_uint32 allowed_write_positions =
+      (GRPC_WRITE_USED_MASK | GRPC_WRITE_INTERNAL_USED_MASK);
   const gpr_uint32 invalid_positions = ~allowed_write_positions;
   return !(flags & invalid_positions);
 }
 
-grpc_call_error
-grpc_call_start_batch (grpc_call * call, const grpc_op * ops, size_t nops, void *tag, void *reserved)
-{
+grpc_call_error grpc_call_start_batch(grpc_call *call, const grpc_op *ops,
+                                      size_t nops, void *tag, void *reserved) {
   grpc_ioreq reqs[GRPC_IOREQ_OP_COUNT];
   size_t in;
   size_t out;
   const grpc_op *op;
   grpc_ioreq *req;
-  void (*finish_func) (grpc_exec_ctx *, grpc_call *, int, void *) = finish_batch;
+  void (*finish_func)(grpc_exec_ctx *, grpc_call *, int, void *) = finish_batch;
   grpc_call_error error;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
-  if (reserved != NULL)
-    {
-      error = GRPC_CALL_ERROR;
-      goto done;
-    }
+  if (reserved != NULL) {
+    error = GRPC_CALL_ERROR;
+    goto done;
+  }
 
-  GRPC_CALL_LOG_BATCH (GPR_INFO, call, ops, nops, tag);
+  GRPC_CALL_LOG_BATCH(GPR_INFO, call, ops, nops, tag);
 
-  if (nops == 0)
-    {
-      grpc_cq_begin_op (call->cq);
-      GRPC_CALL_INTERNAL_REF (call, "completion");
-      grpc_cq_end_op (&exec_ctx, call->cq, tag, 1, done_completion, call, allocate_completion (call));
-      error = GRPC_CALL_OK;
-      goto done;
-    }
+  if (nops == 0) {
+    grpc_cq_begin_op(call->cq);
+    GRPC_CALL_INTERNAL_REF(call, "completion");
+    grpc_cq_end_op(&exec_ctx, call->cq, tag, 1, done_completion, call,
+                   allocate_completion(call));
+    error = GRPC_CALL_OK;
+    goto done;
+  }
 
   /* rewrite batch ops into ioreq ops */
-  for (in = 0, out = 0; in < nops; in++)
-    {
-      op = &ops[in];
-      if (op->reserved != NULL)
-	{
-	  error = GRPC_CALL_ERROR;
-	  goto done;
-	}
-      switch (op->op)
-	{
-	case GRPC_OP_SEND_INITIAL_METADATA:
-	  /* Flag validation: currently allow no flags */
-	  if (op->flags != 0)
-	    {
-	      error = GRPC_CALL_ERROR_INVALID_FLAGS;
-	      goto done;
-	    }
-	  req = &reqs[out++];
-	  if (out > GRPC_IOREQ_OP_COUNT)
-	    {
-	      error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
-	      goto done;
-	    }
-	  req->op = GRPC_IOREQ_SEND_INITIAL_METADATA;
-	  req->data.send_metadata.count = op->data.send_initial_metadata.count;
-	  req->data.send_metadata.metadata = op->data.send_initial_metadata.metadata;
-	  req->flags = op->flags;
-	  break;
-	case GRPC_OP_SEND_MESSAGE:
-	  if (!are_write_flags_valid (op->flags))
-	    {
-	      error = GRPC_CALL_ERROR_INVALID_FLAGS;
-	      goto done;
-	    }
-	  if (op->data.send_message == NULL)
-	    {
-	      error = GRPC_CALL_ERROR_INVALID_MESSAGE;
-	      goto done;
-	    }
-	  req = &reqs[out++];
-	  if (out > GRPC_IOREQ_OP_COUNT)
-	    {
-	      error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
-	      goto done;
-	    }
-	  req->op = GRPC_IOREQ_SEND_MESSAGE;
-	  req->data.send_message = op->data.send_message;
-	  req->flags = op->flags;
-	  break;
-	case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
-	  /* Flag validation: currently allow no flags */
-	  if (op->flags != 0)
-	    {
-	      error = GRPC_CALL_ERROR_INVALID_FLAGS;
-	      goto done;
-	    }
-	  if (!call->is_client)
-	    {
-	      error = GRPC_CALL_ERROR_NOT_ON_SERVER;
-	      goto done;
-	    }
-	  req = &reqs[out++];
-	  if (out > GRPC_IOREQ_OP_COUNT)
-	    {
-	      error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
-	      goto done;
-	    }
-	  req->op = GRPC_IOREQ_SEND_CLOSE;
-	  req->flags = op->flags;
-	  break;
-	case GRPC_OP_SEND_STATUS_FROM_SERVER:
-	  /* Flag validation: currently allow no flags */
-	  if (op->flags != 0)
-	    {
-	      error = GRPC_CALL_ERROR_INVALID_FLAGS;
-	      goto done;
-	    }
-	  if (call->is_client)
-	    {
-	      error = GRPC_CALL_ERROR_NOT_ON_CLIENT;
-	      goto done;
-	    }
-	  req = &reqs[out++];
-	  if (out > GRPC_IOREQ_OP_COUNT)
-	    {
-	      error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
-	      goto done;
-	    }
-	  req->op = GRPC_IOREQ_SEND_TRAILING_METADATA;
-	  req->flags = op->flags;
-	  req->data.send_metadata.count = op->data.send_status_from_server.trailing_metadata_count;
-	  req->data.send_metadata.metadata = op->data.send_status_from_server.trailing_metadata;
-	  req = &reqs[out++];
-	  if (out > GRPC_IOREQ_OP_COUNT)
-	    {
-	      error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
-	      goto done;
-	    }
-	  req->op = GRPC_IOREQ_SEND_STATUS;
-	  req->data.send_status.code = op->data.send_status_from_server.status;
-	  req->data.send_status.details = op->data.send_status_from_server.status_details != NULL ? grpc_mdstr_from_string (call->metadata_context, op->data.send_status_from_server.status_details, 0) : NULL;
-	  req = &reqs[out++];
-	  if (out > GRPC_IOREQ_OP_COUNT)
-	    {
-	      error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
-	      goto done;
-	    }
-	  req->op = GRPC_IOREQ_SEND_CLOSE;
-	  break;
-	case GRPC_OP_RECV_INITIAL_METADATA:
-	  /* Flag validation: currently allow no flags */
-	  if (op->flags != 0)
-	    {
-	      error = GRPC_CALL_ERROR_INVALID_FLAGS;
-	      goto done;
-	    }
-	  if (!call->is_client)
-	    {
-	      error = GRPC_CALL_ERROR_NOT_ON_SERVER;
-	      goto done;
-	    }
-	  req = &reqs[out++];
-	  if (out > GRPC_IOREQ_OP_COUNT)
-	    {
-	      error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
-	      goto done;
-	    }
-	  req->op = GRPC_IOREQ_RECV_INITIAL_METADATA;
-	  req->data.recv_metadata = op->data.recv_initial_metadata;
-	  req->data.recv_metadata->count = 0;
-	  req->flags = op->flags;
-	  break;
-	case GRPC_OP_RECV_MESSAGE:
-	  /* Flag validation: currently allow no flags */
-	  if (op->flags != 0)
-	    {
-	      error = GRPC_CALL_ERROR_INVALID_FLAGS;
-	      goto done;
-	    }
-	  req = &reqs[out++];
-	  if (out > GRPC_IOREQ_OP_COUNT)
-	    {
-	      error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
-	      goto done;
-	    }
-	  req->op = GRPC_IOREQ_RECV_MESSAGE;
-	  req->data.recv_message = op->data.recv_message;
-	  req->flags = op->flags;
-	  break;
-	case GRPC_OP_RECV_STATUS_ON_CLIENT:
-	  /* Flag validation: currently allow no flags */
-	  if (op->flags != 0)
-	    {
-	      error = GRPC_CALL_ERROR_INVALID_FLAGS;
-	      goto done;
-	    }
-	  if (!call->is_client)
-	    {
-	      error = GRPC_CALL_ERROR_NOT_ON_SERVER;
-	      goto done;
-	    }
-	  req = &reqs[out++];
-	  if (out > GRPC_IOREQ_OP_COUNT)
-	    {
-	      error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
-	      goto done;
-	    }
-	  req->op = GRPC_IOREQ_RECV_STATUS;
-	  req->flags = op->flags;
-	  req->data.recv_status.set_value = set_status_value_directly;
-	  req->data.recv_status.user_data = op->data.recv_status_on_client.status;
-	  req = &reqs[out++];
-	  if (out > GRPC_IOREQ_OP_COUNT)
-	    {
-	      error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
-	      goto done;
-	    }
-	  req->op = GRPC_IOREQ_RECV_STATUS_DETAILS;
-	  req->data.recv_status_details.details = op->data.recv_status_on_client.status_details;
-	  req->data.recv_status_details.details_capacity = op->data.recv_status_on_client.status_details_capacity;
-	  req = &reqs[out++];
-	  if (out > GRPC_IOREQ_OP_COUNT)
-	    {
-	      error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
-	      goto done;
-	    }
-	  req->op = GRPC_IOREQ_RECV_TRAILING_METADATA;
-	  req->data.recv_metadata = op->data.recv_status_on_client.trailing_metadata;
-	  req->data.recv_metadata->count = 0;
-	  req = &reqs[out++];
-	  if (out > GRPC_IOREQ_OP_COUNT)
-	    {
-	      error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
-	      goto done;
-	    }
-	  req->op = GRPC_IOREQ_RECV_CLOSE;
-	  finish_func = finish_batch_with_close;
-	  break;
-	case GRPC_OP_RECV_CLOSE_ON_SERVER:
-	  /* Flag validation: currently allow no flags */
-	  if (op->flags != 0)
-	    {
-	      error = GRPC_CALL_ERROR_INVALID_FLAGS;
-	      goto done;
-	    }
-	  req = &reqs[out++];
-	  if (out > GRPC_IOREQ_OP_COUNT)
-	    {
-	      error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
-	      goto done;
-	    }
-	  req->op = GRPC_IOREQ_RECV_STATUS;
-	  req->flags = op->flags;
-	  req->data.recv_status.set_value = set_cancelled_value;
-	  req->data.recv_status.user_data = op->data.recv_close_on_server.cancelled;
-	  req = &reqs[out++];
-	  if (out > GRPC_IOREQ_OP_COUNT)
-	    {
-	      error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
-	      goto done;
-	    }
-	  req->op = GRPC_IOREQ_RECV_CLOSE;
-	  finish_func = finish_batch_with_close;
-	  break;
-	}
+  for (in = 0, out = 0; in < nops; in++) {
+    op = &ops[in];
+    if (op->reserved != NULL) {
+      error = GRPC_CALL_ERROR;
+      goto done;
     }
-
-  GRPC_CALL_INTERNAL_REF (call, "completion");
-  grpc_cq_begin_op (call->cq);
-
-  error = grpc_call_start_ioreq_and_call_back (&exec_ctx, call, reqs, out, finish_func, tag);
+    switch (op->op) {
+      case GRPC_OP_SEND_INITIAL_METADATA:
+        /* Flag validation: currently allow no flags */
+        if (op->flags != 0) {
+          error = GRPC_CALL_ERROR_INVALID_FLAGS;
+          goto done;
+        }
+        req = &reqs[out++];
+        if (out > GRPC_IOREQ_OP_COUNT) {
+          error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
+          goto done;
+        }
+        req->op = GRPC_IOREQ_SEND_INITIAL_METADATA;
+        req->data.send_metadata.count = op->data.send_initial_metadata.count;
+        req->data.send_metadata.metadata =
+            op->data.send_initial_metadata.metadata;
+        req->flags = op->flags;
+        break;
+      case GRPC_OP_SEND_MESSAGE:
+        if (!are_write_flags_valid(op->flags)) {
+          error = GRPC_CALL_ERROR_INVALID_FLAGS;
+          goto done;
+        }
+        if (op->data.send_message == NULL) {
+          error = GRPC_CALL_ERROR_INVALID_MESSAGE;
+          goto done;
+        }
+        req = &reqs[out++];
+        if (out > GRPC_IOREQ_OP_COUNT) {
+          error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
+          goto done;
+        }
+        req->op = GRPC_IOREQ_SEND_MESSAGE;
+        req->data.send_message = op->data.send_message;
+        req->flags = op->flags;
+        break;
+      case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
+        /* Flag validation: currently allow no flags */
+        if (op->flags != 0) {
+          error = GRPC_CALL_ERROR_INVALID_FLAGS;
+          goto done;
+        }
+        if (!call->is_client) {
+          error = GRPC_CALL_ERROR_NOT_ON_SERVER;
+          goto done;
+        }
+        req = &reqs[out++];
+        if (out > GRPC_IOREQ_OP_COUNT) {
+          error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
+          goto done;
+        }
+        req->op = GRPC_IOREQ_SEND_CLOSE;
+        req->flags = op->flags;
+        break;
+      case GRPC_OP_SEND_STATUS_FROM_SERVER:
+        /* Flag validation: currently allow no flags */
+        if (op->flags != 0) {
+          error = GRPC_CALL_ERROR_INVALID_FLAGS;
+          goto done;
+        }
+        if (call->is_client) {
+          error = GRPC_CALL_ERROR_NOT_ON_CLIENT;
+          goto done;
+        }
+        req = &reqs[out++];
+        if (out > GRPC_IOREQ_OP_COUNT) {
+          error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
+          goto done;
+        }
+        req->op = GRPC_IOREQ_SEND_TRAILING_METADATA;
+        req->flags = op->flags;
+        req->data.send_metadata.count =
+            op->data.send_status_from_server.trailing_metadata_count;
+        req->data.send_metadata.metadata =
+            op->data.send_status_from_server.trailing_metadata;
+        req = &reqs[out++];
+        if (out > GRPC_IOREQ_OP_COUNT) {
+          error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
+          goto done;
+        }
+        req->op = GRPC_IOREQ_SEND_STATUS;
+        req->data.send_status.code = op->data.send_status_from_server.status;
+        req->data.send_status.details =
+            op->data.send_status_from_server.status_details != NULL
+                ? grpc_mdstr_from_string(
+                      call->metadata_context,
+                      op->data.send_status_from_server.status_details, 0)
+                : NULL;
+        req = &reqs[out++];
+        if (out > GRPC_IOREQ_OP_COUNT) {
+          error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
+          goto done;
+        }
+        req->op = GRPC_IOREQ_SEND_CLOSE;
+        break;
+      case GRPC_OP_RECV_INITIAL_METADATA:
+        /* Flag validation: currently allow no flags */
+        if (op->flags != 0) {
+          error = GRPC_CALL_ERROR_INVALID_FLAGS;
+          goto done;
+        }
+        if (!call->is_client) {
+          error = GRPC_CALL_ERROR_NOT_ON_SERVER;
+          goto done;
+        }
+        req = &reqs[out++];
+        if (out > GRPC_IOREQ_OP_COUNT) {
+          error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
+          goto done;
+        }
+        req->op = GRPC_IOREQ_RECV_INITIAL_METADATA;
+        req->data.recv_metadata = op->data.recv_initial_metadata;
+        req->data.recv_metadata->count = 0;
+        req->flags = op->flags;
+        break;
+      case GRPC_OP_RECV_MESSAGE:
+        /* Flag validation: currently allow no flags */
+        if (op->flags != 0) {
+          error = GRPC_CALL_ERROR_INVALID_FLAGS;
+          goto done;
+        }
+        req = &reqs[out++];
+        if (out > GRPC_IOREQ_OP_COUNT) {
+          error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
+          goto done;
+        }
+        req->op = GRPC_IOREQ_RECV_MESSAGE;
+        req->data.recv_message = op->data.recv_message;
+        req->flags = op->flags;
+        break;
+      case GRPC_OP_RECV_STATUS_ON_CLIENT:
+        /* Flag validation: currently allow no flags */
+        if (op->flags != 0) {
+          error = GRPC_CALL_ERROR_INVALID_FLAGS;
+          goto done;
+        }
+        if (!call->is_client) {
+          error = GRPC_CALL_ERROR_NOT_ON_SERVER;
+          goto done;
+        }
+        req = &reqs[out++];
+        if (out > GRPC_IOREQ_OP_COUNT) {
+          error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
+          goto done;
+        }
+        req->op = GRPC_IOREQ_RECV_STATUS;
+        req->flags = op->flags;
+        req->data.recv_status.set_value = set_status_value_directly;
+        req->data.recv_status.user_data = op->data.recv_status_on_client.status;
+        req = &reqs[out++];
+        if (out > GRPC_IOREQ_OP_COUNT) {
+          error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
+          goto done;
+        }
+        req->op = GRPC_IOREQ_RECV_STATUS_DETAILS;
+        req->data.recv_status_details.details =
+            op->data.recv_status_on_client.status_details;
+        req->data.recv_status_details.details_capacity =
+            op->data.recv_status_on_client.status_details_capacity;
+        req = &reqs[out++];
+        if (out > GRPC_IOREQ_OP_COUNT) {
+          error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
+          goto done;
+        }
+        req->op = GRPC_IOREQ_RECV_TRAILING_METADATA;
+        req->data.recv_metadata =
+            op->data.recv_status_on_client.trailing_metadata;
+        req->data.recv_metadata->count = 0;
+        req = &reqs[out++];
+        if (out > GRPC_IOREQ_OP_COUNT) {
+          error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
+          goto done;
+        }
+        req->op = GRPC_IOREQ_RECV_CLOSE;
+        finish_func = finish_batch_with_close;
+        break;
+      case GRPC_OP_RECV_CLOSE_ON_SERVER:
+        /* Flag validation: currently allow no flags */
+        if (op->flags != 0) {
+          error = GRPC_CALL_ERROR_INVALID_FLAGS;
+          goto done;
+        }
+        req = &reqs[out++];
+        if (out > GRPC_IOREQ_OP_COUNT) {
+          error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
+          goto done;
+        }
+        req->op = GRPC_IOREQ_RECV_STATUS;
+        req->flags = op->flags;
+        req->data.recv_status.set_value = set_cancelled_value;
+        req->data.recv_status.user_data =
+            op->data.recv_close_on_server.cancelled;
+        req = &reqs[out++];
+        if (out > GRPC_IOREQ_OP_COUNT) {
+          error = GRPC_CALL_ERROR_BATCH_TOO_BIG;
+          goto done;
+        }
+        req->op = GRPC_IOREQ_RECV_CLOSE;
+        finish_func = finish_batch_with_close;
+        break;
+    }
+  }
+
+  GRPC_CALL_INTERNAL_REF(call, "completion");
+  grpc_cq_begin_op(call->cq);
+
+  error = grpc_call_start_ioreq_and_call_back(&exec_ctx, call, reqs, out,
+                                              finish_func, tag);
 done:
-  grpc_exec_ctx_finish (&exec_ctx);
+  grpc_exec_ctx_finish(&exec_ctx);
   return error;
 }
 
-void
-grpc_call_context_set (grpc_call * call, grpc_context_index elem, void *value, void (*destroy) (void *value))
-{
-  if (call->context[elem].destroy)
-    {
-      call->context[elem].destroy (call->context[elem].value);
-    }
+void grpc_call_context_set(grpc_call *call, grpc_context_index elem,
+                           void *value, void (*destroy)(void *value)) {
+  if (call->context[elem].destroy) {
+    call->context[elem].destroy(call->context[elem].value);
+  }
   call->context[elem].value = value;
   call->context[elem].destroy = destroy;
 }
 
-void *
-grpc_call_context_get (grpc_call * call, grpc_context_index elem)
-{
+void *grpc_call_context_get(grpc_call *call, grpc_context_index elem) {
   return call->context[elem].value;
 }
 
-gpr_uint8
-grpc_call_is_client (grpc_call * call)
-{
-  return call->is_client;
-}
+gpr_uint8 grpc_call_is_client(grpc_call *call) { return call->is_client; }
diff --git a/src/core/surface/call.h b/src/core/surface/call.h
index b1f3be8521..7ac0c92ab7 100644
--- a/src/core/surface/call.h
+++ b/src/core/surface/call.h
@@ -39,104 +39,120 @@
 #include <grpc/grpc.h>
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
 /* Primitive operation types - grpc_op's get rewritten into these */
-  typedef enum
-  {
-    GRPC_IOREQ_RECV_INITIAL_METADATA,
-    GRPC_IOREQ_RECV_MESSAGE,
-    GRPC_IOREQ_RECV_TRAILING_METADATA,
-    GRPC_IOREQ_RECV_STATUS,
-    GRPC_IOREQ_RECV_STATUS_DETAILS,
-    GRPC_IOREQ_RECV_CLOSE,
-    GRPC_IOREQ_SEND_INITIAL_METADATA,
-    GRPC_IOREQ_SEND_MESSAGE,
-    GRPC_IOREQ_SEND_TRAILING_METADATA,
-    GRPC_IOREQ_SEND_STATUS,
-    GRPC_IOREQ_SEND_CLOSE,
-    GRPC_IOREQ_OP_COUNT
-  } grpc_ioreq_op;
-
-  typedef union
-  {
-    grpc_metadata_array *recv_metadata;
-    grpc_byte_buffer **recv_message;
-    struct
-    {
-      void (*set_value) (grpc_status_code status, void *user_data);
-      void *user_data;
-    } recv_status;
-    struct
-    {
-      char **details;
-      size_t *details_capacity;
-    } recv_status_details;
-    struct
-    {
-      size_t count;
-      grpc_metadata *metadata;
-    } send_metadata;
-    grpc_byte_buffer *send_message;
-    struct
-    {
-      grpc_status_code code;
-      grpc_mdstr *details;
-    } send_status;
-  } grpc_ioreq_data;
-
-  typedef struct
-  {
-    grpc_ioreq_op op;
-    gpr_uint32 flags;
-		    /**< A copy of the write flags from grpc_op */
-    grpc_ioreq_data data;
-  } grpc_ioreq;
-
-  typedef void (*grpc_ioreq_completion_func) (grpc_exec_ctx * exec_ctx, grpc_call * call, int success, void *user_data);
-
-  grpc_call *grpc_call_create (grpc_channel * channel, grpc_call * parent_call, gpr_uint32 propagation_mask, grpc_completion_queue * cq, const void *server_transport_data, grpc_mdelem ** add_initial_metadata, size_t add_initial_metadata_count, gpr_timespec send_deadline);
-
-  void grpc_call_set_completion_queue (grpc_exec_ctx * exec_ctx, grpc_call * call, grpc_completion_queue * cq);
-  grpc_completion_queue *grpc_call_get_completion_queue (grpc_call * call);
+typedef enum {
+  GRPC_IOREQ_RECV_INITIAL_METADATA,
+  GRPC_IOREQ_RECV_MESSAGE,
+  GRPC_IOREQ_RECV_TRAILING_METADATA,
+  GRPC_IOREQ_RECV_STATUS,
+  GRPC_IOREQ_RECV_STATUS_DETAILS,
+  GRPC_IOREQ_RECV_CLOSE,
+  GRPC_IOREQ_SEND_INITIAL_METADATA,
+  GRPC_IOREQ_SEND_MESSAGE,
+  GRPC_IOREQ_SEND_TRAILING_METADATA,
+  GRPC_IOREQ_SEND_STATUS,
+  GRPC_IOREQ_SEND_CLOSE,
+  GRPC_IOREQ_OP_COUNT
+} grpc_ioreq_op;
+
+typedef union {
+  grpc_metadata_array *recv_metadata;
+  grpc_byte_buffer **recv_message;
+  struct {
+    void (*set_value)(grpc_status_code status, void *user_data);
+    void *user_data;
+  } recv_status;
+  struct {
+    char **details;
+    size_t *details_capacity;
+  } recv_status_details;
+  struct {
+    size_t count;
+    grpc_metadata *metadata;
+  } send_metadata;
+  grpc_byte_buffer *send_message;
+  struct {
+    grpc_status_code code;
+    grpc_mdstr *details;
+  } send_status;
+} grpc_ioreq_data;
+
+typedef struct {
+  grpc_ioreq_op op;
+  gpr_uint32 flags;
+  /**< A copy of the write flags from grpc_op */
+  grpc_ioreq_data data;
+} grpc_ioreq;
+
+typedef void (*grpc_ioreq_completion_func)(grpc_exec_ctx *exec_ctx,
+                                           grpc_call *call, int success,
+                                           void *user_data);
+
+grpc_call *grpc_call_create(grpc_channel *channel, grpc_call *parent_call,
+                            gpr_uint32 propagation_mask,
+                            grpc_completion_queue *cq,
+                            const void *server_transport_data,
+                            grpc_mdelem **add_initial_metadata,
+                            size_t add_initial_metadata_count,
+                            gpr_timespec send_deadline);
+
+void grpc_call_set_completion_queue(grpc_exec_ctx *exec_ctx, grpc_call *call,
+                                    grpc_completion_queue *cq);
+grpc_completion_queue *grpc_call_get_completion_queue(grpc_call *call);
 
 #ifdef GRPC_CALL_REF_COUNT_DEBUG
-  void grpc_call_internal_ref (grpc_call * call, const char *reason);
-  void grpc_call_internal_unref (grpc_exec_ctx * exec_ctx, grpc_call * call, const char *reason);
+void grpc_call_internal_ref(grpc_call *call, const char *reason);
+void grpc_call_internal_unref(grpc_exec_ctx *exec_ctx, grpc_call *call,
+                              const char *reason);
 #define GRPC_CALL_INTERNAL_REF(call, reason) \
   grpc_call_internal_ref(call, reason)
 #define GRPC_CALL_INTERNAL_UNREF(exec_ctx, call, reason) \
   grpc_call_internal_unref(exec_ctx, call, reason)
 #else
-  void grpc_call_internal_ref (grpc_call * call);
-  void grpc_call_internal_unref (grpc_exec_ctx * exec_ctx, grpc_call * call);
+void grpc_call_internal_ref(grpc_call *call);
+void grpc_call_internal_unref(grpc_exec_ctx *exec_ctx, grpc_call *call);
 #define GRPC_CALL_INTERNAL_REF(call, reason) grpc_call_internal_ref(call)
 #define GRPC_CALL_INTERNAL_UNREF(exec_ctx, call, reason) \
   grpc_call_internal_unref(exec_ctx, call)
 #endif
 
-  grpc_call_error grpc_call_start_ioreq_and_call_back (grpc_exec_ctx * exec_ctx, grpc_call * call, const grpc_ioreq * reqs, size_t nreqs, grpc_ioreq_completion_func on_complete, void *user_data);
+grpc_call_error grpc_call_start_ioreq_and_call_back(
+    grpc_exec_ctx *exec_ctx, grpc_call *call, const grpc_ioreq *reqs,
+    size_t nreqs, grpc_ioreq_completion_func on_complete, void *user_data);
 
-  grpc_call_stack *grpc_call_get_call_stack (grpc_call * call);
+grpc_call_stack *grpc_call_get_call_stack(grpc_call *call);
 
 /* Given the top call_element, get the call object. */
-  grpc_call *grpc_call_from_top_element (grpc_call_element * surface_element);
+grpc_call *grpc_call_from_top_element(grpc_call_element *surface_element);
 
-  extern int grpc_trace_batch;
+extern int grpc_trace_batch;
 
-  void grpc_call_log_batch (char *file, int line, gpr_log_severity severity, grpc_call * call, const grpc_op * ops, size_t nops, void *tag);
+void grpc_call_log_batch(char *file, int line, gpr_log_severity severity,
+                         grpc_call *call, const grpc_op *ops, size_t nops,
+                         void *tag);
 
-  void grpc_server_log_request_call (char *file, int line, gpr_log_severity severity, grpc_server * server, grpc_call ** call, grpc_call_details * details, grpc_metadata_array * initial_metadata, grpc_completion_queue * cq_bound_to_call, grpc_completion_queue * cq_for_notification, void *tag);
+void grpc_server_log_request_call(char *file, int line,
+                                  gpr_log_severity severity,
+                                  grpc_server *server, grpc_call **call,
+                                  grpc_call_details *details,
+                                  grpc_metadata_array *initial_metadata,
+                                  grpc_completion_queue *cq_bound_to_call,
+                                  grpc_completion_queue *cq_for_notification,
+                                  void *tag);
 
-  void grpc_server_log_shutdown (char *file, int line, gpr_log_severity severity, grpc_server * server, grpc_completion_queue * cq, void *tag);
+void grpc_server_log_shutdown(char *file, int line, gpr_log_severity severity,
+                              grpc_server *server, grpc_completion_queue *cq,
+                              void *tag);
 
 /* Set a context pointer.
    No thread safety guarantees are made wrt this value. */
-  void grpc_call_context_set (grpc_call * call, grpc_context_index elem, void *value, void (*destroy) (void *value));
+void grpc_call_context_set(grpc_call *call, grpc_context_index elem,
+                           void *value, void (*destroy)(void *value));
 /* Get a context pointer. */
-  void *grpc_call_context_get (grpc_call * call, grpc_context_index elem);
+void *grpc_call_context_get(grpc_call *call, grpc_context_index elem);
 
 #define GRPC_CALL_LOG_BATCH(sev, call, ops, nops, tag) \
   if (grpc_trace_batch) grpc_call_log_batch(sev, call, ops, nops, tag)
@@ -151,20 +167,21 @@ extern "C"
 #define GRPC_SERVER_LOG_SHUTDOWN(sev, server, cq, tag) \
   if (grpc_trace_batch) grpc_server_log_shutdown(sev, server, cq, tag)
 
-  gpr_uint8 grpc_call_is_client (grpc_call * call);
+gpr_uint8 grpc_call_is_client(grpc_call *call);
 
-  grpc_compression_algorithm grpc_call_get_compression_algorithm (const grpc_call * call);
+grpc_compression_algorithm grpc_call_get_compression_algorithm(
+    const grpc_call *call);
 
-  gpr_uint32 grpc_call_get_message_flags (const grpc_call * call);
+gpr_uint32 grpc_call_get_message_flags(const grpc_call *call);
 
 /** Returns a bitset for the encodings (compression algorithms) supported by \a
  * call's peer.
  *
  * To be indexed by grpc_compression_algorithm enum values. */
-  gpr_uint32 grpc_call_get_encodings_accepted_by_peer (grpc_call * call);
+gpr_uint32 grpc_call_get_encodings_accepted_by_peer(grpc_call *call);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif				/* GRPC_INTERNAL_CORE_SURFACE_CALL_H */
+#endif /* GRPC_INTERNAL_CORE_SURFACE_CALL_H */
diff --git a/src/core/surface/call_details.c b/src/core/surface/call_details.c
index ac9ba7ebe2..65d2d1da5b 100644
--- a/src/core/surface/call_details.c
+++ b/src/core/surface/call_details.c
@@ -36,15 +36,11 @@
 
 #include <string.h>
 
-void
-grpc_call_details_init (grpc_call_details * cd)
-{
-  memset (cd, 0, sizeof (*cd));
+void grpc_call_details_init(grpc_call_details* cd) {
+  memset(cd, 0, sizeof(*cd));
 }
 
-void
-grpc_call_details_destroy (grpc_call_details * cd)
-{
-  gpr_free (cd->method);
-  gpr_free (cd->host);
+void grpc_call_details_destroy(grpc_call_details* cd) {
+  gpr_free(cd->method);
+  gpr_free(cd->host);
 }
diff --git a/src/core/surface/call_log_batch.c b/src/core/surface/call_log_batch.c
index 3b0f922cda..5a3ef1e5f4 100644
--- a/src/core/surface/call_log_batch.c
+++ b/src/core/surface/call_log_batch.c
@@ -39,91 +39,109 @@
 
 int grpc_trace_batch = 0;
 
-static void
-add_metadata (gpr_strvec * b, const grpc_metadata * md, size_t count)
-{
+static void add_metadata(gpr_strvec *b, const grpc_metadata *md, size_t count) {
   size_t i;
-  for (i = 0; i < count; i++)
-    {
-      gpr_strvec_add (b, gpr_strdup ("\nkey="));
-      gpr_strvec_add (b, gpr_strdup (md[i].key));
+  for (i = 0; i < count; i++) {
+    gpr_strvec_add(b, gpr_strdup("\nkey="));
+    gpr_strvec_add(b, gpr_strdup(md[i].key));
 
-      gpr_strvec_add (b, gpr_strdup (" value="));
-      gpr_strvec_add (b, gpr_dump (md[i].value, md[i].value_length, GPR_DUMP_HEX | GPR_DUMP_ASCII));
-    }
+    gpr_strvec_add(b, gpr_strdup(" value="));
+    gpr_strvec_add(b, gpr_dump(md[i].value, md[i].value_length,
+                               GPR_DUMP_HEX | GPR_DUMP_ASCII));
+  }
 }
 
-char *
-grpc_op_string (const grpc_op * op)
-{
+char *grpc_op_string(const grpc_op *op) {
   char *tmp;
   char *out;
 
   gpr_strvec b;
-  gpr_strvec_init (&b);
+  gpr_strvec_init(&b);
 
-  switch (op->op)
-    {
+  switch (op->op) {
     case GRPC_OP_SEND_INITIAL_METADATA:
-      gpr_strvec_add (&b, gpr_strdup ("SEND_INITIAL_METADATA"));
-      add_metadata (&b, op->data.send_initial_metadata.metadata, op->data.send_initial_metadata.count);
+      gpr_strvec_add(&b, gpr_strdup("SEND_INITIAL_METADATA"));
+      add_metadata(&b, op->data.send_initial_metadata.metadata,
+                   op->data.send_initial_metadata.count);
       break;
     case GRPC_OP_SEND_MESSAGE:
-      gpr_asprintf (&tmp, "SEND_MESSAGE ptr=%p", op->data.send_message);
-      gpr_strvec_add (&b, tmp);
+      gpr_asprintf(&tmp, "SEND_MESSAGE ptr=%p", op->data.send_message);
+      gpr_strvec_add(&b, tmp);
       break;
     case GRPC_OP_SEND_CLOSE_FROM_CLIENT:
-      gpr_strvec_add (&b, gpr_strdup ("SEND_CLOSE_FROM_CLIENT"));
+      gpr_strvec_add(&b, gpr_strdup("SEND_CLOSE_FROM_CLIENT"));
       break;
     case GRPC_OP_SEND_STATUS_FROM_SERVER:
-      gpr_asprintf (&tmp, "SEND_STATUS_FROM_SERVER status=%d details=%s", op->data.send_status_from_server.status, op->data.send_status_from_server.status_details);
-      gpr_strvec_add (&b, tmp);
-      add_metadata (&b, op->data.send_status_from_server.trailing_metadata, op->data.send_status_from_server.trailing_metadata_count);
+      gpr_asprintf(&tmp, "SEND_STATUS_FROM_SERVER status=%d details=%s",
+                   op->data.send_status_from_server.status,
+                   op->data.send_status_from_server.status_details);
+      gpr_strvec_add(&b, tmp);
+      add_metadata(&b, op->data.send_status_from_server.trailing_metadata,
+                   op->data.send_status_from_server.trailing_metadata_count);
       break;
     case GRPC_OP_RECV_INITIAL_METADATA:
-      gpr_asprintf (&tmp, "RECV_INITIAL_METADATA ptr=%p", op->data.recv_initial_metadata);
-      gpr_strvec_add (&b, tmp);
+      gpr_asprintf(&tmp, "RECV_INITIAL_METADATA ptr=%p",
+                   op->data.recv_initial_metadata);
+      gpr_strvec_add(&b, tmp);
       break;
     case GRPC_OP_RECV_MESSAGE:
-      gpr_asprintf (&tmp, "RECV_MESSAGE ptr=%p", op->data.recv_message);
-      gpr_strvec_add (&b, tmp);
+      gpr_asprintf(&tmp, "RECV_MESSAGE ptr=%p", op->data.recv_message);
+      gpr_strvec_add(&b, tmp);
       break;
     case GRPC_OP_RECV_STATUS_ON_CLIENT:
-      gpr_asprintf (&tmp, "RECV_STATUS_ON_CLIENT metadata=%p status=%p details=%p", op->data.recv_status_on_client.trailing_metadata, op->data.recv_status_on_client.status, op->data.recv_status_on_client.status_details);
-      gpr_strvec_add (&b, tmp);
+      gpr_asprintf(&tmp,
+                   "RECV_STATUS_ON_CLIENT metadata=%p status=%p details=%p",
+                   op->data.recv_status_on_client.trailing_metadata,
+                   op->data.recv_status_on_client.status,
+                   op->data.recv_status_on_client.status_details);
+      gpr_strvec_add(&b, tmp);
       break;
     case GRPC_OP_RECV_CLOSE_ON_SERVER:
-      gpr_asprintf (&tmp, "RECV_CLOSE_ON_SERVER cancelled=%p", op->data.recv_close_on_server.cancelled);
-      gpr_strvec_add (&b, tmp);
-    }
-  out = gpr_strvec_flatten (&b, NULL);
-  gpr_strvec_destroy (&b);
+      gpr_asprintf(&tmp, "RECV_CLOSE_ON_SERVER cancelled=%p",
+                   op->data.recv_close_on_server.cancelled);
+      gpr_strvec_add(&b, tmp);
+  }
+  out = gpr_strvec_flatten(&b, NULL);
+  gpr_strvec_destroy(&b);
 
   return out;
 }
 
-void
-grpc_call_log_batch (char *file, int line, gpr_log_severity severity, grpc_call * call, const grpc_op * ops, size_t nops, void *tag)
-{
+void grpc_call_log_batch(char *file, int line, gpr_log_severity severity,
+                         grpc_call *call, const grpc_op *ops, size_t nops,
+                         void *tag) {
   char *tmp;
   size_t i;
-  gpr_log (file, line, severity, "grpc_call_start_batch(call=%p, ops=%p, nops=%d, tag=%p)", call, ops, nops, tag);
-  for (i = 0; i < nops; i++)
-    {
-      tmp = grpc_op_string (&ops[i]);
-      gpr_log (file, line, severity, "ops[%d]: %s", i, tmp);
-      gpr_free (tmp);
-    }
+  gpr_log(file, line, severity,
+          "grpc_call_start_batch(call=%p, ops=%p, nops=%d, tag=%p)", call, ops,
+          nops, tag);
+  for (i = 0; i < nops; i++) {
+    tmp = grpc_op_string(&ops[i]);
+    gpr_log(file, line, severity, "ops[%d]: %s", i, tmp);
+    gpr_free(tmp);
+  }
 }
 
-void
-grpc_server_log_request_call (char *file, int line, gpr_log_severity severity, grpc_server * server, grpc_call ** call, grpc_call_details * details, grpc_metadata_array * initial_metadata, grpc_completion_queue * cq_bound_to_call, grpc_completion_queue * cq_for_notification, void *tag)
-{
-  gpr_log (file, line, severity, "grpc_server_request_call(server=%p, call=%p, details=%p, " "initial_metadata=%p, cq_bound_to_call=%p, cq_for_notification=%p, " "tag=%p)", server, call, details, initial_metadata, cq_bound_to_call, cq_for_notification, tag);
+void grpc_server_log_request_call(char *file, int line,
+                                  gpr_log_severity severity,
+                                  grpc_server *server, grpc_call **call,
+                                  grpc_call_details *details,
+                                  grpc_metadata_array *initial_metadata,
+                                  grpc_completion_queue *cq_bound_to_call,
+                                  grpc_completion_queue *cq_for_notification,
+                                  void *tag) {
+  gpr_log(file, line, severity,
+          "grpc_server_request_call(server=%p, call=%p, details=%p, "
+          "initial_metadata=%p, cq_bound_to_call=%p, cq_for_notification=%p, "
+          "tag=%p)",
+          server, call, details, initial_metadata, cq_bound_to_call,
+          cq_for_notification, tag);
 }
 
-void
-grpc_server_log_shutdown (char *file, int line, gpr_log_severity severity, grpc_server * server, grpc_completion_queue * cq, void *tag)
-{
-  gpr_log (file, line, severity, "grpc_server_shutdown_and_notify(server=%p, cq=%p, tag=%p)", server, cq, tag);
+void grpc_server_log_shutdown(char *file, int line, gpr_log_severity severity,
+                              grpc_server *server, grpc_completion_queue *cq,
+                              void *tag) {
+  gpr_log(file, line, severity,
+          "grpc_server_shutdown_and_notify(server=%p, cq=%p, tag=%p)", server,
+          cq, tag);
 }
diff --git a/src/core/surface/channel.c b/src/core/surface/channel.c
index a5816c3fb3..08d003daca 100644
--- a/src/core/surface/channel.c
+++ b/src/core/surface/channel.c
@@ -53,15 +53,13 @@
  *  (OK, Cancelled, Unknown). */
 #define NUM_CACHED_STATUS_ELEMS 3
 
-typedef struct registered_call
-{
+typedef struct registered_call {
   grpc_mdelem *path;
   grpc_mdelem *authority;
   struct registered_call *next;
 } registered_call;
 
-struct grpc_channel
-{
+struct grpc_channel {
   int is_client;
   gpr_refcount refs;
   gpr_uint32 max_message_length;
@@ -91,297 +89,283 @@ struct grpc_channel
 /* the protobuf library will (by default) start warning at 100megs */
 #define DEFAULT_MAX_MESSAGE_LENGTH (100 * 1024 * 1024)
 
-grpc_channel *
-grpc_channel_create_from_filters (grpc_exec_ctx * exec_ctx, const char *target, const grpc_channel_filter ** filters, size_t num_filters, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_client)
-{
+grpc_channel *grpc_channel_create_from_filters(
+    grpc_exec_ctx *exec_ctx, const char *target,
+    const grpc_channel_filter **filters, size_t num_filters,
+    const grpc_channel_args *args, grpc_mdctx *mdctx, int is_client) {
   size_t i;
-  size_t size = sizeof (grpc_channel) + grpc_channel_stack_size (filters, num_filters);
-  grpc_channel *channel = gpr_malloc (size);
-  memset (channel, 0, sizeof (*channel));
-  channel->target = gpr_strdup (target);
-  GPR_ASSERT (grpc_is_initialized () && "call grpc_init()");
+  size_t size =
+      sizeof(grpc_channel) + grpc_channel_stack_size(filters, num_filters);
+  grpc_channel *channel = gpr_malloc(size);
+  memset(channel, 0, sizeof(*channel));
+  channel->target = gpr_strdup(target);
+  GPR_ASSERT(grpc_is_initialized() && "call grpc_init()");
   channel->is_client = is_client;
   /* decremented by grpc_channel_destroy */
-  gpr_ref_init (&channel->refs, 1);
+  gpr_ref_init(&channel->refs, 1);
   channel->metadata_context = mdctx;
-  channel->grpc_status_string = grpc_mdstr_from_string (mdctx, "grpc-status", 0);
-  channel->grpc_compression_algorithm_string = grpc_mdstr_from_string (mdctx, "grpc-encoding", 0);
-  channel->grpc_encodings_accepted_by_peer_string = grpc_mdstr_from_string (mdctx, "grpc-accept-encoding", 0);
-  channel->grpc_message_string = grpc_mdstr_from_string (mdctx, "grpc-message", 0);
-  for (i = 0; i < NUM_CACHED_STATUS_ELEMS; i++)
-    {
-      char buf[GPR_LTOA_MIN_BUFSIZE];
-      gpr_ltoa ((long) i, buf);
-      channel->grpc_status_elem[i] = grpc_mdelem_from_metadata_strings (mdctx, GRPC_MDSTR_REF (channel->grpc_status_string), grpc_mdstr_from_string (mdctx, buf, 0));
-    }
-  channel->path_string = grpc_mdstr_from_string (mdctx, ":path", 0);
-  channel->authority_string = grpc_mdstr_from_string (mdctx, ":authority", 0);
-  gpr_mu_init (&channel->registered_call_mu);
+  channel->grpc_status_string = grpc_mdstr_from_string(mdctx, "grpc-status", 0);
+  channel->grpc_compression_algorithm_string =
+      grpc_mdstr_from_string(mdctx, "grpc-encoding", 0);
+  channel->grpc_encodings_accepted_by_peer_string =
+      grpc_mdstr_from_string(mdctx, "grpc-accept-encoding", 0);
+  channel->grpc_message_string =
+      grpc_mdstr_from_string(mdctx, "grpc-message", 0);
+  for (i = 0; i < NUM_CACHED_STATUS_ELEMS; i++) {
+    char buf[GPR_LTOA_MIN_BUFSIZE];
+    gpr_ltoa((long)i, buf);
+    channel->grpc_status_elem[i] = grpc_mdelem_from_metadata_strings(
+        mdctx, GRPC_MDSTR_REF(channel->grpc_status_string),
+        grpc_mdstr_from_string(mdctx, buf, 0));
+  }
+  channel->path_string = grpc_mdstr_from_string(mdctx, ":path", 0);
+  channel->authority_string = grpc_mdstr_from_string(mdctx, ":authority", 0);
+  gpr_mu_init(&channel->registered_call_mu);
   channel->registered_calls = NULL;
 
   channel->max_message_length = DEFAULT_MAX_MESSAGE_LENGTH;
-  if (args)
-    {
-      for (i = 0; i < args->num_args; i++)
-	{
-	  if (0 == strcmp (args->args[i].key, GRPC_ARG_MAX_MESSAGE_LENGTH))
-	    {
-	      if (args->args[i].type != GRPC_ARG_INTEGER)
-		{
-		  gpr_log (GPR_ERROR, "%s ignored: it must be an integer", GRPC_ARG_MAX_MESSAGE_LENGTH);
-		}
-	      else if (args->args[i].value.integer < 0)
-		{
-		  gpr_log (GPR_ERROR, "%s ignored: it must be >= 0", GRPC_ARG_MAX_MESSAGE_LENGTH);
-		}
-	      else
-		{
-		  channel->max_message_length = (gpr_uint32) args->args[i].value.integer;
-		}
-	    }
-	  else if (0 == strcmp (args->args[i].key, GRPC_ARG_DEFAULT_AUTHORITY))
-	    {
-	      if (args->args[i].type != GRPC_ARG_STRING)
-		{
-		  gpr_log (GPR_ERROR, "%s: must be an string", GRPC_ARG_DEFAULT_AUTHORITY);
-		}
-	      else
-		{
-		  if (channel->default_authority)
-		    {
-		      /* setting this takes precedence over anything else */
-		      GRPC_MDELEM_UNREF (channel->default_authority);
-		    }
-		  channel->default_authority = grpc_mdelem_from_strings (mdctx, ":authority", args->args[i].value.string);
-		}
-	    }
-	  else if (0 == strcmp (args->args[i].key, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG))
-	    {
-	      if (args->args[i].type != GRPC_ARG_STRING)
-		{
-		  gpr_log (GPR_ERROR, "%s: must be an string", GRPC_SSL_TARGET_NAME_OVERRIDE_ARG);
-		}
-	      else
-		{
-		  if (channel->default_authority)
-		    {
-		      /* other ways of setting this (notably ssl) take precedence */
-		      gpr_log (GPR_ERROR, "%s: default host already set some other way", GRPC_ARG_DEFAULT_AUTHORITY);
-		    }
-		  else
-		    {
-		      channel->default_authority = grpc_mdelem_from_strings (mdctx, ":authority", args->args[i].value.string);
-		    }
-		}
-	    }
-	}
+  if (args) {
+    for (i = 0; i < args->num_args; i++) {
+      if (0 == strcmp(args->args[i].key, GRPC_ARG_MAX_MESSAGE_LENGTH)) {
+        if (args->args[i].type != GRPC_ARG_INTEGER) {
+          gpr_log(GPR_ERROR, "%s ignored: it must be an integer",
+                  GRPC_ARG_MAX_MESSAGE_LENGTH);
+        } else if (args->args[i].value.integer < 0) {
+          gpr_log(GPR_ERROR, "%s ignored: it must be >= 0",
+                  GRPC_ARG_MAX_MESSAGE_LENGTH);
+        } else {
+          channel->max_message_length = (gpr_uint32)args->args[i].value.integer;
+        }
+      } else if (0 == strcmp(args->args[i].key, GRPC_ARG_DEFAULT_AUTHORITY)) {
+        if (args->args[i].type != GRPC_ARG_STRING) {
+          gpr_log(GPR_ERROR, "%s: must be an string",
+                  GRPC_ARG_DEFAULT_AUTHORITY);
+        } else {
+          if (channel->default_authority) {
+            /* setting this takes precedence over anything else */
+            GRPC_MDELEM_UNREF(channel->default_authority);
+          }
+          channel->default_authority = grpc_mdelem_from_strings(
+              mdctx, ":authority", args->args[i].value.string);
+        }
+      } else if (0 ==
+                 strcmp(args->args[i].key, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG)) {
+        if (args->args[i].type != GRPC_ARG_STRING) {
+          gpr_log(GPR_ERROR, "%s: must be an string",
+                  GRPC_SSL_TARGET_NAME_OVERRIDE_ARG);
+        } else {
+          if (channel->default_authority) {
+            /* other ways of setting this (notably ssl) take precedence */
+            gpr_log(GPR_ERROR, "%s: default host already set some other way",
+                    GRPC_ARG_DEFAULT_AUTHORITY);
+          } else {
+            channel->default_authority = grpc_mdelem_from_strings(
+                mdctx, ":authority", args->args[i].value.string);
+          }
+        }
+      }
     }
-
-  if (channel->is_client && channel->default_authority == NULL && target != NULL)
-    {
-      char *default_authority = grpc_get_default_authority (target);
-      if (default_authority)
-	{
-	  channel->default_authority = grpc_mdelem_from_strings (channel->metadata_context, ":authority", default_authority);
-	}
-      gpr_free (default_authority);
+  }
+
+  if (channel->is_client && channel->default_authority == NULL &&
+      target != NULL) {
+    char *default_authority = grpc_get_default_authority(target);
+    if (default_authority) {
+      channel->default_authority = grpc_mdelem_from_strings(
+          channel->metadata_context, ":authority", default_authority);
     }
+    gpr_free(default_authority);
+  }
 
-  grpc_channel_stack_init (exec_ctx, filters, num_filters, channel, args, channel->metadata_context, CHANNEL_STACK_FROM_CHANNEL (channel));
+  grpc_channel_stack_init(exec_ctx, filters, num_filters, channel, args,
+                          channel->metadata_context,
+                          CHANNEL_STACK_FROM_CHANNEL(channel));
 
   return channel;
 }
 
-char *
-grpc_channel_get_target (grpc_channel * channel)
-{
-  return gpr_strdup (channel->target);
+char *grpc_channel_get_target(grpc_channel *channel) {
+  return gpr_strdup(channel->target);
 }
 
-static grpc_call *
-grpc_channel_create_call_internal (grpc_channel * channel, grpc_call * parent_call, gpr_uint32 propagation_mask, grpc_completion_queue * cq, grpc_mdelem * path_mdelem, grpc_mdelem * authority_mdelem, gpr_timespec deadline)
-{
+static grpc_call *grpc_channel_create_call_internal(
+    grpc_channel *channel, grpc_call *parent_call, gpr_uint32 propagation_mask,
+    grpc_completion_queue *cq, grpc_mdelem *path_mdelem,
+    grpc_mdelem *authority_mdelem, gpr_timespec deadline) {
   grpc_mdelem *send_metadata[2];
   size_t num_metadata = 0;
 
-  GPR_ASSERT (channel->is_client);
+  GPR_ASSERT(channel->is_client);
 
   send_metadata[num_metadata++] = path_mdelem;
-  if (authority_mdelem != NULL)
-    {
-      send_metadata[num_metadata++] = authority_mdelem;
-    }
-  else if (channel->default_authority != NULL)
-    {
-      send_metadata[num_metadata++] = GRPC_MDELEM_REF (channel->default_authority);
-    }
-
-  return grpc_call_create (channel, parent_call, propagation_mask, cq, NULL, send_metadata, num_metadata, deadline);
+  if (authority_mdelem != NULL) {
+    send_metadata[num_metadata++] = authority_mdelem;
+  } else if (channel->default_authority != NULL) {
+    send_metadata[num_metadata++] = GRPC_MDELEM_REF(channel->default_authority);
+  }
+
+  return grpc_call_create(channel, parent_call, propagation_mask, cq, NULL,
+                          send_metadata, num_metadata, deadline);
 }
 
-grpc_call *
-grpc_channel_create_call (grpc_channel * channel, grpc_call * parent_call, gpr_uint32 propagation_mask, grpc_completion_queue * cq, const char *method, const char *host, gpr_timespec deadline, void *reserved)
-{
-  GPR_ASSERT (!reserved);
-  return grpc_channel_create_call_internal (channel, parent_call, propagation_mask, cq, grpc_mdelem_from_metadata_strings (channel->metadata_context, GRPC_MDSTR_REF (channel->path_string), grpc_mdstr_from_string (channel->metadata_context, method, 0)), host ? grpc_mdelem_from_metadata_strings (channel->metadata_context, GRPC_MDSTR_REF (channel->authority_string), grpc_mdstr_from_string (channel->metadata_context, host, 0)) : NULL, deadline);
+grpc_call *grpc_channel_create_call(grpc_channel *channel,
+                                    grpc_call *parent_call,
+                                    gpr_uint32 propagation_mask,
+                                    grpc_completion_queue *cq,
+                                    const char *method, const char *host,
+                                    gpr_timespec deadline, void *reserved) {
+  GPR_ASSERT(!reserved);
+  return grpc_channel_create_call_internal(
+      channel, parent_call, propagation_mask, cq,
+      grpc_mdelem_from_metadata_strings(
+          channel->metadata_context, GRPC_MDSTR_REF(channel->path_string),
+          grpc_mdstr_from_string(channel->metadata_context, method, 0)),
+      host ? grpc_mdelem_from_metadata_strings(
+                 channel->metadata_context,
+                 GRPC_MDSTR_REF(channel->authority_string),
+                 grpc_mdstr_from_string(channel->metadata_context, host, 0))
+           : NULL,
+      deadline);
 }
 
-void *
-grpc_channel_register_call (grpc_channel * channel, const char *method, const char *host, void *reserved)
-{
-  registered_call *rc = gpr_malloc (sizeof (registered_call));
-  GPR_ASSERT (!reserved);
-  rc->path = grpc_mdelem_from_metadata_strings (channel->metadata_context, GRPC_MDSTR_REF (channel->path_string), grpc_mdstr_from_string (channel->metadata_context, method, 0));
-  rc->authority = host ? grpc_mdelem_from_metadata_strings (channel->metadata_context, GRPC_MDSTR_REF (channel->authority_string), grpc_mdstr_from_string (channel->metadata_context, host, 0)) : NULL;
-  gpr_mu_lock (&channel->registered_call_mu);
+void *grpc_channel_register_call(grpc_channel *channel, const char *method,
+                                 const char *host, void *reserved) {
+  registered_call *rc = gpr_malloc(sizeof(registered_call));
+  GPR_ASSERT(!reserved);
+  rc->path = grpc_mdelem_from_metadata_strings(
+      channel->metadata_context, GRPC_MDSTR_REF(channel->path_string),
+      grpc_mdstr_from_string(channel->metadata_context, method, 0));
+  rc->authority =
+      host ? grpc_mdelem_from_metadata_strings(
+                 channel->metadata_context,
+                 GRPC_MDSTR_REF(channel->authority_string),
+                 grpc_mdstr_from_string(channel->metadata_context, host, 0))
+           : NULL;
+  gpr_mu_lock(&channel->registered_call_mu);
   rc->next = channel->registered_calls;
   channel->registered_calls = rc;
-  gpr_mu_unlock (&channel->registered_call_mu);
+  gpr_mu_unlock(&channel->registered_call_mu);
   return rc;
 }
 
-grpc_call *
-grpc_channel_create_registered_call (grpc_channel * channel, grpc_call * parent_call, gpr_uint32 propagation_mask, grpc_completion_queue * completion_queue, void *registered_call_handle, gpr_timespec deadline, void *reserved)
-{
+grpc_call *grpc_channel_create_registered_call(
+    grpc_channel *channel, grpc_call *parent_call, gpr_uint32 propagation_mask,
+    grpc_completion_queue *completion_queue, void *registered_call_handle,
+    gpr_timespec deadline, void *reserved) {
   registered_call *rc = registered_call_handle;
-  GPR_ASSERT (!reserved);
-  return grpc_channel_create_call_internal (channel, parent_call, propagation_mask, completion_queue, GRPC_MDELEM_REF (rc->path), rc->authority ? GRPC_MDELEM_REF (rc->authority) : NULL, deadline);
+  GPR_ASSERT(!reserved);
+  return grpc_channel_create_call_internal(
+      channel, parent_call, propagation_mask, completion_queue,
+      GRPC_MDELEM_REF(rc->path),
+      rc->authority ? GRPC_MDELEM_REF(rc->authority) : NULL, deadline);
 }
 
 #ifdef GRPC_CHANNEL_REF_COUNT_DEBUG
-void
-grpc_channel_internal_ref (grpc_channel * c, const char *reason)
-{
-  gpr_log (GPR_DEBUG, "CHANNEL:   ref %p %d -> %d [%s]", c, c->refs.count, c->refs.count + 1, reason);
+void grpc_channel_internal_ref(grpc_channel *c, const char *reason) {
+  gpr_log(GPR_DEBUG, "CHANNEL:   ref %p %d -> %d [%s]", c, c->refs.count,
+          c->refs.count + 1, reason);
 #else
-void
-grpc_channel_internal_ref (grpc_channel * c)
-{
+void grpc_channel_internal_ref(grpc_channel *c) {
 #endif
-  gpr_ref (&c->refs);
+  gpr_ref(&c->refs);
 }
 
-static void
-destroy_channel (grpc_exec_ctx * exec_ctx, grpc_channel * channel)
-{
+static void destroy_channel(grpc_exec_ctx *exec_ctx, grpc_channel *channel) {
   size_t i;
-  grpc_channel_stack_destroy (exec_ctx,CHANNEL_STACK_FROM_CHANNEL ( channel));
-  for (i = 0; i < NUM_CACHED_STATUS_ELEMS; i++)
-    {
-      GRPC_MDELEM_UNREF (channel->grpc_status_elem[i]);
+  grpc_channel_stack_destroy(exec_ctx, CHANNEL_STACK_FROM_CHANNEL(channel));
+  for (i = 0; i < NUM_CACHED_STATUS_ELEMS; i++) {
+    GRPC_MDELEM_UNREF(channel->grpc_status_elem[i]);
+  }
+  GRPC_MDSTR_UNREF(channel->grpc_status_string);
+  GRPC_MDSTR_UNREF(channel->grpc_compression_algorithm_string);
+  GRPC_MDSTR_UNREF(channel->grpc_encodings_accepted_by_peer_string);
+  GRPC_MDSTR_UNREF(channel->grpc_message_string);
+  GRPC_MDSTR_UNREF(channel->path_string);
+  GRPC_MDSTR_UNREF(channel->authority_string);
+  while (channel->registered_calls) {
+    registered_call *rc = channel->registered_calls;
+    channel->registered_calls = rc->next;
+    GRPC_MDELEM_UNREF(rc->path);
+    if (rc->authority) {
+      GRPC_MDELEM_UNREF(rc->authority);
     }
-  GRPC_MDSTR_UNREF (channel->grpc_status_string);
-  GRPC_MDSTR_UNREF (channel->grpc_compression_algorithm_string);
-  GRPC_MDSTR_UNREF (channel->grpc_encodings_accepted_by_peer_string);
-  GRPC_MDSTR_UNREF (channel->grpc_message_string);
-  GRPC_MDSTR_UNREF (channel->path_string);
-  GRPC_MDSTR_UNREF (channel->authority_string);
-  while (channel->registered_calls)
-    {
-      registered_call *rc = channel->registered_calls;
-      channel->registered_calls = rc->next;
-      GRPC_MDELEM_UNREF (rc->path);
-      if (rc->authority)
-	{
-	  GRPC_MDELEM_UNREF (rc->authority);
-	}
-      gpr_free (rc);
-    }
-  if (channel->default_authority != NULL)
-    {
-      GRPC_MDELEM_UNREF (channel->default_authority);
-    }
-  grpc_mdctx_unref (channel->metadata_context);
-  gpr_mu_destroy (&channel->registered_call_mu);
-  gpr_free (channel->target);
-  gpr_free (channel);
+    gpr_free(rc);
+  }
+  if (channel->default_authority != NULL) {
+    GRPC_MDELEM_UNREF(channel->default_authority);
+  }
+  grpc_mdctx_unref(channel->metadata_context);
+  gpr_mu_destroy(&channel->registered_call_mu);
+  gpr_free(channel->target);
+  gpr_free(channel);
 }
 
 #ifdef GRPC_CHANNEL_REF_COUNT_DEBUG
-void
-grpc_channel_internal_unref (grpc_exec_ctx * exec_ctx, grpc_channel * channel, const char *reason)
-{
-  gpr_log (GPR_DEBUG, "CHANNEL: unref %p %d -> %d [%s]", channel, channel->refs.count, channel->refs.count - 1, reason);
+void grpc_channel_internal_unref(grpc_exec_ctx *exec_ctx, grpc_channel *channel,
+                                 const char *reason) {
+  gpr_log(GPR_DEBUG, "CHANNEL: unref %p %d -> %d [%s]", channel,
+          channel->refs.count, channel->refs.count - 1, reason);
 #else
-void
-grpc_channel_internal_unref (grpc_exec_ctx * exec_ctx, grpc_channel * channel)
-{
+void grpc_channel_internal_unref(grpc_exec_ctx *exec_ctx,
+                                 grpc_channel *channel) {
 #endif
-  if (gpr_unref (&channel->refs))
-    {
-      destroy_channel (exec_ctx, channel);
-    }
+  if (gpr_unref(&channel->refs)) {
+    destroy_channel(exec_ctx, channel);
+  }
 }
 
-void
-grpc_channel_destroy (grpc_channel * channel)
-{
+void grpc_channel_destroy(grpc_channel *channel) {
   grpc_transport_op op;
   grpc_channel_element *elem;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  memset (&op, 0, sizeof (op));
+  memset(&op, 0, sizeof(op));
   op.disconnect = 1;
-  elem = grpc_channel_stack_element (CHANNEL_STACK_FROM_CHANNEL (channel), 0);
-  elem->filter->start_transport_op (&exec_ctx, elem, &op);
+  elem = grpc_channel_stack_element(CHANNEL_STACK_FROM_CHANNEL(channel), 0);
+  elem->filter->start_transport_op(&exec_ctx, elem, &op);
 
-  GRPC_CHANNEL_INTERNAL_UNREF (&exec_ctx, channel, "channel");
+  GRPC_CHANNEL_INTERNAL_UNREF(&exec_ctx, channel, "channel");
 
-  grpc_exec_ctx_finish (&exec_ctx);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
-grpc_channel_stack *
-grpc_channel_get_channel_stack (grpc_channel * channel)
-{
-  return CHANNEL_STACK_FROM_CHANNEL (channel);
+grpc_channel_stack *grpc_channel_get_channel_stack(grpc_channel *channel) {
+  return CHANNEL_STACK_FROM_CHANNEL(channel);
 }
 
-grpc_mdctx *
-grpc_channel_get_metadata_context (grpc_channel * channel)
-{
+grpc_mdctx *grpc_channel_get_metadata_context(grpc_channel *channel) {
   return channel->metadata_context;
 }
 
-grpc_mdstr *
-grpc_channel_get_status_string (grpc_channel * channel)
-{
+grpc_mdstr *grpc_channel_get_status_string(grpc_channel *channel) {
   return channel->grpc_status_string;
 }
 
-grpc_mdstr *
-grpc_channel_get_compression_algorithm_string (grpc_channel * channel)
-{
+grpc_mdstr *grpc_channel_get_compression_algorithm_string(
+    grpc_channel *channel) {
   return channel->grpc_compression_algorithm_string;
 }
 
-grpc_mdstr *
-grpc_channel_get_encodings_accepted_by_peer_string (grpc_channel * channel)
-{
+grpc_mdstr *grpc_channel_get_encodings_accepted_by_peer_string(
+    grpc_channel *channel) {
   return channel->grpc_encodings_accepted_by_peer_string;
 }
 
-grpc_mdelem *
-grpc_channel_get_reffed_status_elem (grpc_channel * channel, int i)
-{
-  if (i >= 0 && i < NUM_CACHED_STATUS_ELEMS)
-    {
-      return GRPC_MDELEM_REF (channel->grpc_status_elem[i]);
-    }
-  else
-    {
-      char tmp[GPR_LTOA_MIN_BUFSIZE];
-      gpr_ltoa (i, tmp);
-      return grpc_mdelem_from_metadata_strings (channel->metadata_context, GRPC_MDSTR_REF (channel->grpc_status_string), grpc_mdstr_from_string (channel->metadata_context, tmp, 0));
-    }
+grpc_mdelem *grpc_channel_get_reffed_status_elem(grpc_channel *channel, int i) {
+  if (i >= 0 && i < NUM_CACHED_STATUS_ELEMS) {
+    return GRPC_MDELEM_REF(channel->grpc_status_elem[i]);
+  } else {
+    char tmp[GPR_LTOA_MIN_BUFSIZE];
+    gpr_ltoa(i, tmp);
+    return grpc_mdelem_from_metadata_strings(
+        channel->metadata_context, GRPC_MDSTR_REF(channel->grpc_status_string),
+        grpc_mdstr_from_string(channel->metadata_context, tmp, 0));
+  }
 }
 
-grpc_mdstr *
-grpc_channel_get_message_string (grpc_channel * channel)
-{
+grpc_mdstr *grpc_channel_get_message_string(grpc_channel *channel) {
   return channel->grpc_message_string;
 }
 
-gpr_uint32
-grpc_channel_get_max_message_length (grpc_channel * channel)
-{
+gpr_uint32 grpc_channel_get_max_message_length(grpc_channel *channel) {
   return channel->max_message_length;
 }
diff --git a/src/core/surface/channel.h b/src/core/surface/channel.h
index 678aa5ba56..e5030d52d2 100644
--- a/src/core/surface/channel.h
+++ b/src/core/surface/channel.h
@@ -37,35 +37,43 @@
 #include "src/core/channel/channel_stack.h"
 #include "src/core/client_config/subchannel_factory.h"
 
-grpc_channel *grpc_channel_create_from_filters (grpc_exec_ctx * exec_ctx, const char *target, const grpc_channel_filter ** filters, size_t count, const grpc_channel_args * args, grpc_mdctx * mdctx, int is_client);
+grpc_channel *grpc_channel_create_from_filters(
+    grpc_exec_ctx *exec_ctx, const char *target,
+    const grpc_channel_filter **filters, size_t count,
+    const grpc_channel_args *args, grpc_mdctx *mdctx, int is_client);
 
 /** Get a (borrowed) pointer to this channels underlying channel stack */
-grpc_channel_stack *grpc_channel_get_channel_stack (grpc_channel * channel);
+grpc_channel_stack *grpc_channel_get_channel_stack(grpc_channel *channel);
 
 /** Get a (borrowed) pointer to the channel wide metadata context */
-grpc_mdctx *grpc_channel_get_metadata_context (grpc_channel * channel);
+grpc_mdctx *grpc_channel_get_metadata_context(grpc_channel *channel);
 
 /** Get a grpc_mdelem of grpc-status: X where X is the numeric value of
     status_code.
 
     The returned elem is owned by the caller. */
-grpc_mdelem *grpc_channel_get_reffed_status_elem (grpc_channel * channel, int status_code);
-grpc_mdstr *grpc_channel_get_status_string (grpc_channel * channel);
-grpc_mdstr *grpc_channel_get_compression_algorithm_string (grpc_channel * channel);
-grpc_mdstr *grpc_channel_get_encodings_accepted_by_peer_string (grpc_channel * channel);
-grpc_mdstr *grpc_channel_get_message_string (grpc_channel * channel);
-gpr_uint32 grpc_channel_get_max_message_length (grpc_channel * channel);
+grpc_mdelem *grpc_channel_get_reffed_status_elem(grpc_channel *channel,
+                                                 int status_code);
+grpc_mdstr *grpc_channel_get_status_string(grpc_channel *channel);
+grpc_mdstr *grpc_channel_get_compression_algorithm_string(
+    grpc_channel *channel);
+grpc_mdstr *grpc_channel_get_encodings_accepted_by_peer_string(
+    grpc_channel *channel);
+grpc_mdstr *grpc_channel_get_message_string(grpc_channel *channel);
+gpr_uint32 grpc_channel_get_max_message_length(grpc_channel *channel);
 
 #ifdef GRPC_CHANNEL_REF_COUNT_DEBUG
-void grpc_channel_internal_ref (grpc_channel * channel, const char *reason);
-void grpc_channel_internal_unref (grpc_exec_ctx * exec_ctx, grpc_channel * channel, const char *reason);
+void grpc_channel_internal_ref(grpc_channel *channel, const char *reason);
+void grpc_channel_internal_unref(grpc_exec_ctx *exec_ctx, grpc_channel *channel,
+                                 const char *reason);
 #define GRPC_CHANNEL_INTERNAL_REF(channel, reason) \
   grpc_channel_internal_ref(channel, reason)
 #define GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, channel, reason) \
   grpc_channel_internal_unref(exec_ctx, channel, reason)
 #else
-void grpc_channel_internal_ref (grpc_channel * channel);
-void grpc_channel_internal_unref (grpc_exec_ctx * exec_ctx, grpc_channel * channel);
+void grpc_channel_internal_ref(grpc_channel *channel);
+void grpc_channel_internal_unref(grpc_exec_ctx *exec_ctx,
+                                 grpc_channel *channel);
 #define GRPC_CHANNEL_INTERNAL_REF(channel, reason) \
   grpc_channel_internal_ref(channel)
 #define GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, channel, reason) \
diff --git a/src/core/surface/channel_connectivity.c b/src/core/surface/channel_connectivity.c
index a9fc1cf59f..a685a99eac 100644
--- a/src/core/surface/channel_connectivity.c
+++ b/src/core/surface/channel_connectivity.c
@@ -40,33 +40,34 @@
 #include "src/core/iomgr/alarm.h"
 #include "src/core/surface/completion_queue.h"
 
-grpc_connectivity_state
-grpc_channel_check_connectivity_state (grpc_channel * channel, int try_to_connect)
-{
+grpc_connectivity_state grpc_channel_check_connectivity_state(
+    grpc_channel *channel, int try_to_connect) {
   /* forward through to the underlying client channel */
-  grpc_channel_element *client_channel_elem = grpc_channel_stack_last_element (grpc_channel_get_channel_stack (channel));
+  grpc_channel_element *client_channel_elem =
+      grpc_channel_stack_last_element(grpc_channel_get_channel_stack(channel));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_connectivity_state state;
-  if (client_channel_elem->filter != &grpc_client_channel_filter)
-    {
-      gpr_log (GPR_ERROR, "grpc_channel_check_connectivity_state called on something that is " "not a client channel, but '%s'", client_channel_elem->filter->name);
-      return GRPC_CHANNEL_FATAL_FAILURE;
-    }
-  state = grpc_client_channel_check_connectivity_state (&exec_ctx, client_channel_elem, try_to_connect);
-  grpc_exec_ctx_finish (&exec_ctx);
+  if (client_channel_elem->filter != &grpc_client_channel_filter) {
+    gpr_log(GPR_ERROR,
+            "grpc_channel_check_connectivity_state called on something that is "
+            "not a client channel, but '%s'",
+            client_channel_elem->filter->name);
+    return GRPC_CHANNEL_FATAL_FAILURE;
+  }
+  state = grpc_client_channel_check_connectivity_state(
+      &exec_ctx, client_channel_elem, try_to_connect);
+  grpc_exec_ctx_finish(&exec_ctx);
   return state;
 }
 
-typedef enum
-{
+typedef enum {
   WAITING,
   CALLING_BACK,
   CALLING_BACK_AND_FINISHED,
   CALLED_BACK
 } callback_phase;
 
-typedef struct
-{
+typedef struct {
   gpr_mu mu;
   callback_phase phase;
   int success;
@@ -80,26 +81,22 @@ typedef struct
   void *tag;
 } state_watcher;
 
-static void
-delete_state_watcher (grpc_exec_ctx * exec_ctx, state_watcher * w)
-{
-  GRPC_CHANNEL_INTERNAL_UNREF (exec_ctx, w->channel, "watch_connectivity");
-  gpr_mu_destroy (&w->mu);
-  gpr_free (w);
+static void delete_state_watcher(grpc_exec_ctx *exec_ctx, state_watcher *w) {
+  GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, w->channel, "watch_connectivity");
+  gpr_mu_destroy(&w->mu);
+  gpr_free(w);
 }
 
-static void
-finished_completion (grpc_exec_ctx * exec_ctx, void *pw, grpc_cq_completion * ignored)
-{
+static void finished_completion(grpc_exec_ctx *exec_ctx, void *pw,
+                                grpc_cq_completion *ignored) {
   int delete = 0;
   state_watcher *w = pw;
-  gpr_mu_lock (&w->mu);
-  switch (w->phase)
-    {
+  gpr_mu_lock(&w->mu);
+  switch (w->phase) {
     case WAITING:
     case CALLED_BACK:
-      gpr_log (GPR_ERROR, "should never reach here");
-      abort ();
+      gpr_log(GPR_ERROR, "should never reach here");
+      abort();
       break;
     case CALLING_BACK:
       w->phase = CALLED_BACK;
@@ -107,86 +104,80 @@ finished_completion (grpc_exec_ctx * exec_ctx, void *pw, grpc_cq_completion * ig
     case CALLING_BACK_AND_FINISHED:
       delete = 1;
       break;
-    }
-  gpr_mu_unlock (&w->mu);
+  }
+  gpr_mu_unlock(&w->mu);
 
-  if (delete)
-    {
-      delete_state_watcher (exec_ctx, w);
-    }
+  if (delete) {
+    delete_state_watcher(exec_ctx, w);
+  }
 }
 
-static void
-partly_done (grpc_exec_ctx * exec_ctx, state_watcher * w, int due_to_completion)
-{
+static void partly_done(grpc_exec_ctx *exec_ctx, state_watcher *w,
+                        int due_to_completion) {
   int delete = 0;
   grpc_channel_element *client_channel_elem = NULL;
 
-  gpr_mu_lock (&w->mu);
-  if (w->removed == 0)
-    {
-      w->removed = 1;
-      client_channel_elem = grpc_channel_stack_last_element (grpc_channel_get_channel_stack (w->channel));
-      grpc_client_channel_del_interested_party (exec_ctx, client_channel_elem, grpc_cq_pollset (w->cq));
-    }
-  gpr_mu_unlock (&w->mu);
-  if (due_to_completion)
-    {
-      gpr_mu_lock (&w->mu);
-      w->success = 1;
-      gpr_mu_unlock (&w->mu);
-      grpc_alarm_cancel (exec_ctx, &w->alarm);
-    }
-
-  gpr_mu_lock (&w->mu);
-  switch (w->phase)
-    {
+  gpr_mu_lock(&w->mu);
+  if (w->removed == 0) {
+    w->removed = 1;
+    client_channel_elem = grpc_channel_stack_last_element(
+        grpc_channel_get_channel_stack(w->channel));
+    grpc_client_channel_del_interested_party(exec_ctx, client_channel_elem,
+                                             grpc_cq_pollset(w->cq));
+  }
+  gpr_mu_unlock(&w->mu);
+  if (due_to_completion) {
+    gpr_mu_lock(&w->mu);
+    w->success = 1;
+    gpr_mu_unlock(&w->mu);
+    grpc_alarm_cancel(exec_ctx, &w->alarm);
+  }
+
+  gpr_mu_lock(&w->mu);
+  switch (w->phase) {
     case WAITING:
       w->phase = CALLING_BACK;
-      grpc_cq_end_op (exec_ctx, w->cq, w->tag, w->success, finished_completion, w, &w->completion_storage);
+      grpc_cq_end_op(exec_ctx, w->cq, w->tag, w->success, finished_completion,
+                     w, &w->completion_storage);
       break;
     case CALLING_BACK:
       w->phase = CALLING_BACK_AND_FINISHED;
       break;
     case CALLING_BACK_AND_FINISHED:
-      gpr_log (GPR_ERROR, "should never reach here");
-      abort ();
+      gpr_log(GPR_ERROR, "should never reach here");
+      abort();
       break;
     case CALLED_BACK:
       delete = 1;
       break;
-    }
-  gpr_mu_unlock (&w->mu);
+  }
+  gpr_mu_unlock(&w->mu);
 
-  if (delete)
-    {
-      delete_state_watcher (exec_ctx, w);
-    }
+  if (delete) {
+    delete_state_watcher(exec_ctx, w);
+  }
 }
 
-static void
-watch_complete (grpc_exec_ctx * exec_ctx, void *pw, int success)
-{
-  partly_done (exec_ctx, pw, 1);
+static void watch_complete(grpc_exec_ctx *exec_ctx, void *pw, int success) {
+  partly_done(exec_ctx, pw, 1);
 }
 
-static void
-timeout_complete (grpc_exec_ctx * exec_ctx, void *pw, int success)
-{
-  partly_done (exec_ctx, pw, 0);
+static void timeout_complete(grpc_exec_ctx *exec_ctx, void *pw, int success) {
+  partly_done(exec_ctx, pw, 0);
 }
 
-void
-grpc_channel_watch_connectivity_state (grpc_channel * channel, grpc_connectivity_state last_observed_state, gpr_timespec deadline, grpc_completion_queue * cq, void *tag)
-{
-  grpc_channel_element *client_channel_elem = grpc_channel_stack_last_element (grpc_channel_get_channel_stack (channel));
+void grpc_channel_watch_connectivity_state(
+    grpc_channel *channel, grpc_connectivity_state last_observed_state,
+    gpr_timespec deadline, grpc_completion_queue *cq, void *tag) {
+  grpc_channel_element *client_channel_elem =
+      grpc_channel_stack_last_element(grpc_channel_get_channel_stack(channel));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  state_watcher *w = gpr_malloc (sizeof (*w));
+  state_watcher *w = gpr_malloc(sizeof(*w));
 
-  grpc_cq_begin_op (cq);
+  grpc_cq_begin_op(cq);
 
-  gpr_mu_init (&w->mu);
-  grpc_closure_init (&w->on_complete, watch_complete, w);
+  gpr_mu_init(&w->mu);
+  grpc_closure_init(&w->on_complete, watch_complete, w);
   w->phase = WAITING;
   w->state = last_observed_state;
   w->success = 0;
@@ -195,19 +186,23 @@ grpc_channel_watch_connectivity_state (grpc_channel * channel, grpc_connectivity
   w->tag = tag;
   w->channel = channel;
 
-  grpc_alarm_init (&exec_ctx, &w->alarm, gpr_convert_clock_type (deadline, GPR_CLOCK_MONOTONIC), timeout_complete, w, gpr_now (GPR_CLOCK_MONOTONIC));
-
-  if (client_channel_elem->filter != &grpc_client_channel_filter)
-    {
-      gpr_log (GPR_ERROR, "grpc_channel_watch_connectivity_state called on something that is " "not a client channel, but '%s'", client_channel_elem->filter->name);
-      grpc_exec_ctx_enqueue(&exec_ctx, &w->on_complete ,1);
-    }
-  else
-    {
-      GRPC_CHANNEL_INTERNAL_REF (channel, "watch_connectivity");
-      grpc_client_channel_add_interested_party (&exec_ctx, client_channel_elem, grpc_cq_pollset (cq));
-      grpc_client_channel_watch_connectivity_state (&exec_ctx, client_channel_elem, &w->state, &w->on_complete);
-    }
-
-  grpc_exec_ctx_finish (&exec_ctx);
+  grpc_alarm_init(&exec_ctx, &w->alarm,
+                  gpr_convert_clock_type(deadline, GPR_CLOCK_MONOTONIC),
+                  timeout_complete, w, gpr_now(GPR_CLOCK_MONOTONIC));
+
+  if (client_channel_elem->filter != &grpc_client_channel_filter) {
+    gpr_log(GPR_ERROR,
+            "grpc_channel_watch_connectivity_state called on something that is "
+            "not a client channel, but '%s'",
+            client_channel_elem->filter->name);
+    grpc_exec_ctx_enqueue(&exec_ctx, &w->on_complete, 1);
+  } else {
+    GRPC_CHANNEL_INTERNAL_REF(channel, "watch_connectivity");
+    grpc_client_channel_add_interested_party(&exec_ctx, client_channel_elem,
+                                             grpc_cq_pollset(cq));
+    grpc_client_channel_watch_connectivity_state(&exec_ctx, client_channel_elem,
+                                                 &w->state, &w->on_complete);
+  }
+
+  grpc_exec_ctx_finish(&exec_ctx);
 }
diff --git a/src/core/surface/channel_create.c b/src/core/surface/channel_create.c
index 1fd1479a66..05591ce27f 100644
--- a/src/core/surface/channel_create.c
+++ b/src/core/surface/channel_create.c
@@ -48,8 +48,7 @@
 #include "src/core/surface/channel.h"
 #include "src/core/transport/chttp2_transport.h"
 
-typedef struct
-{
+typedef struct {
   grpc_connector base;
   gpr_refcount refs;
 
@@ -64,73 +63,63 @@ typedef struct
   grpc_closure connected;
 } connector;
 
-static void
-connector_ref (grpc_connector * con)
-{
-  connector *c = (connector *) con;
-  gpr_ref (&c->refs);
+static void connector_ref(grpc_connector *con) {
+  connector *c = (connector *)con;
+  gpr_ref(&c->refs);
 }
 
-static void
-connector_unref (grpc_exec_ctx * exec_ctx, grpc_connector * con)
-{
-  connector *c = (connector *) con;
-  if (gpr_unref (&c->refs))
-    {
-      grpc_mdctx_unref (c->mdctx);
-      gpr_free (c);
-    }
+static void connector_unref(grpc_exec_ctx *exec_ctx, grpc_connector *con) {
+  connector *c = (connector *)con;
+  if (gpr_unref(&c->refs)) {
+    grpc_mdctx_unref(c->mdctx);
+    gpr_free(c);
+  }
 }
 
-static void
-connected (grpc_exec_ctx * exec_ctx, void *arg, int success)
-{
+static void connected(grpc_exec_ctx *exec_ctx, void *arg, int success) {
   connector *c = arg;
   grpc_closure *notify;
   grpc_endpoint *tcp = c->tcp;
-  if (tcp != NULL)
-    {
-      c->result->transport = grpc_create_chttp2_transport (exec_ctx, c->args.channel_args, tcp, c->mdctx, 1);
-      grpc_chttp2_transport_start_reading (exec_ctx, c->result->transport, NULL, 0);
-      GPR_ASSERT (c->result->transport);
-      c->result->filters = gpr_malloc (sizeof (grpc_channel_filter *));
-      c->result->filters[0] = &grpc_http_client_filter;
-      c->result->num_filters = 1;
-    }
-  else
-    {
-      memset (c->result, 0, sizeof (*c->result));
-    }
+  if (tcp != NULL) {
+    c->result->transport = grpc_create_chttp2_transport(
+        exec_ctx, c->args.channel_args, tcp, c->mdctx, 1);
+    grpc_chttp2_transport_start_reading(exec_ctx, c->result->transport, NULL,
+                                        0);
+    GPR_ASSERT(c->result->transport);
+    c->result->filters = gpr_malloc(sizeof(grpc_channel_filter *));
+    c->result->filters[0] = &grpc_http_client_filter;
+    c->result->num_filters = 1;
+  } else {
+    memset(c->result, 0, sizeof(*c->result));
+  }
   notify = c->notify;
   c->notify = NULL;
-  notify->cb (exec_ctx, notify->cb_arg, 1);
+  notify->cb(exec_ctx, notify->cb_arg, 1);
 }
 
-static void
-connector_shutdown (grpc_exec_ctx * exec_ctx, grpc_connector * con)
-{
-}
+static void connector_shutdown(grpc_exec_ctx *exec_ctx, grpc_connector *con) {}
 
-static void
-connector_connect (grpc_exec_ctx * exec_ctx, grpc_connector * con, const grpc_connect_in_args * args, grpc_connect_out_args * result, grpc_closure * notify)
-{
-  connector *c = (connector *) con;
-  GPR_ASSERT (c->notify == NULL);
-  GPR_ASSERT (notify->cb);
+static void connector_connect(grpc_exec_ctx *exec_ctx, grpc_connector *con,
+                              const grpc_connect_in_args *args,
+                              grpc_connect_out_args *result,
+                              grpc_closure *notify) {
+  connector *c = (connector *)con;
+  GPR_ASSERT(c->notify == NULL);
+  GPR_ASSERT(notify->cb);
   c->notify = notify;
   c->args = *args;
   c->result = result;
   c->tcp = NULL;
-  grpc_closure_init (&c->connected, connected, c);
-  grpc_tcp_client_connect (exec_ctx, &c->connected, &c->tcp, args->interested_parties, args->addr, args->addr_len, args->deadline);
+  grpc_closure_init(&c->connected, connected, c);
+  grpc_tcp_client_connect(exec_ctx, &c->connected, &c->tcp,
+                          args->interested_parties, args->addr, args->addr_len,
+                          args->deadline);
 }
 
 static const grpc_connector_vtable connector_vtable = {
-  connector_ref, connector_unref, connector_shutdown, connector_connect
-};
+    connector_ref, connector_unref, connector_shutdown, connector_connect};
 
-typedef struct
-{
+typedef struct {
   grpc_subchannel_factory base;
   gpr_refcount refs;
   grpc_mdctx *mdctx;
@@ -138,97 +127,93 @@ typedef struct
   grpc_channel *master;
 } subchannel_factory;
 
-static void
-subchannel_factory_ref (grpc_subchannel_factory * scf)
-{
-  subchannel_factory *f = (subchannel_factory *) scf;
-  gpr_ref (&f->refs);
+static void subchannel_factory_ref(grpc_subchannel_factory *scf) {
+  subchannel_factory *f = (subchannel_factory *)scf;
+  gpr_ref(&f->refs);
 }
 
-static void
-subchannel_factory_unref (grpc_exec_ctx * exec_ctx, grpc_subchannel_factory * scf)
-{
-  subchannel_factory *f = (subchannel_factory *) scf;
-  if (gpr_unref (&f->refs))
-    {
-      GRPC_CHANNEL_INTERNAL_UNREF (exec_ctx, f->master, "subchannel_factory");
-      grpc_channel_args_destroy (f->merge_args);
-      grpc_mdctx_unref (f->mdctx);
-      gpr_free (f);
-    }
+static void subchannel_factory_unref(grpc_exec_ctx *exec_ctx,
+                                     grpc_subchannel_factory *scf) {
+  subchannel_factory *f = (subchannel_factory *)scf;
+  if (gpr_unref(&f->refs)) {
+    GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, f->master, "subchannel_factory");
+    grpc_channel_args_destroy(f->merge_args);
+    grpc_mdctx_unref(f->mdctx);
+    gpr_free(f);
+  }
 }
 
-static grpc_subchannel *
-subchannel_factory_create_subchannel (grpc_exec_ctx * exec_ctx, grpc_subchannel_factory * scf, grpc_subchannel_args * args)
-{
-  subchannel_factory *f = (subchannel_factory *) scf;
-  connector *c = gpr_malloc (sizeof (*c));
-  grpc_channel_args *final_args = grpc_channel_args_merge (args->args, f->merge_args);
+static grpc_subchannel *subchannel_factory_create_subchannel(
+    grpc_exec_ctx *exec_ctx, grpc_subchannel_factory *scf,
+    grpc_subchannel_args *args) {
+  subchannel_factory *f = (subchannel_factory *)scf;
+  connector *c = gpr_malloc(sizeof(*c));
+  grpc_channel_args *final_args =
+      grpc_channel_args_merge(args->args, f->merge_args);
   grpc_subchannel *s;
-  memset (c, 0, sizeof (*c));
+  memset(c, 0, sizeof(*c));
   c->base.vtable = &connector_vtable;
   c->mdctx = f->mdctx;
-  grpc_mdctx_ref (c->mdctx);
-  gpr_ref_init (&c->refs, 1);
+  grpc_mdctx_ref(c->mdctx);
+  gpr_ref_init(&c->refs, 1);
   args->mdctx = f->mdctx;
   args->args = final_args;
   args->master = f->master;
-  s = grpc_subchannel_create (&c->base, args);
-  grpc_connector_unref (exec_ctx, &c->base);
-  grpc_channel_args_destroy (final_args);
+  s = grpc_subchannel_create(&c->base, args);
+  grpc_connector_unref(exec_ctx, &c->base);
+  grpc_channel_args_destroy(final_args);
   return s;
 }
 
 static const grpc_subchannel_factory_vtable subchannel_factory_vtable = {
-  subchannel_factory_ref, subchannel_factory_unref,
-  subchannel_factory_create_subchannel
-};
+    subchannel_factory_ref, subchannel_factory_unref,
+    subchannel_factory_create_subchannel};
 
 /* Create a client channel:
    Asynchronously: - resolve target
                    - connect to it (trying alternatives as presented)
                    - perform handshakes */
-grpc_channel *
-grpc_insecure_channel_create (const char *target, const grpc_channel_args * args, void *reserved)
-{
+grpc_channel *grpc_insecure_channel_create(const char *target,
+                                           const grpc_channel_args *args,
+                                           void *reserved) {
   grpc_channel *channel = NULL;
 #define MAX_FILTERS 3
   const grpc_channel_filter *filters[MAX_FILTERS];
   grpc_resolver *resolver;
   subchannel_factory *f;
-  grpc_mdctx *mdctx = grpc_mdctx_create ();
+  grpc_mdctx *mdctx = grpc_mdctx_create();
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   size_t n = 0;
-  GPR_ASSERT (!reserved);
-  if (grpc_channel_args_is_census_enabled (args))
-    {
-      filters[n++] = &grpc_client_census_filter;
-    }
+  GPR_ASSERT(!reserved);
+  if (grpc_channel_args_is_census_enabled(args)) {
+    filters[n++] = &grpc_client_census_filter;
+  }
   filters[n++] = &grpc_compress_filter;
   filters[n++] = &grpc_client_channel_filter;
-  GPR_ASSERT (n <= MAX_FILTERS);
+  GPR_ASSERT(n <= MAX_FILTERS);
 
-  channel = grpc_channel_create_from_filters (&exec_ctx, target, filters, n, args, mdctx, 1);
+  channel = grpc_channel_create_from_filters(&exec_ctx, target, filters, n,
+                                             args, mdctx, 1);
 
-  f = gpr_malloc (sizeof (*f));
+  f = gpr_malloc(sizeof(*f));
   f->base.vtable = &subchannel_factory_vtable;
-  gpr_ref_init (&f->refs, 1);
-  grpc_mdctx_ref (mdctx);
+  gpr_ref_init(&f->refs, 1);
+  grpc_mdctx_ref(mdctx);
   f->mdctx = mdctx;
-  f->merge_args = grpc_channel_args_copy (args);
+  f->merge_args = grpc_channel_args_copy(args);
   f->master = channel;
-  GRPC_CHANNEL_INTERNAL_REF (f->master, "subchannel_factory");
-  resolver = grpc_resolver_create (target, &f->base);
-  if (!resolver)
-    {
-      return NULL;
-    }
-
-  grpc_client_channel_set_resolver (&exec_ctx, grpc_channel_get_channel_stack (channel), resolver);
-  GRPC_RESOLVER_UNREF (&exec_ctx, resolver, "create");
-  grpc_subchannel_factory_unref (&exec_ctx, &f->base);
-
-  grpc_exec_ctx_finish (&exec_ctx);
+  GRPC_CHANNEL_INTERNAL_REF(f->master, "subchannel_factory");
+  resolver = grpc_resolver_create(target, &f->base);
+  if (!resolver) {
+    return NULL;
+  }
+
+  grpc_client_channel_set_resolver(
+      &exec_ctx, grpc_channel_get_channel_stack(channel), resolver);
+  GRPC_RESOLVER_UNREF(&exec_ctx, resolver, "create");
+  grpc_subchannel_factory_unref(&exec_ctx, &f->base);
+
+  grpc_exec_ctx_finish(&exec_ctx);
 
   return channel;
 }
diff --git a/src/core/surface/completion_queue.c b/src/core/surface/completion_queue.c
index 56dceec30c..5dac8ebcf8 100644
--- a/src/core/surface/completion_queue.c
+++ b/src/core/surface/completion_queue.c
@@ -45,15 +45,13 @@
 #include <grpc/support/atm.h>
 #include <grpc/support/log.h>
 
-typedef struct
-{
+typedef struct {
   grpc_pollset_worker *worker;
   void *tag;
 } plucker;
 
 /* Completion queue structure */
-struct grpc_completion_queue
-{
+struct grpc_completion_queue {
   /** completed events */
   grpc_cq_completion completed_head;
   grpc_cq_completion *completed_tail;
@@ -72,80 +70,73 @@ struct grpc_completion_queue
   grpc_closure pollset_destroy_done;
 };
 
-static void on_pollset_destroy_done (grpc_exec_ctx * exec_ctx, void *cc, int success);
+static void on_pollset_destroy_done(grpc_exec_ctx *exec_ctx, void *cc,
+                                    int success);
 
-grpc_completion_queue *
-grpc_completion_queue_create (void *reserved)
-{
-  grpc_completion_queue *cc = gpr_malloc (sizeof (grpc_completion_queue));
-  GPR_ASSERT (!reserved);
-  memset (cc, 0, sizeof (*cc));
+grpc_completion_queue *grpc_completion_queue_create(void *reserved) {
+  grpc_completion_queue *cc = gpr_malloc(sizeof(grpc_completion_queue));
+  GPR_ASSERT(!reserved);
+  memset(cc, 0, sizeof(*cc));
   /* Initial ref is dropped by grpc_completion_queue_shutdown */
-  gpr_ref_init (&cc->pending_events, 1);
+  gpr_ref_init(&cc->pending_events, 1);
   /* One for destroy(), one for pollset_shutdown */
-  gpr_ref_init (&cc->owning_refs, 2);
-  grpc_pollset_init (&cc->pollset);
+  gpr_ref_init(&cc->owning_refs, 2);
+  grpc_pollset_init(&cc->pollset);
   cc->completed_tail = &cc->completed_head;
-  cc->completed_head.next = (gpr_uintptr) cc->completed_tail;
-  grpc_closure_init (&cc->pollset_destroy_done, on_pollset_destroy_done, cc);
+  cc->completed_head.next = (gpr_uintptr)cc->completed_tail;
+  grpc_closure_init(&cc->pollset_destroy_done, on_pollset_destroy_done, cc);
   return cc;
 }
 
 #ifdef GRPC_CQ_REF_COUNT_DEBUG
-void
-grpc_cq_internal_ref (grpc_completion_queue * cc, const char *reason, const char *file, int line)
-{
-  gpr_log (file, line, GPR_LOG_SEVERITY_DEBUG, "CQ:%p   ref %d -> %d %s", cc, (int) cc->owning_refs.count, (int) cc->owning_refs.count + 1, reason);
+void grpc_cq_internal_ref(grpc_completion_queue *cc, const char *reason,
+                          const char *file, int line) {
+  gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "CQ:%p   ref %d -> %d %s", cc,
+          (int)cc->owning_refs.count, (int)cc->owning_refs.count + 1, reason);
 #else
-void
-grpc_cq_internal_ref (grpc_completion_queue * cc)
-{
+void grpc_cq_internal_ref(grpc_completion_queue *cc) {
 #endif
-  gpr_ref (&cc->owning_refs);
+  gpr_ref(&cc->owning_refs);
 }
 
-static void
-on_pollset_destroy_done (grpc_exec_ctx * exec_ctx, void *arg, int success)
-{
+static void on_pollset_destroy_done(grpc_exec_ctx *exec_ctx, void *arg,
+                                    int success) {
   grpc_completion_queue *cc = arg;
-  GRPC_CQ_INTERNAL_UNREF (cc, "pollset_destroy");
+  GRPC_CQ_INTERNAL_UNREF(cc, "pollset_destroy");
 }
 
 #ifdef GRPC_CQ_REF_COUNT_DEBUG
-void
-grpc_cq_internal_unref (grpc_completion_queue * cc, const char *reason, const char *file, int line)
-{
-  gpr_log (file, line, GPR_LOG_SEVERITY_DEBUG, "CQ:%p unref %d -> %d %s", cc, (int) cc->owning_refs.count, (int) cc->owning_refs.count - 1, reason);
+void grpc_cq_internal_unref(grpc_completion_queue *cc, const char *reason,
+                            const char *file, int line) {
+  gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "CQ:%p unref %d -> %d %s", cc,
+          (int)cc->owning_refs.count, (int)cc->owning_refs.count - 1, reason);
 #else
-void
-grpc_cq_internal_unref (grpc_completion_queue * cc)
-{
+void grpc_cq_internal_unref(grpc_completion_queue *cc) {
 #endif
-  if (gpr_unref (&cc->owning_refs))
-    {
-      GPR_ASSERT (cc->completed_head.next == (gpr_uintptr) & cc->completed_head);
-      grpc_pollset_destroy (&cc->pollset);
-      gpr_free (cc);
-    }
+  if (gpr_unref(&cc->owning_refs)) {
+    GPR_ASSERT(cc->completed_head.next == (gpr_uintptr)&cc->completed_head);
+    grpc_pollset_destroy(&cc->pollset);
+    gpr_free(cc);
+  }
 }
 
-void
-grpc_cq_begin_op (grpc_completion_queue * cc)
-{
+void grpc_cq_begin_op(grpc_completion_queue *cc) {
 #ifndef NDEBUG
-  gpr_mu_lock (GRPC_POLLSET_MU (&cc->pollset));
-  GPR_ASSERT (!cc->shutdown_called);
-  gpr_mu_unlock (GRPC_POLLSET_MU (&cc->pollset));
+  gpr_mu_lock(GRPC_POLLSET_MU(&cc->pollset));
+  GPR_ASSERT(!cc->shutdown_called);
+  gpr_mu_unlock(GRPC_POLLSET_MU(&cc->pollset));
 #endif
-  gpr_ref (&cc->pending_events);
+  gpr_ref(&cc->pending_events);
 }
 
 /* Signal the end of an operation - if this is the last waiting-to-be-queued
    event, then enter shutdown mode */
 /* Queue a GRPC_OP_COMPLETED operation */
-void
-grpc_cq_end_op (grpc_exec_ctx * exec_ctx,grpc_completion_queue * cc, void *tag, int success, void (*done) (grpc_exec_ctx * exec_ctx, void *done_arg, grpc_cq_completion * storage), void *done_arg, grpc_cq_completion * storage)
-{
+void grpc_cq_end_op(grpc_exec_ctx *exec_ctx, grpc_completion_queue *cc,
+                    void *tag, int success,
+                    void (*done)(grpc_exec_ctx *exec_ctx, void *done_arg,
+                                 grpc_cq_completion *storage),
+                    void *done_arg, grpc_cq_completion *storage) {
   int shutdown;
   int i;
   grpc_pollset_worker *pluck_worker;
@@ -153,127 +144,113 @@ grpc_cq_end_op (grpc_exec_ctx * exec_ctx,grpc_completion_queue * cc, void *tag,
   storage->tag = tag;
   storage->done = done;
   storage->done_arg = done_arg;
-  storage->next = ((gpr_uintptr) & cc->completed_head) | ((gpr_uintptr) (success != 0));
+  storage->next =
+      ((gpr_uintptr)&cc->completed_head) | ((gpr_uintptr)(success != 0));
 
-  gpr_mu_lock (GRPC_POLLSET_MU (&cc->pollset));
-  shutdown = gpr_unref (&cc->pending_events);
-  if (!shutdown)
-    {
-      cc->completed_tail->next = ((gpr_uintptr) storage) | (1u & (gpr_uintptr) cc->completed_tail->next);
-      cc->completed_tail = storage;
-      pluck_worker = NULL;
-      for (i = 0; i < cc->num_pluckers; i++)
-	{
-	  if (cc->pluckers[i].tag == tag)
-	    {
-	      pluck_worker = cc->pluckers[i].worker;
-	      break;
-	    }
-	}
-      grpc_pollset_kick (&cc->pollset, pluck_worker);
-      gpr_mu_unlock (GRPC_POLLSET_MU (&cc->pollset));
-    }
-  else
-    {
-      cc->completed_tail->next = ((gpr_uintptr) storage) | (1u & (gpr_uintptr) cc->completed_tail->next);
-      cc->completed_tail = storage;
-      GPR_ASSERT (!cc->shutdown);
-      GPR_ASSERT (cc->shutdown_called);
-      cc->shutdown = 1;
-      gpr_mu_unlock (GRPC_POLLSET_MU (&cc->pollset));
-      grpc_pollset_shutdown (exec_ctx, &cc->pollset, &cc->pollset_destroy_done);
+  gpr_mu_lock(GRPC_POLLSET_MU(&cc->pollset));
+  shutdown = gpr_unref(&cc->pending_events);
+  if (!shutdown) {
+    cc->completed_tail->next =
+        ((gpr_uintptr)storage) | (1u & (gpr_uintptr)cc->completed_tail->next);
+    cc->completed_tail = storage;
+    pluck_worker = NULL;
+    for (i = 0; i < cc->num_pluckers; i++) {
+      if (cc->pluckers[i].tag == tag) {
+        pluck_worker = cc->pluckers[i].worker;
+        break;
+      }
     }
+    grpc_pollset_kick(&cc->pollset, pluck_worker);
+    gpr_mu_unlock(GRPC_POLLSET_MU(&cc->pollset));
+  } else {
+    cc->completed_tail->next =
+        ((gpr_uintptr)storage) | (1u & (gpr_uintptr)cc->completed_tail->next);
+    cc->completed_tail = storage;
+    GPR_ASSERT(!cc->shutdown);
+    GPR_ASSERT(cc->shutdown_called);
+    cc->shutdown = 1;
+    gpr_mu_unlock(GRPC_POLLSET_MU(&cc->pollset));
+    grpc_pollset_shutdown(exec_ctx, &cc->pollset, &cc->pollset_destroy_done);
+  }
 }
 
-grpc_event
-grpc_completion_queue_next (grpc_completion_queue * cc, gpr_timespec deadline, void *reserved)
-{
+grpc_event grpc_completion_queue_next(grpc_completion_queue *cc,
+                                      gpr_timespec deadline, void *reserved) {
   grpc_event ret;
   grpc_pollset_worker worker;
   int first_loop = 1;
   gpr_timespec now;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
-  GPR_ASSERT (!reserved);
+  GPR_ASSERT(!reserved);
 
-  deadline = gpr_convert_clock_type (deadline, GPR_CLOCK_MONOTONIC);
+  deadline = gpr_convert_clock_type(deadline, GPR_CLOCK_MONOTONIC);
 
-  GRPC_CQ_INTERNAL_REF (cc, "next");
-  gpr_mu_lock (GRPC_POLLSET_MU (&cc->pollset));
-  for (;;)
-    {
-      if (cc->completed_tail != &cc->completed_head)
-	{
-	  grpc_cq_completion *c = (grpc_cq_completion *) cc->completed_head.next;
-	  cc->completed_head.next = c->next & ~(gpr_uintptr) 1;
-	  if (c == cc->completed_tail)
-	    {
-	      cc->completed_tail = &cc->completed_head;
-	    }
-	  gpr_mu_unlock (GRPC_POLLSET_MU (&cc->pollset));
-	  ret.type = GRPC_OP_COMPLETE;
-	  ret.success = c->next & 1u;
-	  ret.tag = c->tag;
-	  c->done (&exec_ctx, c->done_arg, c);
-	  break;
-	}
-      if (cc->shutdown)
-	{
-	  gpr_mu_unlock (GRPC_POLLSET_MU (&cc->pollset));
-	  memset (&ret, 0, sizeof (ret));
-	  ret.type = GRPC_QUEUE_SHUTDOWN;
-	  break;
-	}
-      now = gpr_now (GPR_CLOCK_MONOTONIC);
-      if (!first_loop && gpr_time_cmp (now, deadline) >= 0)
-	{
-	  gpr_mu_unlock (GRPC_POLLSET_MU (&cc->pollset));
-	  memset (&ret, 0, sizeof (ret));
-	  ret.type = GRPC_QUEUE_TIMEOUT;
-	  break;
-	}
-      first_loop = 0;
-      grpc_pollset_work (&exec_ctx, &cc->pollset, &worker, now, deadline);
+  GRPC_CQ_INTERNAL_REF(cc, "next");
+  gpr_mu_lock(GRPC_POLLSET_MU(&cc->pollset));
+  for (;;) {
+    if (cc->completed_tail != &cc->completed_head) {
+      grpc_cq_completion *c = (grpc_cq_completion *)cc->completed_head.next;
+      cc->completed_head.next = c->next & ~(gpr_uintptr)1;
+      if (c == cc->completed_tail) {
+        cc->completed_tail = &cc->completed_head;
+      }
+      gpr_mu_unlock(GRPC_POLLSET_MU(&cc->pollset));
+      ret.type = GRPC_OP_COMPLETE;
+      ret.success = c->next & 1u;
+      ret.tag = c->tag;
+      c->done(&exec_ctx, c->done_arg, c);
+      break;
+    }
+    if (cc->shutdown) {
+      gpr_mu_unlock(GRPC_POLLSET_MU(&cc->pollset));
+      memset(&ret, 0, sizeof(ret));
+      ret.type = GRPC_QUEUE_SHUTDOWN;
+      break;
+    }
+    now = gpr_now(GPR_CLOCK_MONOTONIC);
+    if (!first_loop && gpr_time_cmp(now, deadline) >= 0) {
+      gpr_mu_unlock(GRPC_POLLSET_MU(&cc->pollset));
+      memset(&ret, 0, sizeof(ret));
+      ret.type = GRPC_QUEUE_TIMEOUT;
+      break;
     }
-  GRPC_SURFACE_TRACE_RETURNED_EVENT (cc, &ret);
-  GRPC_CQ_INTERNAL_UNREF (cc, "next");
-  grpc_exec_ctx_finish (&exec_ctx);
+    first_loop = 0;
+    grpc_pollset_work(&exec_ctx, &cc->pollset, &worker, now, deadline);
+  }
+  GRPC_SURFACE_TRACE_RETURNED_EVENT(cc, &ret);
+  GRPC_CQ_INTERNAL_UNREF(cc, "next");
+  grpc_exec_ctx_finish(&exec_ctx);
   return ret;
 }
 
-static int
-add_plucker (grpc_completion_queue * cc, void *tag, grpc_pollset_worker * worker)
-{
-  if (cc->num_pluckers == GRPC_MAX_COMPLETION_QUEUE_PLUCKERS)
-    {
-      return 0;
-    }
+static int add_plucker(grpc_completion_queue *cc, void *tag,
+                       grpc_pollset_worker *worker) {
+  if (cc->num_pluckers == GRPC_MAX_COMPLETION_QUEUE_PLUCKERS) {
+    return 0;
+  }
   cc->pluckers[cc->num_pluckers].tag = tag;
   cc->pluckers[cc->num_pluckers].worker = worker;
   cc->num_pluckers++;
   return 1;
 }
 
-static void
-del_plucker (grpc_completion_queue * cc, void *tag, grpc_pollset_worker * worker)
-{
+static void del_plucker(grpc_completion_queue *cc, void *tag,
+                        grpc_pollset_worker *worker) {
   int i;
-  for (i = 0; i < cc->num_pluckers; i++)
-    {
-      if (cc->pluckers[i].tag == tag && cc->pluckers[i].worker == worker)
-	{
-	  cc->num_pluckers--;
-	  GPR_SWAP (plucker, cc->pluckers[i], cc->pluckers[cc->num_pluckers]);
-	  return;
-	}
+  for (i = 0; i < cc->num_pluckers; i++) {
+    if (cc->pluckers[i].tag == tag && cc->pluckers[i].worker == worker) {
+      cc->num_pluckers--;
+      GPR_SWAP(plucker, cc->pluckers[i], cc->pluckers[cc->num_pluckers]);
+      return;
     }
-  gpr_log (GPR_ERROR, "should never reach here");
-  abort ();
+  }
+  gpr_log(GPR_ERROR, "should never reach here");
+  abort();
 }
 
-grpc_event
-grpc_completion_queue_pluck (grpc_completion_queue * cc, void *tag, gpr_timespec deadline, void *reserved)
-{
+grpc_event grpc_completion_queue_pluck(grpc_completion_queue *cc, void *tag,
+                                       gpr_timespec deadline, void *reserved) {
   grpc_event ret;
   grpc_cq_completion *c;
   grpc_cq_completion *prev;
@@ -282,116 +259,98 @@ grpc_completion_queue_pluck (grpc_completion_queue * cc, void *tag, gpr_timespec
   int first_loop = 1;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
-  GPR_ASSERT (!reserved);
+  GPR_ASSERT(!reserved);
 
-  deadline = gpr_convert_clock_type (deadline, GPR_CLOCK_MONOTONIC);
+  deadline = gpr_convert_clock_type(deadline, GPR_CLOCK_MONOTONIC);
 
-  GRPC_CQ_INTERNAL_REF (cc, "pluck");
-  gpr_mu_lock (GRPC_POLLSET_MU (&cc->pollset));
-  for (;;)
-    {
-      prev = &cc->completed_head;
-      while ((c = (grpc_cq_completion *) (prev->next & ~(gpr_uintptr) 1)) != &cc->completed_head)
-	{
-	  if (c->tag == tag)
-	    {
-	      prev->next = (prev->next & (gpr_uintptr) 1) | (c->next & ~(gpr_uintptr) 1);
-	      if (c == cc->completed_tail)
-		{
-		  cc->completed_tail = prev;
-		}
-	      gpr_mu_unlock (GRPC_POLLSET_MU (&cc->pollset));
-	      ret.type = GRPC_OP_COMPLETE;
-	      ret.success = c->next & 1u;
-	      ret.tag = c->tag;
-	      c->done (&exec_ctx, c->done_arg, c);
-	      goto done;
-	    }
-	  prev = c;
-	}
-      if (cc->shutdown)
-	{
-	  gpr_mu_unlock (GRPC_POLLSET_MU (&cc->pollset));
-	  memset (&ret, 0, sizeof (ret));
-	  ret.type = GRPC_QUEUE_SHUTDOWN;
-	  break;
-	}
-      if (!add_plucker (cc, tag, &worker))
-	{
-	  gpr_log (GPR_DEBUG, "Too many outstanding grpc_completion_queue_pluck calls: maximum " "is %d", GRPC_MAX_COMPLETION_QUEUE_PLUCKERS);
-	  gpr_mu_unlock (GRPC_POLLSET_MU (&cc->pollset));
-	  memset (&ret, 0, sizeof (ret));
-	  /* TODO(ctiller): should we use a different result here */
-	  ret.type = GRPC_QUEUE_TIMEOUT;
-	  break;
-	}
-      now = gpr_now (GPR_CLOCK_MONOTONIC);
-      if (!first_loop && gpr_time_cmp (now, deadline) >= 0)
-	{
-	  del_plucker (cc, tag, &worker);
-	  gpr_mu_unlock (GRPC_POLLSET_MU (&cc->pollset));
-	  memset (&ret, 0, sizeof (ret));
-	  ret.type = GRPC_QUEUE_TIMEOUT;
-	  break;
-	}
-      first_loop = 0;
-      grpc_pollset_work (&exec_ctx, &cc->pollset, &worker, now, deadline);
-      del_plucker (cc, tag, &worker);
+  GRPC_CQ_INTERNAL_REF(cc, "pluck");
+  gpr_mu_lock(GRPC_POLLSET_MU(&cc->pollset));
+  for (;;) {
+    prev = &cc->completed_head;
+    while ((c = (grpc_cq_completion *)(prev->next & ~(gpr_uintptr)1)) !=
+           &cc->completed_head) {
+      if (c->tag == tag) {
+        prev->next =
+            (prev->next & (gpr_uintptr)1) | (c->next & ~(gpr_uintptr)1);
+        if (c == cc->completed_tail) {
+          cc->completed_tail = prev;
+        }
+        gpr_mu_unlock(GRPC_POLLSET_MU(&cc->pollset));
+        ret.type = GRPC_OP_COMPLETE;
+        ret.success = c->next & 1u;
+        ret.tag = c->tag;
+        c->done(&exec_ctx, c->done_arg, c);
+        goto done;
+      }
+      prev = c;
+    }
+    if (cc->shutdown) {
+      gpr_mu_unlock(GRPC_POLLSET_MU(&cc->pollset));
+      memset(&ret, 0, sizeof(ret));
+      ret.type = GRPC_QUEUE_SHUTDOWN;
+      break;
     }
+    if (!add_plucker(cc, tag, &worker)) {
+      gpr_log(GPR_DEBUG,
+              "Too many outstanding grpc_completion_queue_pluck calls: maximum "
+              "is %d",
+              GRPC_MAX_COMPLETION_QUEUE_PLUCKERS);
+      gpr_mu_unlock(GRPC_POLLSET_MU(&cc->pollset));
+      memset(&ret, 0, sizeof(ret));
+      /* TODO(ctiller): should we use a different result here */
+      ret.type = GRPC_QUEUE_TIMEOUT;
+      break;
+    }
+    now = gpr_now(GPR_CLOCK_MONOTONIC);
+    if (!first_loop && gpr_time_cmp(now, deadline) >= 0) {
+      del_plucker(cc, tag, &worker);
+      gpr_mu_unlock(GRPC_POLLSET_MU(&cc->pollset));
+      memset(&ret, 0, sizeof(ret));
+      ret.type = GRPC_QUEUE_TIMEOUT;
+      break;
+    }
+    first_loop = 0;
+    grpc_pollset_work(&exec_ctx, &cc->pollset, &worker, now, deadline);
+    del_plucker(cc, tag, &worker);
+  }
 done:
-  GRPC_SURFACE_TRACE_RETURNED_EVENT (cc, &ret);
-  GRPC_CQ_INTERNAL_UNREF (cc, "pluck");
-  grpc_exec_ctx_finish (&exec_ctx);
+  GRPC_SURFACE_TRACE_RETURNED_EVENT(cc, &ret);
+  GRPC_CQ_INTERNAL_UNREF(cc, "pluck");
+  grpc_exec_ctx_finish(&exec_ctx);
   return ret;
 }
 
 /* Shutdown simply drops a ref that we reserved at creation time; if we drop
    to zero here, then enter shutdown mode and wake up any waiters */
-void
-grpc_completion_queue_shutdown (grpc_completion_queue * cc)
-{
+void grpc_completion_queue_shutdown(grpc_completion_queue *cc) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  gpr_mu_lock (GRPC_POLLSET_MU (&cc->pollset));
-  if (cc->shutdown_called)
-    {
-      gpr_mu_unlock (GRPC_POLLSET_MU (&cc->pollset));
-      return;
-    }
+  gpr_mu_lock(GRPC_POLLSET_MU(&cc->pollset));
+  if (cc->shutdown_called) {
+    gpr_mu_unlock(GRPC_POLLSET_MU(&cc->pollset));
+    return;
+  }
   cc->shutdown_called = 1;
-  gpr_mu_unlock (GRPC_POLLSET_MU (&cc->pollset));
+  gpr_mu_unlock(GRPC_POLLSET_MU(&cc->pollset));
 
-  if (gpr_unref (&cc->pending_events))
-    {
-      gpr_mu_lock (GRPC_POLLSET_MU (&cc->pollset));
-      GPR_ASSERT (!cc->shutdown);
-      cc->shutdown = 1;
-      gpr_mu_unlock (GRPC_POLLSET_MU (&cc->pollset));
-      grpc_pollset_shutdown (&exec_ctx, &cc->pollset, &cc->pollset_destroy_done);
-    }
-  grpc_exec_ctx_finish (&exec_ctx);
+  if (gpr_unref(&cc->pending_events)) {
+    gpr_mu_lock(GRPC_POLLSET_MU(&cc->pollset));
+    GPR_ASSERT(!cc->shutdown);
+    cc->shutdown = 1;
+    gpr_mu_unlock(GRPC_POLLSET_MU(&cc->pollset));
+    grpc_pollset_shutdown(&exec_ctx, &cc->pollset, &cc->pollset_destroy_done);
+  }
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
-void
-grpc_completion_queue_destroy (grpc_completion_queue * cc)
-{
-  grpc_completion_queue_shutdown (cc);
-  GRPC_CQ_INTERNAL_UNREF (cc, "destroy");
+void grpc_completion_queue_destroy(grpc_completion_queue *cc) {
+  grpc_completion_queue_shutdown(cc);
+  GRPC_CQ_INTERNAL_UNREF(cc, "destroy");
 }
 
-grpc_pollset *
-grpc_cq_pollset (grpc_completion_queue * cc)
-{
+grpc_pollset *grpc_cq_pollset(grpc_completion_queue *cc) {
   return &cc->pollset;
 }
 
-void
-grpc_cq_mark_server_cq (grpc_completion_queue * cc)
-{
-  cc->is_server_cq = 1;
-}
+void grpc_cq_mark_server_cq(grpc_completion_queue *cc) { cc->is_server_cq = 1; }
 
-int
-grpc_cq_is_server_cq (grpc_completion_queue * cc)
-{
-  return cc->is_server_cq;
-}
+int grpc_cq_is_server_cq(grpc_completion_queue *cc) { return cc->is_server_cq; }
diff --git a/src/core/surface/completion_queue.h b/src/core/surface/completion_queue.h
index d9b06223a8..5f8282e542 100644
--- a/src/core/surface/completion_queue.h
+++ b/src/core/surface/completion_queue.h
@@ -39,42 +39,48 @@
 #include "src/core/iomgr/pollset.h"
 #include <grpc/grpc.h>
 
-typedef struct grpc_cq_completion
-{
+typedef struct grpc_cq_completion {
   /** user supplied tag */
   void *tag;
   /** done callback - called when this queue element is no longer
       needed by the completion queue */
-  void (*done) (grpc_exec_ctx * exec_ctx, void *done_arg, struct grpc_cq_completion * c);
+  void (*done)(grpc_exec_ctx *exec_ctx, void *done_arg,
+               struct grpc_cq_completion *c);
   void *done_arg;
   /** next pointer; low bit is used to indicate success or not */
   gpr_uintptr next;
 } grpc_cq_completion;
 
 #ifdef GRPC_CQ_REF_COUNT_DEBUG
-void grpc_cq_internal_ref (grpc_completion_queue * cc, const char *reason, const char *file, int line);
-void grpc_cq_internal_unref (grpc_completion_queue * cc, const char *reason, const char *file, int line);
+void grpc_cq_internal_ref(grpc_completion_queue *cc, const char *reason,
+                          const char *file, int line);
+void grpc_cq_internal_unref(grpc_completion_queue *cc, const char *reason,
+                            const char *file, int line);
 #define GRPC_CQ_INTERNAL_REF(cc, reason) \
   grpc_cq_internal_ref(cc, reason, __FILE__, __LINE__)
 #define GRPC_CQ_INTERNAL_UNREF(cc, reason) \
   grpc_cq_internal_unref(cc, reason, __FILE__, __LINE__)
 #else
-void grpc_cq_internal_ref (grpc_completion_queue * cc);
-void grpc_cq_internal_unref (grpc_completion_queue * cc);
+void grpc_cq_internal_ref(grpc_completion_queue *cc);
+void grpc_cq_internal_unref(grpc_completion_queue *cc);
 #define GRPC_CQ_INTERNAL_REF(cc, reason) grpc_cq_internal_ref(cc)
 #define GRPC_CQ_INTERNAL_UNREF(cc, reason) grpc_cq_internal_unref(cc)
 #endif
 
 /* Flag that an operation is beginning: the completion channel will not finish
    shutdown until a corrensponding grpc_cq_end_* call is made */
-void grpc_cq_begin_op (grpc_completion_queue * cc);
+void grpc_cq_begin_op(grpc_completion_queue *cc);
 
 /* Queue a GRPC_OP_COMPLETED operation */
-void grpc_cq_end_op (grpc_exec_ctx * exec_ctx, grpc_completion_queue * cc, void *tag, int success, void (*done) (grpc_exec_ctx * exec_ctx,void *done_arg, grpc_cq_completion * storage), void *done_arg, grpc_cq_completion * storage);
+void grpc_cq_end_op(grpc_exec_ctx *exec_ctx, grpc_completion_queue *cc,
+                    void *tag, int success,
+                    void (*done)(grpc_exec_ctx *exec_ctx, void *done_arg,
+                                 grpc_cq_completion *storage),
+                    void *done_arg, grpc_cq_completion *storage);
 
-grpc_pollset *grpc_cq_pollset (grpc_completion_queue * cc);
+grpc_pollset *grpc_cq_pollset(grpc_completion_queue *cc);
 
-void grpc_cq_mark_server_cq (grpc_completion_queue * cc);
-int grpc_cq_is_server_cq (grpc_completion_queue * cc);
+void grpc_cq_mark_server_cq(grpc_completion_queue *cc);
+int grpc_cq_is_server_cq(grpc_completion_queue *cc);
 
 #endif /* GRPC_INTERNAL_CORE_SURFACE_COMPLETION_QUEUE_H */
diff --git a/src/core/surface/event_string.c b/src/core/surface/event_string.c
index ac5cb657cd..33cd4a43aa 100644
--- a/src/core/surface/event_string.c
+++ b/src/core/surface/event_string.c
@@ -39,55 +39,43 @@
 #include <grpc/byte_buffer.h>
 #include <grpc/support/string_util.h>
 
-static void
-addhdr (gpr_strvec * buf, grpc_event * ev)
-{
+static void addhdr(gpr_strvec *buf, grpc_event *ev) {
   char *tmp;
-  gpr_asprintf (&tmp, "tag:%p", ev->tag);
-  gpr_strvec_add (buf, tmp);
+  gpr_asprintf(&tmp, "tag:%p", ev->tag);
+  gpr_strvec_add(buf, tmp);
 }
 
-static const char *
-errstr (int success)
-{
-  return success ? "OK" : "ERROR";
-}
+static const char *errstr(int success) { return success ? "OK" : "ERROR"; }
 
-static void
-adderr (gpr_strvec * buf, int success)
-{
+static void adderr(gpr_strvec *buf, int success) {
   char *tmp;
-  gpr_asprintf (&tmp, " %s", errstr (success));
-  gpr_strvec_add (buf, tmp);
+  gpr_asprintf(&tmp, " %s", errstr(success));
+  gpr_strvec_add(buf, tmp);
 }
 
-char *
-grpc_event_string (grpc_event * ev)
-{
+char *grpc_event_string(grpc_event *ev) {
   char *out;
   gpr_strvec buf;
 
-  if (ev == NULL)
-    return gpr_strdup ("null");
+  if (ev == NULL) return gpr_strdup("null");
 
-  gpr_strvec_init (&buf);
+  gpr_strvec_init(&buf);
 
-  switch (ev->type)
-    {
+  switch (ev->type) {
     case GRPC_QUEUE_TIMEOUT:
-      gpr_strvec_add (&buf, gpr_strdup ("QUEUE_TIMEOUT"));
+      gpr_strvec_add(&buf, gpr_strdup("QUEUE_TIMEOUT"));
       break;
     case GRPC_QUEUE_SHUTDOWN:
-      gpr_strvec_add (&buf, gpr_strdup ("QUEUE_SHUTDOWN"));
+      gpr_strvec_add(&buf, gpr_strdup("QUEUE_SHUTDOWN"));
       break;
     case GRPC_OP_COMPLETE:
-      gpr_strvec_add (&buf, gpr_strdup ("OP_COMPLETE: "));
-      addhdr (&buf, ev);
-      adderr (&buf, ev->success);
+      gpr_strvec_add(&buf, gpr_strdup("OP_COMPLETE: "));
+      addhdr(&buf, ev);
+      adderr(&buf, ev->success);
       break;
-    }
+  }
 
-  out = gpr_strvec_flatten (&buf, NULL);
-  gpr_strvec_destroy (&buf);
+  out = gpr_strvec_flatten(&buf, NULL);
+  gpr_strvec_destroy(&buf);
   return out;
 }
diff --git a/src/core/surface/event_string.h b/src/core/surface/event_string.h
index 6f2dfe0282..07c474e3a0 100644
--- a/src/core/surface/event_string.h
+++ b/src/core/surface/event_string.h
@@ -37,6 +37,6 @@
 #include <grpc/grpc.h>
 
 /* Returns a string describing an event. Must be later freed with gpr_free() */
-char *grpc_event_string (grpc_event * ev);
+char *grpc_event_string(grpc_event *ev);
 
 #endif /* GRPC_INTERNAL_CORE_SURFACE_EVENT_STRING_H */
diff --git a/src/core/surface/init.c b/src/core/surface/init.c
index 4d0be4f7b9..93c27c77bf 100644
--- a/src/core/surface/init.c
+++ b/src/core/surface/init.c
@@ -61,110 +61,91 @@ static gpr_once g_basic_init = GPR_ONCE_INIT;
 static gpr_mu g_init_mu;
 static int g_initializations;
 
-static void
-do_basic_init (void)
-{
-  gpr_mu_init (&g_init_mu);
+static void do_basic_init(void) {
+  gpr_mu_init(&g_init_mu);
   g_initializations = 0;
 }
 
-typedef struct grpc_plugin
-{
-  void (*init) ();
-  void (*destroy) ();
+typedef struct grpc_plugin {
+  void (*init)();
+  void (*destroy)();
 } grpc_plugin;
 
 static grpc_plugin g_all_of_the_plugins[MAX_PLUGINS];
 static int g_number_of_plugins = 0;
 
-void
-grpc_register_plugin (void (*init) (void), void (*destroy) (void))
-{
-  GPR_ASSERT (g_number_of_plugins != MAX_PLUGINS);
+void grpc_register_plugin(void (*init)(void), void (*destroy)(void)) {
+  GPR_ASSERT(g_number_of_plugins != MAX_PLUGINS);
   g_all_of_the_plugins[g_number_of_plugins].init = init;
   g_all_of_the_plugins[g_number_of_plugins].destroy = destroy;
   g_number_of_plugins++;
 }
 
-void
-grpc_init (void)
-{
+void grpc_init(void) {
   int i;
-  gpr_once_init (&g_basic_init, do_basic_init);
+  gpr_once_init(&g_basic_init, do_basic_init);
 
-  gpr_mu_lock (&g_init_mu);
-  if (++g_initializations == 1)
-    {
-      gpr_time_init ();
-      grpc_lb_policy_registry_init (grpc_pick_first_lb_factory_create ());
-      grpc_register_lb_policy (grpc_pick_first_lb_factory_create ());
-      grpc_register_lb_policy (grpc_round_robin_lb_factory_create ());
-      grpc_resolver_registry_init ("dns:///");
-      grpc_register_resolver_type (grpc_dns_resolver_factory_create ());
-      grpc_register_resolver_type (grpc_ipv4_resolver_factory_create ());
-      grpc_register_resolver_type (grpc_ipv6_resolver_factory_create ());
+  gpr_mu_lock(&g_init_mu);
+  if (++g_initializations == 1) {
+    gpr_time_init();
+    grpc_lb_policy_registry_init(grpc_pick_first_lb_factory_create());
+    grpc_register_lb_policy(grpc_pick_first_lb_factory_create());
+    grpc_register_lb_policy(grpc_round_robin_lb_factory_create());
+    grpc_resolver_registry_init("dns:///");
+    grpc_register_resolver_type(grpc_dns_resolver_factory_create());
+    grpc_register_resolver_type(grpc_ipv4_resolver_factory_create());
+    grpc_register_resolver_type(grpc_ipv6_resolver_factory_create());
 #ifdef GPR_POSIX_SOCKET
-      grpc_register_resolver_type (grpc_unix_resolver_factory_create ());
+    grpc_register_resolver_type(grpc_unix_resolver_factory_create());
 #endif
-      grpc_register_tracer ("channel", &grpc_trace_channel);
-      grpc_register_tracer ("surface", &grpc_surface_trace);
-      grpc_register_tracer ("http", &grpc_http_trace);
-      grpc_register_tracer ("flowctl", &grpc_flowctl_trace);
-      grpc_register_tracer ("batch", &grpc_trace_batch);
-      grpc_register_tracer ("connectivity_state", &grpc_connectivity_state_trace);
-      grpc_security_pre_init ();
-      grpc_iomgr_init ();
-      grpc_tracer_init ("GRPC_TRACE");
-      /* Only initialize census if noone else has. */
-      if (census_enabled () == CENSUS_FEATURE_NONE)
-	{
-	  if (census_initialize (census_supported ()))
-	    {			/* enable all features. */
-	      gpr_log (GPR_ERROR, "Could not initialize census.");
-	    }
-	}
-      grpc_timers_global_init ();
-      for (i = 0; i < g_number_of_plugins; i++)
-	{
-	  if (g_all_of_the_plugins[i].init != NULL)
-	    {
-	      g_all_of_the_plugins[i].init ();
-	    }
-	}
+    grpc_register_tracer("channel", &grpc_trace_channel);
+    grpc_register_tracer("surface", &grpc_surface_trace);
+    grpc_register_tracer("http", &grpc_http_trace);
+    grpc_register_tracer("flowctl", &grpc_flowctl_trace);
+    grpc_register_tracer("batch", &grpc_trace_batch);
+    grpc_register_tracer("connectivity_state", &grpc_connectivity_state_trace);
+    grpc_security_pre_init();
+    grpc_iomgr_init();
+    grpc_tracer_init("GRPC_TRACE");
+    /* Only initialize census if noone else has. */
+    if (census_enabled() == CENSUS_FEATURE_NONE) {
+      if (census_initialize(census_supported())) { /* enable all features. */
+        gpr_log(GPR_ERROR, "Could not initialize census.");
+      }
     }
-  gpr_mu_unlock (&g_init_mu);
+    grpc_timers_global_init();
+    for (i = 0; i < g_number_of_plugins; i++) {
+      if (g_all_of_the_plugins[i].init != NULL) {
+        g_all_of_the_plugins[i].init();
+      }
+    }
+  }
+  gpr_mu_unlock(&g_init_mu);
 }
 
-void
-grpc_shutdown (void)
-{
+void grpc_shutdown(void) {
   int i;
-  gpr_mu_lock (&g_init_mu);
-  if (--g_initializations == 0)
-    {
-      grpc_iomgr_shutdown ();
-      census_shutdown ();
-      grpc_timers_global_destroy ();
-      grpc_tracer_shutdown ();
-      grpc_resolver_registry_shutdown ();
-      for (i = 0; i < g_number_of_plugins; i++)
-	{
-	  if (g_all_of_the_plugins[i].destroy != NULL)
-	    {
-	      g_all_of_the_plugins[i].destroy ();
-	    }
-	}
+  gpr_mu_lock(&g_init_mu);
+  if (--g_initializations == 0) {
+    grpc_iomgr_shutdown();
+    census_shutdown();
+    grpc_timers_global_destroy();
+    grpc_tracer_shutdown();
+    grpc_resolver_registry_shutdown();
+    for (i = 0; i < g_number_of_plugins; i++) {
+      if (g_all_of_the_plugins[i].destroy != NULL) {
+        g_all_of_the_plugins[i].destroy();
+      }
     }
-  gpr_mu_unlock (&g_init_mu);
+  }
+  gpr_mu_unlock(&g_init_mu);
 }
 
-int
-grpc_is_initialized (void)
-{
+int grpc_is_initialized(void) {
   int r;
-  gpr_once_init (&g_basic_init, do_basic_init);
-  gpr_mu_lock (&g_init_mu);
+  gpr_once_init(&g_basic_init, do_basic_init);
+  gpr_mu_lock(&g_init_mu);
   r = g_initializations > 0;
-  gpr_mu_unlock (&g_init_mu);
+  gpr_mu_unlock(&g_init_mu);
   return r;
 }
diff --git a/src/core/surface/init.h b/src/core/surface/init.h
index e880e3b2c0..771c30f412 100644
--- a/src/core/surface/init.h
+++ b/src/core/surface/init.h
@@ -34,7 +34,7 @@
 #ifndef GRPC_INTERNAL_CORE_SURFACE_INIT_H
 #define GRPC_INTERNAL_CORE_SURFACE_INIT_H
 
-void grpc_security_pre_init (void);
-int grpc_is_initialized (void);
+void grpc_security_pre_init(void);
+int grpc_is_initialized(void);
 
 #endif /* GRPC_INTERNAL_CORE_SURFACE_INIT_H */
diff --git a/src/core/surface/init_secure.c b/src/core/surface/init_secure.c
index 2ae1dd8b6f..fa20e91583 100644
--- a/src/core/surface/init_secure.c
+++ b/src/core/surface/init_secure.c
@@ -36,9 +36,7 @@
 #include "src/core/security/secure_endpoint.h"
 #include "src/core/tsi/transport_security_interface.h"
 
-void
-grpc_security_pre_init (void)
-{
-  grpc_register_tracer ("secure_endpoint", &grpc_trace_secure_endpoint);
-  grpc_register_tracer ("transport_security", &tsi_tracing_enabled);
+void grpc_security_pre_init(void) {
+  grpc_register_tracer("secure_endpoint", &grpc_trace_secure_endpoint);
+  grpc_register_tracer("transport_security", &tsi_tracing_enabled);
 }
diff --git a/src/core/surface/init_unsecure.c b/src/core/surface/init_unsecure.c
index 5b8a0abf6f..630d564a7d 100644
--- a/src/core/surface/init_unsecure.c
+++ b/src/core/surface/init_unsecure.c
@@ -33,7 +33,4 @@
 
 #include "src/core/surface/init.h"
 
-void
-grpc_security_pre_init (void)
-{
-}
+void grpc_security_pre_init(void) {}
diff --git a/src/core/surface/lame_client.c b/src/core/surface/lame_client.c
index 2d78623590..0b22d225d0 100644
--- a/src/core/surface/lame_client.c
+++ b/src/core/surface/lame_client.c
@@ -42,135 +42,126 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-typedef struct
-{
+typedef struct {
   grpc_linked_mdelem status;
   grpc_linked_mdelem details;
 } call_data;
 
-typedef struct
-{
+typedef struct {
   grpc_mdctx *mdctx;
   grpc_channel *master;
   grpc_status_code error_code;
   const char *error_message;
 } channel_data;
 
-static void
-lame_start_transport_stream_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
-{
+static void lame_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;
-  GRPC_CALL_LOG_OP (GPR_INFO, elem, op);
-  if (op->send_ops != NULL)
-    {
-      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 != NULL)
-    {
-      char tmp[GPR_LTOA_MIN_BUFSIZE];
-      grpc_metadata_batch mdb;
-      gpr_ltoa (chand->error_code, tmp);
-      calld->status.md = grpc_mdelem_from_strings (chand->mdctx, "grpc-status", tmp);
-      calld->details.md = grpc_mdelem_from_strings (chand->mdctx, "grpc-message", chand->error_message);
-      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 != NULL)
-    {
-      op->on_consumed->cb (exec_ctx, op->on_consumed->cb_arg, 0);
-    }
+  GRPC_CALL_LOG_OP(GPR_INFO, elem, op);
+  if (op->send_ops != NULL) {
+    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 != NULL) {
+    char tmp[GPR_LTOA_MIN_BUFSIZE];
+    grpc_metadata_batch mdb;
+    gpr_ltoa(chand->error_code, tmp);
+    calld->status.md =
+        grpc_mdelem_from_strings(chand->mdctx, "grpc-status", tmp);
+    calld->details.md = grpc_mdelem_from_strings(chand->mdctx, "grpc-message",
+                                                 chand->error_message);
+    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 != NULL) {
+    op->on_consumed->cb(exec_ctx, op->on_consumed->cb_arg, 0);
+  }
 }
 
-static char *
-lame_get_peer (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
-{
+static char *lame_get_peer(grpc_exec_ctx *exec_ctx, grpc_call_element *elem) {
   channel_data *chand = elem->channel_data;
-  return grpc_channel_get_target (chand->master);
+  return grpc_channel_get_target(chand->master);
 }
 
-static void
-lame_start_transport_op (grpc_exec_ctx * exec_ctx, grpc_channel_element * elem, grpc_transport_op * op)
-{
-  if (op->on_connectivity_state_change)
-    {
-      GPR_ASSERT (*op->connectivity_state != GRPC_CHANNEL_FATAL_FAILURE);
-      *op->connectivity_state = GRPC_CHANNEL_FATAL_FAILURE;
-      op->on_connectivity_state_change->cb (exec_ctx, op->on_connectivity_state_change->cb_arg, 1);
-    }
-  if (op->on_consumed != NULL)
-    {
-      op->on_consumed->cb (exec_ctx, op->on_consumed->cb_arg, 1);
-    }
+static void lame_start_transport_op(grpc_exec_ctx *exec_ctx,
+                                    grpc_channel_element *elem,
+                                    grpc_transport_op *op) {
+  if (op->on_connectivity_state_change) {
+    GPR_ASSERT(*op->connectivity_state != GRPC_CHANNEL_FATAL_FAILURE);
+    *op->connectivity_state = GRPC_CHANNEL_FATAL_FAILURE;
+    op->on_connectivity_state_change->cb(
+        exec_ctx, op->on_connectivity_state_change->cb_arg, 1);
+  }
+  if (op->on_consumed != NULL) {
+    op->on_consumed->cb(exec_ctx, op->on_consumed->cb_arg, 1);
+  }
 }
 
-static void
-init_call_elem (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, const void *transport_server_data, grpc_transport_stream_op * initial_op)
-{
-  if (initial_op)
-    {
-      grpc_transport_stream_op_finish_with_failure (exec_ctx, initial_op);
-    }
+static void init_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
+                           const void *transport_server_data,
+                           grpc_transport_stream_op *initial_op) {
+  if (initial_op) {
+    grpc_transport_stream_op_finish_with_failure(exec_ctx, initial_op);
+  }
 }
 
-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 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 (is_first);
-  GPR_ASSERT (is_last);
+  GPR_ASSERT(is_first);
+  GPR_ASSERT(is_last);
   chand->mdctx = mdctx;
   chand->master = master;
 }
 
-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) {}
 
 static const grpc_channel_filter lame_filter = {
-  lame_start_transport_stream_op,
-  lame_start_transport_op,
-  sizeof (call_data),
-  init_call_elem,
-  destroy_call_elem,
-  sizeof (channel_data),
-  init_channel_elem,
-  destroy_channel_elem,
-  lame_get_peer,
-  "lame-client",
+    lame_start_transport_stream_op,
+    lame_start_transport_op,
+    sizeof(call_data),
+    init_call_elem,
+    destroy_call_elem,
+    sizeof(channel_data),
+    init_channel_elem,
+    destroy_channel_elem,
+    lame_get_peer,
+    "lame-client",
 };
 
 #define CHANNEL_STACK_FROM_CHANNEL(c) ((grpc_channel_stack *)((c) + 1))
 
-grpc_channel *
-grpc_lame_client_channel_create (const char *target, grpc_status_code error_code, const char *error_message)
-{
+grpc_channel *grpc_lame_client_channel_create(const char *target,
+                                              grpc_status_code error_code,
+                                              const char *error_message) {
   grpc_channel *channel;
   grpc_channel_element *elem;
   channel_data *chand;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  static const grpc_channel_filter *filters[] = { &lame_filter };
-  channel = grpc_channel_create_from_filters (&exec_ctx, target, filters, 1, NULL, grpc_mdctx_create (), 1);
-  elem = grpc_channel_stack_element (grpc_channel_get_channel_stack (channel), 0);
-  GPR_ASSERT (elem->filter == &lame_filter);
-  chand = (channel_data *) elem->channel_data;
+  static const grpc_channel_filter *filters[] = {&lame_filter};
+  channel = grpc_channel_create_from_filters(&exec_ctx, target, filters, 1,
+                                             NULL, grpc_mdctx_create(), 1);
+  elem = grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0);
+  GPR_ASSERT(elem->filter == &lame_filter);
+  chand = (channel_data *)elem->channel_data;
   chand->error_code = error_code;
   chand->error_message = error_message;
-  grpc_exec_ctx_finish (&exec_ctx);
+  grpc_exec_ctx_finish(&exec_ctx);
   return channel;
 }
diff --git a/src/core/surface/metadata_array.c b/src/core/surface/metadata_array.c
index 5abc582f64..648c579266 100644
--- a/src/core/surface/metadata_array.c
+++ b/src/core/surface/metadata_array.c
@@ -36,14 +36,10 @@
 
 #include <string.h>
 
-void
-grpc_metadata_array_init (grpc_metadata_array * array)
-{
-  memset (array, 0, sizeof (*array));
+void grpc_metadata_array_init(grpc_metadata_array* array) {
+  memset(array, 0, sizeof(*array));
 }
 
-void
-grpc_metadata_array_destroy (grpc_metadata_array * array)
-{
-  gpr_free (array->metadata);
+void grpc_metadata_array_destroy(grpc_metadata_array* array) {
+  gpr_free(array->metadata);
 }
diff --git a/src/core/surface/secure_channel_create.c b/src/core/surface/secure_channel_create.c
index dbbf6f5140..ae2eaad896 100644
--- a/src/core/surface/secure_channel_create.c
+++ b/src/core/surface/secure_channel_create.c
@@ -51,8 +51,7 @@
 #include "src/core/transport/chttp2_transport.h"
 #include "src/core/tsi/transport_security_interface.h"
 
-typedef struct
-{
+typedef struct {
   grpc_connector base;
   gpr_refcount refs;
 
@@ -71,120 +70,107 @@ typedef struct
   grpc_mdctx *mdctx;
 } connector;
 
-static void
-connector_ref (grpc_connector * con)
-{
-  connector *c = (connector *) con;
-  gpr_ref (&c->refs);
+static void connector_ref(grpc_connector *con) {
+  connector *c = (connector *)con;
+  gpr_ref(&c->refs);
 }
 
-static void
-connector_unref (grpc_exec_ctx * exec_ctx, grpc_connector * con)
-{
-  connector *c = (connector *) con;
-  if (gpr_unref (&c->refs))
-    {
-      grpc_mdctx_unref (c->mdctx);
-      gpr_free (c);
-    }
+static void connector_unref(grpc_exec_ctx *exec_ctx, grpc_connector *con) {
+  connector *c = (connector *)con;
+  if (gpr_unref(&c->refs)) {
+    grpc_mdctx_unref(c->mdctx);
+    gpr_free(c);
+  }
 }
 
-static void
-on_secure_handshake_done (grpc_exec_ctx * exec_ctx, void *arg, grpc_security_status status, grpc_endpoint * wrapped_endpoint, grpc_endpoint * secure_endpoint)
-{
+static void on_secure_handshake_done(grpc_exec_ctx *exec_ctx, void *arg,
+                                     grpc_security_status status,
+                                     grpc_endpoint *wrapped_endpoint,
+                                     grpc_endpoint *secure_endpoint) {
   connector *c = arg;
   grpc_closure *notify;
-  gpr_mu_lock (&c->mu);
-  if (c->connecting_endpoint == NULL)
-    {
-      memset (c->result, 0, sizeof (*c->result));
-      gpr_mu_unlock (&c->mu);
-    }
-  else if (status != GRPC_SECURITY_OK)
-    {
-      GPR_ASSERT (c->connecting_endpoint == wrapped_endpoint);
-      gpr_log (GPR_ERROR, "Secure handshake failed with error %d.", status);
-      memset (c->result, 0, sizeof (*c->result));
-      c->connecting_endpoint = NULL;
-      gpr_mu_unlock (&c->mu);
-    }
-  else
-    {
-      GPR_ASSERT (c->connecting_endpoint == wrapped_endpoint);
-      c->connecting_endpoint = NULL;
-      gpr_mu_unlock (&c->mu);
-      c->result->transport = grpc_create_chttp2_transport (exec_ctx, c->args.channel_args, secure_endpoint, c->mdctx, 1);
-      grpc_chttp2_transport_start_reading (exec_ctx, c->result->transport, NULL, 0);
-      c->result->filters = gpr_malloc (sizeof (grpc_channel_filter *) * 2);
-      c->result->filters[0] = &grpc_http_client_filter;
-      c->result->filters[1] = &grpc_client_auth_filter;
-      c->result->num_filters = 2;
-    }
+  gpr_mu_lock(&c->mu);
+  if (c->connecting_endpoint == NULL) {
+    memset(c->result, 0, sizeof(*c->result));
+    gpr_mu_unlock(&c->mu);
+  } else if (status != GRPC_SECURITY_OK) {
+    GPR_ASSERT(c->connecting_endpoint == wrapped_endpoint);
+    gpr_log(GPR_ERROR, "Secure handshake failed with error %d.", status);
+    memset(c->result, 0, sizeof(*c->result));
+    c->connecting_endpoint = NULL;
+    gpr_mu_unlock(&c->mu);
+  } else {
+    GPR_ASSERT(c->connecting_endpoint == wrapped_endpoint);
+    c->connecting_endpoint = NULL;
+    gpr_mu_unlock(&c->mu);
+    c->result->transport = grpc_create_chttp2_transport(
+        exec_ctx, c->args.channel_args, secure_endpoint, c->mdctx, 1);
+    grpc_chttp2_transport_start_reading(exec_ctx, c->result->transport, NULL,
+                                        0);
+    c->result->filters = gpr_malloc(sizeof(grpc_channel_filter *) * 2);
+    c->result->filters[0] = &grpc_http_client_filter;
+    c->result->filters[1] = &grpc_client_auth_filter;
+    c->result->num_filters = 2;
+  }
   notify = c->notify;
   c->notify = NULL;
-  notify->cb (exec_ctx, notify->cb_arg, 1);
+  notify->cb(exec_ctx, notify->cb_arg, 1);
 }
 
-static void
-connected (grpc_exec_ctx * exec_ctx, void *arg, int success)
-{
+static void connected(grpc_exec_ctx *exec_ctx, void *arg, int success) {
   connector *c = arg;
   grpc_closure *notify;
   grpc_endpoint *tcp = c->newly_connecting_endpoint;
-  if (tcp != NULL)
-    {
-      gpr_mu_lock (&c->mu);
-      GPR_ASSERT (c->connecting_endpoint == NULL);
-      c->connecting_endpoint = tcp;
-      gpr_mu_unlock (&c->mu);
-      grpc_security_connector_do_handshake (exec_ctx, &c->security_connector->base, tcp, on_secure_handshake_done, c);
-    }
-  else
-    {
-      memset (c->result, 0, sizeof (*c->result));
-      notify = c->notify;
-      c->notify = NULL;
-      notify->cb (exec_ctx, notify->cb_arg, 1);
-    }
+  if (tcp != NULL) {
+    gpr_mu_lock(&c->mu);
+    GPR_ASSERT(c->connecting_endpoint == NULL);
+    c->connecting_endpoint = tcp;
+    gpr_mu_unlock(&c->mu);
+    grpc_security_connector_do_handshake(exec_ctx, &c->security_connector->base,
+                                         tcp, on_secure_handshake_done, c);
+  } else {
+    memset(c->result, 0, sizeof(*c->result));
+    notify = c->notify;
+    c->notify = NULL;
+    notify->cb(exec_ctx, notify->cb_arg, 1);
+  }
 }
 
-static void
-connector_shutdown (grpc_exec_ctx * exec_ctx, grpc_connector * con)
-{
-  connector *c = (connector *) con;
+static void connector_shutdown(grpc_exec_ctx *exec_ctx, grpc_connector *con) {
+  connector *c = (connector *)con;
   grpc_endpoint *ep;
-  gpr_mu_lock (&c->mu);
+  gpr_mu_lock(&c->mu);
   ep = c->connecting_endpoint;
   c->connecting_endpoint = NULL;
-  gpr_mu_unlock (&c->mu);
-  if (ep)
-    {
-      grpc_endpoint_shutdown (exec_ctx, ep);
-    }
+  gpr_mu_unlock(&c->mu);
+  if (ep) {
+    grpc_endpoint_shutdown(exec_ctx, ep);
+  }
 }
 
-static void
-connector_connect (grpc_exec_ctx * exec_ctx, grpc_connector * con, const grpc_connect_in_args * args, grpc_connect_out_args * result, grpc_closure * notify)
-{
-  connector *c = (connector *) con;
-  GPR_ASSERT (c->notify == NULL);
-  GPR_ASSERT (notify->cb);
+static void connector_connect(grpc_exec_ctx *exec_ctx, grpc_connector *con,
+                              const grpc_connect_in_args *args,
+                              grpc_connect_out_args *result,
+                              grpc_closure *notify) {
+  connector *c = (connector *)con;
+  GPR_ASSERT(c->notify == NULL);
+  GPR_ASSERT(notify->cb);
   c->notify = notify;
   c->args = *args;
   c->result = result;
-  gpr_mu_lock (&c->mu);
-  GPR_ASSERT (c->connecting_endpoint == NULL);
-  gpr_mu_unlock (&c->mu);
-  grpc_closure_init (&c->connected_closure, connected, c);
-  grpc_tcp_client_connect (exec_ctx, &c->connected_closure, &c->newly_connecting_endpoint, args->interested_parties, args->addr, args->addr_len, args->deadline);
+  gpr_mu_lock(&c->mu);
+  GPR_ASSERT(c->connecting_endpoint == NULL);
+  gpr_mu_unlock(&c->mu);
+  grpc_closure_init(&c->connected_closure, connected, c);
+  grpc_tcp_client_connect(
+      exec_ctx, &c->connected_closure, &c->newly_connecting_endpoint,
+      args->interested_parties, args->addr, args->addr_len, args->deadline);
 }
 
 static const grpc_connector_vtable connector_vtable = {
-  connector_ref, connector_unref, connector_shutdown, connector_connect
-};
+    connector_ref, connector_unref, connector_shutdown, connector_connect};
 
-typedef struct
-{
+typedef struct {
   grpc_subchannel_factory base;
   gpr_refcount refs;
   grpc_mdctx *mdctx;
@@ -193,61 +179,59 @@ typedef struct
   grpc_channel *master;
 } subchannel_factory;
 
-static void
-subchannel_factory_ref (grpc_subchannel_factory * scf)
-{
-  subchannel_factory *f = (subchannel_factory *) scf;
-  gpr_ref (&f->refs);
+static void subchannel_factory_ref(grpc_subchannel_factory *scf) {
+  subchannel_factory *f = (subchannel_factory *)scf;
+  gpr_ref(&f->refs);
 }
 
-static void
-subchannel_factory_unref (grpc_exec_ctx * exec_ctx, grpc_subchannel_factory * scf)
-{
-  subchannel_factory *f = (subchannel_factory *) scf;
-  if (gpr_unref (&f->refs))
-    {
-      GRPC_SECURITY_CONNECTOR_UNREF (&f->security_connector->base, "subchannel_factory");
-      GRPC_CHANNEL_INTERNAL_UNREF (exec_ctx, f->master, "subchannel_factory");
-      grpc_channel_args_destroy (f->merge_args);
-      grpc_mdctx_unref (f->mdctx);
-      gpr_free (f);
-    }
+static void subchannel_factory_unref(grpc_exec_ctx *exec_ctx,
+                                     grpc_subchannel_factory *scf) {
+  subchannel_factory *f = (subchannel_factory *)scf;
+  if (gpr_unref(&f->refs)) {
+    GRPC_SECURITY_CONNECTOR_UNREF(&f->security_connector->base,
+                                  "subchannel_factory");
+    GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, f->master, "subchannel_factory");
+    grpc_channel_args_destroy(f->merge_args);
+    grpc_mdctx_unref(f->mdctx);
+    gpr_free(f);
+  }
 }
 
-static grpc_subchannel *
-subchannel_factory_create_subchannel (grpc_exec_ctx * exec_ctx, grpc_subchannel_factory * scf, grpc_subchannel_args * args)
-{
-  subchannel_factory *f = (subchannel_factory *) scf;
-  connector *c = gpr_malloc (sizeof (*c));
-  grpc_channel_args *final_args = grpc_channel_args_merge (args->args, f->merge_args);
+static grpc_subchannel *subchannel_factory_create_subchannel(
+    grpc_exec_ctx *exec_ctx, grpc_subchannel_factory *scf,
+    grpc_subchannel_args *args) {
+  subchannel_factory *f = (subchannel_factory *)scf;
+  connector *c = gpr_malloc(sizeof(*c));
+  grpc_channel_args *final_args =
+      grpc_channel_args_merge(args->args, f->merge_args);
   grpc_subchannel *s;
-  memset (c, 0, sizeof (*c));
+  memset(c, 0, sizeof(*c));
   c->base.vtable = &connector_vtable;
   c->security_connector = f->security_connector;
   c->mdctx = f->mdctx;
-  grpc_mdctx_ref (c->mdctx);
-  gpr_ref_init (&c->refs, 1);
+  grpc_mdctx_ref(c->mdctx);
+  gpr_ref_init(&c->refs, 1);
   args->args = final_args;
   args->master = f->master;
   args->mdctx = f->mdctx;
-  s = grpc_subchannel_create (&c->base, args);
-  grpc_connector_unref (exec_ctx, &c->base);
-  grpc_channel_args_destroy (final_args);
+  s = grpc_subchannel_create(&c->base, args);
+  grpc_connector_unref(exec_ctx, &c->base);
+  grpc_channel_args_destroy(final_args);
   return s;
 }
 
 static const grpc_subchannel_factory_vtable subchannel_factory_vtable = {
-  subchannel_factory_ref, subchannel_factory_unref,
-  subchannel_factory_create_subchannel
-};
+    subchannel_factory_ref, subchannel_factory_unref,
+    subchannel_factory_create_subchannel};
 
 /* Create a secure client channel:
    Asynchronously: - resolve target
                    - connect to it (trying alternatives as presented)
                    - perform handshakes */
-grpc_channel *
-grpc_secure_channel_create (grpc_credentials * creds, const char *target, const grpc_channel_args * args, void *reserved)
-{
+grpc_channel *grpc_secure_channel_create(grpc_credentials *creds,
+                                         const char *target,
+                                         const grpc_channel_args *args,
+                                         void *reserved) {
   grpc_channel *channel;
   grpc_arg connector_arg;
   grpc_channel_args *args_copy;
@@ -261,59 +245,64 @@ grpc_secure_channel_create (grpc_credentials * creds, const char *target, const
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   size_t n = 0;
 
-  GPR_ASSERT (reserved == NULL);
-  if (grpc_find_security_connector_in_args (args) != NULL)
-    {
-      gpr_log (GPR_ERROR, "Cannot set security context in channel args.");
-      return grpc_lame_client_channel_create (target, GRPC_STATUS_INVALID_ARGUMENT, "Security connector exists in channel args.");
-    }
-
-  if (grpc_credentials_create_security_connector (creds, target, args, NULL, &connector, &new_args_from_connector) != GRPC_SECURITY_OK)
-    {
-      return grpc_lame_client_channel_create (target, GRPC_STATUS_INVALID_ARGUMENT, "Failed to create security connector.");
-    }
-  mdctx = grpc_mdctx_create ();
-
-  connector_arg = grpc_security_connector_to_arg (&connector->base);
-  args_copy = grpc_channel_args_copy_and_add (new_args_from_connector != NULL ? new_args_from_connector : args, &connector_arg, 1);
-  if (grpc_channel_args_is_census_enabled (args))
-    {
-      filters[n++] = &grpc_client_census_filter;
-    }
+  GPR_ASSERT(reserved == NULL);
+  if (grpc_find_security_connector_in_args(args) != NULL) {
+    gpr_log(GPR_ERROR, "Cannot set security context in channel args.");
+    return grpc_lame_client_channel_create(
+        target, GRPC_STATUS_INVALID_ARGUMENT,
+        "Security connector exists in channel args.");
+  }
+
+  if (grpc_credentials_create_security_connector(
+          creds, target, args, NULL, &connector, &new_args_from_connector) !=
+      GRPC_SECURITY_OK) {
+    return grpc_lame_client_channel_create(
+        target, GRPC_STATUS_INVALID_ARGUMENT,
+        "Failed to create security connector.");
+  }
+  mdctx = grpc_mdctx_create();
+
+  connector_arg = grpc_security_connector_to_arg(&connector->base);
+  args_copy = grpc_channel_args_copy_and_add(
+      new_args_from_connector != NULL ? new_args_from_connector : args,
+      &connector_arg, 1);
+  if (grpc_channel_args_is_census_enabled(args)) {
+    filters[n++] = &grpc_client_census_filter;
+  }
   filters[n++] = &grpc_compress_filter;
   filters[n++] = &grpc_client_channel_filter;
-  GPR_ASSERT (n <= MAX_FILTERS);
+  GPR_ASSERT(n <= MAX_FILTERS);
 
-  channel = grpc_channel_create_from_filters (&exec_ctx, target, filters, n, args_copy, mdctx, 1);
+  channel = grpc_channel_create_from_filters(&exec_ctx, target, filters, n,
+                                             args_copy, mdctx, 1);
 
-  f = gpr_malloc (sizeof (*f));
+  f = gpr_malloc(sizeof(*f));
   f->base.vtable = &subchannel_factory_vtable;
-  gpr_ref_init (&f->refs, 1);
-  grpc_mdctx_ref (mdctx);
+  gpr_ref_init(&f->refs, 1);
+  grpc_mdctx_ref(mdctx);
   f->mdctx = mdctx;
-  GRPC_SECURITY_CONNECTOR_REF (&connector->base, "subchannel_factory");
+  GRPC_SECURITY_CONNECTOR_REF(&connector->base, "subchannel_factory");
   f->security_connector = connector;
-  f->merge_args = grpc_channel_args_copy (args_copy);
+  f->merge_args = grpc_channel_args_copy(args_copy);
   f->master = channel;
-  GRPC_CHANNEL_INTERNAL_REF (channel, "subchannel_factory");
-  resolver = grpc_resolver_create (target, &f->base);
-  if (!resolver)
-    {
-      return NULL;
-    }
-
-  grpc_client_channel_set_resolver (&exec_ctx, grpc_channel_get_channel_stack (channel), resolver);
-  GRPC_RESOLVER_UNREF (&exec_ctx, resolver, "create");
-  grpc_subchannel_factory_unref (&exec_ctx, &f->base);
-  GRPC_SECURITY_CONNECTOR_UNREF (&connector->base, "channel_create");
-
-  grpc_channel_args_destroy (args_copy);
-  if (new_args_from_connector != NULL)
-    {
-      grpc_channel_args_destroy (new_args_from_connector);
-    }
-
-  grpc_exec_ctx_finish (&exec_ctx);
+  GRPC_CHANNEL_INTERNAL_REF(channel, "subchannel_factory");
+  resolver = grpc_resolver_create(target, &f->base);
+  if (!resolver) {
+    return NULL;
+  }
+
+  grpc_client_channel_set_resolver(
+      &exec_ctx, grpc_channel_get_channel_stack(channel), resolver);
+  GRPC_RESOLVER_UNREF(&exec_ctx, resolver, "create");
+  grpc_subchannel_factory_unref(&exec_ctx, &f->base);
+  GRPC_SECURITY_CONNECTOR_UNREF(&connector->base, "channel_create");
+
+  grpc_channel_args_destroy(args_copy);
+  if (new_args_from_connector != NULL) {
+    grpc_channel_args_destroy(new_args_from_connector);
+  }
+
+  grpc_exec_ctx_finish(&exec_ctx);
 
   return channel;
 }
diff --git a/src/core/surface/server.c b/src/core/surface/server.c
index c11ea26da7..a26b84c0d3 100644
--- a/src/core/surface/server.c
+++ b/src/core/surface/server.c
@@ -54,11 +54,12 @@
 #include "src/core/surface/init.h"
 #include "src/core/transport/metadata.h"
 
-typedef struct listener
-{
+typedef struct listener {
   void *arg;
-  void (*start) (grpc_exec_ctx * exec_ctx, grpc_server * server, void *arg, grpc_pollset ** pollsets, size_t pollset_count);
-  void (*destroy) (grpc_exec_ctx * exec_ctx, grpc_server * server, void *arg, grpc_closure * closure);
+  void (*start)(grpc_exec_ctx *exec_ctx, grpc_server *server, void *arg,
+                grpc_pollset **pollsets, size_t pollset_count);
+  void (*destroy)(grpc_exec_ctx *exec_ctx, grpc_server *server, void *arg,
+                  grpc_closure *closure);
   struct listener *next;
   grpc_closure destroy_done;
 } listener;
@@ -67,17 +68,14 @@ typedef struct call_data call_data;
 typedef struct channel_data channel_data;
 typedef struct registered_method registered_method;
 
-typedef struct
-{
+typedef struct {
   call_data *next;
   call_data *prev;
 } call_link;
 
-typedef enum
-{ BATCH_CALL, REGISTERED_CALL } requested_call_type;
+typedef enum { BATCH_CALL, REGISTERED_CALL } requested_call_type;
 
-typedef struct requested_call
-{
+typedef struct requested_call {
   requested_call_type type;
   void *tag;
   grpc_server *server;
@@ -85,15 +83,12 @@ typedef struct requested_call
   grpc_completion_queue *cq_for_notification;
   grpc_call **call;
   grpc_cq_completion completion;
-  union
-  {
-    struct
-    {
+  union {
+    struct {
       grpc_call_details *details;
       grpc_metadata_array *initial_metadata;
     } batch;
-    struct
-    {
+    struct {
       registered_method *registered_method;
       gpr_timespec *deadline;
       grpc_metadata_array *initial_metadata;
@@ -102,15 +97,13 @@ typedef struct requested_call
   } data;
 } requested_call;
 
-typedef struct channel_registered_method
-{
+typedef struct channel_registered_method {
   registered_method *server_registered_method;
   grpc_mdstr *method;
   grpc_mdstr *host;
 } channel_registered_method;
 
-struct channel_data
-{
+struct channel_data {
   grpc_server *server;
   grpc_connectivity_state connectivity_state;
   grpc_channel *channel;
@@ -126,15 +119,13 @@ struct channel_data
   grpc_closure channel_connectivity_changed;
 };
 
-typedef struct shutdown_tag
-{
+typedef struct shutdown_tag {
   void *tag;
   grpc_completion_queue *cq;
   grpc_cq_completion completion;
 } shutdown_tag;
 
-typedef enum
-{
+typedef enum {
   /* waiting for metadata */
   NOT_STARTED,
   /* inital metadata read, not flow controlled in yet */
@@ -147,8 +138,7 @@ typedef enum
 
 typedef struct request_matcher request_matcher;
 
-struct call_data
-{
+struct call_data {
   grpc_call *call;
 
   /** protects state */
@@ -173,29 +163,25 @@ struct call_data
   call_data *pending_next;
 };
 
-struct request_matcher
-{
+struct request_matcher {
   call_data *pending_head;
   call_data *pending_tail;
   gpr_stack_lockfree *requests;
 };
 
-struct registered_method
-{
+struct registered_method {
   char *method;
   char *host;
   request_matcher request_matcher;
   registered_method *next;
 };
 
-typedef struct
-{
+typedef struct {
   grpc_channel **channels;
   size_t num_channels;
 } channel_broadcaster;
 
-struct grpc_server
-{
+struct grpc_server {
   size_t channel_filter_count;
   const grpc_channel_filter **channel_filters;
   grpc_channel_args *channel_args;
@@ -211,8 +197,8 @@ struct grpc_server
      If they are ever required to be nested, you must lock mu_global
      before mu_call. This is currently used in shutdown processing
      (grpc_server_shutdown_and_notify and maybe_finish_shutdown) */
-  gpr_mu mu_global;		/* mutex for server and channel state */
-  gpr_mu mu_call;		/* mutex for call-specific state */
+  gpr_mu mu_global; /* mutex for server and channel state */
+  gpr_mu mu_call;   /* mutex for call-specific state */
 
   registered_method *registered_methods;
   request_matcher unregistered_request_matcher;
@@ -240,267 +226,230 @@ struct grpc_server
 #define SERVER_FROM_CALL_ELEM(elem) \
   (((channel_data *)(elem)->channel_data)->server)
 
-static void begin_call (grpc_exec_ctx * exec_ctx, grpc_server * server, call_data * calld, requested_call * rc);
-static void fail_call (grpc_exec_ctx * exec_ctx, grpc_server * server, requested_call * rc);
+static void begin_call(grpc_exec_ctx *exec_ctx, grpc_server *server,
+                       call_data *calld, requested_call *rc);
+static void fail_call(grpc_exec_ctx *exec_ctx, grpc_server *server,
+                      requested_call *rc);
 /* Before calling maybe_finish_shutdown, we must hold mu_global and not
    hold mu_call */
-static void maybe_finish_shutdown (grpc_exec_ctx * exec_ctx, grpc_server * server);
+static void maybe_finish_shutdown(grpc_exec_ctx *exec_ctx, grpc_server *server);
 
 /*
  * channel broadcaster
  */
 
 /* assumes server locked */
-static void
-channel_broadcaster_init (grpc_server * s, channel_broadcaster * cb)
-{
+static void channel_broadcaster_init(grpc_server *s, channel_broadcaster *cb) {
   channel_data *c;
   size_t count = 0;
-  for (c = s->root_channel_data.next; c != &s->root_channel_data; c = c->next)
-    {
-      count++;
-    }
+  for (c = s->root_channel_data.next; c != &s->root_channel_data; c = c->next) {
+    count++;
+  }
   cb->num_channels = count;
-  cb->channels = gpr_malloc (sizeof (*cb->channels) * cb->num_channels);
+  cb->channels = gpr_malloc(sizeof(*cb->channels) * cb->num_channels);
   count = 0;
-  for (c = s->root_channel_data.next; c != &s->root_channel_data; c = c->next)
-    {
-      cb->channels[count++] = c->channel;
-      GRPC_CHANNEL_INTERNAL_REF (c->channel, "broadcast");
-    }
+  for (c = s->root_channel_data.next; c != &s->root_channel_data; c = c->next) {
+    cb->channels[count++] = c->channel;
+    GRPC_CHANNEL_INTERNAL_REF(c->channel, "broadcast");
+  }
 }
 
-struct shutdown_cleanup_args
-{
+struct shutdown_cleanup_args {
   grpc_closure closure;
   gpr_slice slice;
 };
 
-static void
-shutdown_cleanup (grpc_exec_ctx * exec_ctx, void *arg, int iomgr_status_ignored)
-{
+static void shutdown_cleanup(grpc_exec_ctx *exec_ctx, void *arg,
+                             int iomgr_status_ignored) {
   struct shutdown_cleanup_args *a = arg;
-  gpr_slice_unref (a->slice);
-  gpr_free (a);
+  gpr_slice_unref(a->slice);
+  gpr_free(a);
 }
 
-static void
-send_shutdown (grpc_exec_ctx * exec_ctx, grpc_channel * channel, int send_goaway, int send_disconnect)
-{
+static void send_shutdown(grpc_exec_ctx *exec_ctx, grpc_channel *channel,
+                          int send_goaway, int send_disconnect) {
   grpc_transport_op op;
   struct shutdown_cleanup_args *sc;
   grpc_channel_element *elem;
 
-  memset (&op, 0, sizeof (op));
+  memset(&op, 0, sizeof(op));
   op.send_goaway = send_goaway;
-  sc = gpr_malloc (sizeof (*sc));
-  sc->slice = gpr_slice_from_copied_string ("Server shutdown");
+  sc = gpr_malloc(sizeof(*sc));
+  sc->slice = gpr_slice_from_copied_string("Server shutdown");
   op.goaway_message = &sc->slice;
   op.goaway_status = GRPC_STATUS_OK;
   op.disconnect = send_disconnect;
-  grpc_closure_init (&sc->closure, shutdown_cleanup, sc);
+  grpc_closure_init(&sc->closure, shutdown_cleanup, sc);
   op.on_consumed = &sc->closure;
 
-  elem = grpc_channel_stack_element (grpc_channel_get_channel_stack (channel), 0);
-  elem->filter->start_transport_op (exec_ctx, elem, &op);
+  elem = grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0);
+  elem->filter->start_transport_op(exec_ctx, elem, &op);
 }
 
-static void
-channel_broadcaster_shutdown (grpc_exec_ctx * exec_ctx, channel_broadcaster * cb, int send_goaway, int force_disconnect)
-{
+static void channel_broadcaster_shutdown(grpc_exec_ctx *exec_ctx,
+                                         channel_broadcaster *cb,
+                                         int send_goaway,
+                                         int force_disconnect) {
   size_t i;
 
-  for (i = 0; i < cb->num_channels; i++)
-    {
-      send_shutdown (exec_ctx, cb->channels[i], send_goaway, force_disconnect);
-      GRPC_CHANNEL_INTERNAL_UNREF (exec_ctx, cb->channels[i], "broadcast");
-    }
-  gpr_free (cb->channels);
+  for (i = 0; i < cb->num_channels; i++) {
+    send_shutdown(exec_ctx, cb->channels[i], send_goaway, force_disconnect);
+    GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, cb->channels[i], "broadcast");
+  }
+  gpr_free(cb->channels);
 }
 
 /*
  * request_matcher
  */
 
-static void
-request_matcher_init (request_matcher * request_matcher, size_t entries)
-{
-  memset (request_matcher, 0, sizeof (*request_matcher));
-  request_matcher->requests = gpr_stack_lockfree_create (entries);
+static void request_matcher_init(request_matcher *request_matcher,
+                                 size_t entries) {
+  memset(request_matcher, 0, sizeof(*request_matcher));
+  request_matcher->requests = gpr_stack_lockfree_create(entries);
 }
 
-static void
-request_matcher_destroy (request_matcher * request_matcher)
-{
-  GPR_ASSERT (gpr_stack_lockfree_pop (request_matcher->requests) == -1);
-  gpr_stack_lockfree_destroy (request_matcher->requests);
+static void request_matcher_destroy(request_matcher *request_matcher) {
+  GPR_ASSERT(gpr_stack_lockfree_pop(request_matcher->requests) == -1);
+  gpr_stack_lockfree_destroy(request_matcher->requests);
 }
 
-static void
-kill_zombie (grpc_exec_ctx * exec_ctx, void *elem, int success)
-{
-  grpc_call_destroy (grpc_call_from_top_element (elem));
+static void kill_zombie(grpc_exec_ctx *exec_ctx, void *elem, int success) {
+  grpc_call_destroy(grpc_call_from_top_element(elem));
 }
 
-static void
-request_matcher_zombify_all_pending_calls (grpc_exec_ctx * exec_ctx, request_matcher * request_matcher)
-{
-  while (request_matcher->pending_head)
-    {
-      call_data *calld = request_matcher->pending_head;
-      request_matcher->pending_head = calld->pending_next;
-      gpr_mu_lock (&calld->mu_state);
-      calld->state = ZOMBIED;
-      gpr_mu_unlock (&calld->mu_state);
-      grpc_closure_init (&calld->kill_zombie_closure, kill_zombie, grpc_call_stack_element (grpc_call_get_call_stack (calld->call), 0));
-      grpc_exec_ctx_enqueue (exec_ctx, &calld->kill_zombie_closure, 1);
-    }
+static void request_matcher_zombify_all_pending_calls(
+    grpc_exec_ctx *exec_ctx, request_matcher *request_matcher) {
+  while (request_matcher->pending_head) {
+    call_data *calld = request_matcher->pending_head;
+    request_matcher->pending_head = calld->pending_next;
+    gpr_mu_lock(&calld->mu_state);
+    calld->state = ZOMBIED;
+    gpr_mu_unlock(&calld->mu_state);
+    grpc_closure_init(
+        &calld->kill_zombie_closure, kill_zombie,
+        grpc_call_stack_element(grpc_call_get_call_stack(calld->call), 0));
+    grpc_exec_ctx_enqueue(exec_ctx, &calld->kill_zombie_closure, 1);
+  }
 }
 
-static void
-request_matcher_kill_requests (grpc_exec_ctx * exec_ctx, grpc_server * server, request_matcher * rm)
-{
+static void request_matcher_kill_requests(grpc_exec_ctx *exec_ctx,
+                                          grpc_server *server,
+                                          request_matcher *rm) {
   int request_id;
-  while ((request_id = gpr_stack_lockfree_pop (rm->requests)) != -1)
-    {
-      fail_call (exec_ctx, server, &server->requested_calls[request_id]);
-    }
+  while ((request_id = gpr_stack_lockfree_pop(rm->requests)) != -1) {
+    fail_call(exec_ctx, server, &server->requested_calls[request_id]);
+  }
 }
 
 /*
  * server proper
  */
 
-static void
-server_ref (grpc_server * server)
-{
-  gpr_ref (&server->internal_refcount);
+static void server_ref(grpc_server *server) {
+  gpr_ref(&server->internal_refcount);
 }
 
-static void
-server_delete (grpc_exec_ctx * exec_ctx, grpc_server * server)
-{
+static void server_delete(grpc_exec_ctx *exec_ctx, grpc_server *server) {
   registered_method *rm;
   size_t i;
-  grpc_channel_args_destroy (server->channel_args);
-  gpr_mu_destroy (&server->mu_global);
-  gpr_mu_destroy (&server->mu_call);
-  gpr_free (server->channel_filters);
-  while ((rm = server->registered_methods) != NULL)
-    {
-      server->registered_methods = rm->next;
-      request_matcher_destroy (&rm->request_matcher);
-      gpr_free (rm->method);
-      gpr_free (rm->host);
-      gpr_free (rm);
-    }
-  for (i = 0; i < server->cq_count; i++)
-    {
-      GRPC_CQ_INTERNAL_UNREF (server->cqs[i], "server");
-    }
-  request_matcher_destroy (&server->unregistered_request_matcher);
-  gpr_stack_lockfree_destroy (server->request_freelist);
-  gpr_free (server->cqs);
-  gpr_free (server->pollsets);
-  gpr_free (server->shutdown_tags);
-  gpr_free (server->requested_calls);
-  gpr_free (server);
+  grpc_channel_args_destroy(server->channel_args);
+  gpr_mu_destroy(&server->mu_global);
+  gpr_mu_destroy(&server->mu_call);
+  gpr_free(server->channel_filters);
+  while ((rm = server->registered_methods) != NULL) {
+    server->registered_methods = rm->next;
+    request_matcher_destroy(&rm->request_matcher);
+    gpr_free(rm->method);
+    gpr_free(rm->host);
+    gpr_free(rm);
+  }
+  for (i = 0; i < server->cq_count; i++) {
+    GRPC_CQ_INTERNAL_UNREF(server->cqs[i], "server");
+  }
+  request_matcher_destroy(&server->unregistered_request_matcher);
+  gpr_stack_lockfree_destroy(server->request_freelist);
+  gpr_free(server->cqs);
+  gpr_free(server->pollsets);
+  gpr_free(server->shutdown_tags);
+  gpr_free(server->requested_calls);
+  gpr_free(server);
 }
 
-static void
-server_unref (grpc_exec_ctx * exec_ctx, grpc_server * server)
-{
-  if (gpr_unref (&server->internal_refcount))
-    {
-      server_delete (exec_ctx, server);
-    }
+static void server_unref(grpc_exec_ctx *exec_ctx, grpc_server *server) {
+  if (gpr_unref(&server->internal_refcount)) {
+    server_delete(exec_ctx, server);
+  }
 }
 
-static int
-is_channel_orphaned (channel_data * chand)
-{
+static int is_channel_orphaned(channel_data *chand) {
   return chand->next == chand;
 }
 
-static void
-orphan_channel (channel_data * chand)
-{
+static void orphan_channel(channel_data *chand) {
   chand->next->prev = chand->prev;
   chand->prev->next = chand->next;
   chand->next = chand->prev = chand;
 }
 
-static void
-finish_destroy_channel (grpc_exec_ctx * exec_ctx, void *cd, int success)
-{
+static void finish_destroy_channel(grpc_exec_ctx *exec_ctx, void *cd,
+                                   int success) {
   channel_data *chand = cd;
   grpc_server *server = chand->server;
-  gpr_log (GPR_DEBUG, "finish_destroy_channel: %p", chand->channel);
-  GRPC_CHANNEL_INTERNAL_UNREF (exec_ctx, chand->channel, "server");
-  server_unref (exec_ctx, server);
+  gpr_log(GPR_DEBUG, "finish_destroy_channel: %p", chand->channel);
+  GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, chand->channel, "server");
+  server_unref(exec_ctx, server);
 }
 
-static void
-destroy_channel (grpc_exec_ctx * exec_ctx, channel_data * chand)
-{
-  if (is_channel_orphaned (chand))
-    return;
-  GPR_ASSERT (chand->server != NULL);
-  orphan_channel (chand);
-  server_ref (chand->server);
-  maybe_finish_shutdown (exec_ctx, chand->server);
+static void destroy_channel(grpc_exec_ctx *exec_ctx, channel_data *chand) {
+  if (is_channel_orphaned(chand)) return;
+  GPR_ASSERT(chand->server != NULL);
+  orphan_channel(chand);
+  server_ref(chand->server);
+  maybe_finish_shutdown(exec_ctx, chand->server);
   chand->finish_destroy_channel_closure.cb = finish_destroy_channel;
   chand->finish_destroy_channel_closure.cb_arg = chand;
-  grpc_exec_ctx_enqueue (exec_ctx, &chand->finish_destroy_channel_closure, 1);
+  grpc_exec_ctx_enqueue(exec_ctx, &chand->finish_destroy_channel_closure, 1);
 }
 
-static void
-finish_start_new_rpc (grpc_exec_ctx * exec_ctx, grpc_server * server, grpc_call_element * elem, request_matcher * request_matcher)
-{
+static void finish_start_new_rpc(grpc_exec_ctx *exec_ctx, grpc_server *server,
+                                 grpc_call_element *elem,
+                                 request_matcher *request_matcher) {
   call_data *calld = elem->call_data;
   int request_id;
 
-  if (gpr_atm_acq_load (&server->shutdown_flag))
-    {
-      gpr_mu_lock (&calld->mu_state);
-      calld->state = ZOMBIED;
-      gpr_mu_unlock (&calld->mu_state);
-      grpc_closure_init (&calld->kill_zombie_closure, kill_zombie, elem);
-      grpc_exec_ctx_enqueue (exec_ctx, &calld->kill_zombie_closure, 1);
-      return;
-    }
-
-  request_id = gpr_stack_lockfree_pop (request_matcher->requests);
-  if (request_id == -1)
-    {
-      gpr_mu_lock (&server->mu_call);
-      gpr_mu_lock (&calld->mu_state);
-      calld->state = PENDING;
-      gpr_mu_unlock (&calld->mu_state);
-      if (request_matcher->pending_head == NULL)
-	{
-	  request_matcher->pending_tail = request_matcher->pending_head = calld;
-	}
-      else
-	{
-	  request_matcher->pending_tail->pending_next = calld;
-	  request_matcher->pending_tail = calld;
-	}
-      calld->pending_next = NULL;
-      gpr_mu_unlock (&server->mu_call);
-    }
-  else
-    {
-      gpr_mu_lock (&calld->mu_state);
-      calld->state = ACTIVATED;
-      gpr_mu_unlock (&calld->mu_state);
-      begin_call (exec_ctx, server, calld, &server->requested_calls[request_id]);
+  if (gpr_atm_acq_load(&server->shutdown_flag)) {
+    gpr_mu_lock(&calld->mu_state);
+    calld->state = ZOMBIED;
+    gpr_mu_unlock(&calld->mu_state);
+    grpc_closure_init(&calld->kill_zombie_closure, kill_zombie, elem);
+    grpc_exec_ctx_enqueue(exec_ctx, &calld->kill_zombie_closure, 1);
+    return;
+  }
+
+  request_id = gpr_stack_lockfree_pop(request_matcher->requests);
+  if (request_id == -1) {
+    gpr_mu_lock(&server->mu_call);
+    gpr_mu_lock(&calld->mu_state);
+    calld->state = PENDING;
+    gpr_mu_unlock(&calld->mu_state);
+    if (request_matcher->pending_head == NULL) {
+      request_matcher->pending_tail = request_matcher->pending_head = calld;
+    } else {
+      request_matcher->pending_tail->pending_next = calld;
+      request_matcher->pending_tail = calld;
     }
+    calld->pending_next = NULL;
+    gpr_mu_unlock(&server->mu_call);
+  } else {
+    gpr_mu_lock(&calld->mu_state);
+    calld->state = ACTIVATED;
+    gpr_mu_unlock(&calld->mu_state);
+    begin_call(exec_ctx, server, calld, &server->requested_calls[request_id]);
+  }
 }
 
-static void
-start_new_rpc (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
-{
+static void start_new_rpc(grpc_exec_ctx *exec_ctx, grpc_call_element *elem) {
   channel_data *chand = elem->channel_data;
   call_data *calld = elem->call_data;
   grpc_server *server = chand->server;
@@ -508,411 +457,380 @@ start_new_rpc (grpc_exec_ctx * exec_ctx, grpc_call_element * elem)
   gpr_uint32 hash;
   channel_registered_method *rm;
 
-  if (chand->registered_methods && calld->path && calld->host)
-    {
-      /* TODO(ctiller): unify these two searches */
-      /* check for an exact match with host */
-      hash = GRPC_MDSTR_KV_HASH (calld->host->hash, calld->path->hash);
-      for (i = 0; i <= chand->registered_method_max_probes; i++)
-	{
-	  rm = &chand->registered_methods[(hash + i) % chand->registered_method_slots];
-	  if (!rm)
-	    break;
-	  if (rm->host != calld->host)
-	    continue;
-	  if (rm->method != calld->path)
-	    continue;
-	  finish_start_new_rpc (exec_ctx, server, elem, &rm->server_registered_method->request_matcher);
-	  return;
-	}
-      /* check for a wildcard method definition (no host set) */
-      hash = GRPC_MDSTR_KV_HASH (0, calld->path->hash);
-      for (i = 0; i <= chand->registered_method_max_probes; i++)
-	{
-	  rm = &chand->registered_methods[(hash + i) % chand->registered_method_slots];
-	  if (!rm)
-	    break;
-	  if (rm->host != NULL)
-	    continue;
-	  if (rm->method != calld->path)
-	    continue;
-	  finish_start_new_rpc (exec_ctx, server, elem, &rm->server_registered_method->request_matcher);
-	  return;
-	}
+  if (chand->registered_methods && calld->path && calld->host) {
+    /* TODO(ctiller): unify these two searches */
+    /* check for an exact match with host */
+    hash = GRPC_MDSTR_KV_HASH(calld->host->hash, calld->path->hash);
+    for (i = 0; i <= chand->registered_method_max_probes; i++) {
+      rm = &chand->registered_methods[(hash + i) %
+                                      chand->registered_method_slots];
+      if (!rm) break;
+      if (rm->host != calld->host) continue;
+      if (rm->method != calld->path) continue;
+      finish_start_new_rpc(exec_ctx, server, elem,
+                           &rm->server_registered_method->request_matcher);
+      return;
+    }
+    /* check for a wildcard method definition (no host set) */
+    hash = GRPC_MDSTR_KV_HASH(0, calld->path->hash);
+    for (i = 0; i <= chand->registered_method_max_probes; i++) {
+      rm = &chand->registered_methods[(hash + i) %
+                                      chand->registered_method_slots];
+      if (!rm) break;
+      if (rm->host != NULL) continue;
+      if (rm->method != calld->path) continue;
+      finish_start_new_rpc(exec_ctx, server, elem,
+                           &rm->server_registered_method->request_matcher);
+      return;
     }
-  finish_start_new_rpc (exec_ctx, server, elem, &server->unregistered_request_matcher);
+  }
+  finish_start_new_rpc(exec_ctx, server, elem,
+                       &server->unregistered_request_matcher);
 }
 
-static int
-num_listeners (grpc_server * server)
-{
+static int num_listeners(grpc_server *server) {
   listener *l;
   int n = 0;
-  for (l = server->listeners; l; l = l->next)
-    {
-      n++;
-    }
+  for (l = server->listeners; l; l = l->next) {
+    n++;
+  }
   return n;
 }
 
-static void
-done_shutdown_event (grpc_exec_ctx * exec_ctx, void *server, grpc_cq_completion * completion)
-{
-  server_unref (exec_ctx, server);
+static void done_shutdown_event(grpc_exec_ctx *exec_ctx, void *server,
+                                grpc_cq_completion *completion) {
+  server_unref(exec_ctx, server);
 }
 
-static int
-num_channels (grpc_server * server)
-{
+static int num_channels(grpc_server *server) {
   channel_data *chand;
   int n = 0;
-  for (chand = server->root_channel_data.next; chand != &server->root_channel_data; chand = chand->next)
-    {
-      n++;
-    }
+  for (chand = server->root_channel_data.next;
+       chand != &server->root_channel_data; chand = chand->next) {
+    n++;
+  }
   return n;
 }
 
-static void
-kill_pending_work_locked (grpc_exec_ctx * exec_ctx, grpc_server * server)
-{
+static void kill_pending_work_locked(grpc_exec_ctx *exec_ctx,
+                                     grpc_server *server) {
   registered_method *rm;
-  request_matcher_kill_requests (exec_ctx, server, &server->unregistered_request_matcher);
-  request_matcher_zombify_all_pending_calls (exec_ctx, &server->unregistered_request_matcher);
-  for (rm = server->registered_methods; rm; rm = rm->next)
-    {
-      request_matcher_kill_requests (exec_ctx, server, &rm->request_matcher);
-      request_matcher_zombify_all_pending_calls (exec_ctx, &rm->request_matcher);
-    }
+  request_matcher_kill_requests(exec_ctx, server,
+                                &server->unregistered_request_matcher);
+  request_matcher_zombify_all_pending_calls(
+      exec_ctx, &server->unregistered_request_matcher);
+  for (rm = server->registered_methods; rm; rm = rm->next) {
+    request_matcher_kill_requests(exec_ctx, server, &rm->request_matcher);
+    request_matcher_zombify_all_pending_calls(exec_ctx, &rm->request_matcher);
+  }
 }
 
-static void
-maybe_finish_shutdown (grpc_exec_ctx * exec_ctx, grpc_server * server)
-{
+static void maybe_finish_shutdown(grpc_exec_ctx *exec_ctx,
+                                  grpc_server *server) {
   size_t i;
-  if (!gpr_atm_acq_load (&server->shutdown_flag) || server->shutdown_published)
-    {
-      return;
-    }
-
-  kill_pending_work_locked (exec_ctx, server);
-
-  if (server->root_channel_data.next != &server->root_channel_data || server->listeners_destroyed < num_listeners (server))
-    {
-      if (gpr_time_cmp (gpr_time_sub (gpr_now (GPR_CLOCK_REALTIME), server->last_shutdown_message_time), gpr_time_from_seconds (1, GPR_TIMESPAN)) >= 0)
-	{
-	  server->last_shutdown_message_time = gpr_now (GPR_CLOCK_REALTIME);
-	  gpr_log (GPR_DEBUG, "Waiting for %d channels and %d/%d listeners to be destroyed" " before shutting down server", num_channels (server), num_listeners (server) - server->listeners_destroyed, num_listeners (server));
-	}
-      return;
+  if (!gpr_atm_acq_load(&server->shutdown_flag) || server->shutdown_published) {
+    return;
+  }
+
+  kill_pending_work_locked(exec_ctx, server);
+
+  if (server->root_channel_data.next != &server->root_channel_data ||
+      server->listeners_destroyed < num_listeners(server)) {
+    if (gpr_time_cmp(gpr_time_sub(gpr_now(GPR_CLOCK_REALTIME),
+                                  server->last_shutdown_message_time),
+                     gpr_time_from_seconds(1, GPR_TIMESPAN)) >= 0) {
+      server->last_shutdown_message_time = gpr_now(GPR_CLOCK_REALTIME);
+      gpr_log(GPR_DEBUG,
+              "Waiting for %d channels and %d/%d listeners to be destroyed"
+              " before shutting down server",
+              num_channels(server),
+              num_listeners(server) - server->listeners_destroyed,
+              num_listeners(server));
     }
+    return;
+  }
   server->shutdown_published = 1;
-  for (i = 0; i < server->num_shutdown_tags; i++)
-    {
-      server_ref (server);
-      grpc_cq_end_op (exec_ctx, server->shutdown_tags[i].cq, server->shutdown_tags[i].tag, 1, done_shutdown_event, server, &server->shutdown_tags[i].completion);
-    }
+  for (i = 0; i < server->num_shutdown_tags; i++) {
+    server_ref(server);
+    grpc_cq_end_op(exec_ctx, server->shutdown_tags[i].cq,
+                   server->shutdown_tags[i].tag, 1, done_shutdown_event, server,
+                   &server->shutdown_tags[i].completion);
+  }
 }
 
-static grpc_mdelem *
-server_filter (void *user_data, grpc_mdelem * md)
-{
+static grpc_mdelem *server_filter(void *user_data, grpc_mdelem *md) {
   grpc_call_element *elem = user_data;
   channel_data *chand = elem->channel_data;
   call_data *calld = elem->call_data;
-  if (md->key == chand->path_key)
-    {
-      calld->path = GRPC_MDSTR_REF (md->value);
-      return NULL;
-    }
-  else if (md->key == chand->authority_key)
-    {
-      calld->host = GRPC_MDSTR_REF (md->value);
-      return NULL;
-    }
+  if (md->key == chand->path_key) {
+    calld->path = GRPC_MDSTR_REF(md->value);
+    return NULL;
+  } else if (md->key == chand->authority_key) {
+    calld->host = GRPC_MDSTR_REF(md->value);
+    return NULL;
+  }
   return md;
 }
 
-static void
-server_on_recv (grpc_exec_ctx * exec_ctx, void *ptr, int success)
-{
+static void server_on_recv(grpc_exec_ctx *exec_ctx, void *ptr, int success) {
   grpc_call_element *elem = ptr;
   call_data *calld = elem->call_data;
   gpr_timespec op_deadline;
 
-  if (success && !calld->got_initial_metadata)
-    {
-      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];
-	  if (op->type != GRPC_OP_METADATA)
-	    continue;
-	  grpc_metadata_batch_filter (&op->data.metadata, server_filter, elem);
-	  op_deadline = op->data.metadata.deadline;
-	  if (0 != gpr_time_cmp (op_deadline, gpr_inf_future (op_deadline.clock_type)))
-	    {
-	      calld->deadline = op->data.metadata.deadline;
-	    }
-	  if (calld->host && calld->path)
-	    {
-	      calld->got_initial_metadata = 1;
-	      start_new_rpc (exec_ctx, elem);
-	    }
-	  break;
-	}
+  if (success && !calld->got_initial_metadata) {
+    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];
+      if (op->type != GRPC_OP_METADATA) continue;
+      grpc_metadata_batch_filter(&op->data.metadata, server_filter, elem);
+      op_deadline = op->data.metadata.deadline;
+      if (0 !=
+          gpr_time_cmp(op_deadline, gpr_inf_future(op_deadline.clock_type))) {
+        calld->deadline = op->data.metadata.deadline;
+      }
+      if (calld->host && calld->path) {
+        calld->got_initial_metadata = 1;
+        start_new_rpc(exec_ctx, elem);
+      }
+      break;
     }
+  }
 
-  switch (*calld->recv_state)
-    {
+  switch (*calld->recv_state) {
     case GRPC_STREAM_OPEN:
       break;
     case GRPC_STREAM_SEND_CLOSED:
       break;
     case GRPC_STREAM_RECV_CLOSED:
-      gpr_mu_lock (&calld->mu_state);
-      if (calld->state == NOT_STARTED)
-	{
-	  calld->state = ZOMBIED;
-	  gpr_mu_unlock (&calld->mu_state);
-	  grpc_closure_init (&calld->kill_zombie_closure, kill_zombie, elem);
-	  grpc_exec_ctx_enqueue (exec_ctx, &calld->kill_zombie_closure, 1);
-	}
-      else
-	{
-	  gpr_mu_unlock (&calld->mu_state);
-	}
+      gpr_mu_lock(&calld->mu_state);
+      if (calld->state == NOT_STARTED) {
+        calld->state = ZOMBIED;
+        gpr_mu_unlock(&calld->mu_state);
+        grpc_closure_init(&calld->kill_zombie_closure, kill_zombie, elem);
+        grpc_exec_ctx_enqueue(exec_ctx, &calld->kill_zombie_closure, 1);
+      } else {
+        gpr_mu_unlock(&calld->mu_state);
+      }
       break;
     case GRPC_STREAM_CLOSED:
-      gpr_mu_lock (&calld->mu_state);
-      if (calld->state == NOT_STARTED)
-	{
-	  calld->state = ZOMBIED;
-	  gpr_mu_unlock (&calld->mu_state);
-	  grpc_closure_init (&calld->kill_zombie_closure, kill_zombie, elem);
-	  grpc_exec_ctx_enqueue (exec_ctx, &calld->kill_zombie_closure, 1);
-	}
-      else if (calld->state == PENDING)
-	{
-	  calld->state = ZOMBIED;
-	  gpr_mu_unlock (&calld->mu_state);
-	  /* zombied call will be destroyed when it's removed from the pending
-	     queue... later */
-	}
-      else
-	{
-	  gpr_mu_unlock (&calld->mu_state);
-	}
+      gpr_mu_lock(&calld->mu_state);
+      if (calld->state == NOT_STARTED) {
+        calld->state = ZOMBIED;
+        gpr_mu_unlock(&calld->mu_state);
+        grpc_closure_init(&calld->kill_zombie_closure, kill_zombie, elem);
+        grpc_exec_ctx_enqueue(exec_ctx, &calld->kill_zombie_closure, 1);
+      } else if (calld->state == PENDING) {
+        calld->state = ZOMBIED;
+        gpr_mu_unlock(&calld->mu_state);
+        /* zombied call will be destroyed when it's removed from the pending
+           queue... later */
+      } else {
+        gpr_mu_unlock(&calld->mu_state);
+      }
       break;
-    }
+  }
 
-  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
-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 higher callback */
-      calld->recv_ops = op->recv_ops;
-      calld->recv_state = op->recv_state;
-      calld->on_done_recv = op->on_done_recv;
-      op->on_done_recv = &calld->server_on_recv;
-    }
+  if (op->recv_ops) {
+    /* substitute our callback for the higher callback */
+    calld->recv_ops = op->recv_ops;
+    calld->recv_state = op->recv_state;
+    calld->on_done_recv = op->on_done_recv;
+    op->on_done_recv = &calld->server_on_recv;
+  }
 }
 
-static void
-server_start_transport_stream_op (grpc_exec_ctx * exec_ctx, grpc_call_element * elem, grpc_transport_stream_op * op)
-{
-  GRPC_CALL_LOG_OP (GPR_INFO, elem, op);
-  server_mutate_op (elem, op);
-  grpc_call_next_op (exec_ctx, elem, op);
+static void server_start_transport_stream_op(grpc_exec_ctx *exec_ctx,
+                                             grpc_call_element *elem,
+                                             grpc_transport_stream_op *op) {
+  GRPC_CALL_LOG_OP(GPR_INFO, elem, op);
+  server_mutate_op(elem, op);
+  grpc_call_next_op(exec_ctx, elem, op);
 }
 
-static void
-accept_stream (void *cd, grpc_transport * transport, const void *transport_server_data)
-{
+static void accept_stream(void *cd, grpc_transport *transport,
+                          const void *transport_server_data) {
   channel_data *chand = cd;
   /* create a call */
-  grpc_call_create (chand->channel, NULL, 0, NULL, transport_server_data, NULL, 0, gpr_inf_future (GPR_CLOCK_MONOTONIC));
+  grpc_call_create(chand->channel, NULL, 0, NULL, transport_server_data, NULL,
+                   0, gpr_inf_future(GPR_CLOCK_MONOTONIC));
 }
 
-static void
-channel_connectivity_changed (grpc_exec_ctx * exec_ctx, void *cd, int iomgr_status_ignored)
-{
+static void channel_connectivity_changed(grpc_exec_ctx *exec_ctx, void *cd,
+                                         int iomgr_status_ignored) {
   channel_data *chand = cd;
   grpc_server *server = chand->server;
-  if (chand->connectivity_state != GRPC_CHANNEL_FATAL_FAILURE)
-    {
-      grpc_transport_op op;
-      memset (&op, 0, sizeof (op));
-      op.on_connectivity_state_change = &chand->channel_connectivity_changed, op.connectivity_state = &chand->connectivity_state;
-      grpc_channel_next_op (exec_ctx, grpc_channel_stack_element (grpc_channel_get_channel_stack (chand->channel), 0), &op);
-    }
-  else
-    {
-      gpr_mu_lock (&server->mu_global);
-      destroy_channel (exec_ctx, chand);
-      gpr_mu_unlock (&server->mu_global);
-      GRPC_CHANNEL_INTERNAL_UNREF (exec_ctx, chand->channel, "connectivity");
-    }
+  if (chand->connectivity_state != GRPC_CHANNEL_FATAL_FAILURE) {
+    grpc_transport_op op;
+    memset(&op, 0, sizeof(op));
+    op.on_connectivity_state_change = &chand->channel_connectivity_changed,
+    op.connectivity_state = &chand->connectivity_state;
+    grpc_channel_next_op(exec_ctx,
+                         grpc_channel_stack_element(
+                             grpc_channel_get_channel_stack(chand->channel), 0),
+                         &op);
+  } else {
+    gpr_mu_lock(&server->mu_global);
+    destroy_channel(exec_ctx, chand);
+    gpr_mu_unlock(&server->mu_global);
+    GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, chand->channel, "connectivity");
+  }
 }
 
-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;
-  memset (calld, 0, sizeof (call_data));
-  calld->deadline = gpr_inf_future (GPR_CLOCK_REALTIME);
-  calld->call = grpc_call_from_top_element (elem);
-  gpr_mu_init (&calld->mu_state);
+  memset(calld, 0, sizeof(call_data));
+  calld->deadline = gpr_inf_future(GPR_CLOCK_REALTIME);
+  calld->call = grpc_call_from_top_element(elem);
+  gpr_mu_init(&calld->mu_state);
 
-  grpc_closure_init (&calld->server_on_recv, server_on_recv, elem);
+  grpc_closure_init(&calld->server_on_recv, server_on_recv, elem);
 
-  server_ref (chand->server);
+  server_ref(chand->server);
 
-  if (initial_op)
-    server_mutate_op (elem, initial_op);
+  if (initial_op) server_mutate_op(elem, initial_op);
 }
 
-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) {
   channel_data *chand = elem->channel_data;
   call_data *calld = elem->call_data;
 
-  GPR_ASSERT (calld->state != PENDING);
+  GPR_ASSERT(calld->state != PENDING);
 
-  if (calld->host)
-    {
-      GRPC_MDSTR_UNREF (calld->host);
-    }
-  if (calld->path)
-    {
-      GRPC_MDSTR_UNREF (calld->path);
-    }
+  if (calld->host) {
+    GRPC_MDSTR_UNREF(calld->host);
+  }
+  if (calld->path) {
+    GRPC_MDSTR_UNREF(calld->path);
+  }
 
-  gpr_mu_destroy (&calld->mu_state);
+  gpr_mu_destroy(&calld->mu_state);
 
-  server_unref (exec_ctx, chand->server);
+  server_unref(exec_ctx, chand->server);
 }
 
-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;
-  GPR_ASSERT (is_first);
-  GPR_ASSERT (!is_last);
+  GPR_ASSERT(is_first);
+  GPR_ASSERT(!is_last);
   chand->server = NULL;
   chand->channel = NULL;
-  chand->path_key = grpc_mdstr_from_string (metadata_context, ":path", 0);
-  chand->authority_key = grpc_mdstr_from_string (metadata_context, ":authority", 0);
+  chand->path_key = grpc_mdstr_from_string(metadata_context, ":path", 0);
+  chand->authority_key =
+      grpc_mdstr_from_string(metadata_context, ":authority", 0);
   chand->next = chand->prev = chand;
   chand->registered_methods = NULL;
   chand->connectivity_state = GRPC_CHANNEL_IDLE;
-  grpc_closure_init (&chand->channel_connectivity_changed, channel_connectivity_changed, chand);
+  grpc_closure_init(&chand->channel_connectivity_changed,
+                    channel_connectivity_changed, chand);
 }
 
-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) {
   size_t i;
   channel_data *chand = elem->channel_data;
-  if (chand->registered_methods)
-    {
-      for (i = 0; i < chand->registered_method_slots; i++)
-	{
-	  if (chand->registered_methods[i].method)
-	    {
-	      GRPC_MDSTR_UNREF (chand->registered_methods[i].method);
-	    }
-	  if (chand->registered_methods[i].host)
-	    {
-	      GRPC_MDSTR_UNREF (chand->registered_methods[i].host);
-	    }
-	}
-      gpr_free (chand->registered_methods);
-    }
-  if (chand->server)
-    {
-      gpr_mu_lock (&chand->server->mu_global);
-      chand->next->prev = chand->prev;
-      chand->prev->next = chand->next;
-      chand->next = chand->prev = chand;
-      maybe_finish_shutdown (exec_ctx, chand->server);
-      gpr_mu_unlock (&chand->server->mu_global);
-      GRPC_MDSTR_UNREF (chand->path_key);
-      GRPC_MDSTR_UNREF (chand->authority_key);
-      server_unref (exec_ctx, chand->server);
+  if (chand->registered_methods) {
+    for (i = 0; i < chand->registered_method_slots; i++) {
+      if (chand->registered_methods[i].method) {
+        GRPC_MDSTR_UNREF(chand->registered_methods[i].method);
+      }
+      if (chand->registered_methods[i].host) {
+        GRPC_MDSTR_UNREF(chand->registered_methods[i].host);
+      }
     }
+    gpr_free(chand->registered_methods);
+  }
+  if (chand->server) {
+    gpr_mu_lock(&chand->server->mu_global);
+    chand->next->prev = chand->prev;
+    chand->prev->next = chand->next;
+    chand->next = chand->prev = chand;
+    maybe_finish_shutdown(exec_ctx, chand->server);
+    gpr_mu_unlock(&chand->server->mu_global);
+    GRPC_MDSTR_UNREF(chand->path_key);
+    GRPC_MDSTR_UNREF(chand->authority_key);
+    server_unref(exec_ctx, chand->server);
+  }
 }
 
 static const grpc_channel_filter server_surface_filter = {
-  server_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,
-  "server",
+    server_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,
+    "server",
 };
 
-void
-grpc_server_register_completion_queue (grpc_server * server, grpc_completion_queue * cq, void *reserved)
-{
+void grpc_server_register_completion_queue(grpc_server *server,
+                                           grpc_completion_queue *cq,
+                                           void *reserved) {
   size_t i, n;
-  GPR_ASSERT (!reserved);
-  for (i = 0; i < server->cq_count; i++)
-    {
-      if (server->cqs[i] == cq)
-	return;
-    }
-  GRPC_CQ_INTERNAL_REF (cq, "server");
-  grpc_cq_mark_server_cq (cq);
+  GPR_ASSERT(!reserved);
+  for (i = 0; i < server->cq_count; i++) {
+    if (server->cqs[i] == cq) return;
+  }
+  GRPC_CQ_INTERNAL_REF(cq, "server");
+  grpc_cq_mark_server_cq(cq);
   n = server->cq_count++;
-  server->cqs = gpr_realloc (server->cqs, server->cq_count * sizeof (grpc_completion_queue *));
+  server->cqs = gpr_realloc(server->cqs,
+                            server->cq_count * sizeof(grpc_completion_queue *));
   server->cqs[n] = cq;
 }
 
-grpc_server *
-grpc_server_create_from_filters (const grpc_channel_filter ** filters, size_t filter_count, const grpc_channel_args * args)
-{
+grpc_server *grpc_server_create_from_filters(
+    const grpc_channel_filter **filters, size_t filter_count,
+    const grpc_channel_args *args) {
   size_t i;
   /* TODO(census): restore this once we finalize census filter etc.
      int census_enabled = grpc_channel_args_is_census_enabled(args); */
   int census_enabled = 0;
 
-  grpc_server *server = gpr_malloc (sizeof (grpc_server));
+  grpc_server *server = gpr_malloc(sizeof(grpc_server));
 
-  GPR_ASSERT (grpc_is_initialized () && "call grpc_init()");
+  GPR_ASSERT(grpc_is_initialized() && "call grpc_init()");
 
-  memset (server, 0, sizeof (grpc_server));
+  memset(server, 0, sizeof(grpc_server));
 
-  gpr_mu_init (&server->mu_global);
-  gpr_mu_init (&server->mu_call);
+  gpr_mu_init(&server->mu_global);
+  gpr_mu_init(&server->mu_call);
 
   /* decremented by grpc_server_destroy */
-  gpr_ref_init (&server->internal_refcount, 1);
-  server->root_channel_data.next = server->root_channel_data.prev = &server->root_channel_data;
+  gpr_ref_init(&server->internal_refcount, 1);
+  server->root_channel_data.next = server->root_channel_data.prev =
+      &server->root_channel_data;
 
   /* TODO(ctiller): expose a channel_arg for this */
   server->max_requested_calls = 32768;
-  server->request_freelist = gpr_stack_lockfree_create (server->max_requested_calls);
-  for (i = 0; i < (size_t) server->max_requested_calls; i++)
-    {
-      gpr_stack_lockfree_push (server->request_freelist, (int) i);
-    }
-  request_matcher_init (&server->unregistered_request_matcher, server->max_requested_calls);
-  server->requested_calls = gpr_malloc (server->max_requested_calls * sizeof (*server->requested_calls));
+  server->request_freelist =
+      gpr_stack_lockfree_create(server->max_requested_calls);
+  for (i = 0; i < (size_t)server->max_requested_calls; i++) {
+    gpr_stack_lockfree_push(server->request_freelist, (int)i);
+  }
+  request_matcher_init(&server->unregistered_request_matcher,
+                       server->max_requested_calls);
+  server->requested_calls = gpr_malloc(server->max_requested_calls *
+                                       sizeof(*server->requested_calls));
 
   /* Server filter stack is:
 
@@ -921,87 +839,78 @@ grpc_server_create_from_filters (const grpc_channel_filter ** filters, size_t fi
      {passed in filter stack}
      grpc_connected_channel_filter - for interfacing with transports */
   server->channel_filter_count = filter_count + 1u + (census_enabled ? 1u : 0u);
-  server->channel_filters = gpr_malloc (server->channel_filter_count * sizeof (grpc_channel_filter *));
+  server->channel_filters =
+      gpr_malloc(server->channel_filter_count * sizeof(grpc_channel_filter *));
   server->channel_filters[0] = &server_surface_filter;
-  if (census_enabled)
-    {
-      server->channel_filters[1] = &grpc_server_census_filter;
-    }
-  for (i = 0; i < filter_count; i++)
-    {
-      server->channel_filters[i + 1u + (census_enabled ? 1u : 0u)] = filters[i];
-    }
+  if (census_enabled) {
+    server->channel_filters[1] = &grpc_server_census_filter;
+  }
+  for (i = 0; i < filter_count; i++) {
+    server->channel_filters[i + 1u + (census_enabled ? 1u : 0u)] = filters[i];
+  }
 
-  server->channel_args = grpc_channel_args_copy (args);
+  server->channel_args = grpc_channel_args_copy(args);
 
   return server;
 }
 
-static int
-streq (const char *a, const char *b)
-{
-  if (a == NULL && b == NULL)
-    return 1;
-  if (a == NULL)
-    return 0;
-  if (b == NULL)
-    return 0;
-  return 0 == strcmp (a, b);
+static int streq(const char *a, const char *b) {
+  if (a == NULL && b == NULL) return 1;
+  if (a == NULL) return 0;
+  if (b == NULL) return 0;
+  return 0 == strcmp(a, b);
 }
 
-void *
-grpc_server_register_method (grpc_server * server, const char *method, const char *host)
-{
+void *grpc_server_register_method(grpc_server *server, const char *method,
+                                  const char *host) {
   registered_method *m;
-  if (!method)
-    {
-      gpr_log (GPR_ERROR, "grpc_server_register_method method string cannot be NULL");
+  if (!method) {
+    gpr_log(GPR_ERROR,
+            "grpc_server_register_method method string cannot be NULL");
+    return NULL;
+  }
+  for (m = server->registered_methods; m; m = m->next) {
+    if (streq(m->method, method) && streq(m->host, host)) {
+      gpr_log(GPR_ERROR, "duplicate registration for %s@%s", method,
+              host ? host : "*");
       return NULL;
     }
-  for (m = server->registered_methods; m; m = m->next)
-    {
-      if (streq (m->method, method) && streq (m->host, host))
-	{
-	  gpr_log (GPR_ERROR, "duplicate registration for %s@%s", method, host ? host : "*");
-	  return NULL;
-	}
-    }
-  m = gpr_malloc (sizeof (registered_method));
-  memset (m, 0, sizeof (*m));
-  request_matcher_init (&m->request_matcher, server->max_requested_calls);
-  m->method = gpr_strdup (method);
-  m->host = gpr_strdup (host);
+  }
+  m = gpr_malloc(sizeof(registered_method));
+  memset(m, 0, sizeof(*m));
+  request_matcher_init(&m->request_matcher, server->max_requested_calls);
+  m->method = gpr_strdup(method);
+  m->host = gpr_strdup(host);
   m->next = server->registered_methods;
   server->registered_methods = m;
   return m;
 }
 
-void
-grpc_server_start (grpc_server * server)
-{
+void grpc_server_start(grpc_server *server) {
   listener *l;
   size_t i;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
-  server->pollsets = gpr_malloc (sizeof (grpc_pollset *) * server->cq_count);
-  for (i = 0; i < server->cq_count; i++)
-    {
-      server->pollsets[i] = grpc_cq_pollset (server->cqs[i]);
-    }
+  server->pollsets = gpr_malloc(sizeof(grpc_pollset *) * server->cq_count);
+  for (i = 0; i < server->cq_count; i++) {
+    server->pollsets[i] = grpc_cq_pollset(server->cqs[i]);
+  }
 
-  for (l = server->listeners; l; l = l->next)
-    {
-      l->start (&exec_ctx, server, l->arg, server->pollsets, server->cq_count);
-    }
+  for (l = server->listeners; l; l = l->next) {
+    l->start(&exec_ctx, server, l->arg, server->pollsets, server->cq_count);
+  }
 
-  grpc_exec_ctx_finish (&exec_ctx);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
-void
-grpc_server_setup_transport (grpc_exec_ctx * exec_ctx, grpc_server * s, grpc_transport * transport, grpc_channel_filter const **extra_filters, size_t num_extra_filters, grpc_mdctx * mdctx, const grpc_channel_args * args)
-{
+void grpc_server_setup_transport(grpc_exec_ctx *exec_ctx, grpc_server *s,
+                                 grpc_transport *transport,
+                                 grpc_channel_filter const **extra_filters,
+                                 size_t num_extra_filters, grpc_mdctx *mdctx,
+                                 const grpc_channel_args *args) {
   size_t num_filters = s->channel_filter_count + num_extra_filters + 1;
-  grpc_channel_filter const **filters = gpr_malloc (sizeof (grpc_channel_filter *) * num_filters);
+  grpc_channel_filter const **filters =
+      gpr_malloc(sizeof(grpc_channel_filter *) * num_filters);
   size_t i;
   size_t num_registered_methods;
   size_t alloc;
@@ -1017,194 +926,188 @@ grpc_server_setup_transport (grpc_exec_ctx * exec_ctx, grpc_server * s, grpc_tra
   gpr_uint32 max_probes = 0;
   grpc_transport_op op;
 
-  for (i = 0; i < s->channel_filter_count; i++)
-    {
-      filters[i] = s->channel_filters[i];
-    }
-  for (; i < s->channel_filter_count + num_extra_filters; i++)
-    {
-      filters[i] = extra_filters[i - s->channel_filter_count];
-    }
+  for (i = 0; i < s->channel_filter_count; i++) {
+    filters[i] = s->channel_filters[i];
+  }
+  for (; i < s->channel_filter_count + num_extra_filters; i++) {
+    filters[i] = extra_filters[i - s->channel_filter_count];
+  }
   filters[i] = &grpc_connected_channel_filter;
 
-  for (i = 0; i < s->cq_count; i++)
-    {
-      memset (&op, 0, sizeof (op));
-      op.bind_pollset = grpc_cq_pollset (s->cqs[i]);
-      grpc_transport_perform_op (exec_ctx, transport, &op);
-    }
-
-  channel = grpc_channel_create_from_filters (exec_ctx, NULL, filters, num_filters, args, mdctx, 0);
-  chand = (channel_data *) grpc_channel_stack_element (grpc_channel_get_channel_stack (channel), 0)->channel_data;
+  for (i = 0; i < s->cq_count; i++) {
+    memset(&op, 0, sizeof(op));
+    op.bind_pollset = grpc_cq_pollset(s->cqs[i]);
+    grpc_transport_perform_op(exec_ctx, transport, &op);
+  }
+
+  channel = grpc_channel_create_from_filters(exec_ctx, NULL, filters,
+                                             num_filters, args, mdctx, 0);
+  chand = (channel_data *)grpc_channel_stack_element(
+              grpc_channel_get_channel_stack(channel), 0)
+              ->channel_data;
   chand->server = s;
-  server_ref (s);
+  server_ref(s);
   chand->channel = channel;
 
   num_registered_methods = 0;
-  for (rm = s->registered_methods; rm; rm = rm->next)
-    {
-      num_registered_methods++;
-    }
+  for (rm = s->registered_methods; rm; rm = rm->next) {
+    num_registered_methods++;
+  }
   /* build a lookup table phrased in terms of mdstr's in this channels context
      to quickly find registered methods */
-  if (num_registered_methods > 0)
-    {
-      slots = 2 * num_registered_methods;
-      alloc = sizeof (channel_registered_method) * slots;
-      chand->registered_methods = gpr_malloc (alloc);
-      memset (chand->registered_methods, 0, alloc);
-      for (rm = s->registered_methods; rm; rm = rm->next)
-	{
-	  host = rm->host ? grpc_mdstr_from_string (mdctx, rm->host, 0) : NULL;
-	  method = grpc_mdstr_from_string (mdctx, rm->method, 0);
-	  hash = GRPC_MDSTR_KV_HASH (host ? host->hash : 0, method->hash);
-	  for (probes = 0; chand->registered_methods[(hash + probes) % slots].server_registered_method != NULL; probes++)
-	    ;
-	  if (probes > max_probes)
-	    max_probes = probes;
-	  crm = &chand->registered_methods[(hash + probes) % slots];
-	  crm->server_registered_method = rm;
-	  crm->host = host;
-	  crm->method = method;
-	}
-      GPR_ASSERT (slots <= GPR_UINT32_MAX);
-      chand->registered_method_slots = (gpr_uint32) slots;
-      chand->registered_method_max_probes = max_probes;
+  if (num_registered_methods > 0) {
+    slots = 2 * num_registered_methods;
+    alloc = sizeof(channel_registered_method) * slots;
+    chand->registered_methods = gpr_malloc(alloc);
+    memset(chand->registered_methods, 0, alloc);
+    for (rm = s->registered_methods; rm; rm = rm->next) {
+      host = rm->host ? grpc_mdstr_from_string(mdctx, rm->host, 0) : NULL;
+      method = grpc_mdstr_from_string(mdctx, rm->method, 0);
+      hash = GRPC_MDSTR_KV_HASH(host ? host->hash : 0, method->hash);
+      for (probes = 0; chand->registered_methods[(hash + probes) % slots]
+                           .server_registered_method != NULL;
+           probes++)
+        ;
+      if (probes > max_probes) max_probes = probes;
+      crm = &chand->registered_methods[(hash + probes) % slots];
+      crm->server_registered_method = rm;
+      crm->host = host;
+      crm->method = method;
     }
+    GPR_ASSERT(slots <= GPR_UINT32_MAX);
+    chand->registered_method_slots = (gpr_uint32)slots;
+    chand->registered_method_max_probes = max_probes;
+  }
 
-  grpc_connected_channel_bind_transport (grpc_channel_get_channel_stack (channel), transport);
+  grpc_connected_channel_bind_transport(grpc_channel_get_channel_stack(channel),
+                                        transport);
 
-  gpr_mu_lock (&s->mu_global);
+  gpr_mu_lock(&s->mu_global);
   chand->next = &s->root_channel_data;
   chand->prev = chand->next->prev;
   chand->next->prev = chand->prev->next = chand;
-  gpr_mu_unlock (&s->mu_global);
+  gpr_mu_unlock(&s->mu_global);
 
-  gpr_free (filters);
+  gpr_free(filters);
 
-  GRPC_CHANNEL_INTERNAL_REF (channel, "connectivity");
-  memset (&op, 0, sizeof (op));
+  GRPC_CHANNEL_INTERNAL_REF(channel, "connectivity");
+  memset(&op, 0, sizeof(op));
   op.set_accept_stream = accept_stream;
   op.set_accept_stream_user_data = chand;
   op.on_connectivity_state_change = &chand->channel_connectivity_changed;
   op.connectivity_state = &chand->connectivity_state;
-  op.disconnect = gpr_atm_acq_load (&s->shutdown_flag) != 0;
-  grpc_transport_perform_op (exec_ctx, transport, &op);
+  op.disconnect = gpr_atm_acq_load(&s->shutdown_flag) != 0;
+  grpc_transport_perform_op(exec_ctx, transport, &op);
 }
 
-void
-done_published_shutdown (grpc_exec_ctx * exec_ctx, void *done_arg, grpc_cq_completion * storage)
-{
-  (void) done_arg;
-  gpr_free (storage);
+void done_published_shutdown(grpc_exec_ctx *exec_ctx, void *done_arg,
+                             grpc_cq_completion *storage) {
+  (void)done_arg;
+  gpr_free(storage);
 }
 
-static void
-listener_destroy_done (grpc_exec_ctx * exec_ctx, void *s, int success)
-{
+static void listener_destroy_done(grpc_exec_ctx *exec_ctx, void *s,
+                                  int success) {
   grpc_server *server = s;
-  gpr_mu_lock (&server->mu_global);
+  gpr_mu_lock(&server->mu_global);
   server->listeners_destroyed++;
-  maybe_finish_shutdown (exec_ctx, server);
-  gpr_mu_unlock (&server->mu_global);
+  maybe_finish_shutdown(exec_ctx, server);
+  gpr_mu_unlock(&server->mu_global);
 }
 
-void
-grpc_server_shutdown_and_notify (grpc_server * server, grpc_completion_queue * cq, void *tag)
-{
+void grpc_server_shutdown_and_notify(grpc_server *server,
+                                     grpc_completion_queue *cq, void *tag) {
   listener *l;
   shutdown_tag *sdt;
   channel_broadcaster broadcaster;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
-  GRPC_SERVER_LOG_SHUTDOWN (GPR_INFO, server, cq, tag);
+  GRPC_SERVER_LOG_SHUTDOWN(GPR_INFO, server, cq, tag);
 
   /* lock, and gather up some stuff to do */
-  gpr_mu_lock (&server->mu_global);
-  grpc_cq_begin_op (cq);
-  if (server->shutdown_published)
-    {
-      grpc_cq_end_op (&exec_ctx, cq, tag, 1, done_published_shutdown, NULL, gpr_malloc (sizeof (grpc_cq_completion)));
-      gpr_mu_unlock (&server->mu_global);
-      goto done;
-    }
-  server->shutdown_tags = gpr_realloc (server->shutdown_tags, sizeof (shutdown_tag) * (server->num_shutdown_tags + 1));
+  gpr_mu_lock(&server->mu_global);
+  grpc_cq_begin_op(cq);
+  if (server->shutdown_published) {
+    grpc_cq_end_op(&exec_ctx, cq, tag, 1, done_published_shutdown, NULL,
+                   gpr_malloc(sizeof(grpc_cq_completion)));
+    gpr_mu_unlock(&server->mu_global);
+    goto done;
+  }
+  server->shutdown_tags =
+      gpr_realloc(server->shutdown_tags,
+                  sizeof(shutdown_tag) * (server->num_shutdown_tags + 1));
   sdt = &server->shutdown_tags[server->num_shutdown_tags++];
   sdt->tag = tag;
   sdt->cq = cq;
-  if (gpr_atm_acq_load (&server->shutdown_flag))
-    {
-      gpr_mu_unlock (&server->mu_global);
-      goto done;
-    }
+  if (gpr_atm_acq_load(&server->shutdown_flag)) {
+    gpr_mu_unlock(&server->mu_global);
+    goto done;
+  }
 
-  server->last_shutdown_message_time = gpr_now (GPR_CLOCK_REALTIME);
+  server->last_shutdown_message_time = gpr_now(GPR_CLOCK_REALTIME);
 
-  channel_broadcaster_init (server, &broadcaster);
+  channel_broadcaster_init(server, &broadcaster);
 
   /* collect all unregistered then registered calls */
-  gpr_mu_lock (&server->mu_call);
-  kill_pending_work_locked (&exec_ctx, server);
-  gpr_mu_unlock (&server->mu_call);
+  gpr_mu_lock(&server->mu_call);
+  kill_pending_work_locked(&exec_ctx, server);
+  gpr_mu_unlock(&server->mu_call);
 
-  gpr_atm_rel_store (&server->shutdown_flag, 1);
-  maybe_finish_shutdown (&exec_ctx, server);
-  gpr_mu_unlock (&server->mu_global);
+  gpr_atm_rel_store(&server->shutdown_flag, 1);
+  maybe_finish_shutdown(&exec_ctx, server);
+  gpr_mu_unlock(&server->mu_global);
 
   /* Shutdown listeners */
-  for (l = server->listeners; l; l = l->next)
-    {
-      grpc_closure_init (&l->destroy_done, listener_destroy_done, server);
-      l->destroy (&exec_ctx, server, l->arg, &l->destroy_done);
-    }
+  for (l = server->listeners; l; l = l->next) {
+    grpc_closure_init(&l->destroy_done, listener_destroy_done, server);
+    l->destroy(&exec_ctx, server, l->arg, &l->destroy_done);
+  }
 
-  channel_broadcaster_shutdown (&exec_ctx, &broadcaster, 1, 0);
+  channel_broadcaster_shutdown(&exec_ctx, &broadcaster, 1, 0);
 
 done:
-  grpc_exec_ctx_finish (&exec_ctx);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
-void
-grpc_server_cancel_all_calls (grpc_server * server)
-{
+void grpc_server_cancel_all_calls(grpc_server *server) {
   channel_broadcaster broadcaster;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
-  gpr_mu_lock (&server->mu_global);
-  channel_broadcaster_init (server, &broadcaster);
-  gpr_mu_unlock (&server->mu_global);
+  gpr_mu_lock(&server->mu_global);
+  channel_broadcaster_init(server, &broadcaster);
+  gpr_mu_unlock(&server->mu_global);
 
-  channel_broadcaster_shutdown (&exec_ctx, &broadcaster, 0, 1);
-  grpc_exec_ctx_finish (&exec_ctx);
+  channel_broadcaster_shutdown(&exec_ctx, &broadcaster, 0, 1);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
-void
-grpc_server_destroy (grpc_server * server)
-{
+void grpc_server_destroy(grpc_server *server) {
   listener *l;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
-  gpr_mu_lock (&server->mu_global);
-  GPR_ASSERT (gpr_atm_acq_load (&server->shutdown_flag) || !server->listeners);
-  GPR_ASSERT (server->listeners_destroyed == num_listeners (server));
+  gpr_mu_lock(&server->mu_global);
+  GPR_ASSERT(gpr_atm_acq_load(&server->shutdown_flag) || !server->listeners);
+  GPR_ASSERT(server->listeners_destroyed == num_listeners(server));
 
-  while (server->listeners)
-    {
-      l = server->listeners;
-      server->listeners = l->next;
-      gpr_free (l);
-    }
+  while (server->listeners) {
+    l = server->listeners;
+    server->listeners = l->next;
+    gpr_free(l);
+  }
 
-  gpr_mu_unlock (&server->mu_global);
+  gpr_mu_unlock(&server->mu_global);
 
-  server_unref (&exec_ctx, server);
-  grpc_exec_ctx_finish (&exec_ctx);
+  server_unref(&exec_ctx, server);
+  grpc_exec_ctx_finish(&exec_ctx);
 }
 
-void
-grpc_server_add_listener (grpc_exec_ctx * exec_ctx, grpc_server * server, void *arg, void (*start) (grpc_exec_ctx * exec_ctx, grpc_server * server, void *arg, grpc_pollset ** pollsets, size_t pollset_count), void (*destroy) (grpc_exec_ctx * exec_ctx, grpc_server * server, void *arg, grpc_closure * on_done))
-{
-  listener *l = gpr_malloc (sizeof (listener));
+void grpc_server_add_listener(
+    grpc_exec_ctx *exec_ctx, grpc_server *server, void *arg,
+    void (*start)(grpc_exec_ctx *exec_ctx, grpc_server *server, void *arg,
+                  grpc_pollset **pollsets, size_t pollset_count),
+    void (*destroy)(grpc_exec_ctx *exec_ctx, grpc_server *server, void *arg,
+                    grpc_closure *on_done)) {
+  listener *l = gpr_malloc(sizeof(listener));
   l->arg = arg;
   l->start = start;
   l->destroy = destroy;
@@ -1212,82 +1115,79 @@ grpc_server_add_listener (grpc_exec_ctx * exec_ctx, grpc_server * server, void *
   server->listeners = l;
 }
 
-static grpc_call_error
-queue_call_request (grpc_exec_ctx * exec_ctx, grpc_server * server, requested_call * rc)
-{
+static grpc_call_error queue_call_request(grpc_exec_ctx *exec_ctx,
+                                          grpc_server *server,
+                                          requested_call *rc) {
   call_data *calld = NULL;
   request_matcher *request_matcher = NULL;
   int request_id;
-  if (gpr_atm_acq_load (&server->shutdown_flag))
-    {
-      fail_call (exec_ctx, server, rc);
-      return GRPC_CALL_OK;
-    }
-  request_id = gpr_stack_lockfree_pop (server->request_freelist);
-  if (request_id == -1)
-    {
-      /* out of request ids: just fail this one */
-      fail_call (exec_ctx, server, rc);
-      return GRPC_CALL_OK;
-    }
-  switch (rc->type)
-    {
+  if (gpr_atm_acq_load(&server->shutdown_flag)) {
+    fail_call(exec_ctx, server, rc);
+    return GRPC_CALL_OK;
+  }
+  request_id = gpr_stack_lockfree_pop(server->request_freelist);
+  if (request_id == -1) {
+    /* out of request ids: just fail this one */
+    fail_call(exec_ctx, server, rc);
+    return GRPC_CALL_OK;
+  }
+  switch (rc->type) {
     case BATCH_CALL:
       request_matcher = &server->unregistered_request_matcher;
       break;
     case REGISTERED_CALL:
       request_matcher = &rc->data.registered.registered_method->request_matcher;
       break;
-    }
+  }
   server->requested_calls[request_id] = *rc;
-  gpr_free (rc);
-  if (gpr_stack_lockfree_push (request_matcher->requests, request_id))
-    {
-      /* this was the first queued request: we need to lock and start
-         matching calls */
-      gpr_mu_lock (&server->mu_call);
-      while ((calld = request_matcher->pending_head) != NULL)
-	{
-	  request_id = gpr_stack_lockfree_pop (request_matcher->requests);
-	  if (request_id == -1)
-	    break;
-	  request_matcher->pending_head = calld->pending_next;
-	  gpr_mu_unlock (&server->mu_call);
-	  gpr_mu_lock (&calld->mu_state);
-	  if (calld->state == ZOMBIED)
-	    {
-	      gpr_mu_unlock (&calld->mu_state);
-	      grpc_closure_init (&calld->kill_zombie_closure, kill_zombie, grpc_call_stack_element (grpc_call_get_call_stack (calld->call), 0));
-	      grpc_exec_ctx_enqueue (exec_ctx, &calld->kill_zombie_closure, 1);
-	    }
-	  else
-	    {
-	      GPR_ASSERT (calld->state == PENDING);
-	      calld->state = ACTIVATED;
-	      gpr_mu_unlock (&calld->mu_state);
-	      begin_call (exec_ctx, server, calld, &server->requested_calls[request_id]);
-	    }
-	  gpr_mu_lock (&server->mu_call);
-	}
-      gpr_mu_unlock (&server->mu_call);
+  gpr_free(rc);
+  if (gpr_stack_lockfree_push(request_matcher->requests, request_id)) {
+    /* this was the first queued request: we need to lock and start
+       matching calls */
+    gpr_mu_lock(&server->mu_call);
+    while ((calld = request_matcher->pending_head) != NULL) {
+      request_id = gpr_stack_lockfree_pop(request_matcher->requests);
+      if (request_id == -1) break;
+      request_matcher->pending_head = calld->pending_next;
+      gpr_mu_unlock(&server->mu_call);
+      gpr_mu_lock(&calld->mu_state);
+      if (calld->state == ZOMBIED) {
+        gpr_mu_unlock(&calld->mu_state);
+        grpc_closure_init(
+            &calld->kill_zombie_closure, kill_zombie,
+            grpc_call_stack_element(grpc_call_get_call_stack(calld->call), 0));
+        grpc_exec_ctx_enqueue(exec_ctx, &calld->kill_zombie_closure, 1);
+      } else {
+        GPR_ASSERT(calld->state == PENDING);
+        calld->state = ACTIVATED;
+        gpr_mu_unlock(&calld->mu_state);
+        begin_call(exec_ctx, server, calld,
+                   &server->requested_calls[request_id]);
+      }
+      gpr_mu_lock(&server->mu_call);
     }
+    gpr_mu_unlock(&server->mu_call);
+  }
   return GRPC_CALL_OK;
 }
 
-grpc_call_error
-grpc_server_request_call (grpc_server * server, grpc_call ** call, grpc_call_details * details, grpc_metadata_array * initial_metadata, grpc_completion_queue * cq_bound_to_call, grpc_completion_queue * cq_for_notification, void *tag)
-{
+grpc_call_error grpc_server_request_call(
+    grpc_server *server, grpc_call **call, grpc_call_details *details,
+    grpc_metadata_array *initial_metadata,
+    grpc_completion_queue *cq_bound_to_call,
+    grpc_completion_queue *cq_for_notification, void *tag) {
   grpc_call_error error;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  requested_call *rc = gpr_malloc (sizeof (*rc));
-  GRPC_SERVER_LOG_REQUEST_CALL (GPR_INFO, server, call, details, initial_metadata, cq_bound_to_call, cq_for_notification, tag);
-  if (!grpc_cq_is_server_cq (cq_for_notification))
-    {
-      gpr_free (rc);
-      error = GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE;
-      goto done;
-    }
-  grpc_cq_begin_op (cq_for_notification);
+  requested_call *rc = gpr_malloc(sizeof(*rc));
+  GRPC_SERVER_LOG_REQUEST_CALL(GPR_INFO, server, call, details,
+                               initial_metadata, cq_bound_to_call,
+                               cq_for_notification, tag);
+  if (!grpc_cq_is_server_cq(cq_for_notification)) {
+    gpr_free(rc);
+    error = GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE;
+    goto done;
+  }
+  grpc_cq_begin_op(cq_for_notification);
   details->reserved = NULL;
   rc->type = BATCH_CALL;
   rc->server = server;
@@ -1297,26 +1197,27 @@ grpc_server_request_call (grpc_server * server, grpc_call ** call, grpc_call_det
   rc->call = call;
   rc->data.batch.details = details;
   rc->data.batch.initial_metadata = initial_metadata;
-  error = queue_call_request (&exec_ctx, server, rc);
+  error = queue_call_request(&exec_ctx, server, rc);
 done:
-  grpc_exec_ctx_finish (&exec_ctx);
+  grpc_exec_ctx_finish(&exec_ctx);
   return error;
 }
 
-grpc_call_error
-grpc_server_request_registered_call (grpc_server * server, void *rm, grpc_call ** call, gpr_timespec * deadline, grpc_metadata_array * initial_metadata, grpc_byte_buffer ** optional_payload, grpc_completion_queue * cq_bound_to_call, grpc_completion_queue * cq_for_notification, void *tag)
-{
+grpc_call_error grpc_server_request_registered_call(
+    grpc_server *server, void *rm, grpc_call **call, gpr_timespec *deadline,
+    grpc_metadata_array *initial_metadata, grpc_byte_buffer **optional_payload,
+    grpc_completion_queue *cq_bound_to_call,
+    grpc_completion_queue *cq_for_notification, void *tag) {
   grpc_call_error error;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  requested_call *rc = gpr_malloc (sizeof (*rc));
+  requested_call *rc = gpr_malloc(sizeof(*rc));
   registered_method *registered_method = rm;
-  if (!grpc_cq_is_server_cq (cq_for_notification))
-    {
-      gpr_free (rc);
-      error = GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE;
-      goto done;
-    }
-  grpc_cq_begin_op (cq_for_notification);
+  if (!grpc_cq_is_server_cq(cq_for_notification)) {
+    gpr_free(rc);
+    error = GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE;
+    goto done;
+  }
+  grpc_cq_begin_op(cq_for_notification);
   rc->type = REGISTERED_CALL;
   rc->server = server;
   rc->tag = tag;
@@ -1327,36 +1228,33 @@ grpc_server_request_registered_call (grpc_server * server, void *rm, grpc_call *
   rc->data.registered.deadline = deadline;
   rc->data.registered.initial_metadata = initial_metadata;
   rc->data.registered.optional_payload = optional_payload;
-  error = queue_call_request (&exec_ctx, server, rc);
+  error = queue_call_request(&exec_ctx, server, rc);
 done:
-  grpc_exec_ctx_finish (&exec_ctx);
+  grpc_exec_ctx_finish(&exec_ctx);
   return error;
 }
 
-static void publish_registered_or_batch (grpc_exec_ctx * exec_ctx, grpc_call * call, int success, void *tag);
-static void
-publish_was_not_set (grpc_exec_ctx * exec_ctx, grpc_call * call, int success, void *tag)
-{
-  abort ();
+static void publish_registered_or_batch(grpc_exec_ctx *exec_ctx,
+                                        grpc_call *call, int success,
+                                        void *tag);
+static void publish_was_not_set(grpc_exec_ctx *exec_ctx, grpc_call *call,
+                                int success, void *tag) {
+  abort();
 }
 
-static void
-cpstr (char **dest, size_t * capacity, grpc_mdstr * value)
-{
+static void cpstr(char **dest, size_t *capacity, grpc_mdstr *value) {
   gpr_slice slice = value->slice;
-  size_t len = GPR_SLICE_LENGTH (slice);
+  size_t len = GPR_SLICE_LENGTH(slice);
 
-  if (len + 1 > *capacity)
-    {
-      *capacity = GPR_MAX (len + 1, *capacity * 2);
-      *dest = gpr_realloc (*dest, *capacity);
-    }
-  memcpy (*dest, grpc_mdstr_as_c_string (value), len + 1);
+  if (len + 1 > *capacity) {
+    *capacity = GPR_MAX(len + 1, *capacity * 2);
+    *dest = gpr_realloc(*dest, *capacity);
+  }
+  memcpy(*dest, grpc_mdstr_as_c_string(value), len + 1);
 }
 
-static void
-begin_call (grpc_exec_ctx * exec_ctx, grpc_server * server, call_data * calld, requested_call * rc)
-{
+static void begin_call(grpc_exec_ctx *exec_ctx, grpc_server *server,
+                       call_data *calld, requested_call *rc) {
   grpc_ioreq_completion_func publish = publish_was_not_set;
   grpc_ioreq req[2];
   grpc_ioreq *r = req;
@@ -1367,16 +1265,17 @@ begin_call (grpc_exec_ctx * exec_ctx, grpc_server * server, call_data * calld, r
      fill in the metadata array passed by the client, we need to perform
      an ioreq op, that should complete immediately. */
 
-  grpc_call_set_completion_queue (exec_ctx, calld->call, rc->cq_bound_to_call);
+  grpc_call_set_completion_queue(exec_ctx, calld->call, rc->cq_bound_to_call);
   *rc->call = calld->call;
   calld->cq_new = rc->cq_for_notification;
-  switch (rc->type)
-    {
+  switch (rc->type) {
     case BATCH_CALL:
-      GPR_ASSERT (calld->host != NULL);
-      GPR_ASSERT (calld->path != NULL);
-      cpstr (&rc->data.batch.details->host, &rc->data.batch.details->host_capacity, calld->host);
-      cpstr (&rc->data.batch.details->method, &rc->data.batch.details->method_capacity, calld->path);
+      GPR_ASSERT(calld->host != NULL);
+      GPR_ASSERT(calld->path != NULL);
+      cpstr(&rc->data.batch.details->host,
+            &rc->data.batch.details->host_capacity, calld->host);
+      cpstr(&rc->data.batch.details->method,
+            &rc->data.batch.details->method_capacity, calld->path);
       rc->data.batch.details->deadline = calld->deadline;
       r->op = GRPC_IOREQ_RECV_INITIAL_METADATA;
       r->data.recv_metadata = rc->data.batch.initial_metadata;
@@ -1390,81 +1289,76 @@ begin_call (grpc_exec_ctx * exec_ctx, grpc_server * server, call_data * calld, r
       r->data.recv_metadata = rc->data.registered.initial_metadata;
       r->flags = 0;
       r++;
-      if (rc->data.registered.optional_payload)
-	{
-	  r->op = GRPC_IOREQ_RECV_MESSAGE;
-	  r->data.recv_message = rc->data.registered.optional_payload;
-	  r->flags = 0;
-	  r++;
-	}
+      if (rc->data.registered.optional_payload) {
+        r->op = GRPC_IOREQ_RECV_MESSAGE;
+        r->data.recv_message = rc->data.registered.optional_payload;
+        r->flags = 0;
+        r++;
+      }
       publish = publish_registered_or_batch;
       break;
-    }
+  }
 
-  GRPC_CALL_INTERNAL_REF (calld->call, "server");
-  grpc_call_start_ioreq_and_call_back (exec_ctx, calld->call, req, (size_t) (r - req), publish, rc);
+  GRPC_CALL_INTERNAL_REF(calld->call, "server");
+  grpc_call_start_ioreq_and_call_back(exec_ctx, calld->call, req,
+                                      (size_t)(r - req), publish, rc);
 }
 
-static void
-done_request_event (grpc_exec_ctx * exec_ctx, void *req, grpc_cq_completion * c)
-{
+static void done_request_event(grpc_exec_ctx *exec_ctx, void *req,
+                               grpc_cq_completion *c) {
   requested_call *rc = req;
   grpc_server *server = rc->server;
 
-  if (rc >= server->requested_calls && rc < server->requested_calls + server->max_requested_calls)
-    {
-      GPR_ASSERT (rc - server->requested_calls <= INT_MAX);
-      gpr_stack_lockfree_push (server->request_freelist, (int) (rc - server->requested_calls));
-    }
-  else
-    {
-      gpr_free (req);
-    }
+  if (rc >= server->requested_calls &&
+      rc < server->requested_calls + server->max_requested_calls) {
+    GPR_ASSERT(rc - server->requested_calls <= INT_MAX);
+    gpr_stack_lockfree_push(server->request_freelist,
+                            (int)(rc - server->requested_calls));
+  } else {
+    gpr_free(req);
+  }
 
-  server_unref (exec_ctx, server);
+  server_unref(exec_ctx, server);
 }
 
-static void
-fail_call (grpc_exec_ctx * exec_ctx, grpc_server * server, requested_call * rc)
-{
+static void fail_call(grpc_exec_ctx *exec_ctx, grpc_server *server,
+                      requested_call *rc) {
   *rc->call = NULL;
-  switch (rc->type)
-    {
+  switch (rc->type) {
     case BATCH_CALL:
       rc->data.batch.initial_metadata->count = 0;
       break;
     case REGISTERED_CALL:
       rc->data.registered.initial_metadata->count = 0;
       break;
-    }
-  server_ref (server);
-  grpc_cq_end_op (exec_ctx, rc->cq_for_notification, rc->tag, 0, done_request_event, rc, &rc->completion);
+  }
+  server_ref(server);
+  grpc_cq_end_op(exec_ctx, rc->cq_for_notification, rc->tag, 0,
+                 done_request_event, rc, &rc->completion);
 }
 
-static void
-publish_registered_or_batch (grpc_exec_ctx * exec_ctx, grpc_call * call, int success, void *prc)
-{
-  grpc_call_element *elem = grpc_call_stack_element (grpc_call_get_call_stack (call), 0);
+static void publish_registered_or_batch(grpc_exec_ctx *exec_ctx,
+                                        grpc_call *call, int success,
+                                        void *prc) {
+  grpc_call_element *elem =
+      grpc_call_stack_element(grpc_call_get_call_stack(call), 0);
   requested_call *rc = prc;
   call_data *calld = elem->call_data;
   channel_data *chand = elem->channel_data;
-  server_ref (chand->server);
-  grpc_cq_end_op (exec_ctx, calld->cq_new, rc->tag, success, done_request_event, rc, &rc->completion);
-  GRPC_CALL_INTERNAL_UNREF (exec_ctx, call, "server");
+  server_ref(chand->server);
+  grpc_cq_end_op(exec_ctx, calld->cq_new, rc->tag, success, done_request_event,
+                 rc, &rc->completion);
+  GRPC_CALL_INTERNAL_UNREF(exec_ctx, call, "server");
 }
 
-const grpc_channel_args *
-grpc_server_get_channel_args (grpc_server * server)
-{
+const grpc_channel_args *grpc_server_get_channel_args(grpc_server *server) {
   return server->channel_args;
 }
 
-int
-grpc_server_has_open_connections (grpc_server * server)
-{
+int grpc_server_has_open_connections(grpc_server *server) {
   int r;
-  gpr_mu_lock (&server->mu_global);
+  gpr_mu_lock(&server->mu_global);
   r = server->root_channel_data.next != &server->root_channel_data;
-  gpr_mu_unlock (&server->mu_global);
+  gpr_mu_unlock(&server->mu_global);
   return r;
 }
diff --git a/src/core/surface/server.h b/src/core/surface/server.h
index 96d47de3cb..4c46d07679 100644
--- a/src/core/surface/server.h
+++ b/src/core/surface/server.h
@@ -39,18 +39,29 @@
 #include "src/core/transport/transport.h"
 
 /* Create a server */
-grpc_server *grpc_server_create_from_filters (const grpc_channel_filter ** filters, size_t filter_count, const grpc_channel_args * args);
+grpc_server *grpc_server_create_from_filters(
+    const grpc_channel_filter **filters, size_t filter_count,
+    const grpc_channel_args *args);
 
 /* Add a listener to the server: when the server starts, it will call start,
    and when it shuts down, it will call destroy */
-void grpc_server_add_listener (grpc_exec_ctx * exec_ctx, grpc_server * server, void *listener, void (*start) (grpc_exec_ctx * exec_ctx, grpc_server * server, void *arg, grpc_pollset ** pollsets, size_t npollsets), void (*destroy) (grpc_exec_ctx * exec_ctx, grpc_server * server, void *arg, grpc_closure * on_done));
+void grpc_server_add_listener(
+    grpc_exec_ctx *exec_ctx, grpc_server *server, void *listener,
+    void (*start)(grpc_exec_ctx *exec_ctx, grpc_server *server, void *arg,
+                  grpc_pollset **pollsets, size_t npollsets),
+    void (*destroy)(grpc_exec_ctx *exec_ctx, grpc_server *server, void *arg,
+                    grpc_closure *on_done));
 
 /* Setup a transport - creates a channel stack, binds the transport to the
    server */
-void grpc_server_setup_transport (grpc_exec_ctx * exec_ctx, grpc_server * server, grpc_transport * transport, grpc_channel_filter const **extra_filters, size_t num_extra_filters, grpc_mdctx * mdctx, const grpc_channel_args * args);
+void grpc_server_setup_transport(grpc_exec_ctx *exec_ctx, grpc_server *server,
+                                 grpc_transport *transport,
+                                 grpc_channel_filter const **extra_filters,
+                                 size_t num_extra_filters, grpc_mdctx *mdctx,
+                                 const grpc_channel_args *args);
 
-const grpc_channel_args *grpc_server_get_channel_args (grpc_server * server);
+const grpc_channel_args *grpc_server_get_channel_args(grpc_server *server);
 
-int grpc_server_has_open_connections (grpc_server * server);
+int grpc_server_has_open_connections(grpc_server *server);
 
 #endif /* GRPC_INTERNAL_CORE_SURFACE_SERVER_H */
diff --git a/src/core/surface/server_chttp2.c b/src/core/surface/server_chttp2.c
index 8ea3f734e4..3904ce969d 100644
--- a/src/core/surface/server_chttp2.c
+++ b/src/core/surface/server_chttp2.c
@@ -42,18 +42,17 @@
 #include <grpc/support/log.h>
 #include <grpc/support/useful.h>
 
-static void
-setup_transport (grpc_exec_ctx * exec_ctx, void *server, grpc_transport * transport, grpc_mdctx * mdctx)
-{
+static void setup_transport(grpc_exec_ctx *exec_ctx, void *server,
+                            grpc_transport *transport, grpc_mdctx *mdctx) {
   static grpc_channel_filter const *extra_filters[] = {
-    &grpc_http_server_filter
-  };
-  grpc_server_setup_transport (exec_ctx, server, transport, extra_filters, GPR_ARRAY_SIZE (extra_filters), mdctx, grpc_server_get_channel_args (server));
+      &grpc_http_server_filter};
+  grpc_server_setup_transport(exec_ctx, server, transport, extra_filters,
+                              GPR_ARRAY_SIZE(extra_filters), mdctx,
+                              grpc_server_get_channel_args(server));
 }
 
-static void
-new_transport (grpc_exec_ctx * exec_ctx, void *server, grpc_endpoint * tcp)
-{
+static void new_transport(grpc_exec_ctx *exec_ctx, void *server,
+                          grpc_endpoint *tcp) {
   /*
    * Beware that the call to grpc_create_chttp2_transport() has to happen before
    * grpc_tcp_server_destroy(). This is fine here, but similar code
@@ -61,32 +60,30 @@ new_transport (grpc_exec_ctx * exec_ctx, void *server, grpc_endpoint * tcp)
    * (as in server_secure_chttp2.c) needs to add synchronization to avoid this
    * case.
    */
-  grpc_mdctx *mdctx = grpc_mdctx_create ();
-  grpc_transport *transport = grpc_create_chttp2_transport (exec_ctx, grpc_server_get_channel_args (server), tcp, mdctx, 0);
-  setup_transport (exec_ctx, server, transport, mdctx);
-  grpc_chttp2_transport_start_reading (exec_ctx, transport, NULL, 0);
+  grpc_mdctx *mdctx = grpc_mdctx_create();
+  grpc_transport *transport = grpc_create_chttp2_transport(
+      exec_ctx, grpc_server_get_channel_args(server), tcp, mdctx, 0);
+  setup_transport(exec_ctx, server, transport, mdctx);
+  grpc_chttp2_transport_start_reading(exec_ctx, transport, NULL, 0);
 }
 
 /* Server callback: start listening on our ports */
-static void
-start (grpc_exec_ctx * exec_ctx, grpc_server * server, void *tcpp, grpc_pollset ** pollsets, size_t pollset_count)
-{
+static void start(grpc_exec_ctx *exec_ctx, grpc_server *server, void *tcpp,
+                  grpc_pollset **pollsets, size_t pollset_count) {
   grpc_tcp_server *tcp = tcpp;
-  grpc_tcp_server_start (exec_ctx, tcp, pollsets, pollset_count, new_transport, server);
+  grpc_tcp_server_start(exec_ctx, tcp, pollsets, pollset_count, new_transport,
+                        server);
 }
 
 /* Server callback: destroy the tcp listener (so we don't generate further
    callbacks) */
-static void
-destroy (grpc_exec_ctx * exec_ctx, grpc_server * server, void *tcpp, grpc_closure * destroy_done)
-{
+static void destroy(grpc_exec_ctx *exec_ctx, grpc_server *server, void *tcpp,
+                    grpc_closure *destroy_done) {
   grpc_tcp_server *tcp = tcpp;
-  grpc_tcp_server_destroy (exec_ctx, tcp, destroy_done);
+  grpc_tcp_server_destroy(exec_ctx, tcp, destroy_done);
 }
 
-int
-grpc_server_add_insecure_http2_port (grpc_server * server, const char *addr)
-{
+int grpc_server_add_insecure_http2_port(grpc_server *server, const char *addr) {
   grpc_resolved_addresses *resolved = NULL;
   grpc_tcp_server *tcp = NULL;
   size_t i;
@@ -95,62 +92,55 @@ grpc_server_add_insecure_http2_port (grpc_server * server, const char *addr)
   int port_temp;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
-  resolved = grpc_blocking_resolve_address (addr, "http");
-  if (!resolved)
-    {
-      goto error;
-    }
+  resolved = grpc_blocking_resolve_address(addr, "http");
+  if (!resolved) {
+    goto error;
+  }
 
-  tcp = grpc_tcp_server_create ();
-  if (!tcp)
-    {
-      goto error;
-    }
+  tcp = grpc_tcp_server_create();
+  if (!tcp) {
+    goto error;
+  }
 
-  for (i = 0; i < resolved->naddrs; i++)
-    {
-      port_temp = grpc_tcp_server_add_port (tcp, (struct sockaddr *) &resolved->addrs[i].addr, resolved->addrs[i].len);
-      if (port_temp >= 0)
-	{
-	  if (port_num == -1)
-	    {
-	      port_num = port_temp;
-	    }
-	  else
-	    {
-	      GPR_ASSERT (port_num == port_temp);
-	    }
-	  count++;
-	}
-    }
-  if (count == 0)
-    {
-      gpr_log (GPR_ERROR, "No address added out of total %d resolved", resolved->naddrs);
-      goto error;
+  for (i = 0; i < resolved->naddrs; i++) {
+    port_temp = grpc_tcp_server_add_port(
+        tcp, (struct sockaddr *)&resolved->addrs[i].addr,
+        resolved->addrs[i].len);
+    if (port_temp >= 0) {
+      if (port_num == -1) {
+        port_num = port_temp;
+      } else {
+        GPR_ASSERT(port_num == port_temp);
+      }
+      count++;
     }
-  if (count != resolved->naddrs)
-    {
-      gpr_log (GPR_ERROR, "Only %d addresses added out of total %d resolved", count, resolved->naddrs);
-    }
-  grpc_resolved_addresses_destroy (resolved);
+  }
+  if (count == 0) {
+    gpr_log(GPR_ERROR, "No address added out of total %d resolved",
+            resolved->naddrs);
+    goto error;
+  }
+  if (count != resolved->naddrs) {
+    gpr_log(GPR_ERROR, "Only %d addresses added out of total %d resolved",
+            count, resolved->naddrs);
+  }
+  grpc_resolved_addresses_destroy(resolved);
 
   /* Register with the server only upon success */
-  grpc_server_add_listener (&exec_ctx, server, tcp, start, destroy);
+  grpc_server_add_listener(&exec_ctx, server, tcp, start, destroy);
   goto done;
 
 /* Error path: cleanup and return */
 error:
-  if (resolved)
-    {
-      grpc_resolved_addresses_destroy (resolved);
-    }
-  if (tcp)
-    {
-      grpc_tcp_server_destroy (&exec_ctx, tcp, NULL);
-    }
+  if (resolved) {
+    grpc_resolved_addresses_destroy(resolved);
+  }
+  if (tcp) {
+    grpc_tcp_server_destroy(&exec_ctx, tcp, NULL);
+  }
   port_num = 0;
 
 done:
-  grpc_exec_ctx_finish (&exec_ctx);
+  grpc_exec_ctx_finish(&exec_ctx);
   return port_num;
 }
diff --git a/src/core/surface/server_create.c b/src/core/surface/server_create.c
index d2f7b8e262..fc7ae820f5 100644
--- a/src/core/surface/server_create.c
+++ b/src/core/surface/server_create.c
@@ -36,10 +36,9 @@
 #include "src/core/surface/server.h"
 #include "src/core/channel/compress_filter.h"
 
-grpc_server *
-grpc_server_create (const grpc_channel_args * args, void *reserved)
-{
-  const grpc_channel_filter *filters[] = { &grpc_compress_filter };
-  (void) reserved;
-  return grpc_server_create_from_filters (filters, GPR_ARRAY_SIZE (filters), args);
+grpc_server *grpc_server_create(const grpc_channel_args *args, void *reserved) {
+  const grpc_channel_filter *filters[] = {&grpc_compress_filter};
+  (void)reserved;
+  return grpc_server_create_from_filters(filters, GPR_ARRAY_SIZE(filters),
+                                         args);
 }
diff --git a/src/core/surface/version.c b/src/core/surface/version.c
index 4b90e06a04..e559d51448 100644
--- a/src/core/surface/version.c
+++ b/src/core/surface/version.c
@@ -36,6 +36,4 @@
 
 #include <grpc/grpc.h>
 
-const char *grpc_version_string(void) {
-	return "0.11.0.0";
-}
+const char *grpc_version_string(void) { return "0.11.0.0"; }