indent pass to get logical source lines on one physical line

1 files changed, 274 insertions, 245 deletions

diff --git a/src/core/security/secure_endpoint.c b/src/core/security/secure_endpoint.c
index a6fc7e94a0..64c501860f 100644
--- a/src/core/security/secure_endpoint.c
+++ b/src/core/security/secure_endpoint.c
@@ -43,7 +43,8 @@
 
 #define STAGING_BUFFER_SIZE 8192
 
-typedef struct {
+typedef struct
+{
   grpc_endpoint base;
   grpc_endpoint *wrapped_ep;
   struct tsi_frame_protector *protector;
@@ -67,18 +68,19 @@ typedef struct {
 
 int grpc_trace_secure_endpoint = 0;
 
-static void destroy(secure_endpoint *secure_ep,
-                    grpc_closure_list *closure_list) {
+static void
+destroy (secure_endpoint * secure_ep, grpc_closure_list * closure_list)
+{
   secure_endpoint *ep = secure_ep;
-  grpc_endpoint_destroy(ep->wrapped_ep, closure_list);
-  tsi_frame_protector_destroy(ep->protector);
-  gpr_slice_buffer_destroy(&ep->leftover_bytes);
-  gpr_slice_unref(ep->read_staging_buffer);
-  gpr_slice_unref(ep->write_staging_buffer);
-  gpr_slice_buffer_destroy(&ep->output_buffer);
-  gpr_slice_buffer_destroy(&ep->source_buffer);
-  gpr_mu_destroy(&ep->protector_mu);
-  gpr_free(ep);
+  grpc_endpoint_destroy (ep->wrapped_ep, closure_list);
+  tsi_frame_protector_destroy (ep->protector);
+  gpr_slice_buffer_destroy (&ep->leftover_bytes);
+  gpr_slice_unref (ep->read_staging_buffer);
+  gpr_slice_unref (ep->write_staging_buffer);
+  gpr_slice_buffer_destroy (&ep->output_buffer);
+  gpr_slice_buffer_destroy (&ep->source_buffer);
+  gpr_mu_destroy (&ep->protector_mu);
+  gpr_free (ep);
 }
 
 /*#define GRPC_SECURE_ENDPOINT_REFCOUNT_DEBUG*/
@@ -87,299 +89,326 @@ static void destroy(secure_endpoint *secure_ep,
   secure_endpoint_unref((ep), (cl), (reason), __FILE__, __LINE__)
 #define SECURE_ENDPOINT_REF(ep, reason) \
   secure_endpoint_ref((ep), (reason), __FILE__, __LINE__)
-static void secure_endpoint_unref(secure_endpoint *ep,
-                                  grpc_closure_list *closure_list,
-                                  const char *reason, const char *file,
-                                  int line) {
-  gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "SECENDP unref %p : %s %d -> %d",
-          ep, reason, ep->ref.count, ep->ref.count - 1);
-  if (gpr_unref(&ep->ref)) {
-    destroy(ep, closure_list);
-  }
+static void
+secure_endpoint_unref (secure_endpoint * ep, grpc_closure_list * closure_list, const char *reason, const char *file, int line)
+{
+  gpr_log (file, line, GPR_LOG_SEVERITY_DEBUG, "SECENDP unref %p : %s %d -> %d", ep, reason, ep->ref.count, ep->ref.count - 1);
+  if (gpr_unref (&ep->ref))
+    {
+      destroy (ep, closure_list);
+    }
 }
 
-static void secure_endpoint_ref(secure_endpoint *ep, const char *reason,
-                                const char *file, int line) {
-  gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "SECENDP   ref %p : %s %d -> %d",
-          ep, reason, ep->ref.count, ep->ref.count + 1);
-  gpr_ref(&ep->ref);
+static void
+secure_endpoint_ref (secure_endpoint * ep, const char *reason, const char *file, int line)
+{
+  gpr_log (file, line, GPR_LOG_SEVERITY_DEBUG, "SECENDP   ref %p : %s %d -> %d", ep, reason, ep->ref.count, ep->ref.count + 1);
+  gpr_ref (&ep->ref);
 }
 #else
 #define SECURE_ENDPOINT_UNREF(ep, reason, cl) secure_endpoint_unref((ep), (cl))
 #define SECURE_ENDPOINT_REF(ep, reason) secure_endpoint_ref((ep))
-static void secure_endpoint_unref(secure_endpoint *ep,
-                                  grpc_closure_list *closure_list) {
-  if (gpr_unref(&ep->ref)) {
-    destroy(ep, closure_list);
-  }
+static void
+secure_endpoint_unref (secure_endpoint * ep, grpc_closure_list * closure_list)
+{
+  if (gpr_unref (&ep->ref))
+    {
+      destroy (ep, closure_list);
+    }
 }
 
-static void secure_endpoint_ref(secure_endpoint *ep) { gpr_ref(&ep->ref); }
+static void
+secure_endpoint_ref (secure_endpoint * ep)
+{
+  gpr_ref (&ep->ref);
+}
 #endif
 
-static void flush_read_staging_buffer(secure_endpoint *ep, gpr_uint8 **cur,
-                                      gpr_uint8 **end) {
-  gpr_slice_buffer_add(ep->read_buffer, ep->read_staging_buffer);
-  ep->read_staging_buffer = gpr_slice_malloc(STAGING_BUFFER_SIZE);
-  *cur = GPR_SLICE_START_PTR(ep->read_staging_buffer);
-  *end = GPR_SLICE_END_PTR(ep->read_staging_buffer);
+static void
+flush_read_staging_buffer (secure_endpoint * ep, gpr_uint8 ** cur, gpr_uint8 ** end)
+{
+  gpr_slice_buffer_add (ep->read_buffer, ep->read_staging_buffer);
+  ep->read_staging_buffer = gpr_slice_malloc (STAGING_BUFFER_SIZE);
+  *cur = GPR_SLICE_START_PTR (ep->read_staging_buffer);
+  *end = GPR_SLICE_END_PTR (ep->read_staging_buffer);
 }
 
-static void call_read_cb(secure_endpoint *ep, int success,
-                         grpc_closure_list *closure_list) {
-  if (grpc_trace_secure_endpoint) {
-    size_t i;
-    for (i = 0; i < ep->read_buffer->count; i++) {
-      char *data = gpr_dump_slice(ep->read_buffer->slices[i],
-                                  GPR_DUMP_HEX | GPR_DUMP_ASCII);
-      gpr_log(GPR_DEBUG, "READ %p: %s", ep, data);
-      gpr_free(data);
+static void
+call_read_cb (secure_endpoint * ep, int success, grpc_closure_list * closure_list)
+{
+  if (grpc_trace_secure_endpoint)
+    {
+      size_t i;
+      for (i = 0; i < ep->read_buffer->count; i++)
+	{
+	  char *data = gpr_dump_slice (ep->read_buffer->slices[i],
+				       GPR_DUMP_HEX | GPR_DUMP_ASCII);
+	  gpr_log (GPR_DEBUG, "READ %p: %s", ep, data);
+	  gpr_free (data);
+	}
     }
-  }
   ep->read_buffer = NULL;
-  grpc_closure_list_add(closure_list, ep->read_cb, success);
-  SECURE_ENDPOINT_UNREF(ep, "read", closure_list);
+  grpc_closure_list_add (closure_list, ep->read_cb, success);
+  SECURE_ENDPOINT_UNREF (ep, "read", closure_list);
 }
 
-static void on_read(void *user_data, int success,
-                    grpc_closure_list *closure_list) {
+static void
+on_read (void *user_data, int success, grpc_closure_list * closure_list)
+{
   unsigned i;
   gpr_uint8 keep_looping = 0;
   tsi_result result = TSI_OK;
-  secure_endpoint *ep = (secure_endpoint *)user_data;
-  gpr_uint8 *cur = GPR_SLICE_START_PTR(ep->read_staging_buffer);
-  gpr_uint8 *end = GPR_SLICE_END_PTR(ep->read_staging_buffer);
-
-  if (!success) {
-    gpr_slice_buffer_reset_and_unref(ep->read_buffer);
-    call_read_cb(ep, 0, closure_list);
-    return;
-  }
+  secure_endpoint *ep = (secure_endpoint *) user_data;
+  gpr_uint8 *cur = GPR_SLICE_START_PTR (ep->read_staging_buffer);
+  gpr_uint8 *end = GPR_SLICE_END_PTR (ep->read_staging_buffer);
+
+  if (!success)
+    {
+      gpr_slice_buffer_reset_and_unref (ep->read_buffer);
+      call_read_cb (ep, 0, closure_list);
+      return;
+    }
 
   /* TODO(yangg) check error, maybe bail out early */
-  for (i = 0; i < ep->source_buffer.count; i++) {
-    gpr_slice encrypted = ep->source_buffer.slices[i];
-    gpr_uint8 *message_bytes = GPR_SLICE_START_PTR(encrypted);
-    size_t message_size = GPR_SLICE_LENGTH(encrypted);
-
-    while (message_size > 0 || keep_looping) {
-      size_t unprotected_buffer_size_written = (size_t)(end - cur);
-      size_t processed_message_size = message_size;
-      gpr_mu_lock(&ep->protector_mu);
-      result = tsi_frame_protector_unprotect(ep->protector, message_bytes,
-                                             &processed_message_size, cur,
-                                             &unprotected_buffer_size_written);
-      gpr_mu_unlock(&ep->protector_mu);
-      if (result != TSI_OK) {
-        gpr_log(GPR_ERROR, "Decryption error: %s",
-                tsi_result_to_string(result));
-        break;
-      }
-      message_bytes += processed_message_size;
-      message_size -= processed_message_size;
-      cur += unprotected_buffer_size_written;
-
-      if (cur == end) {
-        flush_read_staging_buffer(ep, &cur, &end);
-        /* Force to enter the loop again to extract buffered bytes in protector.
-           The bytes could be buffered because of running out of staging_buffer.
-           If this happens at the end of all slices, doing another unprotect
-           avoids leaving data in the protector. */
-        keep_looping = 1;
-      } else if (unprotected_buffer_size_written > 0) {
-        keep_looping = 1;
-      } else {
-        keep_looping = 0;
-      }
+  for (i = 0; i < ep->source_buffer.count; i++)
+    {
+      gpr_slice encrypted = ep->source_buffer.slices[i];
+      gpr_uint8 *message_bytes = GPR_SLICE_START_PTR (encrypted);
+      size_t message_size = GPR_SLICE_LENGTH (encrypted);
+
+      while (message_size > 0 || keep_looping)
+	{
+	  size_t unprotected_buffer_size_written = (size_t) (end - cur);
+	  size_t processed_message_size = message_size;
+	  gpr_mu_lock (&ep->protector_mu);
+	  result = tsi_frame_protector_unprotect (ep->protector, message_bytes, &processed_message_size, cur, &unprotected_buffer_size_written);
+	  gpr_mu_unlock (&ep->protector_mu);
+	  if (result != TSI_OK)
+	    {
+	      gpr_log (GPR_ERROR, "Decryption error: %s", tsi_result_to_string (result));
+	      break;
+	    }
+	  message_bytes += processed_message_size;
+	  message_size -= processed_message_size;
+	  cur += unprotected_buffer_size_written;
+
+	  if (cur == end)
+	    {
+	      flush_read_staging_buffer (ep, &cur, &end);
+	      /* Force to enter the loop again to extract buffered bytes in protector.
+	         The bytes could be buffered because of running out of staging_buffer.
+	         If this happens at the end of all slices, doing another unprotect
+	         avoids leaving data in the protector. */
+	      keep_looping = 1;
+	    }
+	  else if (unprotected_buffer_size_written > 0)
+	    {
+	      keep_looping = 1;
+	    }
+	  else
+	    {
+	      keep_looping = 0;
+	    }
+	}
+      if (result != TSI_OK)
+	break;
     }
-    if (result != TSI_OK) break;
-  }
 
-  if (cur != GPR_SLICE_START_PTR(ep->read_staging_buffer)) {
-    gpr_slice_buffer_add(
-        ep->read_buffer,
-        gpr_slice_split_head(
-            &ep->read_staging_buffer,
-            (size_t)(cur - GPR_SLICE_START_PTR(ep->read_staging_buffer))));
-  }
+  if (cur != GPR_SLICE_START_PTR (ep->read_staging_buffer))
+    {
+      gpr_slice_buffer_add (ep->read_buffer, gpr_slice_split_head (&ep->read_staging_buffer, (size_t) (cur - GPR_SLICE_START_PTR (ep->read_staging_buffer))));
+    }
 
   /* TODO(yangg) experiment with moving this block after read_cb to see if it
      helps latency */
-  gpr_slice_buffer_reset_and_unref(&ep->source_buffer);
+  gpr_slice_buffer_reset_and_unref (&ep->source_buffer);
 
-  if (result != TSI_OK) {
-    gpr_slice_buffer_reset_and_unref(ep->read_buffer);
-    call_read_cb(ep, 0, closure_list);
-    return;
-  }
+  if (result != TSI_OK)
+    {
+      gpr_slice_buffer_reset_and_unref (ep->read_buffer);
+      call_read_cb (ep, 0, closure_list);
+      return;
+    }
 
-  call_read_cb(ep, 1, closure_list);
+  call_read_cb (ep, 1, closure_list);
 }
 
-static void endpoint_read(grpc_endpoint *secure_ep, gpr_slice_buffer *slices,
-                          grpc_closure *cb, grpc_closure_list *closure_list) {
-  secure_endpoint *ep = (secure_endpoint *)secure_ep;
+static void
+endpoint_read (grpc_endpoint * secure_ep, gpr_slice_buffer * slices, grpc_closure * cb, grpc_closure_list * closure_list)
+{
+  secure_endpoint *ep = (secure_endpoint *) secure_ep;
   ep->read_cb = cb;
   ep->read_buffer = slices;
-  gpr_slice_buffer_reset_and_unref(ep->read_buffer);
-
-  SECURE_ENDPOINT_REF(ep, "read");
-  if (ep->leftover_bytes.count) {
-    gpr_slice_buffer_swap(&ep->leftover_bytes, &ep->source_buffer);
-    GPR_ASSERT(ep->leftover_bytes.count == 0);
-    on_read(ep, 1, closure_list);
-    return;
-  }
-
-  grpc_endpoint_read(ep->wrapped_ep, &ep->source_buffer, &ep->on_read,
-                     closure_list);
+  gpr_slice_buffer_reset_and_unref (ep->read_buffer);
+
+  SECURE_ENDPOINT_REF (ep, "read");
+  if (ep->leftover_bytes.count)
+    {
+      gpr_slice_buffer_swap (&ep->leftover_bytes, &ep->source_buffer);
+      GPR_ASSERT (ep->leftover_bytes.count == 0);
+      on_read (ep, 1, closure_list);
+      return;
+    }
+
+  grpc_endpoint_read (ep->wrapped_ep, &ep->source_buffer, &ep->on_read, closure_list);
 }
 
-static void flush_write_staging_buffer(secure_endpoint *ep, gpr_uint8 **cur,
-                                       gpr_uint8 **end) {
-  gpr_slice_buffer_add(&ep->output_buffer, ep->write_staging_buffer);
-  ep->write_staging_buffer = gpr_slice_malloc(STAGING_BUFFER_SIZE);
-  *cur = GPR_SLICE_START_PTR(ep->write_staging_buffer);
-  *end = GPR_SLICE_END_PTR(ep->write_staging_buffer);
+static void
+flush_write_staging_buffer (secure_endpoint * ep, gpr_uint8 ** cur, gpr_uint8 ** end)
+{
+  gpr_slice_buffer_add (&ep->output_buffer, ep->write_staging_buffer);
+  ep->write_staging_buffer = gpr_slice_malloc (STAGING_BUFFER_SIZE);
+  *cur = GPR_SLICE_START_PTR (ep->write_staging_buffer);
+  *end = GPR_SLICE_END_PTR (ep->write_staging_buffer);
 }
 
-static void endpoint_write(grpc_endpoint *secure_ep, gpr_slice_buffer *slices,
-                           grpc_closure *cb, grpc_closure_list *closure_list) {
+static void
+endpoint_write (grpc_endpoint * secure_ep, gpr_slice_buffer * slices, grpc_closure * cb, grpc_closure_list * closure_list)
+{
   unsigned i;
   tsi_result result = TSI_OK;
-  secure_endpoint *ep = (secure_endpoint *)secure_ep;
-  gpr_uint8 *cur = GPR_SLICE_START_PTR(ep->write_staging_buffer);
-  gpr_uint8 *end = GPR_SLICE_END_PTR(ep->write_staging_buffer);
-
-  gpr_slice_buffer_reset_and_unref(&ep->output_buffer);
-
-  if (grpc_trace_secure_endpoint) {
-    for (i = 0; i < slices->count; i++) {
-      char *data =
-          gpr_dump_slice(slices->slices[i], GPR_DUMP_HEX | GPR_DUMP_ASCII);
-      gpr_log(GPR_DEBUG, "WRITE %p: %s", ep, data);
-      gpr_free(data);
+  secure_endpoint *ep = (secure_endpoint *) secure_ep;
+  gpr_uint8 *cur = GPR_SLICE_START_PTR (ep->write_staging_buffer);
+  gpr_uint8 *end = GPR_SLICE_END_PTR (ep->write_staging_buffer);
+
+  gpr_slice_buffer_reset_and_unref (&ep->output_buffer);
+
+  if (grpc_trace_secure_endpoint)
+    {
+      for (i = 0; i < slices->count; i++)
+	{
+	  char *data = gpr_dump_slice (slices->slices[i], GPR_DUMP_HEX | GPR_DUMP_ASCII);
+	  gpr_log (GPR_DEBUG, "WRITE %p: %s", ep, data);
+	  gpr_free (data);
+	}
     }
-  }
-
-  for (i = 0; i < slices->count; i++) {
-    gpr_slice plain = slices->slices[i];
-    gpr_uint8 *message_bytes = GPR_SLICE_START_PTR(plain);
-    size_t message_size = GPR_SLICE_LENGTH(plain);
-    while (message_size > 0) {
-      size_t protected_buffer_size_to_send = (size_t)(end - cur);
-      size_t processed_message_size = message_size;
-      gpr_mu_lock(&ep->protector_mu);
-      result = tsi_frame_protector_protect(ep->protector, message_bytes,
-                                           &processed_message_size, cur,
-                                           &protected_buffer_size_to_send);
-      gpr_mu_unlock(&ep->protector_mu);
-      if (result != TSI_OK) {
-        gpr_log(GPR_ERROR, "Encryption error: %s",
-                tsi_result_to_string(result));
-        break;
-      }
-      message_bytes += processed_message_size;
-      message_size -= processed_message_size;
-      cur += protected_buffer_size_to_send;
-
-      if (cur == end) {
-        flush_write_staging_buffer(ep, &cur, &end);
-      }
+
+  for (i = 0; i < slices->count; i++)
+    {
+      gpr_slice plain = slices->slices[i];
+      gpr_uint8 *message_bytes = GPR_SLICE_START_PTR (plain);
+      size_t message_size = GPR_SLICE_LENGTH (plain);
+      while (message_size > 0)
+	{
+	  size_t protected_buffer_size_to_send = (size_t) (end - cur);
+	  size_t processed_message_size = message_size;
+	  gpr_mu_lock (&ep->protector_mu);
+	  result = tsi_frame_protector_protect (ep->protector, message_bytes, &processed_message_size, cur, &protected_buffer_size_to_send);
+	  gpr_mu_unlock (&ep->protector_mu);
+	  if (result != TSI_OK)
+	    {
+	      gpr_log (GPR_ERROR, "Encryption error: %s", tsi_result_to_string (result));
+	      break;
+	    }
+	  message_bytes += processed_message_size;
+	  message_size -= processed_message_size;
+	  cur += protected_buffer_size_to_send;
+
+	  if (cur == end)
+	    {
+	      flush_write_staging_buffer (ep, &cur, &end);
+	    }
+	}
+      if (result != TSI_OK)
+	break;
     }
-    if (result != TSI_OK) break;
-  }
-  if (result == TSI_OK) {
-    size_t still_pending_size;
-    do {
-      size_t protected_buffer_size_to_send = (size_t)(end - cur);
-      gpr_mu_lock(&ep->protector_mu);
-      result = tsi_frame_protector_protect_flush(ep->protector, cur,
-                                                 &protected_buffer_size_to_send,
-                                                 &still_pending_size);
-      gpr_mu_unlock(&ep->protector_mu);
-      if (result != TSI_OK) break;
-      cur += protected_buffer_size_to_send;
-      if (cur == end) {
-        flush_write_staging_buffer(ep, &cur, &end);
-      }
-    } while (still_pending_size > 0);
-    if (cur != GPR_SLICE_START_PTR(ep->write_staging_buffer)) {
-      gpr_slice_buffer_add(
-          &ep->output_buffer,
-          gpr_slice_split_head(
-              &ep->write_staging_buffer,
-              (size_t)(cur - GPR_SLICE_START_PTR(ep->write_staging_buffer))));
+  if (result == TSI_OK)
+    {
+      size_t still_pending_size;
+      do
+	{
+	  size_t protected_buffer_size_to_send = (size_t) (end - cur);
+	  gpr_mu_lock (&ep->protector_mu);
+	  result = tsi_frame_protector_protect_flush (ep->protector, cur, &protected_buffer_size_to_send, &still_pending_size);
+	  gpr_mu_unlock (&ep->protector_mu);
+	  if (result != TSI_OK)
+	    break;
+	  cur += protected_buffer_size_to_send;
+	  if (cur == end)
+	    {
+	      flush_write_staging_buffer (ep, &cur, &end);
+	    }
+	}
+      while (still_pending_size > 0);
+      if (cur != GPR_SLICE_START_PTR (ep->write_staging_buffer))
+	{
+	  gpr_slice_buffer_add (&ep->output_buffer, gpr_slice_split_head (&ep->write_staging_buffer, (size_t) (cur - GPR_SLICE_START_PTR (ep->write_staging_buffer))));
+	}
     }
-  }
 
-  if (result != TSI_OK) {
-    /* TODO(yangg) do different things according to the error type? */
-    gpr_slice_buffer_reset_and_unref(&ep->output_buffer);
-    grpc_closure_list_add(closure_list, cb, 0);
-    return;
-  }
+  if (result != TSI_OK)
+    {
+      /* TODO(yangg) do different things according to the error type? */
+      gpr_slice_buffer_reset_and_unref (&ep->output_buffer);
+      grpc_closure_list_add (closure_list, cb, 0);
+      return;
+    }
 
-  grpc_endpoint_write(ep->wrapped_ep, &ep->output_buffer, cb, closure_list);
+  grpc_endpoint_write (ep->wrapped_ep, &ep->output_buffer, cb, closure_list);
 }
 
-static void endpoint_shutdown(grpc_endpoint *secure_ep,
-                              grpc_closure_list *closure_list) {
-  secure_endpoint *ep = (secure_endpoint *)secure_ep;
-  grpc_endpoint_shutdown(ep->wrapped_ep, closure_list);
+static void
+endpoint_shutdown (grpc_endpoint * secure_ep, grpc_closure_list * closure_list)
+{
+  secure_endpoint *ep = (secure_endpoint *) secure_ep;
+  grpc_endpoint_shutdown (ep->wrapped_ep, closure_list);
 }
 
-static void endpoint_destroy(grpc_endpoint *secure_ep,
-                             grpc_closure_list *closure_list) {
-  secure_endpoint *ep = (secure_endpoint *)secure_ep;
-  SECURE_ENDPOINT_UNREF(ep, "destroy", closure_list);
+static void
+endpoint_destroy (grpc_endpoint * secure_ep, grpc_closure_list * closure_list)
+{
+  secure_endpoint *ep = (secure_endpoint *) secure_ep;
+  SECURE_ENDPOINT_UNREF (ep, "destroy", closure_list);
 }
 
-static void endpoint_add_to_pollset(grpc_endpoint *secure_ep,
-                                    grpc_pollset *pollset,
-                                    grpc_closure_list *closure_list) {
-  secure_endpoint *ep = (secure_endpoint *)secure_ep;
-  grpc_endpoint_add_to_pollset(ep->wrapped_ep, pollset, closure_list);
+static void
+endpoint_add_to_pollset (grpc_endpoint * secure_ep, grpc_pollset * pollset, grpc_closure_list * closure_list)
+{
+  secure_endpoint *ep = (secure_endpoint *) secure_ep;
+  grpc_endpoint_add_to_pollset (ep->wrapped_ep, pollset, closure_list);
 }
 
-static void endpoint_add_to_pollset_set(grpc_endpoint *secure_ep,
-                                        grpc_pollset_set *pollset_set,
-                                        grpc_closure_list *closure_list) {
-  secure_endpoint *ep = (secure_endpoint *)secure_ep;
-  grpc_endpoint_add_to_pollset_set(ep->wrapped_ep, pollset_set, closure_list);
+static void
+endpoint_add_to_pollset_set (grpc_endpoint * secure_ep, grpc_pollset_set * pollset_set, grpc_closure_list * closure_list)
+{
+  secure_endpoint *ep = (secure_endpoint *) secure_ep;
+  grpc_endpoint_add_to_pollset_set (ep->wrapped_ep, pollset_set, closure_list);
 }
 
-static char *endpoint_get_peer(grpc_endpoint *secure_ep) {
-  secure_endpoint *ep = (secure_endpoint *)secure_ep;
-  return grpc_endpoint_get_peer(ep->wrapped_ep);
+static char *
+endpoint_get_peer (grpc_endpoint * secure_ep)
+{
+  secure_endpoint *ep = (secure_endpoint *) secure_ep;
+  return grpc_endpoint_get_peer (ep->wrapped_ep);
 }
 
 static const grpc_endpoint_vtable vtable = {
-    endpoint_read,           endpoint_write,
-    endpoint_add_to_pollset, endpoint_add_to_pollset_set,
-    endpoint_shutdown,       endpoint_destroy,
-    endpoint_get_peer};
-
-grpc_endpoint *grpc_secure_endpoint_create(
-    struct tsi_frame_protector *protector, grpc_endpoint *transport,
-    gpr_slice *leftover_slices, size_t leftover_nslices) {
+  endpoint_read, endpoint_write,
+  endpoint_add_to_pollset, endpoint_add_to_pollset_set,
+  endpoint_shutdown, endpoint_destroy,
+  endpoint_get_peer
+};
+
+grpc_endpoint *
+grpc_secure_endpoint_create (struct tsi_frame_protector *protector, grpc_endpoint * transport, gpr_slice * leftover_slices, size_t leftover_nslices)
+{
   size_t i;
-  secure_endpoint *ep = (secure_endpoint *)gpr_malloc(sizeof(secure_endpoint));
+  secure_endpoint *ep = (secure_endpoint *) gpr_malloc (sizeof (secure_endpoint));
   ep->base.vtable = &vtable;
   ep->wrapped_ep = transport;
   ep->protector = protector;
-  gpr_slice_buffer_init(&ep->leftover_bytes);
-  for (i = 0; i < leftover_nslices; i++) {
-    gpr_slice_buffer_add(&ep->leftover_bytes,
-                         gpr_slice_ref(leftover_slices[i]));
-  }
-  ep->write_staging_buffer = gpr_slice_malloc(STAGING_BUFFER_SIZE);
-  ep->read_staging_buffer = gpr_slice_malloc(STAGING_BUFFER_SIZE);
-  gpr_slice_buffer_init(&ep->output_buffer);
-  gpr_slice_buffer_init(&ep->source_buffer);
+  gpr_slice_buffer_init (&ep->leftover_bytes);
+  for (i = 0; i < leftover_nslices; i++)
+    {
+      gpr_slice_buffer_add (&ep->leftover_bytes, gpr_slice_ref (leftover_slices[i]));
+    }
+  ep->write_staging_buffer = gpr_slice_malloc (STAGING_BUFFER_SIZE);
+  ep->read_staging_buffer = gpr_slice_malloc (STAGING_BUFFER_SIZE);
+  gpr_slice_buffer_init (&ep->output_buffer);
+  gpr_slice_buffer_init (&ep->source_buffer);
   ep->read_buffer = NULL;
-  grpc_closure_init(&ep->on_read, on_read, ep);
-  gpr_mu_init(&ep->protector_mu);
-  gpr_ref_init(&ep->ref, 1);
+  grpc_closure_init (&ep->on_read, on_read, ep);
+  gpr_mu_init (&ep->protector_mu);
+  gpr_ref_init (&ep->ref, 1);
   return &ep->base;
 }