1 files changed, 64 insertions, 59 deletions

diff --git a/src/core/lib/surface/server.cc b/src/core/lib/surface/server.cc
index c8c1db337f..d71a23a5d7 100644
--- a/src/core/lib/surface/server.cc
+++ b/src/core/lib/surface/server.cc
@@ -25,7 +25,6 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
-#include <grpc/support/useful.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/connected_channel.h"
@@ -242,8 +241,8 @@ static void channel_broadcaster_init(grpc_server* s, channel_broadcaster* cb) {
     count++;
   }
   cb->num_channels = count;
-  cb->channels =
-      (grpc_channel**)gpr_malloc(sizeof(*cb->channels) * cb->num_channels);
+  cb->channels = static_cast<grpc_channel**>(
+      gpr_malloc(sizeof(*cb->channels) * cb->num_channels));
   count = 0;
   for (c = s->root_channel_data.next; c != &s->root_channel_data; c = c->next) {
     cb->channels[count++] = c->channel;
@@ -257,7 +256,8 @@ struct shutdown_cleanup_args {
 };
 
 static void shutdown_cleanup(void* arg, grpc_error* error) {
-  struct shutdown_cleanup_args* a = (struct shutdown_cleanup_args*)arg;
+  struct shutdown_cleanup_args* a =
+      static_cast<struct shutdown_cleanup_args*>(arg);
   grpc_slice_unref_internal(a->slice);
   gpr_free(a);
 }
@@ -265,7 +265,7 @@ static void shutdown_cleanup(void* arg, grpc_error* error) {
 static void send_shutdown(grpc_channel* channel, bool send_goaway,
                           grpc_error* send_disconnect) {
   struct shutdown_cleanup_args* sc =
-      (struct shutdown_cleanup_args*)gpr_malloc(sizeof(*sc));
+      static_cast<struct shutdown_cleanup_args*>(gpr_malloc(sizeof(*sc)));
   GRPC_CLOSURE_INIT(&sc->closure, shutdown_cleanup, sc,
                     grpc_schedule_on_exec_ctx);
   grpc_transport_op* op = grpc_make_transport_op(&sc->closure);
@@ -305,8 +305,8 @@ static void channel_broadcaster_shutdown(channel_broadcaster* cb,
 static void request_matcher_init(request_matcher* rm, grpc_server* server) {
   memset(rm, 0, sizeof(*rm));
   rm->server = server;
-  rm->requests_per_cq = (gpr_locked_mpscq*)gpr_malloc(
-      sizeof(*rm->requests_per_cq) * server->cq_count);
+  rm->requests_per_cq = static_cast<gpr_locked_mpscq*>(
+      gpr_malloc(sizeof(*rm->requests_per_cq) * server->cq_count));
   for (size_t i = 0; i < server->cq_count; i++) {
     gpr_locked_mpscq_init(&rm->requests_per_cq[i]);
   }
@@ -321,7 +321,8 @@ static void request_matcher_destroy(request_matcher* rm) {
 }
 
 static void kill_zombie(void* elem, grpc_error* error) {
-  grpc_call_unref(grpc_call_from_top_element((grpc_call_element*)elem));
+  grpc_call_unref(
+      grpc_call_from_top_element(static_cast<grpc_call_element*>(elem)));
 }
 
 static void request_matcher_zombify_all_pending_calls(request_matcher* rm) {
@@ -342,8 +343,8 @@ static void request_matcher_kill_requests(grpc_server* server,
                                           grpc_error* error) {
   requested_call* rc;
   for (size_t i = 0; i < server->cq_count; i++) {
-    while ((rc = (requested_call*)gpr_locked_mpscq_pop(
-                &rm->requests_per_cq[i])) != nullptr) {
+    while ((rc = reinterpret_cast<requested_call*>(
+                gpr_locked_mpscq_pop(&rm->requests_per_cq[i]))) != nullptr) {
       fail_call(server, i, rc, GRPC_ERROR_REF(error));
     }
   }
@@ -403,7 +404,7 @@ static void orphan_channel(channel_data* chand) {
 }
 
 static void finish_destroy_channel(void* cd, grpc_error* error) {
-  channel_data* chand = (channel_data*)cd;
+  channel_data* chand = static_cast<channel_data*>(cd);
   grpc_server* server = chand->server;
   GRPC_CHANNEL_INTERNAL_UNREF(chand->channel, "server");
   server_unref(server);
@@ -470,9 +471,9 @@ static void publish_call(grpc_server* server, call_data* calld, size_t cq_idx,
 }
 
 static void publish_new_rpc(void* arg, grpc_error* error) {
-  grpc_call_element* call_elem = (grpc_call_element*)arg;
-  call_data* calld = (call_data*)call_elem->call_data;
-  channel_data* chand = (channel_data*)call_elem->channel_data;
+  grpc_call_element* call_elem = static_cast<grpc_call_element*>(arg);
+  call_data* calld = static_cast<call_data*>(call_elem->call_data);
+  channel_data* chand = static_cast<channel_data*>(call_elem->channel_data);
   request_matcher* rm = calld->matcher;
   grpc_server* server = rm->server;
 
@@ -488,8 +489,8 @@ static void publish_new_rpc(void* arg, grpc_error* error) {
 
   for (size_t i = 0; i < server->cq_count; i++) {
     size_t cq_idx = (chand->cq_idx + i) % server->cq_count;
-    requested_call* rc =
-        (requested_call*)gpr_locked_mpscq_try_pop(&rm->requests_per_cq[cq_idx]);
+    requested_call* rc = reinterpret_cast<requested_call*>(
+        gpr_locked_mpscq_try_pop(&rm->requests_per_cq[cq_idx]));
     if (rc == nullptr) {
       continue;
     } else {
@@ -510,8 +511,8 @@ static void publish_new_rpc(void* arg, grpc_error* error) {
   // added to the pending list.
   for (size_t i = 0; i < server->cq_count; i++) {
     size_t cq_idx = (chand->cq_idx + i) % server->cq_count;
-    requested_call* rc =
-        (requested_call*)gpr_locked_mpscq_pop(&rm->requests_per_cq[cq_idx]);
+    requested_call* rc = reinterpret_cast<requested_call*>(
+        gpr_locked_mpscq_pop(&rm->requests_per_cq[cq_idx]));
     if (rc == nullptr) {
       continue;
     } else {
@@ -537,7 +538,7 @@ static void publish_new_rpc(void* arg, grpc_error* error) {
 static void finish_start_new_rpc(
     grpc_server* server, grpc_call_element* elem, request_matcher* rm,
     grpc_server_register_method_payload_handling payload_handling) {
-  call_data* calld = (call_data*)elem->call_data;
+  call_data* calld = static_cast<call_data*>(elem->call_data);
 
   if (gpr_atm_acq_load(&server->shutdown_flag)) {
     gpr_atm_no_barrier_store(&calld->state, ZOMBIED);
@@ -567,8 +568,8 @@ static void finish_start_new_rpc(
 }
 
 static void start_new_rpc(grpc_call_element* elem) {
-  channel_data* chand = (channel_data*)elem->channel_data;
-  call_data* calld = (call_data*)elem->call_data;
+  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
+  call_data* calld = static_cast<call_data*>(elem->call_data);
   grpc_server* server = chand->server;
   uint32_t i;
   uint32_t hash;
@@ -627,7 +628,7 @@ static int num_listeners(grpc_server* server) {
 }
 
 static void done_shutdown_event(void* server, grpc_cq_completion* completion) {
-  server_unref((grpc_server*)server);
+  server_unref(static_cast<grpc_server*>(server));
 }
 
 static int num_channels(grpc_server* server) {
@@ -690,8 +691,8 @@ static void maybe_finish_shutdown(grpc_server* server) {
 }
 
 static void server_on_recv_initial_metadata(void* ptr, grpc_error* error) {
-  grpc_call_element* elem = (grpc_call_element*)ptr;
-  call_data* calld = (call_data*)elem->call_data;
+  grpc_call_element* elem = static_cast<grpc_call_element*>(ptr);
+  call_data* calld = static_cast<call_data*>(elem->call_data);
   grpc_millis op_deadline;
 
   if (error == GRPC_ERROR_NONE) {
@@ -729,7 +730,7 @@ static void server_on_recv_initial_metadata(void* ptr, grpc_error* error) {
 
 static void server_mutate_op(grpc_call_element* elem,
                              grpc_transport_stream_op_batch* op) {
-  call_data* calld = (call_data*)elem->call_data;
+  call_data* calld = static_cast<call_data*>(elem->call_data);
 
   if (op->recv_initial_metadata) {
     GPR_ASSERT(op->payload->recv_initial_metadata.recv_flags == nullptr);
@@ -751,8 +752,8 @@ static void server_start_transport_stream_op_batch(
 }
 
 static void got_initial_metadata(void* ptr, grpc_error* error) {
-  grpc_call_element* elem = (grpc_call_element*)ptr;
-  call_data* calld = (call_data*)elem->call_data;
+  grpc_call_element* elem = static_cast<grpc_call_element*>(ptr);
+  call_data* calld = static_cast<call_data*>(elem->call_data);
   if (error == GRPC_ERROR_NONE) {
     start_new_rpc(elem);
   } else {
@@ -769,7 +770,7 @@ static void got_initial_metadata(void* ptr, grpc_error* error) {
 
 static void accept_stream(void* cd, grpc_transport* transport,
                           const void* transport_server_data) {
-  channel_data* chand = (channel_data*)cd;
+  channel_data* chand = static_cast<channel_data*>(cd);
   /* create a call */
   grpc_call_create_args args;
   memset(&args, 0, sizeof(args));
@@ -785,7 +786,7 @@ static void accept_stream(void* cd, grpc_transport* transport,
     GRPC_ERROR_UNREF(error);
     return;
   }
-  call_data* calld = (call_data*)elem->call_data;
+  call_data* calld = static_cast<call_data*>(elem->call_data);
   grpc_op op;
   memset(&op, 0, sizeof(op));
   op.op = GRPC_OP_RECV_INITIAL_METADATA;
@@ -797,7 +798,7 @@ static void accept_stream(void* cd, grpc_transport* transport,
 }
 
 static void channel_connectivity_changed(void* cd, grpc_error* error) {
-  channel_data* chand = (channel_data*)cd;
+  channel_data* chand = static_cast<channel_data*>(cd);
   grpc_server* server = chand->server;
   if (chand->connectivity_state != GRPC_CHANNEL_SHUTDOWN) {
     grpc_transport_op* op = grpc_make_transport_op(nullptr);
@@ -816,8 +817,8 @@ static void channel_connectivity_changed(void* cd, grpc_error* error) {
 
 static grpc_error* init_call_elem(grpc_call_element* elem,
                                   const grpc_call_element_args* args) {
-  call_data* calld = (call_data*)elem->call_data;
-  channel_data* chand = (channel_data*)elem->channel_data;
+  call_data* calld = static_cast<call_data*>(elem->call_data);
+  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   memset(calld, 0, sizeof(call_data));
   calld->deadline = GRPC_MILLIS_INF_FUTURE;
   calld->call = grpc_call_from_top_element(elem);
@@ -833,8 +834,8 @@ static grpc_error* init_call_elem(grpc_call_element* elem,
 static void destroy_call_elem(grpc_call_element* elem,
                               const grpc_call_final_info* final_info,
                               grpc_closure* ignored) {
-  channel_data* chand = (channel_data*)elem->channel_data;
-  call_data* calld = (call_data*)elem->call_data;
+  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
+  call_data* calld = static_cast<call_data*>(elem->call_data);
 
   GPR_ASSERT(calld->state != PENDING);
 
@@ -852,7 +853,7 @@ static void destroy_call_elem(grpc_call_element* elem,
 
 static grpc_error* init_channel_elem(grpc_channel_element* elem,
                                      grpc_channel_element_args* args) {
-  channel_data* chand = (channel_data*)elem->channel_data;
+  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   GPR_ASSERT(args->is_first);
   GPR_ASSERT(!args->is_last);
   chand->server = nullptr;
@@ -868,7 +869,7 @@ static grpc_error* init_channel_elem(grpc_channel_element* elem,
 
 static void destroy_channel_elem(grpc_channel_element* elem) {
   size_t i;
-  channel_data* chand = (channel_data*)elem->channel_data;
+  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   if (chand->registered_methods) {
     for (i = 0; i < chand->registered_method_slots; i++) {
       grpc_slice_unref_internal(chand->registered_methods[i].method);
@@ -914,8 +915,8 @@ static void register_completion_queue(grpc_server* server,
 
   GRPC_CQ_INTERNAL_REF(cq, "server");
   n = server->cq_count++;
-  server->cqs = (grpc_completion_queue**)gpr_realloc(
-      server->cqs, server->cq_count * sizeof(grpc_completion_queue*));
+  server->cqs = static_cast<grpc_completion_queue**>(gpr_realloc(
+      server->cqs, server->cq_count * sizeof(grpc_completion_queue*)));
   server->cqs[n] = cq;
 }
 
@@ -940,7 +941,8 @@ void grpc_server_register_completion_queue(grpc_server* server,
 grpc_server* grpc_server_create(const grpc_channel_args* args, void* reserved) {
   GRPC_API_TRACE("grpc_server_create(%p, %p)", 2, (args, reserved));
 
-  grpc_server* server = (grpc_server*)gpr_zalloc(sizeof(grpc_server));
+  grpc_server* server =
+      static_cast<grpc_server*>(gpr_zalloc(sizeof(grpc_server)));
 
   gpr_mu_init(&server->mu_global);
   gpr_mu_init(&server->mu_call);
@@ -989,7 +991,7 @@ void* grpc_server_register_method(
             flags);
     return nullptr;
   }
-  m = (registered_method*)gpr_zalloc(sizeof(registered_method));
+  m = static_cast<registered_method*>(gpr_zalloc(sizeof(registered_method)));
   m->method = gpr_strdup(method);
   m->host = gpr_strdup(host);
   m->next = server->registered_methods;
@@ -1000,7 +1002,7 @@ void* grpc_server_register_method(
 }
 
 static void start_listeners(void* s, grpc_error* error) {
-  grpc_server* server = (grpc_server*)s;
+  grpc_server* server = static_cast<grpc_server*>(s);
   for (listener* l = server->listeners; l; l = l->next) {
     l->start(server, l->arg, server->pollsets, server->pollset_count);
   }
@@ -1021,8 +1023,8 @@ void grpc_server_start(grpc_server* server) {
 
   server->started = true;
   server->pollset_count = 0;
-  server->pollsets =
-      (grpc_pollset**)gpr_malloc(sizeof(grpc_pollset*) * server->cq_count);
+  server->pollsets = static_cast<grpc_pollset**>(
+      gpr_malloc(sizeof(grpc_pollset*) * server->cq_count));
   for (i = 0; i < server->cq_count; i++) {
     if (grpc_cq_can_listen(server->cqs[i])) {
       server->pollsets[server->pollset_count++] =
@@ -1064,9 +1066,9 @@ void grpc_server_setup_transport(grpc_server* s, grpc_transport* transport,
   grpc_transport_op* op = nullptr;
 
   channel = grpc_channel_create(nullptr, args, GRPC_SERVER_CHANNEL, transport);
-  chand = (channel_data*)grpc_channel_stack_element(
-              grpc_channel_get_channel_stack(channel), 0)
-              ->channel_data;
+  chand = static_cast<channel_data*>(
+      grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0)
+          ->channel_data);
   chand->server = s;
   server_ref(s);
   chand->channel = channel;
@@ -1077,7 +1079,7 @@ void grpc_server_setup_transport(grpc_server* s, grpc_transport* transport,
   }
   if (cq_idx == s->cq_count) {
     /* completion queue not found: pick a random one to publish new calls to */
-    cq_idx = (size_t)rand() % s->cq_count;
+    cq_idx = static_cast<size_t>(rand()) % s->cq_count;
   }
   chand->cq_idx = cq_idx;
 
@@ -1090,7 +1092,8 @@ void grpc_server_setup_transport(grpc_server* s, grpc_transport* transport,
   if (num_registered_methods > 0) {
     slots = 2 * num_registered_methods;
     alloc = sizeof(channel_registered_method) * slots;
-    chand->registered_methods = (channel_registered_method*)gpr_zalloc(alloc);
+    chand->registered_methods =
+        static_cast<channel_registered_method*>(gpr_zalloc(alloc));
     for (rm = s->registered_methods; rm; rm = rm->next) {
       grpc_slice host;
       bool has_host;
@@ -1119,7 +1122,7 @@ void grpc_server_setup_transport(grpc_server* s, grpc_transport* transport,
       crm->method = method;
     }
     GPR_ASSERT(slots <= UINT32_MAX);
-    chand->registered_method_slots = (uint32_t)slots;
+    chand->registered_method_slots = static_cast<uint32_t>(slots);
     chand->registered_method_max_probes = max_probes;
   }
 
@@ -1149,7 +1152,7 @@ void done_published_shutdown(void* done_arg, grpc_cq_completion* storage) {
 }
 
 static void listener_destroy_done(void* s, grpc_error* error) {
-  grpc_server* server = (grpc_server*)s;
+  grpc_server* server = static_cast<grpc_server*>(s);
   gpr_mu_lock(&server->mu_global);
   server->listeners_destroyed++;
   maybe_finish_shutdown(server);
@@ -1177,13 +1180,14 @@ void grpc_server_shutdown_and_notify(grpc_server* server,
   GPR_ASSERT(grpc_cq_begin_op(cq, tag));
   if (server->shutdown_published) {
     grpc_cq_end_op(cq, tag, GRPC_ERROR_NONE, done_published_shutdown, nullptr,
-                   (grpc_cq_completion*)gpr_malloc(sizeof(grpc_cq_completion)));
+                   static_cast<grpc_cq_completion*>(
+                       gpr_malloc(sizeof(grpc_cq_completion))));
     gpr_mu_unlock(&server->mu_global);
     return;
   }
-  server->shutdown_tags = (shutdown_tag*)gpr_realloc(
-      server->shutdown_tags,
-      sizeof(shutdown_tag) * (server->num_shutdown_tags + 1));
+  server->shutdown_tags = static_cast<shutdown_tag*>(
+      gpr_realloc(server->shutdown_tags,
+                  sizeof(shutdown_tag) * (server->num_shutdown_tags + 1)));
   sdt = &server->shutdown_tags[server->num_shutdown_tags++];
   sdt->tag = tag;
   sdt->cq = cq;
@@ -1260,7 +1264,7 @@ void grpc_server_add_listener(grpc_server* server, void* arg,
                                             size_t pollset_count),
                               void (*destroy)(grpc_server* server, void* arg,
                                               grpc_closure* on_done)) {
-  listener* l = (listener*)gpr_malloc(sizeof(listener));
+  listener* l = static_cast<listener*>(gpr_malloc(sizeof(listener)));
   l->arg = arg;
   l->start = start;
   l->destroy = destroy;
@@ -1290,7 +1294,8 @@ static grpc_call_error queue_call_request(grpc_server* server, size_t cq_idx,
        matching calls */
     gpr_mu_lock(&server->mu_call);
     while ((calld = rm->pending_head) != nullptr) {
-      rc = (requested_call*)gpr_locked_mpscq_pop(&rm->requests_per_cq[cq_idx]);
+      rc = reinterpret_cast<requested_call*>(
+          gpr_locked_mpscq_pop(&rm->requests_per_cq[cq_idx]));
       if (rc == nullptr) break;
       rm->pending_head = calld->pending_next;
       gpr_mu_unlock(&server->mu_call);
@@ -1318,7 +1323,7 @@ grpc_call_error grpc_server_request_call(
     grpc_completion_queue* cq_for_notification, void* tag) {
   grpc_call_error error;
   grpc_core::ExecCtx exec_ctx;
-  requested_call* rc = (requested_call*)gpr_malloc(sizeof(*rc));
+  requested_call* rc = static_cast<requested_call*>(gpr_malloc(sizeof(*rc)));
   GRPC_STATS_INC_SERVER_REQUESTED_CALLS();
   GRPC_API_TRACE(
       "grpc_server_request_call("
@@ -1365,8 +1370,8 @@ grpc_call_error grpc_server_request_registered_call(
     grpc_completion_queue* cq_for_notification, void* tag) {
   grpc_call_error error;
   grpc_core::ExecCtx exec_ctx;
-  requested_call* rc = (requested_call*)gpr_malloc(sizeof(*rc));
-  registered_method* rm = (registered_method*)rmp;
+  requested_call* rc = static_cast<requested_call*>(gpr_malloc(sizeof(*rc)));
+  registered_method* rm = static_cast<registered_method*>(rmp);
   GRPC_STATS_INC_SERVER_REQUESTED_CALLS();
   GRPC_API_TRACE(
       "grpc_server_request_registered_call("