clang-format

src/core/ext/client_config/subchannel.c

@@ -291,7 +291,7 @@ void grpc_subchannel_weak_unref(grpc_exec_ctx *exec_ctx,
   old_refs = ref_mutate(c, -(gpr_atm)1, 1 REF_MUTATE_PURPOSE("WEAK_UNREF"));
   if (old_refs == 1) {
     grpc_exec_ctx_sched(exec_ctx, grpc_closure_create(subchannel_destroy, c),
-                       GRPC_ERROR_NONE, NULL);
+                        GRPC_ERROR_NONE, NULL);
   }
 }
 

src/core/ext/lb_policy/round_robin/round_robin.c

@@ -240,7 +240,7 @@ static void rr_shutdown(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
     p->pending_picks = pp->next;
     *pp->target = NULL;
     grpc_exec_ctx_sched(exec_ctx, pp->on_complete,
-                       GRPC_ERROR_CREATE("Channel Shutdown"), NULL);
+                        GRPC_ERROR_CREATE("Channel Shutdown"), NULL);
     gpr_free(pp);
   }
   grpc_connectivity_state_set(
@@ -267,7 +267,8 @@ static void rr_cancel_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,
       grpc_pollset_set_del_pollset(exec_ctx, p->base.interested_parties,
                                    pp->pollset);
       *target = NULL;
-      grpc_exec_ctx_sched(exec_ctx, pp->on_complete, GRPC_ERROR_CANCELLED, NULL);
+      grpc_exec_ctx_sched(exec_ctx, pp->on_complete, GRPC_ERROR_CANCELLED,
+                          NULL);
       gpr_free(pp);
     } else {
       pp->next = p->pending_picks;
@@ -293,7 +294,8 @@ static void rr_cancel_picks(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,
       grpc_pollset_set_del_pollset(exec_ctx, p->base.interested_parties,
                                    pp->pollset);
       *pp->target = NULL;
-      grpc_exec_ctx_sched(exec_ctx, pp->on_complete, GRPC_ERROR_CANCELLED, NULL);
+      grpc_exec_ctx_sched(exec_ctx, pp->on_complete, GRPC_ERROR_CANCELLED,
+                          NULL);
       gpr_free(pp);
     } else {
       pp->next = p->pending_picks;
@@ -467,7 +469,7 @@ static void rr_connectivity_changed(grpc_exec_ctx *exec_ctx, void *arg,
             p->pending_picks = pp->next;
             *pp->target = NULL;
             grpc_exec_ctx_sched(exec_ctx, pp->on_complete, GRPC_ERROR_NONE,
-                               NULL);
+                                NULL);
             gpr_free(pp);
           }
         } else {
@@ -522,7 +524,7 @@ static void rr_ping_one(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,
   } else {
     gpr_mu_unlock(&p->mu);
     grpc_exec_ctx_sched(exec_ctx, closure,
-                       GRPC_ERROR_CREATE("Round Robin not connected"), NULL);
+                        GRPC_ERROR_CREATE("Round Robin not connected"), NULL);
   }
 }
 

src/core/ext/resolver/dns/native/dns_resolver.c

@@ -112,7 +112,7 @@ static void dns_shutdown(grpc_exec_ctx *exec_ctx, grpc_resolver *resolver) {
   if (r->next_completion != NULL) {
     *r->target_config = NULL;
     grpc_exec_ctx_sched(exec_ctx, r->next_completion,
-                       GRPC_ERROR_CREATE("Resolver Shutdown"), NULL);
+                        GRPC_ERROR_CREATE("Resolver Shutdown"), NULL);
     r->next_completion = NULL;
   }
   gpr_mu_unlock(&r->mu);

src/core/ext/transport/chttp2/transport/writing.c

@@ -188,7 +188,7 @@ void grpc_chttp2_perform_writes(
                         &transport_writing->done_cb);
   } else {
     grpc_exec_ctx_sched(exec_ctx, &transport_writing->done_cb, GRPC_ERROR_NONE,
-                       NULL);
+                        NULL);
   }
 }
 

src/core/lib/iomgr/exec_ctx.c

@@ -83,8 +83,8 @@ void grpc_exec_ctx_finish(grpc_exec_ctx *exec_ctx) {
 }
 
 void grpc_exec_ctx_sched(grpc_exec_ctx *exec_ctx, grpc_closure *closure,
-                        grpc_error *error,
-                        grpc_workqueue *offload_target_or_null) {
+                         grpc_error *error,
+                         grpc_workqueue *offload_target_or_null) {
   GPR_ASSERT(offload_target_or_null == NULL);
   grpc_closure_list_append(&exec_ctx->closure_list, closure, error);
 }

src/core/lib/iomgr/pollset_windows.c

@@ -168,7 +168,7 @@ grpc_error *grpc_pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
 
       if (pollset->shutting_down && pollset->on_shutdown != NULL) {
         grpc_exec_ctx_sched(exec_ctx, pollset->on_shutdown, GRPC_ERROR_NONE,
-                           NULL);
+                            NULL);
         pollset->on_shutdown = NULL;
       }
       goto done;

src/core/lib/iomgr/tcp_client_posix.c

@@ -283,7 +283,7 @@ static void tcp_client_connect_impl(grpc_exec_ctx *exec_ctx,
   if (errno != EWOULDBLOCK && errno != EINPROGRESS) {
     grpc_fd_orphan(exec_ctx, fdobj, NULL, NULL, "tcp_client_connect_error");
     grpc_exec_ctx_sched(exec_ctx, closure, GRPC_OS_ERROR(errno, "connect"),
-                       NULL);
+                        NULL);
     goto done;
   }
 

src/core/lib/iomgr/tcp_windows.c

@@ -198,7 +198,7 @@ static void win_read(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
 
   if (tcp->shutting_down) {
     grpc_exec_ctx_sched(exec_ctx, cb,
-                       GRPC_ERROR_CREATE("TCP socket is shutting down"), NULL);
+                        GRPC_ERROR_CREATE("TCP socket is shutting down"), NULL);
     return;
   }
 
@@ -236,7 +236,7 @@ static void win_read(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
     if (wsa_error != WSA_IO_PENDING) {
       info->wsa_error = wsa_error;
       grpc_exec_ctx_sched(exec_ctx, &tcp->on_read,
-                         GRPC_WSA_ERROR(info->wsa_error, "WSARecv"), NULL);
+                          GRPC_WSA_ERROR(info->wsa_error, "WSARecv"), NULL);
       return;
     }
   }
@@ -286,7 +286,7 @@ static void win_write(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
 
   if (tcp->shutting_down) {
     grpc_exec_ctx_sched(exec_ctx, cb,
-                       GRPC_ERROR_CREATE("TCP socket is shutting down"), NULL);
+                        GRPC_ERROR_CREATE("TCP socket is shutting down"), NULL);
     return;
   }
 
@@ -335,7 +335,7 @@ static void win_write(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
     if (wsa_error != WSA_IO_PENDING) {
       TCP_UNREF(tcp, "write");
       grpc_exec_ctx_sched(exec_ctx, cb, GRPC_WSA_ERROR(wsa_error, "WSASend"),
-                         NULL);
+                          NULL);
       return;
     }
   }

src/core/lib/iomgr/workqueue_posix.c

@@ -138,7 +138,7 @@ static void on_readable(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
 }
 
 void grpc_workqueue_enqueue(grpc_exec_ctx *exec_ctx, grpc_workqueue *workqueue,
-                         grpc_closure *closure, grpc_error *error) {
+                            grpc_closure *closure, grpc_error *error) {
   grpc_error *push_error = GRPC_ERROR_NONE;
   gpr_mu_lock(&workqueue->mu);
   if (grpc_closure_list_empty(workqueue->closure_list)) {

src/core/lib/security/transport/server_auth_filter.c

@@ -147,9 +147,9 @@ static void on_md_processing_done(
     grpc_transport_stream_op_add_close(&close_op, status, &message);
     grpc_call_next_op(&exec_ctx, elem, &close_op);
     grpc_exec_ctx_sched(&exec_ctx, calld->on_done_recv,
-                       grpc_error_set_int(GRPC_ERROR_CREATE(error_details),
-                                          GRPC_ERROR_INT_GRPC_STATUS, status),
-                       NULL);
+                        grpc_error_set_int(GRPC_ERROR_CREATE(error_details),
+                                           GRPC_ERROR_INT_GRPC_STATUS, status),
+                        NULL);
   }
 
   grpc_exec_ctx_finish(&exec_ctx);
@@ -170,7 +170,7 @@ static void auth_on_recv(grpc_exec_ctx *exec_ctx, void *user_data,
     }
   }
   grpc_exec_ctx_sched(exec_ctx, calld->on_done_recv, GRPC_ERROR_REF(error),
-                     NULL);
+                      NULL);
 }
 
 static void set_recv_ops_md_callbacks(grpc_call_element *elem,

src/core/lib/surface/lame_client.c

@@ -95,14 +95,14 @@ static void lame_start_transport_op(grpc_exec_ctx *exec_ctx,
     GPR_ASSERT(*op->connectivity_state != GRPC_CHANNEL_FATAL_FAILURE);
     *op->connectivity_state = GRPC_CHANNEL_FATAL_FAILURE;
     grpc_exec_ctx_sched(exec_ctx, op->on_connectivity_state_change,
-                       GRPC_ERROR_NONE, NULL);
+                        GRPC_ERROR_NONE, NULL);
   }
   if (op->on_consumed != NULL) {
     grpc_exec_ctx_sched(exec_ctx, op->on_consumed, GRPC_ERROR_NONE, NULL);
   }
   if (op->send_ping != NULL) {
     grpc_exec_ctx_sched(exec_ctx, op->send_ping,
-                       GRPC_ERROR_CREATE("lame client channel"), NULL);
+                        GRPC_ERROR_CREATE("lame client channel"), NULL);
   }
   GRPC_ERROR_UNREF(op->disconnect_with_error);
 }

src/core/lib/transport/connectivity_state.c

@@ -134,7 +134,7 @@ int grpc_connectivity_state_notify_on_state_change(
     if (tracker->current_state != *current) {
       *current = tracker->current_state;
       grpc_exec_ctx_sched(exec_ctx, notify,
-                         GRPC_ERROR_REF(tracker->current_error), NULL);
+                          GRPC_ERROR_REF(tracker->current_error), NULL);
     } else {
       grpc_connectivity_state_watcher *w = gpr_malloc(sizeof(*w));
       w->current = current;
@@ -180,7 +180,7 @@ void grpc_connectivity_state_set(grpc_exec_ctx *exec_ctx,
     *w->current = tracker->current_state;
     tracker->watchers = w->next;
     grpc_exec_ctx_sched(exec_ctx, w->notify,
-                       GRPC_ERROR_REF(tracker->current_error), NULL);
+                        GRPC_ERROR_REF(tracker->current_error), NULL);
     gpr_free(w);
   }
 }

src/core/lib/transport/transport.c

@@ -147,9 +147,9 @@ void grpc_transport_stream_op_finish_with_failure(grpc_exec_ctx *exec_ctx,
                                                   grpc_transport_stream_op *op,
                                                   grpc_error *error) {
   grpc_exec_ctx_sched(exec_ctx, op->recv_message_ready, GRPC_ERROR_REF(error),
-                     NULL);
+                      NULL);
   grpc_exec_ctx_sched(exec_ctx, op->recv_initial_metadata_ready,
-                     GRPC_ERROR_REF(error), NULL);
+                      GRPC_ERROR_REF(error), NULL);
   grpc_exec_ctx_sched(exec_ctx, op->on_complete, error, NULL);
 }
 

test/core/util/mock_endpoint.c

@@ -79,7 +79,7 @@ static void me_shutdown(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep) {
   gpr_mu_lock(&m->mu);
   if (m->on_read) {
     grpc_exec_ctx_sched(exec_ctx, m->on_read,
-                       GRPC_ERROR_CREATE("Endpoint Shutdown"), NULL);
+                        GRPC_ERROR_CREATE("Endpoint Shutdown"), NULL);
     m->on_read = NULL;
   }
   gpr_mu_unlock(&m->mu);

test/core/util/passthru_endpoint.c

@@ -60,7 +60,7 @@ static void me_read(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
   gpr_mu_lock(&m->parent->mu);
   if (m->parent->shutdown) {
     grpc_exec_ctx_sched(exec_ctx, cb, GRPC_ERROR_CREATE("Already shutdown"),
-                       NULL);
+                        NULL);
   } else if (m->read_buffer.count > 0) {
     gpr_slice_buffer_swap(&m->read_buffer, slices);
     grpc_exec_ctx_sched(exec_ctx, cb, GRPC_ERROR_NONE, NULL);
@@ -110,13 +110,13 @@ static void me_shutdown(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep) {
   m->parent->shutdown = true;
   if (m->on_read) {
     grpc_exec_ctx_sched(exec_ctx, m->on_read, GRPC_ERROR_CREATE("Shutdown"),
-                       NULL);
+                        NULL);
     m->on_read = NULL;
   }
   m = other_half(m);
   if (m->on_read) {
     grpc_exec_ctx_sched(exec_ctx, m->on_read, GRPC_ERROR_CREATE("Shutdown"),
-                       NULL);
+                        NULL);
     m->on_read = NULL;
   }
   gpr_mu_unlock(&m->parent->mu);