Autofix c casts to c++ casts

6 files changed, 46 insertions, 46 deletions

diff --git a/src/core/lib/channel/channel_args.cc b/src/core/lib/channel/channel_args.cc
index 5cd158aff2..8f448bfd91 100644
--- a/src/core/lib/channel/channel_args.cc
+++ b/src/core/lib/channel/channel_args.cc
@@ -87,13 +87,13 @@ grpc_channel_args* grpc_channel_args_copy_and_add_and_remove(
   }
   // Create result.
   grpc_channel_args* dst =
-      (grpc_channel_args*)gpr_malloc(sizeof(grpc_channel_args));
+      static_cast<grpc_channel_args*>(gpr_malloc(sizeof(grpc_channel_args)));
   dst->num_args = num_args_to_copy + num_to_add;
   if (dst->num_args == 0) {
     dst->args = nullptr;
     return dst;
   }
-  dst->args = (grpc_arg*)gpr_malloc(sizeof(grpc_arg) * dst->num_args);
+  dst->args = static_cast<grpc_arg*>(gpr_malloc(sizeof(grpc_arg) * dst->num_args));
   // Copy args from src that are not being removed.
   size_t dst_idx = 0;
   if (src != nullptr) {
@@ -118,7 +118,7 @@ grpc_channel_args* grpc_channel_args_copy(const grpc_channel_args* src) {
 grpc_channel_args* grpc_channel_args_union(const grpc_channel_args* a,
                                            const grpc_channel_args* b) {
   const size_t max_out = (a->num_args + b->num_args);
-  grpc_arg* uniques = (grpc_arg*)gpr_malloc(sizeof(*uniques) * max_out);
+  grpc_arg* uniques = static_cast<grpc_arg*>(gpr_malloc(sizeof(*uniques) * max_out));
   for (size_t i = 0; i < a->num_args; ++i) uniques[i] = a->args[i];
 
   size_t uniques_idx = a->num_args;
@@ -161,15 +161,15 @@ static int cmp_arg(const grpc_arg* a, const grpc_arg* b) {
 /* stabilizing comparison function: since channel_args ordering matters for
  * keys with the same name, we need to preserve that ordering */
 static int cmp_key_stable(const void* ap, const void* bp) {
-  const grpc_arg* const* a = (const grpc_arg* const*)ap;
-  const grpc_arg* const* b = (const grpc_arg* const*)bp;
+  const grpc_arg* const* a = static_cast<const grpc_arg* const*>(ap);
+  const grpc_arg* const* b = static_cast<const grpc_arg* const*>(bp);
   int c = strcmp((*a)->key, (*b)->key);
   if (c == 0) c = GPR_ICMP(*a, *b);
   return c;
 }
 
 grpc_channel_args* grpc_channel_args_normalize(const grpc_channel_args* a) {
-  grpc_arg** args = (grpc_arg**)gpr_malloc(sizeof(grpc_arg*) * a->num_args);
+  grpc_arg** args = static_cast<grpc_arg**>(gpr_malloc(sizeof(grpc_arg*) * a->num_args));
   for (size_t i = 0; i < a->num_args; i++) {
     args[i] = &a->args[i];
   }
@@ -177,9 +177,9 @@ grpc_channel_args* grpc_channel_args_normalize(const grpc_channel_args* a) {
     qsort(args, a->num_args, sizeof(grpc_arg*), cmp_key_stable);
 
   grpc_channel_args* b =
-      (grpc_channel_args*)gpr_malloc(sizeof(grpc_channel_args));
+      static_cast<grpc_channel_args*>(gpr_malloc(sizeof(grpc_channel_args)));
   b->num_args = a->num_args;
-  b->args = (grpc_arg*)gpr_malloc(sizeof(grpc_arg) * b->num_args);
+  b->args = static_cast<grpc_arg*>(gpr_malloc(sizeof(grpc_arg) * b->num_args));
   for (size_t i = 0; i < a->num_args; i++) {
     b->args[i] = copy_arg(args[i]);
   }
@@ -215,7 +215,7 @@ grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
   for (i = 0; i < a->num_args; ++i) {
     if (a->args[i].type == GRPC_ARG_INTEGER &&
         !strcmp(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM, a->args[i].key)) {
-      return (grpc_compression_algorithm)a->args[i].value.integer;
+      return static_cast<grpc_compression_algorithm>(a->args[i].value.integer);
       break;
     }
   }
@@ -296,7 +296,7 @@ uint32_t grpc_channel_args_compression_algorithm_get_states(
     const grpc_channel_args* a) {
   int* states_arg;
   if (find_compression_algorithm_states_bitset(a, &states_arg)) {
-    return (uint32_t)*states_arg;
+    return static_cast<uint32_t>(*states_arg);
   } else {
     return (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1; /* All algs. enabled */
   }
diff --git a/src/core/lib/channel/channel_stack.cc b/src/core/lib/channel/channel_stack.cc
index 195fe0b195..c311c73b85 100644
--- a/src/core/lib/channel/channel_stack.cc
+++ b/src/core/lib/channel/channel_stack.cc
@@ -104,7 +104,7 @@ grpc_error* grpc_channel_stack_init(
   GRPC_STREAM_REF_INIT(&stack->refcount, initial_refs, destroy, destroy_arg,
                        name);
   elems = CHANNEL_ELEMS_FROM_STACK(stack);
-  user_data = ((char*)elems) + ROUND_UP_TO_ALIGNMENT_SIZE(
+  user_data = (reinterpret_cast<char*>(elems)) + ROUND_UP_TO_ALIGNMENT_SIZE(
                                    filter_count * sizeof(grpc_channel_element));
 
   /* init per-filter data */
@@ -162,7 +162,7 @@ grpc_error* grpc_call_stack_init(grpc_channel_stack* channel_stack,
   GRPC_STREAM_REF_INIT(&elem_args->call_stack->refcount, initial_refs, destroy,
                        destroy_arg, "CALL_STACK");
   call_elems = CALL_ELEMS_FROM_STACK(elem_args->call_stack);
-  user_data = ((char*)call_elems) +
+  user_data = (reinterpret_cast<char*>(call_elems)) +
               ROUND_UP_TO_ALIGNMENT_SIZE(count * sizeof(grpc_call_element));
 
   /* init per-filter data */
@@ -194,7 +194,7 @@ void grpc_call_stack_set_pollset_or_pollset_set(grpc_call_stack* call_stack,
   size_t i;
 
   call_elems = CALL_ELEMS_FROM_STACK(call_stack);
-  user_data = ((char*)call_elems) +
+  user_data = (reinterpret_cast<char*>(call_elems)) +
               ROUND_UP_TO_ALIGNMENT_SIZE(count * sizeof(grpc_call_element));
 
   /* init per-filter data */
@@ -243,11 +243,11 @@ void grpc_channel_next_op(grpc_channel_element* elem, grpc_transport_op* op) {
 
 grpc_channel_stack* grpc_channel_stack_from_top_element(
     grpc_channel_element* elem) {
-  return (grpc_channel_stack*)((char*)(elem)-ROUND_UP_TO_ALIGNMENT_SIZE(
+  return reinterpret_cast<grpc_channel_stack*>(reinterpret_cast<char*>(elem)-ROUND_UP_TO_ALIGNMENT_SIZE(
       sizeof(grpc_channel_stack)));
 }
 
 grpc_call_stack* grpc_call_stack_from_top_element(grpc_call_element* elem) {
-  return (grpc_call_stack*)((char*)(elem)-ROUND_UP_TO_ALIGNMENT_SIZE(
+  return reinterpret_cast<grpc_call_stack*>(reinterpret_cast<char*>(elem)-ROUND_UP_TO_ALIGNMENT_SIZE(
       sizeof(grpc_call_stack)));
 }
diff --git a/src/core/lib/channel/channel_stack_builder.cc b/src/core/lib/channel/channel_stack_builder.cc
index fcba826644..c04f4c603a 100644
--- a/src/core/lib/channel/channel_stack_builder.cc
+++ b/src/core/lib/channel/channel_stack_builder.cc
@@ -52,7 +52,7 @@ struct grpc_channel_stack_builder_iterator {
 
 grpc_channel_stack_builder* grpc_channel_stack_builder_create(void) {
   grpc_channel_stack_builder* b =
-      (grpc_channel_stack_builder*)gpr_zalloc(sizeof(*b));
+      static_cast<grpc_channel_stack_builder*>(gpr_zalloc(sizeof(*b)));
 
   b->begin.filter = nullptr;
   b->end.filter = nullptr;
@@ -78,7 +78,7 @@ const char* grpc_channel_stack_builder_get_target(
 static grpc_channel_stack_builder_iterator* create_iterator_at_filter_node(
     grpc_channel_stack_builder* builder, filter_node* node) {
   grpc_channel_stack_builder_iterator* it =
-      (grpc_channel_stack_builder_iterator*)gpr_malloc(sizeof(*it));
+      static_cast<grpc_channel_stack_builder_iterator*>(gpr_malloc(sizeof(*it)));
   it->builder = builder;
   it->node = node;
   return it;
@@ -213,7 +213,7 @@ bool grpc_channel_stack_builder_prepend_filter(
 static void add_after(filter_node* before, const grpc_channel_filter* filter,
                       grpc_post_filter_create_init_func post_init_func,
                       void* user_data) {
-  filter_node* new_node = (filter_node*)gpr_malloc(sizeof(*new_node));
+  filter_node* new_node = static_cast<filter_node*>(gpr_malloc(sizeof(*new_node)));
   new_node->next = before->next;
   new_node->prev = before;
   new_node->next->prev = new_node->prev->next = new_node;
@@ -265,7 +265,7 @@ grpc_error* grpc_channel_stack_builder_finish(
 
   // create an array of filters
   const grpc_channel_filter** filters =
-      (const grpc_channel_filter**)gpr_malloc(sizeof(*filters) * num_filters);
+      static_cast<const grpc_channel_filter**>(gpr_malloc(sizeof(*filters) * num_filters));
   size_t i = 0;
   for (filter_node* p = builder->begin.next; p != &builder->end; p = p->next) {
     filters[i++] = p->filter;
@@ -278,7 +278,7 @@ grpc_error* grpc_channel_stack_builder_finish(
   *result = gpr_zalloc(prefix_bytes + channel_stack_size);
   // fetch a pointer to the channel stack
   grpc_channel_stack* channel_stack =
-      (grpc_channel_stack*)((char*)(*result) + prefix_bytes);
+      reinterpret_cast<grpc_channel_stack*>(static_cast<char*>(*result) + prefix_bytes);
   // and initialize it
   grpc_error* error = grpc_channel_stack_init(
       initial_refs, destroy, destroy_arg == nullptr ? *result : destroy_arg,
@@ -303,7 +303,7 @@ grpc_error* grpc_channel_stack_builder_finish(
   }
 
   grpc_channel_stack_builder_destroy(builder);
-  gpr_free((grpc_channel_filter**)filters);
+  gpr_free(const_cast<grpc_channel_filter**>(filters));
 
   return error;
 }
diff --git a/src/core/lib/channel/connected_channel.cc b/src/core/lib/channel/connected_channel.cc
index fb26bdf586..516d49e4d3 100644
--- a/src/core/lib/channel/connected_channel.cc
+++ b/src/core/lib/channel/connected_channel.cc
@@ -52,7 +52,7 @@ typedef struct connected_channel_call_data {
 } call_data;
 
 static void run_in_call_combiner(void* arg, grpc_error* error) {
-  callback_state* state = (callback_state*)arg;
+  callback_state* state = static_cast<callback_state*>(arg);
   GRPC_CALL_COMBINER_START(state->call_combiner, state->original_closure,
                            GRPC_ERROR_REF(error), state->reason);
 }
@@ -96,8 +96,8 @@ static callback_state* get_state_for_batch(
    into transport stream operations */
 static void con_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
-  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);
   if (batch->recv_initial_metadata) {
     callback_state* state = &calld->recv_initial_metadata_ready;
     intercept_callback(
@@ -115,7 +115,7 @@ static void con_start_transport_stream_op_batch(
     // calld->on_complete like we can for the other ops.  However,
     // cancellation isn't in the fast path, so we just allocate a new
     // closure for each one.
-    callback_state* state = (callback_state*)gpr_malloc(sizeof(*state));
+    callback_state* state = static_cast<callback_state*>(gpr_malloc(sizeof(*state)));
     intercept_callback(calld, state, true, "on_complete (cancel_stream)",
                        &batch->on_complete);
   } else {
@@ -129,15 +129,15 @@ static void con_start_transport_stream_op_batch(
 
 static void con_start_transport_op(grpc_channel_element* elem,
                                    grpc_transport_op* op) {
-  channel_data* chand = (channel_data*)elem->channel_data;
+  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   grpc_transport_perform_op(chand->transport, op);
 }
 
 /* Constructor for call_data */
 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);
   calld->call_combiner = args->call_combiner;
   int r = grpc_transport_init_stream(
       chand->transport, TRANSPORT_STREAM_FROM_CALL_DATA(calld),
@@ -149,8 +149,8 @@ static grpc_error* init_call_elem(grpc_call_element* elem,
 
 static void set_pollset_or_pollset_set(grpc_call_element* elem,
                                        grpc_polling_entity* pollent) {
-  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);
   grpc_transport_set_pops(chand->transport,
                           TRANSPORT_STREAM_FROM_CALL_DATA(calld), pollent);
 }
@@ -159,8 +159,8 @@ static void set_pollset_or_pollset_set(grpc_call_element* elem,
 static void destroy_call_elem(grpc_call_element* elem,
                               const grpc_call_final_info* final_info,
                               grpc_closure* then_schedule_closure) {
-  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);
   grpc_transport_destroy_stream(chand->transport,
                                 TRANSPORT_STREAM_FROM_CALL_DATA(calld),
                                 then_schedule_closure);
@@ -169,7 +169,7 @@ static void destroy_call_elem(grpc_call_element* elem,
 /* Constructor for channel_data */
 static grpc_error* init_channel_elem(grpc_channel_element* elem,
                                      grpc_channel_element_args* args) {
-  channel_data* cd = (channel_data*)elem->channel_data;
+  channel_data* cd = static_cast<channel_data*>(elem->channel_data);
   GPR_ASSERT(args->is_last);
   cd->transport = nullptr;
   return GRPC_ERROR_NONE;
@@ -177,7 +177,7 @@ static grpc_error* init_channel_elem(grpc_channel_element* elem,
 
 /* Destructor for channel_data */
 static void destroy_channel_elem(grpc_channel_element* elem) {
-  channel_data* cd = (channel_data*)elem->channel_data;
+  channel_data* cd = static_cast<channel_data*>(elem->channel_data);
   if (cd->transport) {
     grpc_transport_destroy(cd->transport);
   }
@@ -203,10 +203,10 @@ const grpc_channel_filter grpc_connected_filter = {
 
 static void bind_transport(grpc_channel_stack* channel_stack,
                            grpc_channel_element* elem, void* t) {
-  channel_data* cd = (channel_data*)elem->channel_data;
+  channel_data* cd = static_cast<channel_data*>(elem->channel_data);
   GPR_ASSERT(elem->filter == &grpc_connected_filter);
   GPR_ASSERT(cd->transport == nullptr);
-  cd->transport = (grpc_transport*)t;
+  cd->transport = static_cast<grpc_transport*>(t);
 
   /* HACK(ctiller): increase call stack size for the channel to make space
      for channel data. We need a cleaner (but performant) way to do this,
@@ -215,7 +215,7 @@ static void bind_transport(grpc_channel_stack* channel_stack,
      the last call element, and the last call element MUST be the connected
      channel. */
   channel_stack->call_stack_size +=
-      grpc_transport_stream_size((grpc_transport*)t);
+      grpc_transport_stream_size(static_cast<grpc_transport*>(t));
 }
 
 bool grpc_add_connected_filter(grpc_channel_stack_builder* builder,
@@ -228,6 +228,6 @@ bool grpc_add_connected_filter(grpc_channel_stack_builder* builder,
 }
 
 grpc_stream* grpc_connected_channel_get_stream(grpc_call_element* elem) {
-  call_data* calld = (call_data*)elem->call_data;
+  call_data* calld = static_cast<call_data*>(elem->call_data);
   return TRANSPORT_STREAM_FROM_CALL_DATA(calld);
 }
diff --git a/src/core/lib/channel/handshaker.cc b/src/core/lib/channel/handshaker.cc
index dcb149c03e..daacbdebd3 100644
--- a/src/core/lib/channel/handshaker.cc
+++ b/src/core/lib/channel/handshaker.cc
@@ -82,7 +82,7 @@ struct grpc_handshake_manager {
 
 grpc_handshake_manager* grpc_handshake_manager_create() {
   grpc_handshake_manager* mgr =
-      (grpc_handshake_manager*)gpr_zalloc(sizeof(grpc_handshake_manager));
+      static_cast<grpc_handshake_manager*>(gpr_zalloc(sizeof(grpc_handshake_manager)));
   gpr_mu_init(&mgr->mu);
   gpr_ref_init(&mgr->refs, 1);
   return mgr;
@@ -135,8 +135,8 @@ void grpc_handshake_manager_add(grpc_handshake_manager* mgr,
     realloc_count = mgr->count * 2;
   }
   if (realloc_count > 0) {
-    mgr->handshakers = (grpc_handshaker**)gpr_realloc(
-        mgr->handshakers, realloc_count * sizeof(grpc_handshaker*));
+    mgr->handshakers = static_cast<grpc_handshaker**>(gpr_realloc(
+        mgr->handshakers, realloc_count * sizeof(grpc_handshaker*)));
   }
   mgr->handshakers[mgr->count++] = handshaker;
   gpr_mu_unlock(&mgr->mu);
@@ -197,7 +197,7 @@ static bool call_next_handshaker_locked(grpc_handshake_manager* mgr,
 // A function used as the handshaker-done callback when chaining
 // handshakers together.
 static void call_next_handshaker(void* arg, grpc_error* error) {
-  grpc_handshake_manager* mgr = (grpc_handshake_manager*)arg;
+  grpc_handshake_manager* mgr = static_cast<grpc_handshake_manager*>(arg);
   gpr_mu_lock(&mgr->mu);
   bool done = call_next_handshaker_locked(mgr, GRPC_ERROR_REF(error));
   gpr_mu_unlock(&mgr->mu);
@@ -211,7 +211,7 @@ static void call_next_handshaker(void* arg, grpc_error* error) {
 
 // Callback invoked when deadline is exceeded.
 static void on_timeout(void* arg, grpc_error* error) {
-  grpc_handshake_manager* mgr = (grpc_handshake_manager*)arg;
+  grpc_handshake_manager* mgr = static_cast<grpc_handshake_manager*>(arg);
   if (error == GRPC_ERROR_NONE) {  // Timer fired, rather than being cancelled.
     grpc_handshake_manager_shutdown(
         mgr, GRPC_ERROR_CREATE_FROM_STATIC_STRING("Handshake timed out"));
@@ -234,7 +234,7 @@ void grpc_handshake_manager_do_handshake(
   mgr->args.args = grpc_channel_args_copy(channel_args);
   mgr->args.user_data = user_data;
   mgr->args.read_buffer =
-      (grpc_slice_buffer*)gpr_malloc(sizeof(*mgr->args.read_buffer));
+      static_cast<grpc_slice_buffer*>(gpr_malloc(sizeof(*mgr->args.read_buffer)));
   grpc_slice_buffer_init(mgr->args.read_buffer);
   // Initialize state needed for calling handshakers.
   mgr->acceptor = acceptor;
diff --git a/src/core/lib/channel/handshaker_registry.cc b/src/core/lib/channel/handshaker_registry.cc
index 098eabf084..f23f009275 100644
--- a/src/core/lib/channel/handshaker_registry.cc
+++ b/src/core/lib/channel/handshaker_registry.cc
@@ -34,8 +34,8 @@ typedef struct {
 static void grpc_handshaker_factory_list_register(
     grpc_handshaker_factory_list* list, bool at_start,
     grpc_handshaker_factory* factory) {
-  list->list = (grpc_handshaker_factory**)gpr_realloc(
-      list->list, (list->num_factories + 1) * sizeof(grpc_handshaker_factory*));
+  list->list = static_cast<grpc_handshaker_factory**>(gpr_realloc(
+      list->list, (list->num_factories + 1) * sizeof(grpc_handshaker_factory*)));
   if (at_start) {
     memmove(list->list + 1, list->list,
             sizeof(grpc_handshaker_factory*) * list->num_factories);