grpc 1.9.1 → 1.10.0.pre1

data/src/core/lib/security/{transport → security_connector}/security_connector.h

@@ -16,8 +16,8 @@
  *
  */
 
-#ifndef GRPC_CORE_LIB_SECURITY_TRANSPORT_SECURITY_CONNECTOR_H
-#define GRPC_CORE_LIB_SECURITY_TRANSPORT_SECURITY_CONNECTOR_H
+#ifndef GRPC_CORE_LIB_SECURITY_SECURITY_CONNECTOR_SECURITY_CONNECTOR_H
+#define GRPC_CORE_LIB_SECURITY_SECURITY_CONNECTOR_SECURITY_CONNECTOR_H
 
 #include <stdbool.h>
 
@@ -246,4 +246,4 @@ tsi_peer tsi_shallow_peer_from_ssl_auth_context(
     const grpc_auth_context* auth_context);
 void tsi_shallow_peer_destruct(tsi_peer* peer);
 
-#endif /* GRPC_CORE_LIB_SECURITY_TRANSPORT_SECURITY_CONNECTOR_H */
+#endif /* GRPC_CORE_LIB_SECURITY_SECURITY_CONNECTOR_SECURITY_CONNECTOR_H */

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

@@ -29,7 +29,7 @@
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/security/context/security_context.h"
 #include "src/core/lib/security/credentials/credentials.h"
-#include "src/core/lib/security/transport/security_connector.h"
+#include "src/core/lib/security/security_connector/security_connector.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/surface/call.h"
@@ -70,11 +70,11 @@ struct channel_data {
 void grpc_auth_metadata_context_reset(
     grpc_auth_metadata_context* auth_md_context) {
   if (auth_md_context->service_url != nullptr) {
-    gpr_free((char*)auth_md_context->service_url);
+    gpr_free(const_cast<char*>(auth_md_context->service_url));
     auth_md_context->service_url = nullptr;
   }
   if (auth_md_context->method_name != nullptr) {
-    gpr_free((char*)auth_md_context->method_name);
+    gpr_free(const_cast<char*>(auth_md_context->method_name));
     auth_md_context->method_name = nullptr;
   }
   GRPC_AUTH_CONTEXT_UNREF(
@@ -93,10 +93,11 @@ static void add_error(grpc_error** combined, grpc_error* error) {
 }
 
 static void on_credentials_metadata(void* arg, grpc_error* input_error) {
-  grpc_transport_stream_op_batch* batch = (grpc_transport_stream_op_batch*)arg;
+  grpc_transport_stream_op_batch* batch =
+      static_cast<grpc_transport_stream_op_batch*>(arg);
   grpc_call_element* elem =
-      (grpc_call_element*)batch->handler_private.extra_arg;
-  call_data* calld = (call_data*)elem->call_data;
+      static_cast<grpc_call_element*>(batch->handler_private.extra_arg);
+  call_data* calld = static_cast<call_data*>(elem->call_data);
   grpc_auth_metadata_context_reset(&calld->auth_md_context);
   grpc_error* error = GRPC_ERROR_REF(input_error);
   if (error == GRPC_ERROR_NONE) {
@@ -159,8 +160,8 @@ void grpc_auth_metadata_context_build(
 }
 
 static void cancel_get_request_metadata(void* arg, grpc_error* error) {
-  grpc_call_element* elem = (grpc_call_element*)arg;
-  call_data* calld = (call_data*)elem->call_data;
+  grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
+  call_data* calld = static_cast<call_data*>(elem->call_data);
   if (error != GRPC_ERROR_NONE) {
     grpc_call_credentials_cancel_get_request_metadata(
         calld->creds, &calld->md_array, GRPC_ERROR_REF(error));
@@ -170,12 +171,11 @@ static void cancel_get_request_metadata(void* arg, grpc_error* error) {
 
 static void send_security_metadata(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);
   grpc_client_security_context* ctx =
-      (grpc_client_security_context*)batch->payload
-          ->context[GRPC_CONTEXT_SECURITY]
-          .value;
+      static_cast<grpc_client_security_context*>(
+          batch->payload->context[GRPC_CONTEXT_SECURITY].value);
   grpc_call_credentials* channel_call_creds =
       chand->security_connector->request_metadata_creds;
   int call_creds_has_md = (ctx != nullptr) && (ctx->creds != nullptr);
@@ -231,10 +231,11 @@ static void send_security_metadata(grpc_call_element* elem,
 }
 
 static void on_host_checked(void* arg, grpc_error* error) {
-  grpc_transport_stream_op_batch* batch = (grpc_transport_stream_op_batch*)arg;
+  grpc_transport_stream_op_batch* batch =
+      static_cast<grpc_transport_stream_op_batch*>(arg);
   grpc_call_element* elem =
-      (grpc_call_element*)batch->handler_private.extra_arg;
-  call_data* calld = (call_data*)elem->call_data;
+      static_cast<grpc_call_element*>(batch->handler_private.extra_arg);
+  call_data* calld = static_cast<call_data*>(elem->call_data);
   if (error == GRPC_ERROR_NONE) {
     send_security_metadata(elem, batch);
   } else {
@@ -255,9 +256,9 @@ static void on_host_checked(void* arg, grpc_error* error) {
 }
 
 static void cancel_check_call_host(void* arg, grpc_error* error) {
-  grpc_call_element* elem = (grpc_call_element*)arg;
-  call_data* calld = (call_data*)elem->call_data;
-  channel_data* chand = (channel_data*)elem->channel_data;
+  grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
+  call_data* calld = static_cast<call_data*>(elem->call_data);
+  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   if (error != GRPC_ERROR_NONE) {
     grpc_channel_security_connector_cancel_check_call_host(
         chand->security_connector, &calld->async_result_closure,
@@ -268,11 +269,11 @@ static void cancel_check_call_host(void* arg, grpc_error* error) {
 
 static void auth_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
-  GPR_TIMER_BEGIN("auth_start_transport_stream_op_batch", 0);
+  GPR_TIMER_SCOPE("auth_start_transport_stream_op_batch", 0);
 
   /* grab pointers to our data from the call element */
-  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->cancel_stream) {
     GPR_ASSERT(batch->payload->context != nullptr);
@@ -283,9 +284,8 @@ static void auth_start_transport_stream_op_batch(
           grpc_client_security_context_destroy;
     }
     grpc_client_security_context* sec_ctx =
-        (grpc_client_security_context*)batch->payload
-            ->context[GRPC_CONTEXT_SECURITY]
-            .value;
+        static_cast<grpc_client_security_context*>(
+            batch->payload->context[GRPC_CONTEXT_SECURITY].value);
     GRPC_AUTH_CONTEXT_UNREF(sec_ctx->auth_context, "client auth filter");
     sec_ctx->auth_context =
         GRPC_AUTH_CONTEXT_REF(chand->auth_context, "client_auth_filter");
@@ -335,20 +335,18 @@ static void auth_start_transport_stream_op_batch(
                               grpc_schedule_on_exec_ctx));
       }
       gpr_free(call_host);
-      GPR_TIMER_END("auth_start_transport_stream_op_batch", 0);
       return; /* early exit */
     }
   }
 
   /* pass control down the stack */
   grpc_call_next_op(elem, batch);
-  GPR_TIMER_END("auth_start_transport_stream_op_batch", 0);
 }
 
 /* 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;
+  call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->owning_call = args->call_stack;
   calld->call_combiner = args->call_combiner;
   return GRPC_ERROR_NONE;
@@ -356,7 +354,7 @@ 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;
+  call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->pollent = pollent;
 }
 
@@ -364,7 +362,7 @@ 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* ignored) {
-  call_data* calld = (call_data*)elem->call_data;
+  call_data* calld = static_cast<call_data*>(elem->call_data);
   grpc_credentials_mdelem_array_destroy(&calld->md_array);
   grpc_call_credentials_unref(calld->creds);
   if (calld->have_host) {
@@ -393,7 +391,7 @@ static grpc_error* init_channel_elem(grpc_channel_element* elem,
   }
 
   /* grab pointers to our data from the channel element */
-  channel_data* chand = (channel_data*)elem->channel_data;
+  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
 
   /* The first and the last filters tend to be implemented differently to
      handle the case that there's no 'next' filter to call on the up or down
@@ -402,8 +400,8 @@ static grpc_error* init_channel_elem(grpc_channel_element* elem,
 
   /* initialize members */
   chand->security_connector =
-      (grpc_channel_security_connector*)GRPC_SECURITY_CONNECTOR_REF(
-          sc, "client_auth_filter");
+      reinterpret_cast<grpc_channel_security_connector*>(
+          GRPC_SECURITY_CONNECTOR_REF(sc, "client_auth_filter"));
   chand->auth_context =
       GRPC_AUTH_CONTEXT_REF(auth_context, "client_auth_filter");
   return GRPC_ERROR_NONE;
@@ -412,7 +410,7 @@ static grpc_error* init_channel_elem(grpc_channel_element* elem,
 /* Destructor for channel data */
 static void destroy_channel_elem(grpc_channel_element* elem) {
   /* grab pointers to our data from the channel element */
-  channel_data* chand = (channel_data*)elem->channel_data;
+  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   grpc_channel_security_connector* sc = chand->security_connector;
   if (sc != nullptr) {
     GRPC_SECURITY_CONNECTOR_UNREF(&sc->base, "client_auth_filter");

data/src/core/lib/security/transport/lb_targets_info.cc

@@ -26,14 +26,15 @@
 #define GRPC_ARG_LB_SECURE_NAMING_MAP "grpc.lb_secure_naming_map"
 
 static void* targets_info_copy(void* p) {
-  return grpc_slice_hash_table_ref((grpc_slice_hash_table*)p);
+  return grpc_slice_hash_table_ref(static_cast<grpc_slice_hash_table*>(p));
 }
 static void targets_info_destroy(void* p) {
-  grpc_slice_hash_table_unref((grpc_slice_hash_table*)p);
+  grpc_slice_hash_table_unref(static_cast<grpc_slice_hash_table*>(p));
 }
 static int targets_info_cmp(void* a, void* b) {
-  return grpc_slice_hash_table_cmp((const grpc_slice_hash_table*)a,
-                                   (const grpc_slice_hash_table*)b);
+  return grpc_slice_hash_table_cmp(
+      static_cast<const grpc_slice_hash_table*>(a),
+      static_cast<const grpc_slice_hash_table*>(b));
 }
 static const grpc_arg_pointer_vtable server_to_balancer_names_vtable = {
     targets_info_copy, targets_info_destroy, targets_info_cmp};
@@ -51,7 +52,8 @@ grpc_slice_hash_table* grpc_lb_targets_info_find_in_args(
       grpc_channel_args_find(args, GRPC_ARG_LB_SECURE_NAMING_MAP);
   if (targets_info_arg != nullptr) {
     GPR_ASSERT(targets_info_arg->type == GRPC_ARG_POINTER);
-    return (grpc_slice_hash_table*)targets_info_arg->value.pointer.p;
+    return static_cast<grpc_slice_hash_table*>(
+        targets_info_arg->value.pointer.p);
   }
   return nullptr;
 }

data/src/core/lib/security/transport/secure_endpoint.cc

@@ -144,7 +144,7 @@ static void on_read(void* user_data, grpc_error* error) {
   unsigned i;
   uint8_t keep_looping = 0;
   tsi_result result = TSI_OK;
-  secure_endpoint* ep = (secure_endpoint*)user_data;
+  secure_endpoint* ep = static_cast<secure_endpoint*>(user_data);
   uint8_t* cur = GRPC_SLICE_START_PTR(ep->read_staging_buffer);
   uint8_t* end = GRPC_SLICE_END_PTR(ep->read_staging_buffer);
 
@@ -168,7 +168,7 @@ static void on_read(void* user_data, grpc_error* error) {
       size_t message_size = GRPC_SLICE_LENGTH(encrypted);
 
       while (message_size > 0 || keep_looping) {
-        size_t unprotected_buffer_size_written = (size_t)(end - cur);
+        size_t unprotected_buffer_size_written = static_cast<size_t>(end - cur);
         size_t processed_message_size = message_size;
         gpr_mu_lock(&ep->protector_mu);
         result = tsi_frame_protector_unprotect(
@@ -205,7 +205,8 @@ static void on_read(void* user_data, grpc_error* error) {
           ep->read_buffer,
           grpc_slice_split_head(
               &ep->read_staging_buffer,
-              (size_t)(cur - GRPC_SLICE_START_PTR(ep->read_staging_buffer))));
+              static_cast<size_t>(
+                  cur - GRPC_SLICE_START_PTR(ep->read_staging_buffer))));
     }
   }
 
@@ -226,7 +227,7 @@ static void on_read(void* user_data, grpc_error* error) {
 
 static void endpoint_read(grpc_endpoint* secure_ep, grpc_slice_buffer* slices,
                           grpc_closure* cb) {
-  secure_endpoint* ep = (secure_endpoint*)secure_ep;
+  secure_endpoint* ep = reinterpret_cast<secure_endpoint*>(secure_ep);
   ep->read_cb = cb;
   ep->read_buffer = slices;
   grpc_slice_buffer_reset_and_unref_internal(ep->read_buffer);
@@ -252,11 +253,11 @@ static void flush_write_staging_buffer(secure_endpoint* ep, uint8_t** cur,
 
 static void endpoint_write(grpc_endpoint* secure_ep, grpc_slice_buffer* slices,
                            grpc_closure* cb) {
-  GPR_TIMER_BEGIN("secure_endpoint.endpoint_write", 0);
+  GPR_TIMER_SCOPE("secure_endpoint.endpoint_write", 0);
 
   unsigned i;
   tsi_result result = TSI_OK;
-  secure_endpoint* ep = (secure_endpoint*)secure_ep;
+  secure_endpoint* ep = reinterpret_cast<secure_endpoint*>(secure_ep);
   uint8_t* cur = GRPC_SLICE_START_PTR(ep->write_staging_buffer);
   uint8_t* end = GRPC_SLICE_END_PTR(ep->write_staging_buffer);
 
@@ -282,7 +283,7 @@ static void endpoint_write(grpc_endpoint* secure_ep, grpc_slice_buffer* slices,
       uint8_t* message_bytes = GRPC_SLICE_START_PTR(plain);
       size_t message_size = GRPC_SLICE_LENGTH(plain);
       while (message_size > 0) {
-        size_t protected_buffer_size_to_send = (size_t)(end - cur);
+        size_t protected_buffer_size_to_send = static_cast<size_t>(end - cur);
         size_t processed_message_size = message_size;
         gpr_mu_lock(&ep->protector_mu);
         result = tsi_frame_protector_protect(ep->protector, message_bytes,
@@ -307,7 +308,7 @@ static void endpoint_write(grpc_endpoint* secure_ep, grpc_slice_buffer* slices,
     if (result == TSI_OK) {
       size_t still_pending_size;
       do {
-        size_t protected_buffer_size_to_send = (size_t)(end - cur);
+        size_t protected_buffer_size_to_send = static_cast<size_t>(end - cur);
         gpr_mu_lock(&ep->protector_mu);
         result = tsi_frame_protector_protect_flush(
             ep->protector, cur, &protected_buffer_size_to_send,
@@ -324,8 +325,8 @@ static void endpoint_write(grpc_endpoint* secure_ep, grpc_slice_buffer* slices,
             &ep->output_buffer,
             grpc_slice_split_head(
                 &ep->write_staging_buffer,
-                (size_t)(cur -
-                         GRPC_SLICE_START_PTR(ep->write_staging_buffer))));
+                static_cast<size_t>(
+                    cur - GRPC_SLICE_START_PTR(ep->write_staging_buffer))));
       }
     }
   }
@@ -336,55 +337,53 @@ static void endpoint_write(grpc_endpoint* secure_ep, grpc_slice_buffer* slices,
     GRPC_CLOSURE_SCHED(
         cb, grpc_set_tsi_error_result(
                 GRPC_ERROR_CREATE_FROM_STATIC_STRING("Wrap failed"), result));
-    GPR_TIMER_END("secure_endpoint.endpoint_write", 0);
     return;
   }
 
   grpc_endpoint_write(ep->wrapped_ep, &ep->output_buffer, cb);
-  GPR_TIMER_END("secure_endpoint.endpoint_write", 0);
 }
 
 static void endpoint_shutdown(grpc_endpoint* secure_ep, grpc_error* why) {
-  secure_endpoint* ep = (secure_endpoint*)secure_ep;
+  secure_endpoint* ep = reinterpret_cast<secure_endpoint*>(secure_ep);
   grpc_endpoint_shutdown(ep->wrapped_ep, why);
 }
 
 static void endpoint_destroy(grpc_endpoint* secure_ep) {
-  secure_endpoint* ep = (secure_endpoint*)secure_ep;
+  secure_endpoint* ep = reinterpret_cast<secure_endpoint*>(secure_ep);
   SECURE_ENDPOINT_UNREF(ep, "destroy");
 }
 
 static void endpoint_add_to_pollset(grpc_endpoint* secure_ep,
                                     grpc_pollset* pollset) {
-  secure_endpoint* ep = (secure_endpoint*)secure_ep;
+  secure_endpoint* ep = reinterpret_cast<secure_endpoint*>(secure_ep);
   grpc_endpoint_add_to_pollset(ep->wrapped_ep, pollset);
 }
 
 static void endpoint_add_to_pollset_set(grpc_endpoint* secure_ep,
                                         grpc_pollset_set* pollset_set) {
-  secure_endpoint* ep = (secure_endpoint*)secure_ep;
+  secure_endpoint* ep = reinterpret_cast<secure_endpoint*>(secure_ep);
   grpc_endpoint_add_to_pollset_set(ep->wrapped_ep, pollset_set);
 }
 
 static void endpoint_delete_from_pollset_set(grpc_endpoint* secure_ep,
                                              grpc_pollset_set* pollset_set) {
-  secure_endpoint* ep = (secure_endpoint*)secure_ep;
+  secure_endpoint* ep = reinterpret_cast<secure_endpoint*>(secure_ep);
   grpc_endpoint_delete_from_pollset_set(ep->wrapped_ep, pollset_set);
 }
 
 static char* endpoint_get_peer(grpc_endpoint* secure_ep) {
-  secure_endpoint* ep = (secure_endpoint*)secure_ep;
+  secure_endpoint* ep = reinterpret_cast<secure_endpoint*>(secure_ep);
   return grpc_endpoint_get_peer(ep->wrapped_ep);
 }
 
 static int endpoint_get_fd(grpc_endpoint* secure_ep) {
-  secure_endpoint* ep = (secure_endpoint*)secure_ep;
+  secure_endpoint* ep = reinterpret_cast<secure_endpoint*>(secure_ep);
   return grpc_endpoint_get_fd(ep->wrapped_ep);
 }
 
 static grpc_resource_user* endpoint_get_resource_user(
     grpc_endpoint* secure_ep) {
-  secure_endpoint* ep = (secure_endpoint*)secure_ep;
+  secure_endpoint* ep = reinterpret_cast<secure_endpoint*>(secure_ep);
   return grpc_endpoint_get_resource_user(ep->wrapped_ep);
 }
 
@@ -405,7 +404,8 @@ grpc_endpoint* grpc_secure_endpoint_create(
     grpc_endpoint* transport, grpc_slice* leftover_slices,
     size_t leftover_nslices) {
   size_t i;
-  secure_endpoint* ep = (secure_endpoint*)gpr_malloc(sizeof(secure_endpoint));
+  secure_endpoint* ep =
+      static_cast<secure_endpoint*>(gpr_malloc(sizeof(secure_endpoint)));
   ep->base.vtable = &vtable;
   ep->wrapped_ep = transport;
   ep->protector = protector;

data/src/core/lib/security/transport/security_handshaker.cc

@@ -68,8 +68,8 @@ typedef struct {
 static size_t move_read_buffer_into_handshake_buffer(security_handshaker* h) {
   size_t bytes_in_read_buffer = h->args->read_buffer->length;
   if (h->handshake_buffer_size < bytes_in_read_buffer) {
-    h->handshake_buffer =
-        (uint8_t*)gpr_realloc(h->handshake_buffer, bytes_in_read_buffer);
+    h->handshake_buffer = static_cast<uint8_t*>(
+        gpr_realloc(h->handshake_buffer, bytes_in_read_buffer));
     h->handshake_buffer_size = bytes_in_read_buffer;
   }
   size_t offset = 0;
@@ -205,7 +205,7 @@ static void on_peer_checked_inner(security_handshaker* h, grpc_error* error) {
 }
 
 static void on_peer_checked(void* arg, grpc_error* error) {
-  security_handshaker* h = (security_handshaker*)arg;
+  security_handshaker* h = static_cast<security_handshaker*>(arg);
   gpr_mu_lock(&h->mu);
   on_peer_checked_inner(h, error);
   gpr_mu_unlock(&h->mu);
@@ -249,7 +249,7 @@ static grpc_error* on_handshake_next_done_locked(
   if (bytes_to_send_size > 0) {
     // Send data to peer, if needed.
     grpc_slice to_send = grpc_slice_from_copied_buffer(
-        (const char*)bytes_to_send, bytes_to_send_size);
+        reinterpret_cast<const char*>(bytes_to_send), bytes_to_send_size);
     grpc_slice_buffer_reset_and_unref_internal(&h->outgoing);
     grpc_slice_buffer_add(&h->outgoing, to_send);
     grpc_endpoint_write(h->args->endpoint, &h->outgoing,
@@ -268,7 +268,7 @@ static grpc_error* on_handshake_next_done_locked(
 static void on_handshake_next_done_grpc_wrapper(
     tsi_result result, void* user_data, const unsigned char* bytes_to_send,
     size_t bytes_to_send_size, tsi_handshaker_result* handshaker_result) {
-  security_handshaker* h = (security_handshaker*)user_data;
+  security_handshaker* h = static_cast<security_handshaker*>(user_data);
   // This callback will be invoked by TSI in a non-grpc thread, so it's
   // safe to create our own exec_ctx here.
   grpc_core::ExecCtx exec_ctx;
@@ -307,7 +307,7 @@ static grpc_error* do_handshaker_next_locked(
 }
 
 static void on_handshake_data_received_from_peer(void* arg, grpc_error* error) {
-  security_handshaker* h = (security_handshaker*)arg;
+  security_handshaker* h = static_cast<security_handshaker*>(arg);
   gpr_mu_lock(&h->mu);
   if (error != GRPC_ERROR_NONE || h->shutdown) {
     security_handshake_failed_locked(
@@ -333,7 +333,7 @@ static void on_handshake_data_received_from_peer(void* arg, grpc_error* error) {
 }
 
 static void on_handshake_data_sent_to_peer(void* arg, grpc_error* error) {
-  security_handshaker* h = (security_handshaker*)arg;
+  security_handshaker* h = static_cast<security_handshaker*>(arg);
   gpr_mu_lock(&h->mu);
   if (error != GRPC_ERROR_NONE || h->shutdown) {
     security_handshake_failed_locked(
@@ -364,13 +364,13 @@ static void on_handshake_data_sent_to_peer(void* arg, grpc_error* error) {
 //
 
 static void security_handshaker_destroy(grpc_handshaker* handshaker) {
-  security_handshaker* h = (security_handshaker*)handshaker;
+  security_handshaker* h = reinterpret_cast<security_handshaker*>(handshaker);
   security_handshaker_unref(h);
 }
 
 static void security_handshaker_shutdown(grpc_handshaker* handshaker,
                                          grpc_error* why) {
-  security_handshaker* h = (security_handshaker*)handshaker;
+  security_handshaker* h = reinterpret_cast<security_handshaker*>(handshaker);
   gpr_mu_lock(&h->mu);
   if (!h->shutdown) {
     h->shutdown = true;
@@ -385,7 +385,7 @@ static void security_handshaker_do_handshake(grpc_handshaker* handshaker,
                                              grpc_tcp_server_acceptor* acceptor,
                                              grpc_closure* on_handshake_done,
                                              grpc_handshaker_args* args) {
-  security_handshaker* h = (security_handshaker*)handshaker;
+  security_handshaker* h = reinterpret_cast<security_handshaker*>(handshaker);
   gpr_mu_lock(&h->mu);
   h->args = args;
   h->on_handshake_done = on_handshake_done;
@@ -408,15 +408,16 @@ static const grpc_handshaker_vtable security_handshaker_vtable = {
 
 static grpc_handshaker* security_handshaker_create(
     tsi_handshaker* handshaker, grpc_security_connector* connector) {
-  security_handshaker* h =
-      (security_handshaker*)gpr_zalloc(sizeof(security_handshaker));
+  security_handshaker* h = static_cast<security_handshaker*>(
+      gpr_zalloc(sizeof(security_handshaker)));
   grpc_handshaker_init(&security_handshaker_vtable, &h->base);
   h->handshaker = handshaker;
   h->connector = GRPC_SECURITY_CONNECTOR_REF(connector, "handshake");
   gpr_mu_init(&h->mu);
   gpr_ref_init(&h->refs, 1);
   h->handshake_buffer_size = GRPC_INITIAL_HANDSHAKE_BUFFER_SIZE;
-  h->handshake_buffer = (uint8_t*)gpr_malloc(h->handshake_buffer_size);
+  h->handshake_buffer =
+      static_cast<uint8_t*>(gpr_malloc(h->handshake_buffer_size));
   GRPC_CLOSURE_INIT(&h->on_handshake_data_sent_to_peer,
                     on_handshake_data_sent_to_peer, h,
                     grpc_schedule_on_exec_ctx);
@@ -456,7 +457,7 @@ static const grpc_handshaker_vtable fail_handshaker_vtable = {
     fail_handshaker_do_handshake};
 
 static grpc_handshaker* fail_handshaker_create() {
-  grpc_handshaker* h = (grpc_handshaker*)gpr_malloc(sizeof(*h));
+  grpc_handshaker* h = static_cast<grpc_handshaker*>(gpr_malloc(sizeof(*h)));
   grpc_handshaker_init(&fail_handshaker_vtable, h);
   return h;
 }
@@ -469,8 +470,8 @@ static void client_handshaker_factory_add_handshakers(
     grpc_handshaker_factory* handshaker_factory, const grpc_channel_args* args,
     grpc_handshake_manager* handshake_mgr) {
   grpc_channel_security_connector* security_connector =
-      (grpc_channel_security_connector*)grpc_security_connector_find_in_args(
-          args);
+      reinterpret_cast<grpc_channel_security_connector*>(
+          grpc_security_connector_find_in_args(args));
   grpc_channel_security_connector_add_handshakers(security_connector,
                                                   handshake_mgr);
 }
@@ -479,8 +480,8 @@ static void server_handshaker_factory_add_handshakers(
     grpc_handshaker_factory* hf, const grpc_channel_args* args,
     grpc_handshake_manager* handshake_mgr) {
   grpc_server_security_connector* security_connector =
-      (grpc_server_security_connector*)grpc_security_connector_find_in_args(
-          args);
+      reinterpret_cast<grpc_server_security_connector*>(
+          grpc_security_connector_find_in_args(args));
   grpc_server_security_connector_add_handshakers(security_connector,
                                                  handshake_mgr);
 }