clang-format after nullptr changes

src/core/ext/filters/client_channel/channel_connectivity.cc

@@ -115,8 +115,8 @@ static void partly_done(grpc_exec_ctx* exec_ctx, state_watcher* w,
         grpc_channel_get_channel_stack(w->channel));
     grpc_client_channel_watch_connectivity_state(
         exec_ctx, client_channel_elem,
-        grpc_polling_entity_create_from_pollset(grpc_cq_pollset(w->cq)), nullptr,
-        &w->on_complete, nullptr);
+        grpc_polling_entity_create_from_pollset(grpc_cq_pollset(w->cq)),
+        nullptr, &w->on_complete, nullptr);
   }
 
   gpr_mu_lock(&w->mu);

src/core/ext/filters/client_channel/client_channel.cc

@@ -266,7 +266,8 @@ static void on_lb_policy_state_changed_locked(grpc_exec_ctx* exec_ctx,
       gpr_log(GPR_DEBUG, "chand=%p: lb_policy=%p state changed to %s", w->chand,
               w->lb_policy, grpc_connectivity_state_name(w->state));
     }
-    if (publish_state == GRPC_CHANNEL_SHUTDOWN && w->chand->resolver != nullptr) {
+    if (publish_state == GRPC_CHANNEL_SHUTDOWN &&
+        w->chand->resolver != nullptr) {
       publish_state = GRPC_CHANNEL_TRANSIENT_FAILURE;
       grpc_resolver_channel_saw_error_locked(exec_ctx, w->chand->resolver);
       GRPC_LB_POLICY_UNREF(exec_ctx, w->chand->lb_policy, "channel");
@@ -408,7 +409,8 @@ static void on_resolver_result_changed_locked(grpc_exec_ctx* exec_ctx,
         }
       }
       if (found_balancer_address) {
-        if (lb_policy_name != nullptr && strcmp(lb_policy_name, "grpclb") != 0) {
+        if (lb_policy_name != nullptr &&
+            strcmp(lb_policy_name, "grpclb") != 0) {
           gpr_log(GPR_INFO,
                   "resolver requested LB policy %s but provided at least one "
                   "balancer address -- forcing use of grpclb LB policy",

src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb.cc

@@ -1178,8 +1178,8 @@ static int glb_pick_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol,
   bool pick_done = false;
   if (glb_policy->rr_policy != nullptr) {
     const grpc_connectivity_state rr_connectivity_state =
-        grpc_lb_policy_check_connectivity_locked(exec_ctx,
-                                                 glb_policy->rr_policy, nullptr);
+        grpc_lb_policy_check_connectivity_locked(
+            exec_ctx, glb_policy->rr_policy, nullptr);
     // The glb_policy->rr_policy may have transitioned to SHUTDOWN but the
     // callback registered to capture this event
     // (glb_rr_connectivity_changed_locked) may not have been invoked yet. We
@@ -1525,8 +1525,8 @@ static void query_for_backends_locked(grpc_exec_ctx* exec_ctx,
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  call_error = grpc_call_start_batch_and_execute(exec_ctx, glb_policy->lb_call,
-                                                 ops, (size_t)(op - ops), nullptr);
+  call_error = grpc_call_start_batch_and_execute(
+      exec_ctx, glb_policy->lb_call, ops, (size_t)(op - ops), nullptr);
   GPR_ASSERT(GRPC_CALL_OK == call_error);
 
   op = ops;

src/core/ext/filters/client_channel/lb_policy/pick_first/pick_first.cc

@@ -155,7 +155,8 @@ static void pf_cancel_picks_locked(grpc_exec_ctx* exec_ctx, grpc_lb_policy* pol,
 static void start_picking_locked(grpc_exec_ctx* exec_ctx,
                                  pick_first_lb_policy* p) {
   p->started_picking = true;
-  if (p->subchannel_list != nullptr && p->subchannel_list->num_subchannels > 0) {
+  if (p->subchannel_list != nullptr &&
+      p->subchannel_list->num_subchannels > 0) {
     p->subchannel_list->checking_subchannel = 0;
     grpc_lb_subchannel_list_ref_for_connectivity_watch(
         p->subchannel_list, "connectivity_watch+start_picking");

src/core/ext/filters/client_channel/lb_policy/subchannel_list.cc

@@ -240,7 +240,8 @@ static void subchannel_data_cancel_connectivity_watch(
             (size_t)(sd - sd->subchannel_list->subchannels),
             sd->subchannel_list->num_subchannels, sd->subchannel, reason);
   }
-  grpc_subchannel_notify_on_state_change(exec_ctx, sd->subchannel, nullptr, nullptr,
+  grpc_subchannel_notify_on_state_change(exec_ctx, sd->subchannel, nullptr,
+                                         nullptr,
                                          &sd->connectivity_changed_closure);
 }
 

src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc

@@ -177,7 +177,8 @@ static char* choose_service_config(char* service_config_choice_json) {
       break;
     }
     grpc_json* service_config_json = nullptr;
-    for (grpc_json* field = choice->child; field != nullptr; field = field->next) {
+    for (grpc_json* field = choice->child; field != nullptr;
+         field = field->next) {
       // Check client language, if specified.
       if (strcmp(field->key, "clientLanguage") == 0) {
         if (field->type != GRPC_JSON_ARRAY ||

src/core/ext/filters/client_channel/resolver/sockaddr/sockaddr_resolver.cc

@@ -157,8 +157,8 @@ static grpc_resolver* sockaddr_create(grpc_exec_ctx* exec_ctx,
   grpc_slice_buffer path_parts;
   grpc_slice_buffer_init(&path_parts);
   grpc_slice_split(path_slice, ",", &path_parts);
-  grpc_lb_addresses* addresses =
-      grpc_lb_addresses_create(path_parts.count, nullptr /* user_data_vtable */);
+  grpc_lb_addresses* addresses = grpc_lb_addresses_create(
+      path_parts.count, nullptr /* user_data_vtable */);
   bool errors_found = false;
   for (size_t i = 0; i < addresses->num_addresses; i++) {
     grpc_uri ith_uri = *args->uri;

src/core/ext/filters/client_channel/subchannel.cc

@@ -756,7 +756,7 @@ grpc_error* grpc_connected_subchannel_create_call(
   (*call)->connection = GRPC_CONNECTED_SUBCHANNEL_REF(con, "subchannel_call");
   const grpc_call_element_args call_args = {
       callstk,            /* call_stack */
-      nullptr,               /* server_transport_data */
+      nullptr,            /* server_transport_data */
       args->context,      /* context */
       args->path,         /* path */
       args->start_time,   /* start_time */

src/core/ext/transport/chttp2/client/insecure/channel_create.cc

@@ -99,7 +99,7 @@ grpc_channel* grpc_insecure_channel_create(const char* target,
   grpc_channel_args_destroy(&exec_ctx, new_args);
   grpc_exec_ctx_finish(&exec_ctx);
   return channel != nullptr ? channel
-                         : grpc_lame_client_channel_create(
-                               target, GRPC_STATUS_INTERNAL,
-                               "Failed to create client channel");
+                            : grpc_lame_client_channel_create(
+                                  target, GRPC_STATUS_INTERNAL,
+                                  "Failed to create client channel");
 }

src/core/ext/transport/chttp2/client/insecure/channel_create_posix.cc

@@ -63,9 +63,9 @@ grpc_channel* grpc_insecure_channel_create_from_fd(
   grpc_exec_ctx_finish(&exec_ctx);
 
   return channel != nullptr ? channel
-                         : grpc_lame_client_channel_create(
-                               target, GRPC_STATUS_INTERNAL,
-                               "Failed to create client channel");
+                            : grpc_lame_client_channel_create(
+                                  target, GRPC_STATUS_INTERNAL,
+                                  "Failed to create client channel");
 }
 
 #else  // !GPR_SUPPORT_CHANNELS_FROM_FD

src/core/ext/transport/chttp2/client/secure/secure_channel_create.cc

@@ -218,7 +218,7 @@ grpc_channel* grpc_secure_channel_create(grpc_channel_credentials* creds,
     grpc_exec_ctx_finish(&exec_ctx);
   }
   return channel != nullptr ? channel
-                         : grpc_lame_client_channel_create(
-                               target, GRPC_STATUS_INTERNAL,
-                               "Failed to create secure client channel");
+                            : grpc_lame_client_channel_create(
+                                  target, GRPC_STATUS_INTERNAL,
+                                  "Failed to create secure client channel");
 }

src/core/ext/transport/chttp2/server/insecure/server_chttp2_posix.cc

@@ -60,7 +60,8 @@ void grpc_server_add_insecure_channel_from_fd(grpc_server* server,
     grpc_endpoint_add_to_pollset(&exec_ctx, server_endpoint, pollsets[i]);
   }
 
-  grpc_server_setup_transport(&exec_ctx, server, transport, nullptr, server_args);
+  grpc_server_setup_transport(&exec_ctx, server, transport, nullptr,
+                              server_args);
   grpc_chttp2_transport_start_reading(&exec_ctx, transport, nullptr);
   grpc_exec_ctx_finish(&exec_ctx);
 }

src/core/ext/transport/chttp2/transport/chttp2_transport.cc

@@ -1761,8 +1761,8 @@ static void send_goaway(grpc_exec_ctx* exec_ctx, grpc_chttp2_transport* t,
   t->sent_goaway_state = GRPC_CHTTP2_GOAWAY_SEND_SCHEDULED;
   grpc_http2_error_code http_error;
   grpc_slice slice;
-  grpc_error_get_status(exec_ctx, error, GRPC_MILLIS_INF_FUTURE, nullptr, &slice,
-                        &http_error);
+  grpc_error_get_status(exec_ctx, error, GRPC_MILLIS_INF_FUTURE, nullptr,
+                        &slice, &http_error);
   grpc_chttp2_goaway_append(t->last_new_stream_id, (uint32_t)http_error,
                             grpc_slice_ref_internal(slice), &t->qbuf);
   grpc_chttp2_initiate_write(exec_ctx, t,
@@ -1980,10 +1980,10 @@ void grpc_chttp2_maybe_complete_recv_trailing_metadata(grpc_exec_ctx* exec_ctx,
         s->stream_decompression_ctx = grpc_stream_compression_context_create(
             s->stream_decompression_method);
       }
-      if (!grpc_stream_decompress(s->stream_decompression_ctx,
-                                  &s->frame_storage,
-                                  &s->unprocessed_incoming_frames_buffer, nullptr,
-                                  GRPC_HEADER_SIZE_IN_BYTES, &end_of_context)) {
+      if (!grpc_stream_decompress(
+              s->stream_decompression_ctx, &s->frame_storage,
+              &s->unprocessed_incoming_frames_buffer, nullptr,
+              GRPC_HEADER_SIZE_IN_BYTES, &end_of_context)) {
         grpc_slice_buffer_reset_and_unref_internal(exec_ctx, &s->frame_storage);
         grpc_slice_buffer_reset_and_unref_internal(
             exec_ctx, &s->unprocessed_incoming_frames_buffer);
@@ -2064,8 +2064,8 @@ void grpc_chttp2_cancel_stream(grpc_exec_ctx* exec_ctx,
   if (!s->read_closed || !s->write_closed) {
     if (s->id != 0) {
       grpc_http2_error_code http_error;
-      grpc_error_get_status(exec_ctx, due_to_error, s->deadline, nullptr, nullptr,
-                            &http_error);
+      grpc_error_get_status(exec_ctx, due_to_error, s->deadline, nullptr,
+                            nullptr, &http_error);
       grpc_slice_buffer_add(
           &t->qbuf, grpc_chttp2_rst_stream_create(s->id, (uint32_t)http_error,
                                                   &s->stats.outgoing));

src/core/ext/transport/chttp2/transport/hpack_encoder.cc

@@ -54,7 +54,7 @@
 static grpc_slice_refcount terminal_slice_refcount = {nullptr, nullptr};
 static const grpc_slice terminal_slice = {
     &terminal_slice_refcount, /* refcount */
-    {{nullptr, 0}}                  /* data.refcounted */
+    {{nullptr, 0}}            /* data.refcounted */
 };
 
 extern "C" grpc_tracer_flag grpc_http_trace;

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

@@ -333,10 +333,10 @@ class DataSendContext {
          s_->fetching_send_message == nullptr);
     if (is_last_data_frame && s_->send_trailing_metadata != nullptr &&
         s_->stream_compression_ctx != nullptr) {
-      if (!grpc_stream_compress(s_->stream_compression_ctx,
-                                &s_->flow_controlled_buffer,
-                                &s_->compressed_data_buffer, nullptr, MAX_SIZE_T,
-                                GRPC_STREAM_COMPRESSION_FLUSH_FINISH)) {
+      if (!grpc_stream_compress(
+              s_->stream_compression_ctx, &s_->flow_controlled_buffer,
+              &s_->compressed_data_buffer, nullptr, MAX_SIZE_T,
+              GRPC_STREAM_COMPRESSION_FLUSH_FINISH)) {
         gpr_log(GPR_ERROR, "Stream compression failed.");
       }
       grpc_stream_compression_context_destroy(s_->stream_compression_ctx);
@@ -347,7 +347,8 @@ class DataSendContext {
        * recalculated. */
       return;
     }
-    is_last_frame_ = is_last_data_frame && s_->send_trailing_metadata != nullptr &&
+    is_last_frame_ = is_last_data_frame &&
+                     s_->send_trailing_metadata != nullptr &&
                      grpc_metadata_batch_is_empty(s_->send_trailing_metadata);
     grpc_chttp2_encode_data(s_->id, &s_->compressed_data_buffer, send_bytes,
                             is_last_frame_, &s_->stats.outgoing, &t_->outbuf);

src/core/ext/transport/inproc/inproc_transport.cc

@@ -410,10 +410,11 @@ static void fail_helper_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
     grpc_metadata_batch_init(&fake_md);
 
     inproc_stream* other = s->other_side;
-    grpc_metadata_batch* dest = (other == nullptr) ? &s->write_buffer_trailing_md
-                                                : &other->to_read_trailing_md;
+    grpc_metadata_batch* dest = (other == nullptr)
+                                    ? &s->write_buffer_trailing_md
+                                    : &other->to_read_trailing_md;
     bool* destfilled = (other == nullptr) ? &s->write_buffer_trailing_md_filled
-                                       : &other->to_read_trailing_md_filled;
+                                          : &other->to_read_trailing_md_filled;
     fill_in_metadata(exec_ctx, s, &fake_md, 0, dest, nullptr, destfilled);
     grpc_metadata_batch_destroy(exec_ctx, &fake_md);
 
@@ -612,10 +613,11 @@ static void op_state_machine(grpc_exec_ctx* exec_ctx, void* arg,
       (!s->send_message_op ||
        (s->t->is_client &&
         (s->trailing_md_recvd || s->to_read_trailing_md_filled)))) {
-    grpc_metadata_batch* dest = (other == nullptr) ? &s->write_buffer_trailing_md
-                                                : &other->to_read_trailing_md;
+    grpc_metadata_batch* dest = (other == nullptr)
+                                    ? &s->write_buffer_trailing_md
+                                    : &other->to_read_trailing_md;
     bool* destfilled = (other == nullptr) ? &s->write_buffer_trailing_md_filled
-                                       : &other->to_read_trailing_md_filled;
+                                          : &other->to_read_trailing_md_filled;
     if (*destfilled || s->trailing_md_sent) {
       // The buffer is already in use; that's an error!
       INPROC_LOG(GPR_DEBUG, "Extra trailing metadata %p", s);
@@ -827,10 +829,11 @@ static bool cancel_stream_locked(grpc_exec_ctx* exec_ctx, inproc_stream* s,
     grpc_metadata_batch_init(&cancel_md);
 
     inproc_stream* other = s->other_side;
-    grpc_metadata_batch* dest = (other == nullptr) ? &s->write_buffer_trailing_md
-                                                : &other->to_read_trailing_md;
+    grpc_metadata_batch* dest = (other == nullptr)
+                                    ? &s->write_buffer_trailing_md
+                                    : &other->to_read_trailing_md;
     bool* destfilled = (other == nullptr) ? &s->write_buffer_trailing_md_filled
-                                       : &other->to_read_trailing_md_filled;
+                                          : &other->to_read_trailing_md_filled;
     fill_in_metadata(exec_ctx, s, &cancel_md, 0, dest, nullptr, destfilled);
     grpc_metadata_batch_destroy(exec_ctx, &cancel_md);
 
@@ -914,12 +917,14 @@ static void perform_stream_op(grpc_exec_ctx* exec_ctx, grpc_transport* gt,
       error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Endpoint already shutdown");
     }
     if (error == GRPC_ERROR_NONE && op->send_initial_metadata) {
-      grpc_metadata_batch* dest = (other == nullptr) ? &s->write_buffer_initial_md
-                                                  : &other->to_read_initial_md;
-      uint32_t* destflags = (other == nullptr) ? &s->write_buffer_initial_md_flags
-                                            : &other->to_read_initial_md_flags;
+      grpc_metadata_batch* dest = (other == nullptr)
+                                      ? &s->write_buffer_initial_md
+                                      : &other->to_read_initial_md;
+      uint32_t* destflags = (other == nullptr)
+                                ? &s->write_buffer_initial_md_flags
+                                : &other->to_read_initial_md_flags;
       bool* destfilled = (other == nullptr) ? &s->write_buffer_initial_md_filled
-                                         : &other->to_read_initial_md_filled;
+                                            : &other->to_read_initial_md_filled;
       if (*destfilled || s->initial_md_sent) {
         // The buffer is already in use; that's an error!
         INPROC_LOG(GPR_DEBUG, "Extra initial metadata %p", s);

src/core/lib/http/httpcli.cc

@@ -136,8 +136,8 @@ static void on_read(grpc_exec_ctx* exec_ctx, void* user_data,
   for (i = 0; i < req->incoming.count; i++) {
     if (GRPC_SLICE_LENGTH(req->incoming.slices[i])) {
       req->have_read_byte = 1;
-      grpc_error* err =
-          grpc_http_parser_parse(&req->parser, req->incoming.slices[i], nullptr);
+      grpc_error* err = grpc_http_parser_parse(
+          &req->parser, req->incoming.slices[i], nullptr);
       if (err != GRPC_ERROR_NONE) {
         finish(exec_ctx, req, err);
         return;

src/core/lib/iomgr/error.cc

@@ -767,8 +767,8 @@ grpc_error* grpc_os_error(const char* file, int line, int err,
       grpc_error_set_str(
           grpc_error_set_int(
               grpc_error_create(file, line,
-                                grpc_slice_from_static_string("OS Error"), nullptr,
-                                0),
+                                grpc_slice_from_static_string("OS Error"),
+                                nullptr, 0),
               GRPC_ERROR_INT_ERRNO, err),
           GRPC_ERROR_STR_OS_ERROR,
           grpc_slice_from_static_string(strerror(err))),

src/core/lib/iomgr/sockaddr_utils.cc

@@ -167,8 +167,8 @@ int grpc_sockaddr_to_string(char** out,
     port = ntohs(addr6->sin6_port);
     sin6_scope_id = addr6->sin6_scope_id;
   }
-  if (ip != nullptr &&
-      grpc_inet_ntop(addr->sa_family, ip, ntop_buf, sizeof(ntop_buf)) != nullptr) {
+  if (ip != nullptr && grpc_inet_ntop(addr->sa_family, ip, ntop_buf,
+                                      sizeof(ntop_buf)) != nullptr) {
     if (sin6_scope_id != 0) {
       char* host_with_scope;
       /* Enclose sin6_scope_id with the format defined in RFC 6784 section 2. */

src/core/lib/iomgr/socket_utils_common_posix.cc

@@ -263,8 +263,8 @@ static grpc_error* error_for_fd(int fd, const grpc_resolved_address* addr) {
 grpc_error* grpc_create_dualstack_socket(
     const grpc_resolved_address* resolved_addr, int type, int protocol,
     grpc_dualstack_mode* dsmode, int* newfd) {
-  return grpc_create_dualstack_socket_using_factory(nullptr, resolved_addr, type,
-                                                    protocol, dsmode, newfd);
+  return grpc_create_dualstack_socket_using_factory(
+      nullptr, resolved_addr, type, protocol, dsmode, newfd);
 }
 
 static int create_socket(grpc_socket_factory* factory, int domain, int type,

src/core/lib/iomgr/tcp_client_posix.cc

@@ -296,8 +296,8 @@ static void tcp_client_connect_impl(grpc_exec_ctx* exec_ctx,
   }
 
   if (errno != EWOULDBLOCK && errno != EINPROGRESS) {
-    grpc_fd_orphan(exec_ctx, fdobj, nullptr, nullptr, false /* already_closed */,
-                   "tcp_client_connect_error");
+    grpc_fd_orphan(exec_ctx, fdobj, nullptr, nullptr,
+                   false /* already_closed */, "tcp_client_connect_error");
     GRPC_CLOSURE_SCHED(exec_ctx, closure, GRPC_OS_ERROR(errno, "connect"));
     goto done;
   }

src/core/lib/iomgr/tcp_posix.cc

@@ -198,7 +198,8 @@ static void cover_self(grpc_exec_ctx* exec_ctx, grpc_tcp* tcp) {
                           grpc_executor_scheduler(GRPC_EXECUTOR_LONG)),
         GRPC_ERROR_NONE);
   } else {
-    while ((p = (backup_poller*)gpr_atm_acq_load(&g_backup_poller)) == nullptr) {
+    while ((p = (backup_poller*)gpr_atm_acq_load(&g_backup_poller)) ==
+           nullptr) {
       // spin waiting for backup poller
     }
   }

src/core/lib/security/credentials/composite/composite_credentials.cc

@@ -224,7 +224,8 @@ static grpc_security_status composite_channel_create_security_connector(
      downstream. */
   if (call_creds != nullptr) {
     grpc_call_credentials* composite_call_creds =
-        grpc_composite_call_credentials_create(c->call_creds, call_creds, nullptr);
+        grpc_composite_call_credentials_create(c->call_creds, call_creds,
+                                               nullptr);
     status = c->inner_creds->vtable->create_security_connector(
         exec_ctx, c->inner_creds, composite_call_creds, target, args, sc,
         new_args);
@@ -253,7 +254,8 @@ grpc_channel_credentials* grpc_composite_channel_credentials_create(
     void* reserved) {
   grpc_composite_channel_credentials* c =
       (grpc_composite_channel_credentials*)gpr_zalloc(sizeof(*c));
-  GPR_ASSERT(channel_creds != nullptr && call_creds != nullptr && reserved == nullptr);
+  GPR_ASSERT(channel_creds != nullptr && call_creds != nullptr &&
+             reserved == nullptr);
   GRPC_API_TRACE(
       "grpc_composite_channel_credentials_create(channel_creds=%p, "
       "call_creds=%p, reserved=%p)",

src/core/lib/security/credentials/credentials.cc

@@ -117,7 +117,8 @@ bool grpc_call_credentials_get_request_metadata(
 void grpc_call_credentials_cancel_get_request_metadata(
     grpc_exec_ctx* exec_ctx, grpc_call_credentials* creds,
     grpc_credentials_mdelem_array* md_array, grpc_error* error) {
-  if (creds == nullptr || creds->vtable->cancel_get_request_metadata == nullptr) {
+  if (creds == nullptr ||
+      creds->vtable->cancel_get_request_metadata == nullptr) {
     return;
   }
   creds->vtable->cancel_get_request_metadata(exec_ctx, creds, md_array, error);
@@ -206,7 +207,8 @@ void grpc_server_credentials_unref(grpc_exec_ctx* exec_ctx,
     if (creds->vtable->destruct != nullptr) {
       creds->vtable->destruct(exec_ctx, creds);
     }
-    if (creds->processor.destroy != nullptr && creds->processor.state != nullptr) {
+    if (creds->processor.destroy != nullptr &&
+        creds->processor.state != nullptr) {
       creds->processor.destroy(creds->processor.state);
     }
     gpr_free(creds);
@@ -238,7 +240,8 @@ void grpc_server_credentials_set_auth_metadata_processor(
       "processor=grpc_auth_metadata_processor { process: %p, state: %p })",
       3, (creds, (void*)(intptr_t)processor.process, processor.state));
   if (creds == nullptr) return;
-  if (creds->processor.destroy != nullptr && creds->processor.state != nullptr) {
+  if (creds->processor.destroy != nullptr &&
+      creds->processor.state != nullptr) {
     creds->processor.destroy(creds->processor.state);
   }
   creds->processor = processor;

src/core/lib/security/credentials/google_default/google_default_credentials.cc

@@ -80,8 +80,8 @@ static void on_compute_engine_detection_http_response(grpc_exec_ctx* exec_ctx,
   detector->is_done = 1;
   GRPC_LOG_IF_ERROR(
       "Pollset kick",
-      grpc_pollset_kick(exec_ctx,
-                        grpc_polling_entity_pollset(&detector->pollent), nullptr));
+      grpc_pollset_kick(
+          exec_ctx, grpc_polling_entity_pollset(&detector->pollent), nullptr));
   gpr_mu_unlock(g_polling_mu);
 }
 

src/core/lib/security/credentials/jwt/json_token.cc

@@ -52,7 +52,8 @@ gpr_timespec grpc_max_auth_token_lifetime() {
 
 /* --- Override for testing. --- */
 
-static grpc_jwt_encode_and_sign_override g_jwt_encode_and_sign_override = nullptr;
+static grpc_jwt_encode_and_sign_override g_jwt_encode_and_sign_override =
+    nullptr;
 
 /* --- grpc_auth_json_key. --- */
 
@@ -99,7 +100,8 @@ grpc_auth_json_key grpc_auth_json_key_create_from_json(const grpc_json* json) {
     gpr_log(GPR_ERROR, "Could not write into openssl BIO.");
     goto end;
   }
-  result.private_key = PEM_read_bio_RSAPrivateKey(bio, nullptr, nullptr, (void*)"");
+  result.private_key =
+      PEM_read_bio_RSAPrivateKey(bio, nullptr, nullptr, (void*)"");
   if (result.private_key == nullptr) {
     gpr_log(GPR_ERROR, "Could not deserialize private key.");
     goto end;
@@ -192,8 +194,8 @@ static char* encoded_jwt_claim(const grpc_auth_json_key* json_key,
   int64_ttoa(now.tv_sec, now_str);
   int64_ttoa(expiration.tv_sec, expiration_str);
 
-  child =
-      create_child(nullptr, json, "iss", json_key->client_email, GRPC_JSON_STRING);
+  child = create_child(nullptr, json, "iss", json_key->client_email,
+                       GRPC_JSON_STRING);
   if (scope != nullptr) {
     child = create_child(child, json, "scope", scope, GRPC_JSON_STRING);
   } else {

src/core/lib/security/credentials/jwt/jwt_verifier.cc

@@ -576,7 +576,8 @@ static EVP_PKEY* find_verification_key(grpc_exec_ctx* exec_ctx,
     const char* kty = nullptr;
 
     if (jkey->type != GRPC_JSON_OBJECT) continue;
-    for (key_prop = jkey->child; key_prop != nullptr; key_prop = key_prop->next) {
+    for (key_prop = jkey->child; key_prop != nullptr;
+         key_prop = key_prop->next) {
       if (strcmp(key_prop->key, "alg") == 0 &&
           key_prop->type == GRPC_JSON_STRING) {
         alg = key_prop->value;
@@ -783,7 +784,8 @@ static void retrieve_key_and_verify(grpc_exec_ctx* exec_ctx,
   req.handshaker = &grpc_httpcli_ssl;
   http_response_index rsp_idx;
 
-  GPR_ASSERT(ctx != nullptr && ctx->header != nullptr && ctx->claims != nullptr);
+  GPR_ASSERT(ctx != nullptr && ctx->header != nullptr &&
+             ctx->claims != nullptr);
   iss = ctx->claims->iss;
   if (ctx->header->kid == nullptr) {
     gpr_log(GPR_ERROR, "Missing kid in jose header.");
@@ -869,7 +871,8 @@ void grpc_jwt_verifier_verify(grpc_exec_ctx* exec_ctx,
   size_t signed_jwt_len;
   const char* cur = jwt;
 
-  GPR_ASSERT(verifier != nullptr && jwt != nullptr && audience != nullptr && cb != nullptr);
+  GPR_ASSERT(verifier != nullptr && jwt != nullptr && audience != nullptr &&
+             cb != nullptr);
   dot = strchr(cur, '.');
   if (dot == nullptr) goto error;
   json = parse_json_part_from_jwt(exec_ctx, cur, (size_t)(dot - cur),

src/core/lib/security/transport/client_auth_filter.cc

@@ -146,8 +146,8 @@ void grpc_auth_metadata_context_build(
       *port_delimiter = '\0';
     }
   }
-  gpr_asprintf(&service_url, "%s://%s%s", url_scheme == nullptr ? "" : url_scheme,
-               host_and_port, service);
+  gpr_asprintf(&service_url, "%s://%s%s",
+               url_scheme == nullptr ? "" : url_scheme, host_and_port, service);
   auth_md_context->service_url = service_url;
   auth_md_context->method_name = method_name;
   auth_md_context->channel_auth_context =

src/core/lib/security/transport/security_connector.cc

@@ -600,7 +600,7 @@ static void ssl_channel_add_handshakers(grpc_exec_ctx* exec_ctx,
   tsi_result result = tsi_ssl_client_handshaker_factory_create_handshaker(
       c->client_handshaker_factory,
       c->overridden_target_name != nullptr ? c->overridden_target_name
-                                        : c->target_name,
+                                           : c->target_name,
       &tsi_hs);
   if (result != TSI_OK) {
     gpr_log(GPR_ERROR, "Handshaker creation failed with error %s.",
@@ -911,7 +911,8 @@ static bool ssl_channel_check_call_host(grpc_exec_ctx* exec_ctx,
   /* If the target name was overridden, then the original target_name was
      'checked' transitively during the previous peer check at the end of the
      handshake. */
-  if (c->overridden_target_name != nullptr && strcmp(host, c->target_name) == 0) {
+  if (c->overridden_target_name != nullptr &&
+      strcmp(host, c->target_name) == 0) {
     status = GRPC_SECURITY_OK;
   }
   if (status != GRPC_SECURITY_OK) {

src/core/lib/slice/slice_intern.cc

@@ -172,7 +172,7 @@ int grpc_static_slice_eq(grpc_slice a, grpc_slice b) {
 
 uint32_t grpc_slice_hash(grpc_slice s) {
   return s.refcount == nullptr ? grpc_slice_default_hash_impl(s)
-                            : s.refcount->vtable->hash(s);
+                               : s.refcount->vtable->hash(s);
 }
 
 grpc_slice grpc_slice_maybe_static_intern(grpc_slice slice,

src/core/lib/support/avl.cc

@@ -60,8 +60,8 @@ static long node_height(gpr_avl_node* node) {
 #ifndef NDEBUG
 static long calculate_height(gpr_avl_node* node) {
   return node == nullptr ? 0
-                      : 1 + GPR_MAX(calculate_height(node->left),
-                                    calculate_height(node->right));
+                         : 1 + GPR_MAX(calculate_height(node->left),
+                                       calculate_height(node->right));
 }
 
 static gpr_avl_node* assert_invariants(gpr_avl_node* n) {

src/core/lib/support/sync_posix.cc

@@ -33,7 +33,9 @@ gpr_atm gpr_counter_atm_cas = 0;
 gpr_atm gpr_counter_atm_add = 0;
 #endif
 
-void gpr_mu_init(gpr_mu* mu) { GPR_ASSERT(pthread_mutex_init(mu, nullptr) == 0); }
+void gpr_mu_init(gpr_mu* mu) {
+  GPR_ASSERT(pthread_mutex_init(mu, nullptr) == 0);
+}
 
 void gpr_mu_destroy(gpr_mu* mu) { GPR_ASSERT(pthread_mutex_destroy(mu) == 0); }
 
@@ -63,7 +65,9 @@ int gpr_mu_trylock(gpr_mu* mu) {
 
 /*----------------------------------------*/
 
-void gpr_cv_init(gpr_cv* cv) { GPR_ASSERT(pthread_cond_init(cv, nullptr) == 0); }
+void gpr_cv_init(gpr_cv* cv) {
+  GPR_ASSERT(pthread_cond_init(cv, nullptr) == 0);
+}
 
 void gpr_cv_destroy(gpr_cv* cv) { GPR_ASSERT(pthread_cond_destroy(cv) == 0); }
 

src/core/lib/surface/call.cc

@@ -601,7 +601,8 @@ void grpc_call_unref(grpc_call* c) {
     // effect of scheduling the previously set cancellation closure, if
     // any, so that it can release any internal references it may be
     // holding to the call stack.
-    grpc_call_combiner_set_notify_on_cancel(&exec_ctx, &c->call_combiner, nullptr);
+    grpc_call_combiner_set_notify_on_cancel(&exec_ctx, &c->call_combiner,
+                                            nullptr);
   }
   GRPC_CALL_INTERNAL_UNREF(&exec_ctx, c, "destroy");
   grpc_exec_ctx_finish(&exec_ctx);
@@ -1910,8 +1911,8 @@ static grpc_call_error call_start_batch(grpc_exec_ctx* exec_ctx,
         if (!prepare_application_metadata(
                 exec_ctx, call,
                 (int)op->data.send_status_from_server.trailing_metadata_count,
-                op->data.send_status_from_server.trailing_metadata, 1, 1, nullptr,
-                0)) {
+                op->data.send_status_from_server.trailing_metadata, 1, 1,
+                nullptr, 0)) {
           for (int n = 0; n < call->send_extra_metadata_count; n++) {
             GRPC_MDELEM_UNREF(exec_ctx, call->send_extra_metadata[n].md);
           }

src/core/lib/surface/channel.cc

@@ -306,8 +306,8 @@ grpc_call* grpc_channel_create_call(grpc_channel* channel,
       grpc_mdelem_from_slices(&exec_ctx, GRPC_MDSTR_PATH,
                               grpc_slice_ref_internal(method)),
       host != nullptr ? grpc_mdelem_from_slices(&exec_ctx, GRPC_MDSTR_AUTHORITY,
-                                             grpc_slice_ref_internal(*host))
-                   : GRPC_MDNULL,
+                                                grpc_slice_ref_internal(*host))
+                      : GRPC_MDNULL,
       grpc_timespec_to_millis_round_up(deadline));
   grpc_exec_ctx_finish(&exec_ctx);
   return call;
@@ -323,8 +323,8 @@ grpc_call* grpc_channel_create_pollset_set_call(
       grpc_mdelem_from_slices(exec_ctx, GRPC_MDSTR_PATH,
                               grpc_slice_ref_internal(method)),
       host != nullptr ? grpc_mdelem_from_slices(exec_ctx, GRPC_MDSTR_AUTHORITY,
-                                             grpc_slice_ref_internal(*host))
-                   : GRPC_MDNULL,
+                                                grpc_slice_ref_internal(*host))
+                      : GRPC_MDNULL,
       deadline);
 }
 
@@ -372,8 +372,8 @@ grpc_call* grpc_channel_create_registered_call(
   GPR_ASSERT(!reserved);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_call* call = grpc_channel_create_call_internal(
-      &exec_ctx, channel, parent_call, propagation_mask, completion_queue, nullptr,
-      GRPC_MDELEM_REF(rc->path), GRPC_MDELEM_REF(rc->authority),
+      &exec_ctx, channel, parent_call, propagation_mask, completion_queue,
+      nullptr, GRPC_MDELEM_REF(rc->path), GRPC_MDELEM_REF(rc->authority),
       grpc_timespec_to_millis_round_up(deadline));
   grpc_exec_ctx_finish(&exec_ctx);
   return call;

src/core/lib/surface/completion_queue.cc

@@ -148,7 +148,8 @@ static grpc_error* non_polling_poller_kick(
     grpc_exec_ctx* exec_ctx, grpc_pollset* pollset,
     grpc_pollset_worker* specific_worker) {
   non_polling_poller* p = (non_polling_poller*)pollset;
-  if (specific_worker == nullptr) specific_worker = (grpc_pollset_worker*)p->root;
+  if (specific_worker == nullptr)
+    specific_worker = (grpc_pollset_worker*)p->root;
   if (specific_worker != nullptr) {
     non_polling_worker* w = (non_polling_worker*)specific_worker;
     if (!w->kicked) {
@@ -327,7 +328,8 @@ static void cq_destroy_pluck(void* data);
 static const cq_vtable g_cq_vtable[] = {
     /* GRPC_CQ_NEXT */
     {GRPC_CQ_NEXT, sizeof(cq_next_data), cq_init_next, cq_shutdown_next,
-     cq_destroy_next, cq_begin_op_for_next, cq_end_op_for_next, cq_next, nullptr},
+     cq_destroy_next, cq_begin_op_for_next, cq_end_op_for_next, cq_next,
+     nullptr},
     /* GRPC_CQ_PLUCK */
     {GRPC_CQ_PLUCK, sizeof(cq_pluck_data), cq_init_pluck, cq_shutdown_pluck,
      cq_destroy_pluck, cq_begin_op_for_pluck, cq_end_op_for_pluck, nullptr,

src/core/lib/surface/lame_client.cc

@@ -167,8 +167,8 @@ grpc_channel* grpc_lame_client_channel_create(const char* target,
                                               const char* error_message) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_channel_element* elem;
-  grpc_channel* channel = grpc_channel_create(&exec_ctx, target, nullptr,
-                                              GRPC_CLIENT_LAME_CHANNEL, nullptr);
+  grpc_channel* channel = grpc_channel_create(
+      &exec_ctx, target, nullptr, GRPC_CLIENT_LAME_CHANNEL, nullptr);
   elem = grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0);
   GRPC_API_TRACE(
       "grpc_lame_client_channel_create(target=%s, error_code=%d, "

src/core/lib/surface/server.cc

@@ -1110,8 +1110,8 @@ void grpc_server_setup_transport(grpc_exec_ctx* exec_ctx, grpc_server* s,
   uint32_t max_probes = 0;
   grpc_transport_op* op = nullptr;
 
-  channel =
-      grpc_channel_create(exec_ctx, nullptr, args, GRPC_SERVER_CHANNEL, transport);
+  channel = grpc_channel_create(exec_ctx, nullptr, args, GRPC_SERVER_CHANNEL,
+                                transport);
   chand = (channel_data*)grpc_channel_stack_element(
               grpc_channel_get_channel_stack(channel), 0)
               ->channel_data;

src/core/lib/transport/metadata_batch.cc

@@ -270,7 +270,8 @@ void grpc_metadata_batch_clear(grpc_exec_ctx* exec_ctx,
 }
 
 bool grpc_metadata_batch_is_empty(grpc_metadata_batch* batch) {
-  return batch->list.head == nullptr && batch->deadline == GRPC_MILLIS_INF_FUTURE;
+  return batch->list.head == nullptr &&
+         batch->deadline == GRPC_MILLIS_INF_FUTURE;
 }
 
 size_t grpc_metadata_batch_size(grpc_metadata_batch* batch) {

src/core/lib/transport/service_config.cc

@@ -233,8 +233,8 @@ grpc_slice_hash_table* grpc_service_config_create_method_config_table(
   // Instantiate method config table.
   grpc_slice_hash_table* method_config_table = nullptr;
   if (entries != nullptr) {
-    method_config_table =
-        grpc_slice_hash_table_create(num_entries, entries, unref_value, nullptr);
+    method_config_table = grpc_slice_hash_table_create(num_entries, entries,
+                                                       unref_value, nullptr);
     gpr_free(entries);
   }
   return method_config_table;

src/core/lib/transport/transport.cc

@@ -186,7 +186,8 @@ void grpc_transport_set_pops(grpc_exec_ctx* exec_ctx, grpc_transport* transport,
   grpc_pollset_set* pollset_set;
   if ((pollset = grpc_polling_entity_pollset(pollent)) != nullptr) {
     transport->vtable->set_pollset(exec_ctx, transport, stream, pollset);
-  } else if ((pollset_set = grpc_polling_entity_pollset_set(pollent)) != nullptr) {
+  } else if ((pollset_set = grpc_polling_entity_pollset_set(pollent)) !=
+             nullptr) {
     transport->vtable->set_pollset_set(exec_ctx, transport, stream,
                                        pollset_set);
   } else {

src/core/tsi/fake_transport_security.cc

@@ -402,7 +402,8 @@ static tsi_result fake_zero_copy_grpc_protector_protect(
     grpc_exec_ctx* exec_ctx, tsi_zero_copy_grpc_protector* self,
     grpc_slice_buffer* unprotected_slices,
     grpc_slice_buffer* protected_slices) {
-  if (self == nullptr || unprotected_slices == nullptr || protected_slices == nullptr) {
+  if (self == nullptr || unprotected_slices == nullptr ||
+      protected_slices == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
   tsi_fake_zero_copy_grpc_protector* impl =
@@ -426,7 +427,8 @@ static tsi_result fake_zero_copy_grpc_protector_unprotect(
     grpc_exec_ctx* exec_ctx, tsi_zero_copy_grpc_protector* self,
     grpc_slice_buffer* protected_slices,
     grpc_slice_buffer* unprotected_slices) {
-  if (self == nullptr || unprotected_slices == nullptr || protected_slices == nullptr) {
+  if (self == nullptr || unprotected_slices == nullptr ||
+      protected_slices == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
   tsi_fake_zero_copy_grpc_protector* impl =

src/core/tsi/ssl_transport_security.cc

@@ -361,8 +361,8 @@ static tsi_result add_subject_alt_names_properties_to_peer(
 static tsi_result peer_from_x509(X509* cert, int include_certificate_type,
                                  tsi_peer* peer) {
   /* TODO(jboeuf): Maybe add more properties. */
-  GENERAL_NAMES* subject_alt_names =
-      (GENERAL_NAMES*)X509_get_ext_d2i(cert, NID_subject_alt_name, nullptr, nullptr);
+  GENERAL_NAMES* subject_alt_names = (GENERAL_NAMES*)X509_get_ext_d2i(
+      cert, NID_subject_alt_name, nullptr, nullptr);
   int subject_alt_name_count = (subject_alt_names != nullptr)
                                    ? (int)sk_GENERAL_NAME_num(subject_alt_names)
                                    : 0;
@@ -631,7 +631,8 @@ static tsi_result populate_ssl_context(
       }
     }
   }
-  if ((cipher_list != nullptr) && !SSL_CTX_set_cipher_list(context, cipher_list)) {
+  if ((cipher_list != nullptr) &&
+      !SSL_CTX_set_cipher_list(context, cipher_list)) {
     gpr_log(GPR_ERROR, "Invalid cipher list: %s.", cipher_list);
     return TSI_INVALID_ARGUMENT;
   }
@@ -679,7 +680,8 @@ static tsi_result build_alpn_protocol_name_list(
   *protocol_name_list_length = 0;
   if (num_alpn_protocols == 0) return TSI_INVALID_ARGUMENT;
   for (i = 0; i < num_alpn_protocols; i++) {
-    size_t length = alpn_protocols[i] == nullptr ? 0 : strlen(alpn_protocols[i]);
+    size_t length =
+        alpn_protocols[i] == nullptr ? 0 : strlen(alpn_protocols[i]);
     if (length == 0 || length > 255) {
       gpr_log(GPR_ERROR, "Invalid protocol name length: %d.", (int)length);
       return TSI_INVALID_ARGUMENT;
@@ -1218,8 +1220,8 @@ tsi_result tsi_ssl_server_handshaker_factory_create_handshaker(
   if (self->ssl_context_count == 0) return TSI_INVALID_ARGUMENT;
   /* Create the handshaker with the first context. We will switch if needed
      because of SNI in ssl_server_handshaker_factory_servername_callback.  */
-  return create_tsi_ssl_handshaker(self->ssl_contexts[0], 0, nullptr, &self->base,
-                                   handshaker);
+  return create_tsi_ssl_handshaker(self->ssl_contexts[0], 0, nullptr,
+                                   &self->base, handshaker);
 }
 
 void tsi_ssl_server_handshaker_factory_unref(

src/core/tsi/transport_security.cc

@@ -74,8 +74,9 @@ tsi_result tsi_frame_protector_protect(tsi_frame_protector* self,
                                        size_t* unprotected_bytes_size,
                                        unsigned char* protected_output_frames,
                                        size_t* protected_output_frames_size) {
-  if (self == nullptr || self->vtable == nullptr || unprotected_bytes == nullptr ||
-      unprotected_bytes_size == nullptr || protected_output_frames == nullptr ||
+  if (self == nullptr || self->vtable == nullptr ||
+      unprotected_bytes == nullptr || unprotected_bytes_size == nullptr ||
+      protected_output_frames == nullptr ||
       protected_output_frames_size == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
@@ -88,8 +89,10 @@ tsi_result tsi_frame_protector_protect(tsi_frame_protector* self,
 tsi_result tsi_frame_protector_protect_flush(
     tsi_frame_protector* self, unsigned char* protected_output_frames,
     size_t* protected_output_frames_size, size_t* still_pending_size) {
-  if (self == nullptr || self->vtable == nullptr || protected_output_frames == nullptr ||
-      protected_output_frames_size == nullptr || still_pending_size == nullptr) {
+  if (self == nullptr || self->vtable == nullptr ||
+      protected_output_frames == nullptr ||
+      protected_output_frames_size == nullptr ||
+      still_pending_size == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
   if (self->vtable->protect_flush == nullptr) return TSI_UNIMPLEMENTED;
@@ -102,7 +105,8 @@ tsi_result tsi_frame_protector_unprotect(
     tsi_frame_protector* self, const unsigned char* protected_frames_bytes,
     size_t* protected_frames_bytes_size, unsigned char* unprotected_bytes,
     size_t* unprotected_bytes_size) {
-  if (self == nullptr || self->vtable == nullptr || protected_frames_bytes == nullptr ||
+  if (self == nullptr || self->vtable == nullptr ||
+      protected_frames_bytes == nullptr ||
       protected_frames_bytes_size == nullptr || unprotected_bytes == nullptr ||
       unprotected_bytes_size == nullptr) {
     return TSI_INVALID_ARGUMENT;
@@ -130,7 +134,8 @@ tsi_result tsi_handshaker_get_bytes_to_send_to_peer(tsi_handshaker* self,
     return TSI_INVALID_ARGUMENT;
   }
   if (self->frame_protector_created) return TSI_FAILED_PRECONDITION;
-  if (self->vtable->get_bytes_to_send_to_peer == nullptr) return TSI_UNIMPLEMENTED;
+  if (self->vtable->get_bytes_to_send_to_peer == nullptr)
+    return TSI_UNIMPLEMENTED;
   return self->vtable->get_bytes_to_send_to_peer(self, bytes, bytes_size);
 }
 
@@ -142,7 +147,8 @@ tsi_result tsi_handshaker_process_bytes_from_peer(tsi_handshaker* self,
     return TSI_INVALID_ARGUMENT;
   }
   if (self->frame_protector_created) return TSI_FAILED_PRECONDITION;
-  if (self->vtable->process_bytes_from_peer == nullptr) return TSI_UNIMPLEMENTED;
+  if (self->vtable->process_bytes_from_peer == nullptr)
+    return TSI_UNIMPLEMENTED;
   return self->vtable->process_bytes_from_peer(self, bytes, bytes_size);
 }
 

src/core/tsi/transport_security_adapter.cc

@@ -77,7 +77,8 @@ static const tsi_handshaker_result_vtable result_vtable = {
 static tsi_result tsi_adapter_create_handshaker_result(
     tsi_handshaker* wrapped, const unsigned char* unused_bytes,
     size_t unused_bytes_size, tsi_handshaker_result** handshaker_result) {
-  if (wrapped == nullptr || (unused_bytes_size > 0 && unused_bytes == nullptr)) {
+  if (wrapped == nullptr ||
+      (unused_bytes_size > 0 && unused_bytes == nullptr)) {
     return TSI_INVALID_ARGUMENT;
   }
   tsi_adapter_handshaker_result* impl =

src/cpp/client/create_channel.cc

@@ -39,11 +39,11 @@ std::shared_ptr<Channel> CreateCustomChannel(
     const std::shared_ptr<ChannelCredentials>& creds,
     const ChannelArguments& args) {
   GrpcLibraryCodegen init_lib;  // We need to call init in case of a bad creds.
-  return creds
-             ? creds->CreateChannel(target, args)
-             : CreateChannelInternal("", grpc_lame_client_channel_create(
-                                             nullptr, GRPC_STATUS_INVALID_ARGUMENT,
-                                             "Invalid credentials."));
+  return creds ? creds->CreateChannel(target, args)
+               : CreateChannelInternal(
+                     "", grpc_lame_client_channel_create(
+                             nullptr, GRPC_STATUS_INVALID_ARGUMENT,
+                             "Invalid credentials."));
 }
 
 }  // namespace grpc

test/core/bad_client/bad_client.cc

@@ -175,9 +175,10 @@ void grpc_run_bad_client_test(
         grpc_exec_ctx_finish(&exec_ctx);
         do {
           GPR_ASSERT(gpr_time_cmp(deadline, gpr_now(deadline.clock_type)) > 0);
-          GPR_ASSERT(grpc_completion_queue_next(
-                         a.cq, grpc_timeout_milliseconds_to_deadline(100), nullptr)
-                         .type == GRPC_QUEUE_TIMEOUT);
+          GPR_ASSERT(
+              grpc_completion_queue_next(
+                  a.cq, grpc_timeout_milliseconds_to_deadline(100), nullptr)
+                  .type == GRPC_QUEUE_TIMEOUT);
         } while (!gpr_event_get(&read_done_event));
         if (client_validator(&incoming)) break;
         gpr_log(GPR_INFO,
@@ -198,8 +199,9 @@ void grpc_run_bad_client_test(
       gpr_event_wait(&a.done_write, grpc_timeout_seconds_to_deadline(1)));
   shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
   grpc_server_shutdown_and_notify(a.server, shutdown_cq, nullptr);
-  GPR_ASSERT(grpc_completion_queue_pluck(
-                 shutdown_cq, nullptr, grpc_timeout_seconds_to_deadline(1), nullptr)
+  GPR_ASSERT(grpc_completion_queue_pluck(shutdown_cq, nullptr,
+                                         grpc_timeout_seconds_to_deadline(1),
+                                         nullptr)
                  .type == GRPC_OP_COMPLETE);
   grpc_completion_queue_destroy(shutdown_cq);
   grpc_server_destroy(a.server);

test/core/bad_client/tests/connection_prefix.cc

@@ -53,7 +53,8 @@ int main(int argc, char** argv) {
   GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/2.0\r\n\r\nSX", 0);
   GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/2.0\r\n\r\nSMX", 0);
   GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/2.0\r\n\r\nSM\rX", 0);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/2.0\r\n\r\nSM\r\nX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/2.0\r\n\r\nSM\r\nX",
+                           0);
   GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, "PRI * HTTP/2.0\r\n\r\nSM\r\n\rX",
                            0);
   return 0;

test/core/bad_client/tests/headers.cc

@@ -50,7 +50,8 @@ int main(int argc, char** argv) {
                            GRPC_BAD_CLIENT_DISCONNECT);
   GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00\x00\x00\x01\x05",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00\x00\x00\x01\x04\x00",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR "\x00\x00\x00\x01\x04\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
   GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x00\x01\x04\x00\x00",

test/core/bad_client/tests/initial_settings_frame.cc

@@ -55,7 +55,8 @@ int main(int argc, char** argv) {
                            GRPC_BAD_CLIENT_DISCONNECT);
   GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00\x00\x00\x04\xff",
                            GRPC_BAD_CLIENT_DISCONNECT);
-  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr, PFX_STR "\x00\x00\x00\x04\x00\x00",
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
+                           PFX_STR "\x00\x00\x00\x04\x00\x00",
                            GRPC_BAD_CLIENT_DISCONNECT);
   GRPC_RUN_BAD_CLIENT_TEST(verifier, nullptr,
                            PFX_STR "\x00\x00\x00\x04\x00\x00\x00",

test/core/bad_ssl/server_common.cc

@@ -71,10 +71,10 @@ void bad_ssl_run(grpc_server* server) {
       gpr_log(GPR_INFO, "Shutting down due to SIGINT");
       shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
       grpc_server_shutdown_and_notify(server, shutdown_cq, nullptr);
-      GPR_ASSERT(
-          grpc_completion_queue_pluck(shutdown_cq, nullptr,
-                                      grpc_timeout_seconds_to_deadline(5), nullptr)
-              .type == GRPC_OP_COMPLETE);
+      GPR_ASSERT(grpc_completion_queue_pluck(
+                     shutdown_cq, nullptr, grpc_timeout_seconds_to_deadline(5),
+                     nullptr)
+                     .type == GRPC_OP_COMPLETE);
       grpc_completion_queue_destroy(shutdown_cq);
       grpc_completion_queue_shutdown(cq);
       shutdown_started = 1;

test/core/bad_ssl/servers/alpn.cc

@@ -58,8 +58,8 @@ int main(int argc, char** argv) {
   grpc_server* server;
 
   grpc_init();
-  ssl_creds =
-      grpc_ssl_server_credentials_create(nullptr, &pem_key_cert_pair, 1, 0, nullptr);
+  ssl_creds = grpc_ssl_server_credentials_create(nullptr, &pem_key_cert_pair, 1,
+                                                 0, nullptr);
   server = grpc_server_create(nullptr, nullptr);
   GPR_ASSERT(grpc_server_add_secure_http2_port(server, addr, ssl_creds));
   grpc_server_credentials_release(ssl_creds);

test/core/bad_ssl/servers/cert.cc

@@ -49,8 +49,8 @@ int main(int argc, char** argv) {
   pem_key_cert_pair.private_key = (const char*)GRPC_SLICE_START_PTR(key_slice);
   pem_key_cert_pair.cert_chain = (const char*)GRPC_SLICE_START_PTR(cert_slice);
 
-  ssl_creds =
-      grpc_ssl_server_credentials_create(nullptr, &pem_key_cert_pair, 1, 0, nullptr);
+  ssl_creds = grpc_ssl_server_credentials_create(nullptr, &pem_key_cert_pair, 1,
+                                                 0, nullptr);
   server = grpc_server_create(nullptr, nullptr);
   GPR_ASSERT(grpc_server_add_secure_http2_port(server, addr, ssl_creds));
   grpc_server_credentials_release(ssl_creds);

test/core/channel/minimal_stack_is_minimal_test.cc

@@ -85,20 +85,21 @@ int main(int argc, char** argv) {
   // tests with a default stack
   errors += CHECK_STACK("unknown", nullptr, GRPC_CLIENT_DIRECT_CHANNEL,
                         "message_size", "deadline", "connected", NULL);
-  errors += CHECK_STACK("unknown", nullptr, GRPC_CLIENT_SUBCHANNEL, "message_size",
-                        "connected", NULL);
+  errors += CHECK_STACK("unknown", nullptr, GRPC_CLIENT_SUBCHANNEL,
+                        "message_size", "connected", NULL);
   errors += CHECK_STACK("unknown", nullptr, GRPC_SERVER_CHANNEL, "server",
                         "message_size", "deadline", "connected", NULL);
   errors += CHECK_STACK("chttp2", nullptr, GRPC_CLIENT_DIRECT_CHANNEL,
                         "message_size", "deadline", "http-client",
                         "message_compress", "connected", NULL);
-  errors += CHECK_STACK("chttp2", nullptr, GRPC_CLIENT_SUBCHANNEL, "message_size",
-                        "http-client", "message_compress", "connected", NULL);
+  errors +=
+      CHECK_STACK("chttp2", nullptr, GRPC_CLIENT_SUBCHANNEL, "message_size",
+                  "http-client", "message_compress", "connected", NULL);
   errors += CHECK_STACK("chttp2", nullptr, GRPC_SERVER_CHANNEL, "server",
                         "message_size", "deadline", "http-server",
                         "message_compress", "connected", NULL);
-  errors +=
-      CHECK_STACK(nullptr, nullptr, GRPC_CLIENT_CHANNEL, "client-channel", NULL);
+  errors += CHECK_STACK(nullptr, nullptr, GRPC_CLIENT_CHANNEL, "client-channel",
+                        NULL);
 
   GPR_ASSERT(errors == 0);
   grpc_shutdown();

test/core/client_channel/lb_policies_test.cc

@@ -286,9 +286,10 @@ static request_sequences perform_request(servers_fixture* f,
     memset(s_valid, 0, f->num_servers * sizeof(int));
 
     grpc_slice host = grpc_slice_from_static_string("foo.test.google.fr");
-    c = grpc_channel_create_call(client, nullptr, GRPC_PROPAGATE_DEFAULTS, f->cq,
-                                 grpc_slice_from_static_string("/foo"), &host,
-                                 gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
+    c = grpc_channel_create_call(client, nullptr, GRPC_PROPAGATE_DEFAULTS,
+                                 f->cq, grpc_slice_from_static_string("/foo"),
+                                 &host, gpr_inf_future(GPR_CLOCK_REALTIME),
+                                 nullptr);
     GPR_ASSERT(c);
     completed_client = 0;
 
@@ -317,14 +318,14 @@ static request_sequences perform_request(servers_fixture* f,
     op->flags = 0;
     op->reserved = nullptr;
     op++;
-    GPR_ASSERT(GRPC_CALL_OK ==
-               grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), nullptr));
+    GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(c, ops, (size_t)(op - ops),
+                                                     tag(1), nullptr));
 
     s_idx = -1;
-    while (
-        (ev = grpc_completion_queue_next(
-             f->cq, grpc_timeout_milliseconds_to_deadline(RETRY_TIMEOUT), nullptr))
-            .type != GRPC_QUEUE_TIMEOUT) {
+    while ((ev = grpc_completion_queue_next(
+                f->cq, grpc_timeout_milliseconds_to_deadline(RETRY_TIMEOUT),
+                nullptr))
+               .type != GRPC_QUEUE_TIMEOUT) {
       GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
       read_tag = ((int)(intptr_t)ev.tag);
       const grpc_connectivity_state conn_state =
@@ -401,10 +402,10 @@ static request_sequences perform_request(servers_fixture* f,
       }
     }
 
-    GPR_ASSERT(
-        grpc_completion_queue_next(
-            f->cq, grpc_timeout_milliseconds_to_deadline(RETRY_TIMEOUT), nullptr)
-            .type == GRPC_QUEUE_TIMEOUT);
+    GPR_ASSERT(grpc_completion_queue_next(
+                   f->cq, grpc_timeout_milliseconds_to_deadline(RETRY_TIMEOUT),
+                   nullptr)
+                   .type == GRPC_QUEUE_TIMEOUT);
 
     grpc_metadata_array_destroy(&rdata->initial_metadata_recv);
     grpc_metadata_array_destroy(&rdata->trailing_metadata_recv);
@@ -451,10 +452,10 @@ static grpc_call** perform_multirequest(servers_fixture* f,
 
   grpc_slice host = grpc_slice_from_static_string("foo.test.google.fr");
   for (i = 0; i < concurrent_calls; i++) {
-    calls[i] =
-        grpc_channel_create_call(client, nullptr, GRPC_PROPAGATE_DEFAULTS, f->cq,
-                                 grpc_slice_from_static_string("/foo"), &host,
-                                 gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
+    calls[i] = grpc_channel_create_call(
+        client, nullptr, GRPC_PROPAGATE_DEFAULTS, f->cq,
+        grpc_slice_from_static_string("/foo"), &host,
+        gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
     GPR_ASSERT(calls[i]);
     GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(calls[i], ops,
                                                      (size_t)(op - ops), tag(1),
@@ -602,9 +603,8 @@ static void test_pending_calls(size_t concurrent_calls) {
 
   client = create_client(f);
   calls = perform_multirequest(f, client, concurrent_calls);
-  grpc_call_cancel(
-      calls[0],
-      nullptr); /* exercise the cancel pick path whilst there are pending picks */
+  grpc_call_cancel(calls[0], nullptr); /* exercise the cancel pick path whilst
+                                          there are pending picks */
 
   gpr_free(rdata.call_details);
 

test/core/client_channel/parse_address_test.cc

@@ -63,7 +63,7 @@ static void test_grpc_parse_ipv4(const char* uri_text, const char* host,
   struct sockaddr_in* addr_in = (struct sockaddr_in*)addr.addr;
   GPR_ASSERT(AF_INET == addr_in->sin_family);
   GPR_ASSERT(nullptr != grpc_inet_ntop(AF_INET, &addr_in->sin_addr, ntop_buf,
-                                    sizeof(ntop_buf)));
+                                       sizeof(ntop_buf)));
   GPR_ASSERT(0 == strcmp(ntop_buf, host));
   GPR_ASSERT(ntohs(addr_in->sin_port) == port);
 
@@ -82,7 +82,7 @@ static void test_grpc_parse_ipv6(const char* uri_text, const char* host,
   struct sockaddr_in6* addr_in6 = (struct sockaddr_in6*)addr.addr;
   GPR_ASSERT(AF_INET6 == addr_in6->sin6_family);
   GPR_ASSERT(nullptr != grpc_inet_ntop(AF_INET6, &addr_in6->sin6_addr, ntop_buf,
-                                    sizeof(ntop_buf)));
+                                       sizeof(ntop_buf)));
   GPR_ASSERT(0 == strcmp(ntop_buf, host));
   GPR_ASSERT(ntohs(addr_in6->sin6_port) == port);
   GPR_ASSERT(addr_in6->sin6_scope_id == scope_id);

test/core/client_channel/resolvers/dns_resolver_connectivity_test.cc

@@ -73,7 +73,8 @@ static grpc_ares_request* my_dns_lookup_ares(
   } else {
     gpr_mu_unlock(&g_mu);
     *lb_addrs = grpc_lb_addresses_create(1, nullptr);
-    grpc_lb_addresses_set_address(*lb_addrs, 0, nullptr, 0, false, nullptr, nullptr);
+    grpc_lb_addresses_set_address(*lb_addrs, 0, nullptr, 0, false, nullptr,
+                                  nullptr);
   }
   GRPC_CLOSURE_SCHED(exec_ctx, on_done, error);
   return nullptr;

test/core/end2end/bad_server_response_test.cc

@@ -197,8 +197,8 @@ static void start_rpc(int target_port, grpc_status_code expected_status,
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  error =
-      grpc_call_start_batch(state.call, ops, (size_t)(op - ops), tag(1), nullptr);
+  error = grpc_call_start_batch(state.call, ops, (size_t)(op - ops), tag(1),
+                                nullptr);
 
   GPR_ASSERT(GRPC_CALL_OK == error);
 

test/core/end2end/connection_refused_test.cc

@@ -83,9 +83,10 @@ static void run_test(bool wait_for_ready, bool use_service_config) {
   chan = grpc_insecure_channel_create(addr, args, nullptr);
   grpc_slice host = grpc_slice_from_static_string("nonexistant");
   gpr_timespec deadline = grpc_timeout_seconds_to_deadline(2);
-  call = grpc_channel_create_call(
-      chan, nullptr, GRPC_PROPAGATE_DEFAULTS, cq,
-      grpc_slice_from_static_string("/service/method"), &host, deadline, nullptr);
+  call =
+      grpc_channel_create_call(chan, nullptr, GRPC_PROPAGATE_DEFAULTS, cq,
+                               grpc_slice_from_static_string("/service/method"),
+                               &host, deadline, nullptr);
 
   gpr_free(addr);
 
@@ -105,8 +106,9 @@ static void run_test(bool wait_for_ready, bool use_service_config) {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(
-                                 call, ops, (size_t)(op - ops), tag(1), nullptr));
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call, ops,
+                                                   (size_t)(op - ops), tag(1),
+                                                   nullptr));
   /* verify that all tags get completed */
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
   cq_verify(cqv);
@@ -118,9 +120,9 @@ static void run_test(bool wait_for_ready, bool use_service_config) {
   }
 
   grpc_completion_queue_shutdown(cq);
-  while (
-      grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr)
-          .type != GRPC_QUEUE_SHUTDOWN)
+  while (grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME),
+                                    nullptr)
+             .type != GRPC_QUEUE_SHUTDOWN)
     ;
   grpc_completion_queue_destroy(cq);
   grpc_call_unref(call);

test/core/end2end/cq_verifier.cc

@@ -290,7 +290,8 @@ void cq_verify_empty_timeout(cq_verifier* v, int timeout_sec) {
                    gpr_time_from_seconds(timeout_sec, GPR_TIMESPAN));
   grpc_event ev;
 
-  GPR_ASSERT(v->first_expectation == nullptr && "expectation queue must be empty");
+  GPR_ASSERT(v->first_expectation == nullptr &&
+             "expectation queue must be empty");
 
   ev = grpc_completion_queue_next(v->cq, deadline, nullptr);
   if (ev.type != GRPC_QUEUE_TIMEOUT) {

test/core/end2end/dualstack_socket_test.cc

@@ -211,7 +211,8 @@ void test_connect(const char* server_host, const char* client_host, int port,
     op->data.recv_close_on_server.cancelled = &was_cancelled;
     op->flags = 0;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     CQ_EXPECT_COMPLETION(cqv, tag(102), 1);

test/core/end2end/fixtures/h2_census.cc

@@ -71,7 +71,8 @@ void chttp2_init_client_fullstack(grpc_end2end_test_fixture* f,
       static_cast<fullstack_fixture_data*>(f->fixture_data);
   grpc_arg arg = make_census_enable_arg();
   client_args = grpc_channel_args_copy_and_add(client_args, &arg, 1);
-  f->client = grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
+  f->client =
+      grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
   GPR_ASSERT(f->client);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;

test/core/end2end/fixtures/h2_compress.cc

@@ -72,8 +72,8 @@ void chttp2_init_client_fullstack_compression(grpc_end2end_test_fixture* f,
   }
   ffd->client_args_compression = grpc_channel_args_set_compression_algorithm(
       client_args, GRPC_COMPRESS_GZIP);
-  f->client = grpc_insecure_channel_create(ffd->localaddr,
-                                           ffd->client_args_compression, nullptr);
+  f->client = grpc_insecure_channel_create(
+      ffd->localaddr, ffd->client_args_compression, nullptr);
 }
 
 void chttp2_init_server_fullstack_compression(grpc_end2end_test_fixture* f,

test/core/end2end/fixtures/h2_fakesec.cc

@@ -118,7 +118,8 @@ static void chttp2_init_server_fake_secure_fullstack(
   grpc_server_credentials* fake_ts_creds =
       grpc_fake_transport_security_server_credentials_create();
   if (fail_server_auth_check(server_args)) {
-    grpc_auth_metadata_processor processor = {process_auth_failure, nullptr, nullptr};
+    grpc_auth_metadata_processor processor = {process_auth_failure, nullptr,
+                                              nullptr};
     grpc_server_credentials_set_auth_metadata_processor(fake_ts_creds,
                                                         processor);
   }

test/core/end2end/fixtures/h2_full+pipe.cc

@@ -66,7 +66,8 @@ void chttp2_init_client_fullstack(grpc_end2end_test_fixture* f,
                                   grpc_channel_args* client_args) {
   fullstack_fixture_data* ffd =
       static_cast<fullstack_fixture_data*>(f->fixture_data);
-  f->client = grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
+  f->client =
+      grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
   GPR_ASSERT(f->client);
 }
 

test/core/end2end/fixtures/h2_full+trace.cc

@@ -66,7 +66,8 @@ void chttp2_init_client_fullstack(grpc_end2end_test_fixture* f,
                                   grpc_channel_args* client_args) {
   fullstack_fixture_data* ffd =
       static_cast<fullstack_fixture_data*>(f->fixture_data);
-  f->client = grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
+  f->client =
+      grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
   GPR_ASSERT(f->client);
 }
 

test/core/end2end/fixtures/h2_full+workarounds.cc

@@ -64,7 +64,8 @@ void chttp2_init_client_fullstack(grpc_end2end_test_fixture* f,
                                   grpc_channel_args* client_args) {
   fullstack_fixture_data* ffd =
       static_cast<fullstack_fixture_data*>(f->fixture_data);
-  f->client = grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
+  f->client =
+      grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
   GPR_ASSERT(f->client);
 }
 

test/core/end2end/fixtures/h2_full.cc

@@ -60,7 +60,8 @@ void chttp2_init_client_fullstack(grpc_end2end_test_fixture* f,
                                   grpc_channel_args* client_args) {
   fullstack_fixture_data* ffd =
       static_cast<fullstack_fixture_data*>(f->fixture_data);
-  f->client = grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
+  f->client =
+      grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
   GPR_ASSERT(f->client);
 }
 

test/core/end2end/fixtures/h2_http_proxy.cc

@@ -81,7 +81,8 @@ void chttp2_init_client_fullstack(grpc_end2end_test_fixture* f,
   }
   gpr_setenv("http_proxy", proxy_uri);
   gpr_free(proxy_uri);
-  f->client = grpc_insecure_channel_create(ffd->server_addr, client_args, nullptr);
+  f->client =
+      grpc_insecure_channel_create(ffd->server_addr, client_args, nullptr);
   GPR_ASSERT(f->client);
 }
 

test/core/end2end/fixtures/h2_load_reporting.cc

@@ -62,7 +62,8 @@ void chttp2_init_client_load_reporting(grpc_end2end_test_fixture* f,
                                        grpc_channel_args* client_args) {
   load_reporting_fixture_data* ffd =
       static_cast<load_reporting_fixture_data*>(f->fixture_data);
-  f->client = grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
+  f->client =
+      grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
   GPR_ASSERT(f->client);
 }
 

test/core/end2end/fixtures/h2_oauth2.cc

@@ -149,7 +149,8 @@ static void chttp2_init_client_simple_ssl_with_oauth2_secure_fullstack(
   grpc_call_credentials* oauth2_creds = grpc_md_only_test_credentials_create(
       &exec_ctx, "authorization", oauth2_md, true /* is_async */);
   grpc_channel_credentials* ssl_oauth2_creds =
-      grpc_composite_channel_credentials_create(ssl_creds, oauth2_creds, nullptr);
+      grpc_composite_channel_credentials_create(ssl_creds, oauth2_creds,
+                                                nullptr);
   grpc_arg ssl_name_override = {
       GRPC_ARG_STRING,
       const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),
@@ -200,8 +201,8 @@ static void chttp2_init_server_simple_ssl_secure_fullstack(
     grpc_end2end_test_fixture* f, grpc_channel_args* server_args) {
   grpc_ssl_pem_key_cert_pair pem_key_cert_pair = {test_server1_key,
                                                   test_server1_cert};
-  grpc_server_credentials* ssl_creds =
-      grpc_ssl_server_credentials_create(nullptr, &pem_key_cert_pair, 1, 0, nullptr);
+  grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
+      nullptr, &pem_key_cert_pair, 1, 0, nullptr);
   grpc_server_credentials_set_auth_metadata_processor(
       ssl_creds, test_processor_create(fail_server_auth_check(server_args)));
   chttp2_init_server_secure_fullstack(f, server_args, ssl_creds);

test/core/end2end/fixtures/h2_ssl.cc

@@ -132,10 +132,11 @@ static void chttp2_init_server_simple_ssl_secure_fullstack(
     grpc_end2end_test_fixture* f, grpc_channel_args* server_args) {
   grpc_ssl_pem_key_cert_pair pem_cert_key_pair = {test_server1_key,
                                                   test_server1_cert};
-  grpc_server_credentials* ssl_creds =
-      grpc_ssl_server_credentials_create(nullptr, &pem_cert_key_pair, 1, 0, nullptr);
+  grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
+      nullptr, &pem_cert_key_pair, 1, 0, nullptr);
   if (fail_server_auth_check(server_args)) {
-    grpc_auth_metadata_processor processor = {process_auth_failure, nullptr, nullptr};
+    grpc_auth_metadata_processor processor = {process_auth_failure, nullptr,
+                                              nullptr};
     grpc_server_credentials_set_auth_metadata_processor(ssl_creds, processor);
   }
   chttp2_init_server_secure_fullstack(f, server_args, ssl_creds);

test/core/end2end/fixtures/h2_ssl_proxy.cc

@@ -44,8 +44,8 @@ static grpc_server* create_proxy_server(const char* port,
   grpc_server* s = grpc_server_create(server_args, nullptr);
   grpc_ssl_pem_key_cert_pair pem_cert_key_pair = {test_server1_key,
                                                   test_server1_cert};
-  grpc_server_credentials* ssl_creds =
-      grpc_ssl_server_credentials_create(nullptr, &pem_cert_key_pair, 1, 0, nullptr);
+  grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
+      nullptr, &pem_cert_key_pair, 1, 0, nullptr);
   GPR_ASSERT(grpc_server_add_secure_http2_port(s, port, ssl_creds));
   grpc_server_credentials_release(ssl_creds);
   return s;
@@ -170,10 +170,11 @@ static void chttp2_init_server_simple_ssl_secure_fullstack(
     grpc_end2end_test_fixture* f, grpc_channel_args* server_args) {
   grpc_ssl_pem_key_cert_pair pem_cert_key_pair = {test_server1_key,
                                                   test_server1_cert};
-  grpc_server_credentials* ssl_creds =
-      grpc_ssl_server_credentials_create(nullptr, &pem_cert_key_pair, 1, 0, nullptr);
+  grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
+      nullptr, &pem_cert_key_pair, 1, 0, nullptr);
   if (fail_server_auth_check(server_args)) {
-    grpc_auth_metadata_processor processor = {process_auth_failure, nullptr, nullptr};
+    grpc_auth_metadata_processor processor = {process_auth_failure, nullptr,
+                                              nullptr};
     grpc_server_credentials_set_auth_metadata_processor(ssl_creds, processor);
   }
   chttp2_init_server_secure_fullstack(f, server_args, ssl_creds);

test/core/end2end/fixtures/h2_uds.cc

@@ -66,7 +66,8 @@ void chttp2_init_client_fullstack(grpc_end2end_test_fixture* f,
                                   grpc_channel_args* client_args) {
   fullstack_fixture_data* ffd =
       static_cast<fullstack_fixture_data*>(f->fixture_data);
-  f->client = grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
+  f->client =
+      grpc_insecure_channel_create(ffd->localaddr, client_args, nullptr);
 }
 
 void chttp2_init_server_fullstack(grpc_end2end_test_fixture* f,

test/core/end2end/fixtures/http_proxy_fixture.cc

@@ -348,8 +348,8 @@ static void on_read_request_done(grpc_exec_ctx* exec_ctx, void* arg,
   // Read request and feed it to the parser.
   for (size_t i = 0; i < conn->client_read_buffer.count; ++i) {
     if (GRPC_SLICE_LENGTH(conn->client_read_buffer.slices[i]) > 0) {
-      error = grpc_http_parser_parse(&conn->http_parser,
-                                     conn->client_read_buffer.slices[i], nullptr);
+      error = grpc_http_parser_parse(
+          &conn->http_parser, conn->client_read_buffer.slices[i], nullptr);
       if (error != GRPC_ERROR_NONE) {
         proxy_connection_failed(exec_ctx, conn, true /* is_client */,
                                 "HTTP proxy request parse", error);

test/core/end2end/fixtures/proxy.cc

@@ -163,8 +163,9 @@ static void on_p2s_recv_initial_metadata(void* arg, int success) {
     op.data.send_initial_metadata.count = pc->p2s_initial_metadata.count;
     op.data.send_initial_metadata.metadata = pc->p2s_initial_metadata.metadata;
     refpc(pc, "on_c2p_sent_initial_metadata");
-    err = grpc_call_start_batch(
-        pc->c2p, &op, 1, new_closure(on_c2p_sent_initial_metadata, pc), nullptr);
+    err = grpc_call_start_batch(pc->c2p, &op, 1,
+                                new_closure(on_c2p_sent_initial_metadata, pc),
+                                nullptr);
     GPR_ASSERT(err == GRPC_CALL_OK);
   }
 
@@ -215,8 +216,8 @@ static void on_c2p_recv_msg(void* arg, int success) {
       op.reserved = nullptr;
       op.data.send_message.send_message = pc->c2p_msg;
       refpc(pc, "on_p2s_sent_message");
-      err = grpc_call_start_batch(pc->p2s, &op, 1,
-                                  new_closure(on_p2s_sent_message, pc), nullptr);
+      err = grpc_call_start_batch(
+          pc->p2s, &op, 1, new_closure(on_p2s_sent_message, pc), nullptr);
       GPR_ASSERT(err == GRPC_CALL_OK);
     } else {
       op.op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
@@ -339,8 +340,9 @@ static void on_new_call(void* arg, int success) {
     op.data.recv_initial_metadata.recv_initial_metadata =
         &pc->p2s_initial_metadata;
     refpc(pc, "on_p2s_recv_initial_metadata");
-    err = grpc_call_start_batch(
-        pc->p2s, &op, 1, new_closure(on_p2s_recv_initial_metadata, pc), nullptr);
+    err = grpc_call_start_batch(pc->p2s, &op, 1,
+                                new_closure(on_p2s_recv_initial_metadata, pc),
+                                nullptr);
     GPR_ASSERT(err == GRPC_CALL_OK);
 
     op.op = GRPC_OP_SEND_INITIAL_METADATA;
@@ -348,8 +350,9 @@ static void on_new_call(void* arg, int success) {
     op.data.send_initial_metadata.count = pc->c2p_initial_metadata.count;
     op.data.send_initial_metadata.metadata = pc->c2p_initial_metadata.metadata;
     refpc(pc, "on_p2s_sent_initial_metadata");
-    err = grpc_call_start_batch(
-        pc->p2s, &op, 1, new_closure(on_p2s_sent_initial_metadata, pc), nullptr);
+    err = grpc_call_start_batch(pc->p2s, &op, 1,
+                                new_closure(on_p2s_sent_initial_metadata, pc),
+                                nullptr);
     GPR_ASSERT(err == GRPC_CALL_OK);
 
     op.op = GRPC_OP_RECV_MESSAGE;

test/core/end2end/fuzzers/api_fuzzer.cc

@@ -249,7 +249,8 @@ static const char* read_cred_artifact(cred_artifact_ctx* ctx, input_stream* inp,
                                       size_t num_builtins) {
   uint8_t b = next_byte(inp);
   if (b == 0) return nullptr;
-  if (b == 1) return ctx->release[ctx->num_release++] = read_string(inp, nullptr);
+  if (b == 1)
+    return ctx->release[ctx->num_release++] = read_string(inp, nullptr);
   if (b >= num_builtins + 1) {
     end(inp);
     return nullptr;
@@ -272,7 +273,8 @@ static grpc_channel_credentials* read_ssl_channel_creds(input_stream* inp) {
                                          GPR_ARRAY_SIZE(builtin_cert_chains));
   grpc_ssl_pem_key_cert_pair key_cert_pair = {private_key, certs};
   grpc_channel_credentials* creds = grpc_ssl_credentials_create(
-      root_certs, private_key != nullptr && certs != nullptr ? &key_cert_pair : nullptr,
+      root_certs,
+      private_key != nullptr && certs != nullptr ? &key_cert_pair : nullptr,
       nullptr);
   cred_artifact_ctx_finish(&ctx);
   return creds;
@@ -317,10 +319,11 @@ static grpc_call_credentials* read_call_creds(input_stream* inp) {
       cred_artifact_ctx ctx = CRED_ARTIFACT_CTX_INIT;
       const char* auth_token = read_cred_artifact(&ctx, inp, nullptr, 0);
       const char* auth_selector = read_cred_artifact(&ctx, inp, nullptr, 0);
-      grpc_call_credentials* out = auth_token == nullptr || auth_selector == nullptr
-                                       ? nullptr
-                                       : grpc_google_iam_credentials_create(
-                                             auth_token, auth_selector, nullptr);
+      grpc_call_credentials* out =
+          auth_token == nullptr || auth_selector == nullptr
+              ? nullptr
+              : grpc_google_iam_credentials_create(auth_token, auth_selector,
+                                                   nullptr);
       cred_artifact_ctx_finish(&ctx);
       return out;
     }
@@ -388,7 +391,8 @@ static void finish_resolve(grpc_exec_ctx* exec_ctx, void* arg,
       *r->addrs = addrs;
     } else if (r->lb_addrs != nullptr) {
       grpc_lb_addresses* lb_addrs = grpc_lb_addresses_create(1, nullptr);
-      grpc_lb_addresses_set_address(lb_addrs, 0, nullptr, 0, false, nullptr, nullptr);
+      grpc_lb_addresses_set_address(lb_addrs, 0, nullptr, 0, false, nullptr,
+                                    nullptr);
       *r->lb_addrs = lb_addrs;
     }
     GRPC_CLOSURE_SCHED(exec_ctx, r->on_done, GRPC_ERROR_NONE);
@@ -465,7 +469,8 @@ static void do_connect(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
 
     grpc_transport* transport =
         grpc_create_chttp2_transport(exec_ctx, nullptr, server, 0);
-    grpc_server_setup_transport(exec_ctx, g_server, transport, nullptr, nullptr);
+    grpc_server_setup_transport(exec_ctx, g_server, transport, nullptr,
+                                nullptr);
     grpc_chttp2_transport_start_reading(exec_ctx, transport, nullptr);
 
     GRPC_CLOSURE_SCHED(exec_ctx, fc->closure, GRPC_ERROR_NONE);
@@ -1084,8 +1089,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
         if (ok) {
           validator* v = make_finished_batch_validator(g_active_call, has_ops);
           g_active_call->pending_ops++;
-          grpc_call_error error =
-              grpc_call_start_batch(g_active_call->call, ops, num_ops, v, nullptr);
+          grpc_call_error error = grpc_call_start_batch(
+              g_active_call->call, ops, num_ops, v, nullptr);
           if (error != GRPC_CALL_OK) {
             v->validate(v->arg, false);
             gpr_free(v);
@@ -1133,7 +1138,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
         if (g_channel != nullptr) {
           pending_pings++;
           grpc_channel_ping(g_channel, cq,
-                            create_validator(decrement, &pending_pings), nullptr);
+                            create_validator(decrement, &pending_pings),
+                            nullptr);
         } else {
           end(&inp);
         }
@@ -1195,7 +1201,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
           gpr_asprintf(&target_uri, "dns:%s", target);
           grpc_channel_args* args = read_args(&inp);
           grpc_channel_credentials* creds = read_channel_creds(&inp);
-          g_channel = grpc_secure_channel_create(creds, target_uri, args, nullptr);
+          g_channel =
+              grpc_secure_channel_create(creds, target_uri, args, nullptr);
           GPR_ASSERT(g_channel != nullptr);
           {
             grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;

test/core/end2end/fuzzers/client_fuzzer.cc

@@ -113,7 +113,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   grpc_event ev;
   while (1) {
     grpc_exec_ctx_flush(&exec_ctx);
-    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME), nullptr);
+    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME),
+                                    nullptr);
     switch (ev.type) {
       case GRPC_QUEUE_TIMEOUT:
         goto done;
@@ -130,12 +131,14 @@ done:
     grpc_call_cancel(call, nullptr);
   }
   for (int i = 0; i < requested_calls; i++) {
-    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME), nullptr);
+    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME),
+                                    nullptr);
     GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
   }
   grpc_completion_queue_shutdown(cq);
   for (int i = 0; i < requested_calls; i++) {
-    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME), nullptr);
+    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME),
+                                    nullptr);
     GPR_ASSERT(ev.type == GRPC_QUEUE_SHUTDOWN);
   }
   grpc_call_unref(call);

test/core/end2end/fuzzers/server_fuzzer.cc

@@ -80,7 +80,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   grpc_event ev;
   while (1) {
     grpc_exec_ctx_flush(&exec_ctx);
-    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME), nullptr);
+    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME),
+                                    nullptr);
     switch (ev.type) {
       case GRPC_QUEUE_TIMEOUT:
         goto done;
@@ -103,12 +104,14 @@ done:
   grpc_server_shutdown_and_notify(server, cq, tag(0xdead));
   grpc_server_cancel_all_calls(server);
   for (int i = 0; i <= requested_calls; i++) {
-    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME), nullptr);
+    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME),
+                                    nullptr);
     GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
   }
   grpc_completion_queue_shutdown(cq);
   for (int i = 0; i <= requested_calls; i++) {
-    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME), nullptr);
+    ev = grpc_completion_queue_next(cq, gpr_inf_past(GPR_CLOCK_REALTIME),
+                                    nullptr);
     GPR_ASSERT(ev.type == GRPC_QUEUE_SHUTDOWN);
   }
   grpc_server_destroy(server);

test/core/end2end/goaway_server_test.cc

@@ -176,7 +176,8 @@ int main(int argc, char** argv) {
   client_args.num_args = 1;
 
   /* create a channel that picks first amongst the servers */
-  grpc_channel* chan = grpc_insecure_channel_create("test", &client_args, nullptr);
+  grpc_channel* chan =
+      grpc_insecure_channel_create("test", &client_args, nullptr);
   /* and an initial call to them */
   grpc_slice host = grpc_slice_from_static_string("127.0.0.1");
   grpc_call* call1 =

test/core/end2end/invalid_call_argument_test.cc

@@ -72,7 +72,8 @@ static void prepare_test(int is_client) {
     grpc_slice host = grpc_slice_from_static_string("nonexistant");
     g_state.call = grpc_channel_create_call(
         g_state.chan, nullptr, GRPC_PROPAGATE_DEFAULTS, g_state.cq,
-        grpc_slice_from_static_string("/Foo"), &host, g_state.deadline, nullptr);
+        grpc_slice_from_static_string("/Foo"), &host, g_state.deadline,
+        nullptr);
   } else {
     g_state.server = grpc_server_create(nullptr, nullptr);
     grpc_server_register_completion_queue(g_state.server, g_state.cq, nullptr);
@@ -81,12 +82,14 @@ static void prepare_test(int is_client) {
     grpc_server_start(g_state.server);
     gpr_free(server_hostport);
     gpr_join_host_port(&server_hostport, "localhost", port);
-    g_state.chan = grpc_insecure_channel_create(server_hostport, nullptr, nullptr);
+    g_state.chan =
+        grpc_insecure_channel_create(server_hostport, nullptr, nullptr);
     gpr_free(server_hostport);
     grpc_slice host = grpc_slice_from_static_string("bar");
     g_state.call = grpc_channel_create_call(
         g_state.chan, nullptr, GRPC_PROPAGATE_DEFAULTS, g_state.cq,
-        grpc_slice_from_static_string("/Foo"), &host, g_state.deadline, nullptr);
+        grpc_slice_from_static_string("/Foo"), &host, g_state.deadline,
+        nullptr);
     grpc_metadata_array_init(&g_state.server_initial_metadata_recv);
     grpc_call_details_init(&g_state.call_details);
     op = g_state.ops;
@@ -162,7 +165,8 @@ static void test_non_null_reserved_on_op() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), nullptr));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
@@ -192,7 +196,8 @@ static void test_send_initial_metadata_more_than_once() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), nullptr));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
@@ -210,7 +215,8 @@ static void test_too_many_metadata() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_INVALID_METADATA ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), nullptr));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
@@ -233,7 +239,8 @@ static void test_send_null_message() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_INVALID_MESSAGE ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), nullptr));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
@@ -264,7 +271,8 @@ static void test_send_messages_at_the_same_time() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), nullptr));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   grpc_byte_buffer_destroy(request_payload);
   cleanup_test();
 }
@@ -286,7 +294,8 @@ static void test_send_server_status_from_client() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_NOT_ON_CLIENT ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), nullptr));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
@@ -316,7 +325,8 @@ static void test_receive_initial_metadata_twice_at_client() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), nullptr));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
@@ -334,7 +344,8 @@ static void test_receive_message_with_invalid_flags() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_INVALID_FLAGS ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), nullptr));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
@@ -357,7 +368,8 @@ static void test_receive_two_messages_at_the_same_time() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), nullptr));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
@@ -375,7 +387,8 @@ static void test_recv_close_on_server_from_client() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_NOT_ON_CLIENT ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), nullptr));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
@@ -410,7 +423,8 @@ static void test_recv_status_on_client_twice() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), nullptr));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 
@@ -427,7 +441,8 @@ static void test_send_close_from_client_on_server() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_NOT_ON_SERVER ==
              grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(2), nullptr));
+                                   (size_t)(op - g_state.ops), tag(2),
+                                   nullptr));
   cleanup_test();
 }
 
@@ -448,7 +463,8 @@ static void test_recv_status_on_client_from_server() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_NOT_ON_SERVER ==
              grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(2), nullptr));
+                                   (size_t)(op - g_state.ops), tag(2),
+                                   nullptr));
   cleanup_test();
 }
 
@@ -469,7 +485,8 @@ static void test_send_status_from_server_with_invalid_flags() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_INVALID_FLAGS ==
              grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(2), nullptr));
+                                   (size_t)(op - g_state.ops), tag(2),
+                                   nullptr));
   cleanup_test();
 }
 
@@ -491,7 +508,8 @@ static void test_too_many_trailing_metadata() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_INVALID_METADATA ==
              grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(2), nullptr));
+                                   (size_t)(op - g_state.ops), tag(2),
+                                   nullptr));
   cleanup_test();
 }
 
@@ -519,7 +537,8 @@ static void test_send_server_status_twice() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
              grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(2), nullptr));
+                                   (size_t)(op - g_state.ops), tag(2),
+                                   nullptr));
   cleanup_test();
 }
 
@@ -537,7 +556,8 @@ static void test_recv_close_on_server_with_invalid_flags() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_INVALID_FLAGS ==
              grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(2), nullptr));
+                                   (size_t)(op - g_state.ops), tag(2),
+                                   nullptr));
   cleanup_test();
 }
 
@@ -560,7 +580,8 @@ static void test_recv_close_on_server_twice() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
              grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(2), nullptr));
+                                   (size_t)(op - g_state.ops), tag(2),
+                                   nullptr));
   cleanup_test();
 }
 
@@ -582,7 +603,8 @@ static void test_invalid_initial_metadata_reserved_key() {
   op++;
   GPR_ASSERT(GRPC_CALL_ERROR_INVALID_METADATA ==
              grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops), tag(1), nullptr));
+                                   (size_t)(op - g_state.ops), tag(1),
+                                   nullptr));
   cleanup_test();
 }
 

test/core/end2end/no_server_test.cc

@@ -68,8 +68,9 @@ int main(int argc, char** argv) {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(
-                                 call, ops, (size_t)(op - ops), tag(1), nullptr));
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call, ops,
+                                                   (size_t)(op - ops), tag(1),
+                                                   nullptr));
   /* verify that all tags get completed */
   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
   cq_verify(cqv);
@@ -77,9 +78,9 @@ int main(int argc, char** argv) {
   GPR_ASSERT(status == GRPC_STATUS_DEADLINE_EXCEEDED);
 
   grpc_completion_queue_shutdown(cq);
-  while (
-      grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), nullptr)
-          .type != GRPC_QUEUE_SHUTDOWN)
+  while (grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME),
+                                    nullptr)
+             .type != GRPC_QUEUE_SHUTDOWN)
     ;
   grpc_completion_queue_destroy(cq);
   grpc_call_unref(call);

test/core/end2end/tests/binary_metadata.cc

@@ -119,8 +119,9 @@ static void test_request_response_with_metadata_and_payload(
            "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"),
        0,
        {{nullptr, nullptr, nullptr, nullptr}}}};
-  grpc_end2end_test_fixture f = begin_test(
-      config, "test_request_response_with_metadata_and_payload", nullptr, nullptr);
+  grpc_end2end_test_fixture f =
+      begin_test(config, "test_request_response_with_metadata_and_payload",
+                 nullptr, nullptr);
   cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
   grpc_op* op;

test/core/end2end/tests/call_creds.cc

@@ -170,8 +170,8 @@ static void request_response_with_payload_and_call_creds(
       break;
     case OVERRIDE:
       grpc_call_credentials_release(creds);
-      creds = grpc_google_iam_credentials_create(overridden_iam_token,
-                                                 overridden_iam_selector, nullptr);
+      creds = grpc_google_iam_credentials_create(
+          overridden_iam_token, overridden_iam_selector, nullptr);
       GPR_ASSERT(creds != nullptr);
       GPR_ASSERT(grpc_call_set_credentials(c, creds) == GRPC_CALL_OK);
       break;

test/core/end2end/tests/cancel_after_client_done.cc

@@ -94,8 +94,9 @@ static void test_cancel_after_accept_and_writes_closed(
   grpc_op* op;
   grpc_call* c;
   grpc_call* s;
-  grpc_end2end_test_fixture f = begin_test(
-      config, "test_cancel_after_accept_and_writes_closed", mode, nullptr, nullptr);
+  grpc_end2end_test_fixture f =
+      begin_test(config, "test_cancel_after_accept_and_writes_closed", mode,
+                 nullptr, nullptr);
   cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_metadata_array initial_metadata_recv;
   grpc_metadata_array trailing_metadata_recv;

test/core/end2end/tests/cancel_after_round_trip.cc

@@ -140,8 +140,9 @@ static void test_cancel_after_round_trip(grpc_end2end_test_config config,
     args = grpc_channel_args_copy_and_add(args, &arg, 1);
   }
 
-  grpc_end2end_test_fixture f = begin_test(
-      config, "cancel_after_round_trip", mode, use_service_config, args, nullptr);
+  grpc_end2end_test_fixture f =
+      begin_test(config, "cancel_after_round_trip", mode, use_service_config,
+                 args, nullptr);
   cq_verifier* cqv = cq_verifier_create(f.cq);
 
   gpr_timespec deadline = use_service_config

test/core/end2end/tests/cancel_with_status.cc

@@ -167,7 +167,8 @@ static void test_invoke_simple_request(grpc_end2end_test_config config,
                                        size_t num_ops) {
   grpc_end2end_test_fixture f;
 
-  f = begin_test(config, "test_invoke_simple_request", num_ops, nullptr, nullptr);
+  f = begin_test(config, "test_invoke_simple_request", num_ops, nullptr,
+                 nullptr);
   simple_request_body(config, f, num_ops);
   end_test(&f);
   config.tear_down_data(&f);

test/core/end2end/tests/compressed_payload.cc

@@ -421,7 +421,8 @@ static void request_with_payload_template(
       op->flags = client_send_flags_bitmask;
       op->reserved = nullptr;
       op++;
-      error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), nullptr);
+      error =
+          grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), nullptr);
       GPR_ASSERT(GRPC_CALL_OK == error);
       CQ_EXPECT_COMPLETION(cqv, tag(2), 1);
     }
@@ -433,7 +434,8 @@ static void request_with_payload_template(
     op->flags = 0;
     op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -451,7 +453,8 @@ static void request_with_payload_template(
     op->flags = 0;
     op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     memset(ops, 0, sizeof(ops));
@@ -560,8 +563,8 @@ static void test_invoke_request_with_uncompressed_payload(
   request_with_payload_template(
       config, "test_invoke_request_with_uncompressed_payload", 0,
       GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
-      GRPC_COMPRESS_NONE, nullptr, false, /* ignored */ GRPC_COMPRESS_LEVEL_NONE,
-      false);
+      GRPC_COMPRESS_NONE, nullptr, false,
+      /* ignored */ GRPC_COMPRESS_LEVEL_NONE, false);
 }
 
 static void test_invoke_request_with_compressed_payload(
@@ -569,8 +572,8 @@ static void test_invoke_request_with_compressed_payload(
   request_with_payload_template(
       config, "test_invoke_request_with_compressed_payload", 0,
       GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
-      GRPC_COMPRESS_GZIP, nullptr, false, /* ignored */ GRPC_COMPRESS_LEVEL_NONE,
-      false);
+      GRPC_COMPRESS_GZIP, nullptr, false,
+      /* ignored */ GRPC_COMPRESS_LEVEL_NONE, false);
 }
 
 static void test_invoke_request_with_send_message_before_initial_metadata(
@@ -578,8 +581,8 @@ static void test_invoke_request_with_send_message_before_initial_metadata(
   request_with_payload_template(
       config, "test_invoke_request_with_compressed_payload", 0,
       GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
-      GRPC_COMPRESS_GZIP, nullptr, false, /* ignored */ GRPC_COMPRESS_LEVEL_NONE,
-      true);
+      GRPC_COMPRESS_GZIP, nullptr, false,
+      /* ignored */ GRPC_COMPRESS_LEVEL_NONE, true);
 }
 
 static void test_invoke_request_with_server_level(
@@ -630,9 +633,10 @@ static void test_invoke_request_with_compressed_payload_md_override(
 
 static void test_invoke_request_with_disabled_algorithm(
     grpc_end2end_test_config config) {
-  request_for_disabled_algorithm(
-      config, "test_invoke_request_with_disabled_algorithm", 0,
-      GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_STATUS_UNIMPLEMENTED, nullptr);
+  request_for_disabled_algorithm(config,
+                                 "test_invoke_request_with_disabled_algorithm",
+                                 0, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
+                                 GRPC_STATUS_UNIMPLEMENTED, nullptr);
 }
 
 void compressed_payload(grpc_end2end_test_config config) {

test/core/end2end/tests/filter_latency.cc

@@ -321,8 +321,8 @@ static bool maybe_add_filter(grpc_exec_ctx* exec_ctx,
     grpc_channel_stack_builder_iterator* it =
         grpc_channel_stack_builder_create_iterator_at_last(builder);
     GPR_ASSERT(grpc_channel_stack_builder_move_prev(it));
-    const bool retval =
-        grpc_channel_stack_builder_add_filter_before(it, filter, nullptr, nullptr);
+    const bool retval = grpc_channel_stack_builder_add_filter_before(
+        it, filter, nullptr, nullptr);
     grpc_channel_stack_builder_iterator_destroy(it);
     return retval;
   } else {

test/core/end2end/tests/graceful_server_shutdown.cc

@@ -84,8 +84,9 @@ static void test_early_server_shutdown_finishes_inflight_calls(
     grpc_end2end_test_config config) {
   grpc_call* c;
   grpc_call* s;
-  grpc_end2end_test_fixture f = begin_test(
-      config, "test_early_server_shutdown_finishes_inflight_calls", nullptr, nullptr);
+  grpc_end2end_test_fixture f =
+      begin_test(config, "test_early_server_shutdown_finishes_inflight_calls",
+                 nullptr, nullptr);
   cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
   grpc_op* op;

test/core/end2end/tests/max_message_length.cc

@@ -174,8 +174,10 @@ static void test_max_message_length_on_request(grpc_end2end_test_config config,
                  server_args);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    if (client_args != nullptr) grpc_channel_args_destroy(&exec_ctx, client_args);
-    if (server_args != nullptr) grpc_channel_args_destroy(&exec_ctx, server_args);
+    if (client_args != nullptr)
+      grpc_channel_args_destroy(&exec_ctx, client_args);
+    if (server_args != nullptr)
+      grpc_channel_args_destroy(&exec_ctx, server_args);
     grpc_exec_ctx_finish(&exec_ctx);
   }
 
@@ -365,8 +367,10 @@ static void test_max_message_length_on_response(grpc_end2end_test_config config,
                  server_args);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    if (client_args != nullptr) grpc_channel_args_destroy(&exec_ctx, client_args);
-    if (server_args != nullptr) grpc_channel_args_destroy(&exec_ctx, server_args);
+    if (client_args != nullptr)
+      grpc_channel_args_destroy(&exec_ctx, client_args);
+    if (server_args != nullptr)
+      grpc_channel_args_destroy(&exec_ctx, server_args);
     grpc_exec_ctx_finish(&exec_ctx);
   }
   cqv = cq_verifier_create(f.cq);

test/core/end2end/tests/ping_pong_streaming.cc

@@ -195,7 +195,8 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
     op->flags = 0;
     op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
     CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
     cq_verify(cqv);
@@ -207,7 +208,8 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
     op->flags = 0;
     op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
     CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
     CQ_EXPECT_COMPLETION(cqv, tag(2), 1);

test/core/end2end/tests/shutdown_finishes_calls.cc

@@ -77,8 +77,9 @@ static void test_early_server_shutdown_finishes_inflight_calls(
     grpc_end2end_test_config config) {
   grpc_call* c;
   grpc_call* s;
-  grpc_end2end_test_fixture f = begin_test(
-      config, "test_early_server_shutdown_finishes_inflight_calls", nullptr, nullptr);
+  grpc_end2end_test_fixture f =
+      begin_test(config, "test_early_server_shutdown_finishes_inflight_calls",
+                 nullptr, nullptr);
   cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
   grpc_op* op;

test/core/end2end/tests/simple_cacheable_request.cc

@@ -116,8 +116,8 @@ static void test_cacheable_request_response_with_metadata_and_payload(
                               0,
                               {{nullptr, nullptr, nullptr, nullptr}}}};
   grpc_end2end_test_fixture f = begin_test(
-      config, "test_cacheable_request_response_with_metadata_and_payload", nullptr,
-      nullptr);
+      config, "test_cacheable_request_response_with_metadata_and_payload",
+      nullptr, nullptr);
   cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
   grpc_op* op;

test/core/end2end/tests/simple_metadata.cc

@@ -113,8 +113,9 @@ static void test_request_response_with_metadata_and_payload(
                               grpc_slice_from_static_string("val4"),
                               0,
                               {{nullptr, nullptr, nullptr, nullptr}}}};
-  grpc_end2end_test_fixture f = begin_test(
-      config, "test_request_response_with_metadata_and_payload", nullptr, nullptr);
+  grpc_end2end_test_fixture f =
+      begin_test(config, "test_request_response_with_metadata_and_payload",
+                 nullptr, nullptr);
   cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
   grpc_op* op;

test/core/end2end/tests/stream_compression_compressed_payload.cc

@@ -440,7 +440,8 @@ static void request_with_payload_template(
       op->flags = client_send_flags_bitmask;
       op->reserved = nullptr;
       op++;
-      error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), nullptr);
+      error =
+          grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(2), nullptr);
       GPR_ASSERT(GRPC_CALL_OK == error);
       CQ_EXPECT_COMPLETION(cqv, tag(2), 1);
     }
@@ -452,7 +453,8 @@ static void request_with_payload_template(
     op->flags = 0;
     op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
@@ -468,7 +470,8 @@ static void request_with_payload_template(
     op->flags = 0;
     op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
 
     memset(ops, 0, sizeof(ops));
@@ -580,8 +583,8 @@ static void test_invoke_request_with_server_level(
       config, "test_invoke_request_with_server_level", 0,
       GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_NONE,
       GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_GZIP,
-      /* ignored */ nullptr, true, GRPC_STREAM_COMPRESS_LEVEL_HIGH, false, false,
-      GRPC_COMPRESS_NONE);
+      /* ignored */ nullptr, true, GRPC_STREAM_COMPRESS_LEVEL_HIGH, false,
+      false, GRPC_COMPRESS_NONE);
 }
 
 static void test_invoke_request_with_compressed_payload_md_override(

test/core/end2end/tests/stream_compression_ping_pong_streaming.cc

@@ -204,7 +204,8 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
     op->flags = 0;
     op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
     CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
     cq_verify(cqv);
@@ -216,7 +217,8 @@ static void test_pingpong_streaming(grpc_end2end_test_config config,
     op->flags = 0;
     op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
     CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
     CQ_EXPECT_COMPLETION(cqv, tag(2), 1);

test/core/end2end/tests/streaming_error_response.cc

@@ -99,8 +99,9 @@ static void test(grpc_end2end_test_config config, bool request_status_early) {
   grpc_slice response_payload2_slice = grpc_slice_from_copied_string("world");
   grpc_byte_buffer* response_payload2 =
       grpc_raw_byte_buffer_create(&response_payload2_slice, 1);
-  grpc_end2end_test_fixture f = begin_test(config, "streaming_error_response",
-                                           nullptr, nullptr, request_status_early);
+  grpc_end2end_test_fixture f =
+      begin_test(config, "streaming_error_response", nullptr, nullptr,
+                 request_status_early);
   cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
   grpc_op* op;

test/core/end2end/tests/trailing_metadata.cc

@@ -121,8 +121,9 @@ static void test_request_response_with_metadata_and_payload(
                               grpc_slice_from_static_string("val6"),
                               0,
                               {{nullptr, nullptr, nullptr, nullptr}}}};
-  grpc_end2end_test_fixture f = begin_test(
-      config, "test_request_response_with_metadata_and_payload", nullptr, nullptr);
+  grpc_end2end_test_fixture f =
+      begin_test(config, "test_request_response_with_metadata_and_payload",
+                 nullptr, nullptr);
   cq_verifier* cqv = cq_verifier_create(f.cq);
   grpc_op ops[6];
   grpc_op* op;

test/core/end2end/tests/workaround_cronet_compression.cc

@@ -258,7 +258,8 @@ static void request_with_payload_template(
     op->flags = 0;
     op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
     CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
     cq_verify(cqv);
@@ -275,7 +276,8 @@ static void request_with_payload_template(
     op->flags = 0;
     op->reserved = nullptr;
     op++;
-    error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
+    error =
+        grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(103), nullptr);
     GPR_ASSERT(GRPC_CALL_OK == error);
     CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
     CQ_EXPECT_COMPLETION(cqv, tag(2), 1);

test/core/fling/server.cc

@@ -234,10 +234,10 @@ int main(int argc, char** argv) {
       shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
       grpc_server_shutdown_and_notify(server, shutdown_cq, tag(1000));
 
-      GPR_ASSERT(
-          grpc_completion_queue_pluck(shutdown_cq, tag(1000),
-                                      grpc_timeout_seconds_to_deadline(5), nullptr)
-              .type == GRPC_OP_COMPLETE);
+      GPR_ASSERT(grpc_completion_queue_pluck(
+                     shutdown_cq, tag(1000),
+                     grpc_timeout_seconds_to_deadline(5), nullptr)
+                     .type == GRPC_OP_COMPLETE);
       grpc_completion_queue_destroy(shutdown_cq);
 
       grpc_completion_queue_shutdown(cq);