clang-format

src/core/channel/channel_args.c

@@ -54,7 +54,8 @@ static grpc_arg copy_arg(const grpc_arg *src) {
       break;
     case GRPC_ARG_POINTER:
       dst.value.pointer = src->value.pointer;
-      dst.value.pointer.p = src->value.pointer.vtable->copy(src->value.pointer.p);
+      dst.value.pointer.p =
+          src->value.pointer.vtable->copy(src->value.pointer.p);
       break;
   }
   return dst;
@@ -104,11 +105,9 @@ static int cmp_arg(const grpc_arg *a, const grpc_arg *b) {
       c = GPR_ICMP(a->value.integer, b->value.integer);
       break;
     case GRPC_ARG_POINTER:
-      c = GPR_ICMP(a->value.pointer.p, 
-                   b->value.pointer.p);
+      c = GPR_ICMP(a->value.pointer.p, b->value.pointer.p);
       if (c != 0) {
-        c = GPR_ICMP(a->value.pointer.vtable, 
-                     b->value.pointer.vtable);
+        c = GPR_ICMP(a->value.pointer.vtable, b->value.pointer.vtable);
         if (c == 0) {
           c = a->value.pointer.vtable->cmp(a->value.pointer.p,
                                            b->value.pointer.p);
@@ -128,11 +127,11 @@ static int cmp_key_stable(const void *ap, const void *bp) {
 }
 
 grpc_channel_args *grpc_channel_args_normalize(const grpc_channel_args *a) {
-  grpc_arg **args = gpr_malloc(sizeof(grpc_arg*) * a->num_args);
+  grpc_arg **args = gpr_malloc(sizeof(grpc_arg *) * a->num_args);
   for (size_t i = 0; i < a->num_args; i++) {
     args[i] = &a->args[i];
   }
-  qsort(args, a->num_args, sizeof(grpc_arg*), cmp_key_stable);
+  qsort(args, a->num_args, sizeof(grpc_arg *), cmp_key_stable);
 
   grpc_channel_args *b = gpr_malloc(sizeof(grpc_channel_args));
   b->num_args = a->num_args;
@@ -258,7 +257,7 @@ int grpc_channel_args_compression_algorithm_get_states(
   }
 }
 
-int grpc_channel_args_compare(const grpc_channel_args *a, 
+int grpc_channel_args_compare(const grpc_channel_args *a,
                               const grpc_channel_args *b) {
   int c = GPR_ICMP(a->num_args, b->num_args);
   if (c != 0) return c;

src/core/channel/channel_args.h

@@ -88,6 +88,7 @@ grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(
 int grpc_channel_args_compression_algorithm_get_states(
     const grpc_channel_args *a);
 
-int grpc_channel_args_compare(const grpc_channel_args *a, const grpc_channel_args *b);
+int grpc_channel_args_compare(const grpc_channel_args *a,
+                              const grpc_channel_args *b);
 
 #endif /* GRPC_INTERNAL_CORE_CHANNEL_CHANNEL_ARGS_H */

src/core/client_config/connector.c

@@ -33,7 +33,7 @@
 
 #include "src/core/client_config/connector.h"
 
-grpc_connector *grpc_connector_ref(grpc_connector* connector) {
+grpc_connector* grpc_connector_ref(grpc_connector* connector) {
   connector->vtable->ref(connector);
   return connector;
 }

src/core/client_config/subchannel.c

@@ -239,7 +239,8 @@ void grpc_subchannel_weak_ref(grpc_subchannel *c
   GPR_ASSERT(old_refs != 0);
 }
 
-grpc_subchannel *grpc_subchannel_ref_from_weak_ref(grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
+grpc_subchannel *grpc_subchannel_ref_from_weak_ref(
+    grpc_subchannel *c GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
   if (!c) return NULL;
   for (;;) {
     gpr_atm old_refs = gpr_atm_acq_load(&c->ref_pair);

src/core/client_config/subchannel.h

@@ -68,7 +68,8 @@ typedef struct grpc_subchannel_args grpc_subchannel_args;
   , const char *file, int line, const char *reason
 #else
 #define GRPC_SUBCHANNEL_REF(p, r) grpc_subchannel_ref((p))
-#define GRPC_SUBCHANNEL_REF_FROM_WEAK_REF(p, r) grpc_subchannel_ref_from_weak_ref((p))
+#define GRPC_SUBCHANNEL_REF_FROM_WEAK_REF(p, r) \
+  grpc_subchannel_ref_from_weak_ref((p))
 #define GRPC_SUBCHANNEL_UNREF(cl, p, r) grpc_subchannel_unref((cl), (p))
 #define GRPC_SUBCHANNEL_WEAK_REF(p, r) grpc_subchannel_weak_ref((p))
 #define GRPC_SUBCHANNEL_WEAK_UNREF(cl, p, r) \
@@ -84,8 +85,8 @@ typedef struct grpc_subchannel_args grpc_subchannel_args;
 
 void grpc_subchannel_ref(grpc_subchannel *channel
                              GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
-grpc_subchannel *grpc_subchannel_ref_from_weak_ref(grpc_subchannel *channel
-                             GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
+grpc_subchannel *grpc_subchannel_ref_from_weak_ref(
+    grpc_subchannel *channel GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
 void grpc_subchannel_unref(grpc_exec_ctx *exec_ctx,
                            grpc_subchannel *channel
                                GRPC_SUBCHANNEL_REF_EXTRA_ARGS);
@@ -152,7 +153,7 @@ grpc_call_stack *grpc_subchannel_call_get_call_stack(
 
 struct grpc_subchannel_args {
   /* When updating this struct, also update subchannel_index.c */
-  
+
   /** Channel filters for this channel - wrapped factories will likely
       want to mutate this */
   const grpc_channel_filter **filters;

src/core/client_config/subchannel_index.c

@@ -49,34 +49,37 @@ static gpr_avl g_subchannel_index;
 static gpr_mu g_mu;
 
 struct grpc_subchannel_key {
-	grpc_connector *connector;
-	grpc_subchannel_args args;
+  grpc_connector *connector;
+  grpc_subchannel_args args;
 };
 
 GPR_TLS_DECL(subchannel_index_exec_ctx);
 
 static void enter_ctx(grpc_exec_ctx *exec_ctx) {
-	GPR_ASSERT(gpr_tls_get(&subchannel_index_exec_ctx) == 0);
-	gpr_tls_set(&subchannel_index_exec_ctx, (intptr_t)exec_ctx);
+  GPR_ASSERT(gpr_tls_get(&subchannel_index_exec_ctx) == 0);
+  gpr_tls_set(&subchannel_index_exec_ctx, (intptr_t)exec_ctx);
 }
 
 static void leave_ctx(grpc_exec_ctx *exec_ctx) {
-	GPR_ASSERT(gpr_tls_get(&subchannel_index_exec_ctx) == (intptr_t)exec_ctx);
-	gpr_tls_set(&subchannel_index_exec_ctx, 0);
+  GPR_ASSERT(gpr_tls_get(&subchannel_index_exec_ctx) == (intptr_t)exec_ctx);
+  gpr_tls_set(&subchannel_index_exec_ctx, 0);
 }
 
 static grpc_exec_ctx *current_ctx() {
-	grpc_exec_ctx *c = (grpc_exec_ctx *)gpr_tls_get(&subchannel_index_exec_ctx);
-	GPR_ASSERT(c != NULL);
-	return c;
+  grpc_exec_ctx *c = (grpc_exec_ctx *)gpr_tls_get(&subchannel_index_exec_ctx);
+  GPR_ASSERT(c != NULL);
+  return c;
 }
 
-static grpc_subchannel_key *create_key(grpc_connector *connector, grpc_subchannel_args *args, grpc_channel_args *(*copy_channel_args)(const grpc_channel_args *args)) {
+static grpc_subchannel_key *create_key(
+    grpc_connector *connector, grpc_subchannel_args *args,
+    grpc_channel_args *(*copy_channel_args)(const grpc_channel_args *args)) {
   grpc_subchannel_key *k = gpr_malloc(sizeof(*k));
   k->connector = grpc_connector_ref(connector);
   k->args.filter_count = args->filter_count;
   k->args.filters = gpr_malloc(sizeof(*k->args.filters) * k->args.filter_count);
-  memcpy(k->args.filters, args->filters, sizeof(*k->args.filters) * k->args.filter_count);
+  memcpy(k->args.filters, args->filters,
+         sizeof(*k->args.filters) * k->args.filter_count);
   k->args.addr_len = args->addr_len;
   k->args.addr = gpr_malloc(args->addr_len);
   memcpy(k->args.addr, args->addr, k->args.addr_len);
@@ -84,15 +87,17 @@ static grpc_subchannel_key *create_key(grpc_connector *connector, grpc_subchanne
   return k;
 }
 
-grpc_subchannel_key *grpc_subchannel_key_create(grpc_connector *connector, grpc_subchannel_args *args) {
-	return create_key(connector, args, grpc_channel_args_normalize);
+grpc_subchannel_key *grpc_subchannel_key_create(grpc_connector *connector,
+                                                grpc_subchannel_args *args) {
+  return create_key(connector, args, grpc_channel_args_normalize);
 }
 
 static grpc_subchannel_key *subchannel_key_copy(grpc_subchannel_key *k) {
-	return create_key(k->connector, &k->args, grpc_channel_args_copy);
+  return create_key(k->connector, &k->args, grpc_channel_args_copy);
 }
 
-static int subchannel_key_compare(grpc_subchannel_key *a, grpc_subchannel_key *b) {
+static int subchannel_key_compare(grpc_subchannel_key *a,
+                                  grpc_subchannel_key *b) {
   int c = GPR_ICMP(a->connector, b->connector);
   if (c != 0) return c;
   c = GPR_ICMP(a->args.addr_len, b->args.addr_len);
@@ -101,137 +106,131 @@ static int subchannel_key_compare(grpc_subchannel_key *a, grpc_subchannel_key *b
   if (c != 0) return c;
   c = memcmp(a->args.addr, b->args.addr, a->args.addr_len);
   if (c != 0) return c;
-  c = memcmp(a->args.filters, b->args.filters, a->args.filter_count * sizeof(*a->args.filters));
+  c = memcmp(a->args.filters, b->args.filters,
+             a->args.filter_count * sizeof(*a->args.filters));
   return grpc_channel_args_compare(a->args.args, b->args.args);
 }
 
 void grpc_subchannel_key_destroy(grpc_subchannel_key *k) {
   gpr_free(k->args.addr);
   gpr_free(k->args.filters);
-  grpc_channel_args_destroy((grpc_channel_args*)k->args.args);
+  grpc_channel_args_destroy((grpc_channel_args *)k->args.args);
   gpr_free(k);
 }
 
-static void sck_avl_destroy(void *p) {
-  grpc_subchannel_key_destroy(p);
-}
+static void sck_avl_destroy(void *p) { grpc_subchannel_key_destroy(p); }
 
-static void *sck_avl_copy(void *p) {
-  return subchannel_key_copy(p);
-}
+static void *sck_avl_copy(void *p) { return subchannel_key_copy(p); }
 
 static long sck_avl_compare(void *a, void *b) {
   return subchannel_key_compare(a, b);
 }
 
 static void scv_avl_destroy(void *p) {
-	grpc_exec_ctx *exec_ctx = current_ctx();
+  grpc_exec_ctx *exec_ctx = current_ctx();
   GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, p, "subchannel_index");
 }
 
-static void *scv_avl_copy(void *p) { 
+static void *scv_avl_copy(void *p) {
   GRPC_SUBCHANNEL_WEAK_REF(p, "subchannel_index");
-  return p; 
+  return p;
 }
 
 static const gpr_avl_vtable subchannel_avl_vtable = {
-  .destroy_key = sck_avl_destroy,
-  .copy_key = sck_avl_copy,
-  .compare_keys = sck_avl_compare,
-  .destroy_value = scv_avl_destroy,
-  .copy_value = scv_avl_copy  
-};
+    .destroy_key = sck_avl_destroy,
+    .copy_key = sck_avl_copy,
+    .compare_keys = sck_avl_compare,
+    .destroy_value = scv_avl_destroy,
+    .copy_value = scv_avl_copy};
 
 void grpc_subchannel_index_init(void) {
-	g_subchannel_index = gpr_avl_create(&subchannel_avl_vtable);
-	gpr_mu_init(&g_mu);
+  g_subchannel_index = gpr_avl_create(&subchannel_avl_vtable);
+  gpr_mu_init(&g_mu);
 }
 
 void grpc_subchannel_index_shutdown(void) {
-	gpr_mu_destroy(&g_mu);
-	gpr_avl_unref(g_subchannel_index);
+  gpr_mu_destroy(&g_mu);
+  gpr_avl_unref(g_subchannel_index);
 }
 
-grpc_subchannel *grpc_subchannel_index_find(
-		grpc_exec_ctx *exec_ctx,
-		grpc_subchannel_key *key) {
-	enter_ctx(exec_ctx);
+grpc_subchannel *grpc_subchannel_index_find(grpc_exec_ctx *exec_ctx,
+                                            grpc_subchannel_key *key) {
+  enter_ctx(exec_ctx);
 
-	gpr_mu_lock(&g_mu);
-	gpr_avl index = gpr_avl_ref(g_subchannel_index);
-	gpr_mu_unlock(&g_mu);
+  gpr_mu_lock(&g_mu);
+  gpr_avl index = gpr_avl_ref(g_subchannel_index);
+  gpr_mu_unlock(&g_mu);
 
-	grpc_subchannel *c = GRPC_SUBCHANNEL_REF_FROM_WEAK_REF(gpr_avl_get(index, key), "index_find");
-	gpr_avl_unref(index);
+  grpc_subchannel *c =
+      GRPC_SUBCHANNEL_REF_FROM_WEAK_REF(gpr_avl_get(index, key), "index_find");
+  gpr_avl_unref(index);
 
-	leave_ctx(exec_ctx);
-	return c;
+  leave_ctx(exec_ctx);
+  return c;
 }
 
-grpc_subchannel *grpc_subchannel_index_register(
-	  grpc_exec_ctx *exec_ctx,
-		grpc_subchannel_key *key, 
-		grpc_subchannel *constructed) {
-	enter_ctx(exec_ctx);
+grpc_subchannel *grpc_subchannel_index_register(grpc_exec_ctx *exec_ctx,
+                                                grpc_subchannel_key *key,
+                                                grpc_subchannel *constructed) {
+  enter_ctx(exec_ctx);
 
-	grpc_subchannel *c = NULL;
+  grpc_subchannel *c = NULL;
 
-	while (c == NULL) {
-		gpr_mu_lock(&g_mu);
-		gpr_avl index = gpr_avl_ref(g_subchannel_index);
-		gpr_mu_unlock(&g_mu);
+  while (c == NULL) {
+    gpr_mu_lock(&g_mu);
+    gpr_avl index = gpr_avl_ref(g_subchannel_index);
+    gpr_mu_unlock(&g_mu);
 
-		c = gpr_avl_get(index, key);
-		if (c != NULL) {
-			GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, constructed, "index_register");
-		} else {
-			gpr_avl updated = gpr_avl_add(index, key, constructed);
+    c = gpr_avl_get(index, key);
+    if (c != NULL) {
+      GRPC_SUBCHANNEL_WEAK_UNREF(exec_ctx, constructed, "index_register");
+    } else {
+      gpr_avl updated = gpr_avl_add(index, key, constructed);
 
-			gpr_mu_lock(&g_mu);
-			if (index.root == g_subchannel_index.root) {
-				GPR_SWAP(gpr_avl, updated, g_subchannel_index);
-				c = constructed;
-			}
-			gpr_mu_unlock(&g_mu);
-		}
-		gpr_avl_unref(index);
-	}
+      gpr_mu_lock(&g_mu);
+      if (index.root == g_subchannel_index.root) {
+        GPR_SWAP(gpr_avl, updated, g_subchannel_index);
+        c = constructed;
+      }
+      gpr_mu_unlock(&g_mu);
+    }
+    gpr_avl_unref(index);
+  }
 
-	leave_ctx(exec_ctx);
+  leave_ctx(exec_ctx);
 
-	return c;
+  return c;
 }
 
-void grpc_subchannel_index_unregister(
-    grpc_exec_ctx *exec_ctx,
-    grpc_subchannel_key *key,
-    grpc_subchannel *constructed) {
-	enter_ctx(exec_ctx);
+void grpc_subchannel_index_unregister(grpc_exec_ctx *exec_ctx,
+                                      grpc_subchannel_key *key,
+                                      grpc_subchannel *constructed) {
+  enter_ctx(exec_ctx);
 
-	bool done = false;
-	while (!done) {
-		gpr_mu_lock(&g_mu);
-		gpr_avl index = gpr_avl_ref(g_subchannel_index);
-		gpr_mu_unlock(&g_mu);
+  bool done = false;
+  while (!done) {
+    gpr_mu_lock(&g_mu);
+    gpr_avl index = gpr_avl_ref(g_subchannel_index);
+    gpr_mu_unlock(&g_mu);
 
-		grpc_subchannel *c = gpr_avl_get(index, key);
-		if (c != constructed) {
-			break;
-		}
+    grpc_subchannel *c = gpr_avl_get(index, key);
+    if (c != constructed) {
+      break;
+    }
 
-		gpr_avl updated = gpr_avl_remove(index, key);
+    gpr_avl updated = gpr_avl_remove(index, key);
 
-		gpr_mu_lock(&g_mu);
-		if (index.root == g_subchannel_index.root) {
-			GPR_SWAP(gpr_avl, updated, g_subchannel_index);
-			done = true;
-		} else {
-			GPR_SWAP(gpr_avl, updated, index);
-		}
-		gpr_mu_unlock(&g_mu);
+    gpr_mu_lock(&g_mu);
+    if (index.root == g_subchannel_index.root) {
+      GPR_SWAP(gpr_avl, updated, g_subchannel_index);
+      done = true;
+    } else {
+      GPR_SWAP(gpr_avl, updated, index);
+    }
+    gpr_mu_unlock(&g_mu);
 
-		gpr_avl_unref(index);
-	}
+    gpr_avl_unref(index);
+  }
 
-	leave_ctx(exec_ctx);
+  leave_ctx(exec_ctx);
 }

src/core/client_config/subchannel_index.h

@@ -39,24 +39,21 @@
 
 typedef struct grpc_subchannel_key grpc_subchannel_key;
 
-grpc_subchannel_key *grpc_subchannel_key_create(
-    grpc_connector *con, grpc_subchannel_args *args);
+grpc_subchannel_key *grpc_subchannel_key_create(grpc_connector *con,
+                                                grpc_subchannel_args *args);
 
 void grpc_subchannel_key_destroy(grpc_subchannel_key *key);
 
-grpc_subchannel *grpc_subchannel_index_find(
-    grpc_exec_ctx *exec_ctx,
-    grpc_subchannel_key *key);
+grpc_subchannel *grpc_subchannel_index_find(grpc_exec_ctx *exec_ctx,
+                                            grpc_subchannel_key *key);
 
-grpc_subchannel *grpc_subchannel_index_register(
-    grpc_exec_ctx *exec_ctx,
-    grpc_subchannel_key *key, 
-    grpc_subchannel *constructed);
+grpc_subchannel *grpc_subchannel_index_register(grpc_exec_ctx *exec_ctx,
+                                                grpc_subchannel_key *key,
+                                                grpc_subchannel *constructed);
 
-void grpc_subchannel_index_unregister(
-    grpc_exec_ctx *exec_ctx,
-    grpc_subchannel_key *key,
-    grpc_subchannel *constructed);
+void grpc_subchannel_index_unregister(grpc_exec_ctx *exec_ctx,
+                                      grpc_subchannel_key *key,
+                                      grpc_subchannel *constructed);
 
 void grpc_subchannel_index_init(void);
 void grpc_subchannel_index_shutdown(void);

src/core/security/credentials.c

@@ -201,10 +201,8 @@ static int server_credentials_pointer_cmp(void *a, void *b) {
 }
 
 static const grpc_arg_pointer_vtable cred_ptr_vtable = {
-  server_credentials_pointer_arg_copy,
-  server_credentials_pointer_arg_destroy,
-  server_credentials_pointer_cmp
-};
+    server_credentials_pointer_arg_copy, server_credentials_pointer_arg_destroy,
+    server_credentials_pointer_cmp};
 
 grpc_arg grpc_server_credentials_to_arg(grpc_server_credentials *p) {
   grpc_arg arg;

src/core/security/security_connector.c

@@ -194,15 +194,11 @@ static void *connector_pointer_arg_copy(void *p) {
   return GRPC_SECURITY_CONNECTOR_REF(p, "connector_pointer_arg");
 }
 
-static int connector_pointer_cmp(void *a, void *b) {
-  return GPR_ICMP(a, b);
-}
+static int connector_pointer_cmp(void *a, void *b) { return GPR_ICMP(a, b); }
 
 static const grpc_arg_pointer_vtable connector_pointer_vtable = {
-  connector_pointer_arg_copy,
-  connector_pointer_arg_destroy,
-  connector_pointer_cmp
-};
+    connector_pointer_arg_copy, connector_pointer_arg_destroy,
+    connector_pointer_cmp};
 
 grpc_arg grpc_security_connector_to_arg(grpc_security_connector *sc) {
   grpc_arg result;

src/core/security/security_context.c

@@ -309,15 +309,11 @@ static void *auth_context_pointer_arg_copy(void *p) {
   return GRPC_AUTH_CONTEXT_REF(p, "auth_context_pointer_arg");
 }
 
-static int auth_context_pointer_cmp(void *a, void *b) {
-  return GPR_ICMP(a, b);
-}
+static int auth_context_pointer_cmp(void *a, void *b) { return GPR_ICMP(a, b); }
 
 static const grpc_arg_pointer_vtable auth_context_pointer_vtable = {
-  auth_context_pointer_arg_copy,
-  auth_context_pointer_arg_destroy,
-  auth_context_pointer_cmp
-};
+    auth_context_pointer_arg_copy, auth_context_pointer_arg_destroy,
+    auth_context_pointer_cmp};
 
 grpc_arg grpc_auth_context_to_arg(grpc_auth_context *p) {
   grpc_arg arg;

src/cpp/common/channel_arguments.cc

@@ -93,17 +93,14 @@ void ChannelArguments::SetPointer(const grpc::string& key, void* value) {
   struct VtableMembers {
     static void* Copy(void* in) { return in; }
     static void Destroy(void* in) {}
-    static int Compare(void* a, void *b) {
+    static int Compare(void* a, void* b) {
       if (a < b) return -1;
       if (a > b) return 1;
       return 0;
     }
   };
   static const grpc_arg_pointer_vtable vtable = {
-    &VtableMembers::Copy,
-    &VtableMembers::Destroy,
-    &VtableMembers::Compare
-  };
+      &VtableMembers::Copy, &VtableMembers::Destroy, &VtableMembers::Compare};
 
   grpc_arg arg;
   arg.type = GRPC_ARG_POINTER;