clang-format

src/core/client_config/connector.c

@@ -41,8 +41,7 @@ void grpc_connector_unref(grpc_connector *connector) {
   connector->vtable->unref(connector);
 }
 
-void grpc_connector_connect(
+void grpc_connector_connect(grpc_connector *connector,
-    grpc_connector *connector, 
                             const grpc_connect_in_args *in_args,
                             grpc_connect_out_args *out_args,
                             grpc_iomgr_closure *notify) {

src/core/client_config/connector.h

@@ -72,14 +72,12 @@ struct grpc_connector_vtable {
   void (*unref)(grpc_connector *connector);
   void (*connect)(grpc_connector *connector,
                   const grpc_connect_in_args *in_args,
-                  grpc_connect_out_args *out_args,
+                  grpc_connect_out_args *out_args, grpc_iomgr_closure *notify);
-                  grpc_iomgr_closure *notify);
 };
 
 void grpc_connector_ref(grpc_connector *connector);
 void grpc_connector_unref(grpc_connector *connector);
-void grpc_connector_connect(
+void grpc_connector_connect(grpc_connector *connector,
-    grpc_connector *connector, 
                             const grpc_connect_in_args *in_args,
                             grpc_connect_out_args *out_args,
                             grpc_iomgr_closure *notify);

src/core/client_config/lb_policies/pick_first.c

@@ -105,9 +105,12 @@ void pf_pick(grpc_lb_policy *pol, grpc_pollset *pollset,
       p->checking_subchannel = 0;
       p->checking_connectivity = GRPC_CHANNEL_IDLE;
       GRPC_LB_POLICY_REF(pol, "pick_first_connectivity");
-      grpc_subchannel_notify_on_state_change(p->subchannels[p->checking_subchannel], &p->checking_connectivity, &p->connectivity_changed);
+      grpc_subchannel_notify_on_state_change(
+          p->subchannels[p->checking_subchannel], &p->checking_connectivity,
+          &p->connectivity_changed);
     }
-    grpc_subchannel_add_interested_party(p->subchannels[p->checking_subchannel], pollset);
+    grpc_subchannel_add_interested_party(p->subchannels[p->checking_subchannel],
+                                         pollset);
     pp = gpr_malloc(sizeof(*pp));
     pp->next = p->pending_picks;
     pp->pollset = pollset;
@@ -121,14 +124,16 @@ void pf_pick(grpc_lb_policy *pol, grpc_pollset *pollset,
 static void del_interested_parties_locked(pick_first_lb_policy *p) {
   pending_pick *pp;
   for (pp = p->pending_picks; pp; pp = pp->next) {
-    grpc_subchannel_del_interested_party(p->subchannels[p->checking_subchannel], pp->pollset);
+    grpc_subchannel_del_interested_party(p->subchannels[p->checking_subchannel],
+                                         pp->pollset);
   }
 }
 
 static void add_interested_parties_locked(pick_first_lb_policy *p) {
   pending_pick *pp;
   for (pp = p->pending_picks; pp; pp = pp->next) {
-    grpc_subchannel_add_interested_party(p->subchannels[p->checking_subchannel], pp->pollset);
+    grpc_subchannel_add_interested_party(p->subchannels[p->checking_subchannel],
+                                         pp->pollset);
   }
 }
 
@@ -142,7 +147,8 @@ loop:
   switch (p->checking_connectivity) {
     case GRPC_CHANNEL_READY:
       p->selected = p->subchannels[p->checking_subchannel];
-      GPR_ASSERT(grpc_subchannel_check_connectivity(p->selected) == GRPC_CHANNEL_READY);
+      GPR_ASSERT(grpc_subchannel_check_connectivity(p->selected) ==
+                 GRPC_CHANNEL_READY);
       while ((pp = p->pending_picks)) {
         p->pending_picks = pp->next;
         *pp->target = p->selected;
@@ -154,19 +160,25 @@ loop:
       break;
     case GRPC_CHANNEL_TRANSIENT_FAILURE:
       del_interested_parties_locked(p);
-      p->checking_subchannel = (p->checking_subchannel + 1) % p->num_subchannels;
+      p->checking_subchannel =
-      p->checking_connectivity = grpc_subchannel_check_connectivity(p->subchannels[p->checking_subchannel]);
+          (p->checking_subchannel + 1) % p->num_subchannels;
+      p->checking_connectivity = grpc_subchannel_check_connectivity(
+          p->subchannels[p->checking_subchannel]);
       add_interested_parties_locked(p);
       goto loop;
     case GRPC_CHANNEL_CONNECTING:
     case GRPC_CHANNEL_IDLE:
-      grpc_subchannel_notify_on_state_change(p->subchannels[p->checking_subchannel], &p->checking_connectivity, &p->connectivity_changed);
+      grpc_subchannel_notify_on_state_change(
+          p->subchannels[p->checking_subchannel], &p->checking_connectivity,
+          &p->connectivity_changed);
       break;
     case GRPC_CHANNEL_FATAL_FAILURE:
       del_interested_parties_locked(p);
-      GPR_SWAP(grpc_subchannel *, p->subchannels[p->checking_subchannel], p->subchannels[p->num_subchannels - 1]);
+      GPR_SWAP(grpc_subchannel *, p->subchannels[p->checking_subchannel],
+               p->subchannels[p->num_subchannels - 1]);
       p->checking_subchannel %= p->num_subchannels;
-      p->checking_connectivity = grpc_subchannel_check_connectivity(p->subchannels[p->checking_subchannel]);
+      p->checking_connectivity = grpc_subchannel_check_connectivity(
+          p->subchannels[p->checking_subchannel]);
       p->num_subchannels--;
       grpc_subchannel_unref(p->subchannels[p->num_subchannels]);
       add_interested_parties_locked(p);
@@ -214,15 +226,19 @@ static grpc_connectivity_state pf_check_connectivity(grpc_lb_policy *pol) {
   return st;
 }
 
-static void pf_notify_on_state_change(grpc_lb_policy *pol, grpc_connectivity_state *current, grpc_iomgr_closure *notify) {
+static void pf_notify_on_state_change(grpc_lb_policy *pol,
+                                      grpc_connectivity_state *current,
+                                      grpc_iomgr_closure *notify) {
   pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
   gpr_mu_lock(&p->mu);
-  grpc_connectivity_state_notify_on_state_change(&p->state_tracker, current, notify);
+  grpc_connectivity_state_notify_on_state_change(&p->state_tracker, current,
+                                                 notify);
   gpr_mu_unlock(&p->mu);
 }
 
 static const grpc_lb_policy_vtable pick_first_lb_policy_vtable = {
-    pf_destroy, pf_shutdown, pf_pick, pf_broadcast, pf_check_connectivity, pf_notify_on_state_change};
+    pf_destroy,   pf_shutdown,           pf_pick,
+    pf_broadcast, pf_check_connectivity, pf_notify_on_state_change};
 
 grpc_lb_policy *grpc_create_pick_first_lb_policy(grpc_subchannel **subchannels,
                                                  size_t num_subchannels) {

src/core/client_config/lb_policy.c

@@ -33,16 +33,17 @@
 
 #include "src/core/client_config/lb_policy.h"
 
-void grpc_lb_policy_init(grpc_lb_policy *policy, const grpc_lb_policy_vtable *vtable) {
+void grpc_lb_policy_init(grpc_lb_policy *policy,
+                         const grpc_lb_policy_vtable *vtable) {
   policy->vtable = vtable;
   gpr_ref_init(&policy->refs, 1);
 }
 
 #ifdef GRPC_LB_POLICY_REFCOUNT_DEBUG
-void grpc_lb_policy_ref(grpc_lb_policy *policy, const char *file, int line, const char *reason) {
+void grpc_lb_policy_ref(grpc_lb_policy *policy, const char *file, int line,
+                        const char *reason) {
   gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "LB_POLICY:%p   ref %d -> %d %s",
-          policy, (int)policy->refs.count, (int)policy->refs.count + 1,
+          policy, (int)policy->refs.count, (int)policy->refs.count + 1, reason);
-          reason);
 #else
 void grpc_lb_policy_ref(grpc_lb_policy *policy) {
 #endif
@@ -50,10 +51,10 @@ void grpc_lb_policy_ref(grpc_lb_policy *policy) {
 }
 
 #ifdef GRPC_LB_POLICY_REFCOUNT_DEBUG
-void grpc_lb_policy_unref(grpc_lb_policy *policy, const char *file, int line, const char *reason) {
+void grpc_lb_policy_unref(grpc_lb_policy *policy, const char *file, int line,
+                          const char *reason) {
   gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, "LB_POLICY:%p unref %d -> %d %s",
-          policy, (int)policy->refs.count, (int)policy->refs.count - 1,
+          policy, (int)policy->refs.count, (int)policy->refs.count - 1, reason);
-          reason);
 #else
 void grpc_lb_policy_unref(grpc_lb_policy *policy) {
 #endif

src/core/client_config/lb_policy.h

@@ -67,14 +67,20 @@ struct grpc_lb_policy_vtable {
 
   /** call notify when the connectivity state of a channel changes from *state.
       Updates *state with the new state of the policy */
-  void (*notify_on_state_change)(grpc_lb_policy *policy, grpc_connectivity_state *state, grpc_iomgr_closure *closure);
+  void (*notify_on_state_change)(grpc_lb_policy *policy,
+                                 grpc_connectivity_state *state,
+                                 grpc_iomgr_closure *closure);
 };
 
 #ifdef GRPC_LB_POLICY_REFCOUNT_DEBUG
-#define GRPC_LB_POLICY_REF(p, r) grpc_lb_policy_ref((p), __FILE__, __LINE__, (r))
+#define GRPC_LB_POLICY_REF(p, r) \
-#define GRPC_LB_POLICY_UNREF(p, r) grpc_lb_policy_unref((p), __FILE__, __LINE__, (r))
+  grpc_lb_policy_ref((p), __FILE__, __LINE__, (r))
-void grpc_lb_policy_ref(grpc_lb_policy *policy, const char *file, int line, const char *reason);
+#define GRPC_LB_POLICY_UNREF(p, r) \
-void grpc_lb_policy_unref(grpc_lb_policy *policy, const char *file, int line, const char *reason);
+  grpc_lb_policy_unref((p), __FILE__, __LINE__, (r))
+void grpc_lb_policy_ref(grpc_lb_policy *policy, const char *file, int line,
+                        const char *reason);
+void grpc_lb_policy_unref(grpc_lb_policy *policy, const char *file, int line,
+                          const char *reason);
 #else
 #define GRPC_LB_POLICY_REF(p, r) grpc_lb_policy_ref((p))
 #define GRPC_LB_POLICY_UNREF(p, r) grpc_lb_policy_unref((p))
@@ -83,7 +89,8 @@ void grpc_lb_policy_unref(grpc_lb_policy *policy);
 #endif
 
 /** called by concrete implementations to initialize the base struct */
-void grpc_lb_policy_init(grpc_lb_policy *policy, const grpc_lb_policy_vtable *vtable);
+void grpc_lb_policy_init(grpc_lb_policy *policy,
+                         const grpc_lb_policy_vtable *vtable);
 
 /** Start shutting down (fail any pending picks) */
 void grpc_lb_policy_shutdown(grpc_lb_policy *policy);

src/core/client_config/resolvers/unix_resolver_posix.c

@@ -112,8 +112,7 @@ static void unix_shutdown(grpc_resolver *resolver) {
 }
 
 static void unix_channel_saw_error(grpc_resolver *resolver, struct sockaddr *sa,
-                                  int len) {
+                                   int len) {}
-}
 
 static void unix_next(grpc_resolver *resolver,
                       grpc_client_config **target_config,
@@ -138,7 +137,8 @@ static void unix_maybe_finish_next_locked(unix_resolver *r) {
     memset(&args, 0, sizeof(args));
     args.addr = (struct sockaddr *)&r->addr;
     args.addr_len = r->addr_len;
-    subchannel = grpc_subchannel_factory_create_subchannel(r->subchannel_factory, &args);
+    subchannel =
+        grpc_subchannel_factory_create_subchannel(r->subchannel_factory, &args);
     lb_policy = r->lb_policy_factory(&subchannel, 1);
     grpc_client_config_set_lb_policy(cfg, lb_policy);
     GRPC_LB_POLICY_UNREF(lb_policy, "unix");
@@ -194,8 +194,7 @@ static void unix_factory_unref(grpc_resolver_factory *factory) {}
 static grpc_resolver *unix_factory_create_resolver(
     grpc_resolver_factory *factory, grpc_uri *uri,
     grpc_subchannel_factory *subchannel_factory) {
-  return unix_create(uri, grpc_create_pick_first_lb_policy,
+  return unix_create(uri, grpc_create_pick_first_lb_policy, subchannel_factory);
-                    subchannel_factory);
 }
 
 static const grpc_resolver_factory_vtable unix_factory_vtable = {

src/core/client_config/subchannel.c

@@ -103,7 +103,8 @@ struct grpc_subchannel_call {
 #define SUBCHANNEL_CALL_TO_CALL_STACK(call) ((grpc_call_stack *)((call) + 1))
 #define CHANNEL_STACK_FROM_CONNECTION(con) ((grpc_channel_stack *)((con) + 1))
 
-static grpc_subchannel_call *create_call(connection *con, grpc_transport_stream_op *initial_op);
+static grpc_subchannel_call *create_call(connection *con,
+                                         grpc_transport_stream_op *initial_op);
 static void connectivity_state_changed_locked(grpc_subchannel *c);
 static grpc_connectivity_state compute_connectivity_locked(grpc_subchannel *c);
 static gpr_timespec compute_connect_deadline(grpc_subchannel *c);
@@ -112,7 +113,8 @@ static void subchannel_connected(void *subchannel, int iomgr_success);
 static void subchannel_ref_locked(grpc_subchannel *c);
 static int subchannel_unref_locked(grpc_subchannel *c) GRPC_MUST_USE_RESULT;
 static void connection_ref_locked(connection *c);
-static grpc_subchannel *connection_unref_locked(connection *c) GRPC_MUST_USE_RESULT;
+static grpc_subchannel *connection_unref_locked(connection *c)
+    GRPC_MUST_USE_RESULT;
 static void subchannel_destroy(grpc_subchannel *c);
 
 /*
@@ -141,14 +143,11 @@ static grpc_subchannel *connection_unref_locked(connection *c) {
   return destroy;
 }
 
-
 /*
  * grpc_subchannel implementation
  */
 
-static void subchannel_ref_locked(grpc_subchannel *c) { 
+static void subchannel_ref_locked(grpc_subchannel *c) { ++c->refs; }
-	++c->refs;
-}
 
 static int subchannel_unref_locked(grpc_subchannel *c) {
   return --c->refs == 0;
@@ -225,7 +224,8 @@ static void start_connect(grpc_subchannel *c) {
   args.channel_args = c->args;
   args.metadata_context = c->mdctx;
 
-  grpc_connector_connect(c->connector, &args, &c->connecting_result, &c->connected);
+  grpc_connector_connect(c->connector, &args, &c->connecting_result,
+                         &c->connected);
 }
 
 void grpc_subchannel_create_call(grpc_subchannel *c,
@@ -275,11 +275,13 @@ void grpc_subchannel_notify_on_state_change(grpc_subchannel *c,
                                             grpc_iomgr_closure *notify) {
   int do_connect = 0;
   gpr_mu_lock(&c->mu);
-  if (grpc_connectivity_state_notify_on_state_change(&c->state_tracker, state, notify)) {
+  if (grpc_connectivity_state_notify_on_state_change(&c->state_tracker, state,
+                                                     notify)) {
     do_connect = 1;
     c->connecting = 1;
     subchannel_ref_locked(c);
-    grpc_connectivity_state_set(&c->state_tracker, compute_connectivity_locked(c));
+    grpc_connectivity_state_set(&c->state_tracker,
+                                compute_connectivity_locked(c));
   }
   gpr_mu_unlock(&c->mu);
   if (do_connect) {
@@ -287,7 +289,8 @@ void grpc_subchannel_notify_on_state_change(grpc_subchannel *c,
   }
 }
 
-void grpc_subchannel_process_transport_op(grpc_subchannel *c, grpc_transport_op *op) {
+void grpc_subchannel_process_transport_op(grpc_subchannel *c,
+                                          grpc_transport_op *op) {
   abort();
 }
 
@@ -303,7 +306,8 @@ static void publish_transport(grpc_subchannel *c) {
   num_filters = c->num_filters + c->connecting_result.num_filters + 1;
   filters = gpr_malloc(sizeof(*filters) * num_filters);
   memcpy(filters, c->filters, sizeof(*filters) * c->num_filters);
-	memcpy(filters + c->num_filters, c->connecting_result.filters, sizeof(*filters) * c->connecting_result.num_filters);
+  memcpy(filters + c->num_filters, c->connecting_result.filters,
+         sizeof(*filters) * c->connecting_result.num_filters);
   filters[num_filters - 1] = &grpc_connected_channel_filter;
 
   channel_stack_size = grpc_channel_stack_size(filters, num_filters);
@@ -372,9 +376,7 @@ static void connectivity_state_changed_locked(grpc_subchannel *c) {
  * grpc_subchannel_call implementation
  */
 
-void grpc_subchannel_call_ref(grpc_subchannel_call *c) { 
+void grpc_subchannel_call_ref(grpc_subchannel_call *c) { gpr_ref(&c->refs); }
-  gpr_ref(&c->refs);
-}
 
 void grpc_subchannel_call_unref(grpc_subchannel_call *c) {
   if (gpr_unref(&c->refs)) {
@@ -398,9 +400,11 @@ void grpc_subchannel_call_process_op(grpc_subchannel_call *call,
   top_elem->filter->start_transport_stream_op(top_elem, op);
 }
 
-grpc_subchannel_call *create_call(connection *con, grpc_transport_stream_op *initial_op) {
+grpc_subchannel_call *create_call(connection *con,
+                                  grpc_transport_stream_op *initial_op) {
   grpc_channel_stack *chanstk = CHANNEL_STACK_FROM_CONNECTION(con);
-  grpc_subchannel_call *call = gpr_malloc(sizeof(grpc_subchannel_call) + chanstk->call_stack_size);
+  grpc_subchannel_call *call =
+      gpr_malloc(sizeof(grpc_subchannel_call) + chanstk->call_stack_size);
   grpc_call_stack *callstk = SUBCHANNEL_CALL_TO_CALL_STACK(call);
   call->connection = con;
   gpr_ref_init(&call->refs, 1);

src/core/client_config/subchannel.h

@@ -55,7 +55,8 @@ void grpc_subchannel_create_call(grpc_subchannel *subchannel,
                                  grpc_iomgr_closure *notify);
 
 /** process a transport level op */
-void grpc_subchannel_process_transport_op(grpc_subchannel *subchannel, grpc_transport_op *op);
+void grpc_subchannel_process_transport_op(grpc_subchannel *subchannel,
+                                          grpc_transport_op *op);
 
 /** poll the current connectivity state of a channel */
 grpc_connectivity_state grpc_subchannel_check_connectivity(
@@ -67,8 +68,10 @@ void grpc_subchannel_notify_on_state_change(grpc_subchannel *channel,
                                             grpc_connectivity_state *state,
                                             grpc_iomgr_closure *notify);
 
-void grpc_subchannel_add_interested_party(grpc_subchannel *channel, grpc_pollset *pollset);
+void grpc_subchannel_add_interested_party(grpc_subchannel *channel,
-void grpc_subchannel_del_interested_party(grpc_subchannel *channel, grpc_pollset *pollset);
+                                          grpc_pollset *pollset);
+void grpc_subchannel_del_interested_party(grpc_subchannel *channel,
+                                          grpc_pollset *pollset);
 
 /** continue processing a transport op */
 void grpc_subchannel_call_process_op(grpc_subchannel_call *subchannel_call,