grpc 1.9.1 → 1.10.0.pre1

data/src/core/lib/transport/bdp_estimator.cc

@@ -21,7 +21,7 @@
 #include <inttypes.h>
 #include <stdlib.h>
 
-#include <grpc/support/useful.h>
+#include "src/core/lib/gpr/useful.h"
 
 grpc_core::TraceFlag grpc_bdp_estimator_trace(false, "bdp_estimator");
 
@@ -40,8 +40,9 @@ BdpEstimator::BdpEstimator(const char* name)
 grpc_millis BdpEstimator::CompletePing() {
   gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);
   gpr_timespec dt_ts = gpr_time_sub(now, ping_start_time_);
-  double dt = (double)dt_ts.tv_sec + 1e-9 * (double)dt_ts.tv_nsec;
-  double bw = dt > 0 ? ((double)accumulator_ / dt) : 0;
+  double dt = static_cast<double>(dt_ts.tv_sec) +
+              1e-9 * static_cast<double>(dt_ts.tv_nsec);
+  double bw = dt > 0 ? (static_cast<double>(accumulator_) / dt) : 0;
   int start_inter_ping_delay = inter_ping_delay_;
   if (grpc_bdp_estimator_trace.enabled()) {
     gpr_log(GPR_DEBUG,
@@ -64,8 +65,8 @@ grpc_millis BdpEstimator::CompletePing() {
     stable_estimate_count_++;
     if (stable_estimate_count_ >= 2) {
       inter_ping_delay_ +=
-          100 +
-          (int)(rand() * 100.0 / RAND_MAX);  // if the ping estimate is steady,
+          100 + static_cast<int>(rand() * 100.0 /
+                                 RAND_MAX);  // if the ping estimate is steady,
                                              // slowly ramp down the probe time
     }
   }

data/src/core/lib/transport/byte_stream.cc

@@ -49,34 +49,38 @@ void grpc_byte_stream_destroy(grpc_byte_stream* byte_stream) {
 static bool slice_buffer_stream_next(grpc_byte_stream* byte_stream,
                                      size_t max_size_hint,
                                      grpc_closure* on_complete) {
-  grpc_slice_buffer_stream* stream = (grpc_slice_buffer_stream*)byte_stream;
-  GPR_ASSERT(stream->cursor < stream->backing_buffer->count);
+  grpc_slice_buffer_stream* stream =
+      reinterpret_cast<grpc_slice_buffer_stream*>(byte_stream);
+  GPR_ASSERT(stream->cursor < stream->backing_buffer.count);
   return true;
 }
 
 static grpc_error* slice_buffer_stream_pull(grpc_byte_stream* byte_stream,
                                             grpc_slice* slice) {
-  grpc_slice_buffer_stream* stream = (grpc_slice_buffer_stream*)byte_stream;
+  grpc_slice_buffer_stream* stream =
+      reinterpret_cast<grpc_slice_buffer_stream*>(byte_stream);
   if (stream->shutdown_error != GRPC_ERROR_NONE) {
     return GRPC_ERROR_REF(stream->shutdown_error);
   }
-  GPR_ASSERT(stream->cursor < stream->backing_buffer->count);
+  GPR_ASSERT(stream->cursor < stream->backing_buffer.count);
   *slice =
-      grpc_slice_ref_internal(stream->backing_buffer->slices[stream->cursor]);
+      grpc_slice_ref_internal(stream->backing_buffer.slices[stream->cursor]);
   stream->cursor++;
   return GRPC_ERROR_NONE;
 }
 
 static void slice_buffer_stream_shutdown(grpc_byte_stream* byte_stream,
                                          grpc_error* error) {
-  grpc_slice_buffer_stream* stream = (grpc_slice_buffer_stream*)byte_stream;
+  grpc_slice_buffer_stream* stream =
+      reinterpret_cast<grpc_slice_buffer_stream*>(byte_stream);
   GRPC_ERROR_UNREF(stream->shutdown_error);
   stream->shutdown_error = error;
 }
 
 static void slice_buffer_stream_destroy(grpc_byte_stream* byte_stream) {
-  grpc_slice_buffer_stream* stream = (grpc_slice_buffer_stream*)byte_stream;
-  grpc_slice_buffer_reset_and_unref_internal(stream->backing_buffer);
+  grpc_slice_buffer_stream* stream =
+      reinterpret_cast<grpc_slice_buffer_stream*>(byte_stream);
+  grpc_slice_buffer_destroy(&stream->backing_buffer);
   GRPC_ERROR_UNREF(stream->shutdown_error);
 }
 
@@ -88,10 +92,11 @@ void grpc_slice_buffer_stream_init(grpc_slice_buffer_stream* stream,
                                    grpc_slice_buffer* slice_buffer,
                                    uint32_t flags) {
   GPR_ASSERT(slice_buffer->length <= UINT32_MAX);
-  stream->base.length = (uint32_t)slice_buffer->length;
+  stream->base.length = static_cast<uint32_t>(slice_buffer->length);
   stream->base.flags = flags;
   stream->base.vtable = &slice_buffer_stream_vtable;
-  stream->backing_buffer = slice_buffer;
+  grpc_slice_buffer_init(&stream->backing_buffer);
+  grpc_slice_buffer_swap(slice_buffer, &stream->backing_buffer);
   stream->cursor = 0;
   stream->shutdown_error = GRPC_ERROR_NONE;
 }
@@ -112,7 +117,8 @@ void grpc_byte_stream_cache_destroy(grpc_byte_stream_cache* cache) {
 static bool caching_byte_stream_next(grpc_byte_stream* byte_stream,
                                      size_t max_size_hint,
                                      grpc_closure* on_complete) {
-  grpc_caching_byte_stream* stream = (grpc_caching_byte_stream*)byte_stream;
+  grpc_caching_byte_stream* stream =
+      reinterpret_cast<grpc_caching_byte_stream*>(byte_stream);
   if (stream->shutdown_error != GRPC_ERROR_NONE) return true;
   if (stream->cursor < stream->cache->cache_buffer.count) return true;
   return grpc_byte_stream_next(stream->cache->underlying_stream, max_size_hint,
@@ -121,7 +127,8 @@ static bool caching_byte_stream_next(grpc_byte_stream* byte_stream,
 
 static grpc_error* caching_byte_stream_pull(grpc_byte_stream* byte_stream,
                                             grpc_slice* slice) {
-  grpc_caching_byte_stream* stream = (grpc_caching_byte_stream*)byte_stream;
+  grpc_caching_byte_stream* stream =
+      reinterpret_cast<grpc_caching_byte_stream*>(byte_stream);
   if (stream->shutdown_error != GRPC_ERROR_NONE) {
     return GRPC_ERROR_REF(stream->shutdown_error);
   }
@@ -143,14 +150,16 @@ static grpc_error* caching_byte_stream_pull(grpc_byte_stream* byte_stream,
 
 static void caching_byte_stream_shutdown(grpc_byte_stream* byte_stream,
                                          grpc_error* error) {
-  grpc_caching_byte_stream* stream = (grpc_caching_byte_stream*)byte_stream;
+  grpc_caching_byte_stream* stream =
+      reinterpret_cast<grpc_caching_byte_stream*>(byte_stream);
   GRPC_ERROR_UNREF(stream->shutdown_error);
   stream->shutdown_error = GRPC_ERROR_REF(error);
   grpc_byte_stream_shutdown(stream->cache->underlying_stream, error);
 }
 
 static void caching_byte_stream_destroy(grpc_byte_stream* byte_stream) {
-  grpc_caching_byte_stream* stream = (grpc_caching_byte_stream*)byte_stream;
+  grpc_caching_byte_stream* stream =
+      reinterpret_cast<grpc_caching_byte_stream*>(byte_stream);
   GRPC_ERROR_UNREF(stream->shutdown_error);
 }
 

data/src/core/lib/transport/byte_stream.h

@@ -81,7 +81,7 @@ void grpc_byte_stream_destroy(grpc_byte_stream* byte_stream);
 
 typedef struct grpc_slice_buffer_stream {
   grpc_byte_stream base;
-  grpc_slice_buffer* backing_buffer;
+  grpc_slice_buffer backing_buffer;
   size_t cursor;
   grpc_error* shutdown_error;
 } grpc_slice_buffer_stream;

data/src/core/lib/transport/connectivity_state.cc

@@ -73,9 +73,8 @@ void grpc_connectivity_state_destroy(grpc_connectivity_state_tracker* tracker) {
 
 grpc_connectivity_state grpc_connectivity_state_check(
     grpc_connectivity_state_tracker* tracker) {
-  grpc_connectivity_state cur =
-      (grpc_connectivity_state)gpr_atm_no_barrier_load(
-          &tracker->current_state_atm);
+  grpc_connectivity_state cur = static_cast<grpc_connectivity_state>(
+      gpr_atm_no_barrier_load(&tracker->current_state_atm));
   if (grpc_connectivity_state_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CONWATCH: %p %s: get %s", tracker, tracker->name,
             grpc_connectivity_state_name(cur));
@@ -85,9 +84,8 @@ grpc_connectivity_state grpc_connectivity_state_check(
 
 grpc_connectivity_state grpc_connectivity_state_get(
     grpc_connectivity_state_tracker* tracker, grpc_error** error) {
-  grpc_connectivity_state cur =
-      (grpc_connectivity_state)gpr_atm_no_barrier_load(
-          &tracker->current_state_atm);
+  grpc_connectivity_state cur = static_cast<grpc_connectivity_state>(
+      gpr_atm_no_barrier_load(&tracker->current_state_atm));
   if (grpc_connectivity_state_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CONWATCH: %p %s: get %s", tracker, tracker->name,
             grpc_connectivity_state_name(cur));
@@ -106,9 +104,8 @@ bool grpc_connectivity_state_has_watchers(
 bool grpc_connectivity_state_notify_on_state_change(
     grpc_connectivity_state_tracker* tracker, grpc_connectivity_state* current,
     grpc_closure* notify) {
-  grpc_connectivity_state cur =
-      (grpc_connectivity_state)gpr_atm_no_barrier_load(
-          &tracker->current_state_atm);
+  grpc_connectivity_state cur = static_cast<grpc_connectivity_state>(
+      gpr_atm_no_barrier_load(&tracker->current_state_atm));
   if (grpc_connectivity_state_trace.enabled()) {
     if (current == nullptr) {
       gpr_log(GPR_DEBUG, "CONWATCH: %p %s: unsubscribe notify=%p", tracker,
@@ -144,7 +141,7 @@ bool grpc_connectivity_state_notify_on_state_change(
       GRPC_CLOSURE_SCHED(notify, GRPC_ERROR_REF(tracker->current_error));
     } else {
       grpc_connectivity_state_watcher* w =
-          (grpc_connectivity_state_watcher*)gpr_malloc(sizeof(*w));
+          static_cast<grpc_connectivity_state_watcher*>(gpr_malloc(sizeof(*w)));
       w->current = current;
       w->notify = notify;
       w->next = tracker->watchers;
@@ -157,9 +154,8 @@ bool grpc_connectivity_state_notify_on_state_change(
 void grpc_connectivity_state_set(grpc_connectivity_state_tracker* tracker,
                                  grpc_connectivity_state state,
                                  grpc_error* error, const char* reason) {
-  grpc_connectivity_state cur =
-      (grpc_connectivity_state)gpr_atm_no_barrier_load(
-          &tracker->current_state_atm);
+  grpc_connectivity_state cur = static_cast<grpc_connectivity_state>(
+      gpr_atm_no_barrier_load(&tracker->current_state_atm));
   grpc_connectivity_state_watcher* w;
   if (grpc_connectivity_state_trace.enabled()) {
     const char* error_string = grpc_error_string(error);

data/src/core/lib/transport/error_utils.cc

@@ -32,7 +32,8 @@ static grpc_error* recursively_find_error_with_field(grpc_error* error,
   // Otherwise, search through its children.
   uint8_t slot = error->first_err;
   while (slot != UINT8_MAX) {
-    grpc_linked_error* lerr = (grpc_linked_error*)(error->arena + slot);
+    grpc_linked_error* lerr =
+        reinterpret_cast<grpc_linked_error*>(error->arena + slot);
     grpc_error* result = recursively_find_error_with_field(lerr->err, which);
     if (result) return result;
     slot = lerr->next;
@@ -62,11 +63,11 @@ void grpc_error_get_status(grpc_error* error, grpc_millis deadline,
   grpc_status_code status = GRPC_STATUS_UNKNOWN;
   intptr_t integer;
   if (grpc_error_get_int(found_error, GRPC_ERROR_INT_GRPC_STATUS, &integer)) {
-    status = (grpc_status_code)integer;
+    status = static_cast<grpc_status_code>(integer);
   } else if (grpc_error_get_int(found_error, GRPC_ERROR_INT_HTTP2_ERROR,
                                 &integer)) {
-    status = grpc_http2_error_to_grpc_status((grpc_http2_error_code)integer,
-                                             deadline);
+    status = grpc_http2_error_to_grpc_status(
+        static_cast<grpc_http2_error_code>(integer), deadline);
   }
   if (code != nullptr) *code = status;
 
@@ -76,10 +77,11 @@ void grpc_error_get_status(grpc_error* error, grpc_millis deadline,
 
   if (http_error != nullptr) {
     if (grpc_error_get_int(found_error, GRPC_ERROR_INT_HTTP2_ERROR, &integer)) {
-      *http_error = (grpc_http2_error_code)integer;
+      *http_error = static_cast<grpc_http2_error_code>(integer);
     } else if (grpc_error_get_int(found_error, GRPC_ERROR_INT_GRPC_STATUS,
                                   &integer)) {
-      *http_error = grpc_status_to_http2_error((grpc_status_code)integer);
+      *http_error =
+          grpc_status_to_http2_error(static_cast<grpc_status_code>(integer));
     } else {
       *http_error = found_error == GRPC_ERROR_NONE ? GRPC_HTTP2_NO_ERROR
                                                    : GRPC_HTTP2_INTERNAL_ERROR;
@@ -103,7 +105,8 @@ bool grpc_error_has_clear_grpc_status(grpc_error* error) {
   }
   uint8_t slot = error->first_err;
   while (slot != UINT8_MAX) {
-    grpc_linked_error* lerr = (grpc_linked_error*)(error->arena + slot);
+    grpc_linked_error* lerr =
+        reinterpret_cast<grpc_linked_error*>(error->arena + slot);
     if (grpc_error_has_clear_grpc_status(lerr->err)) {
       return true;
     }

data/src/core/lib/transport/metadata.cc

@@ -118,8 +118,8 @@ void grpc_mdctx_global_init(void) {
     shard->count = 0;
     gpr_atm_no_barrier_store(&shard->free_estimate, 0);
     shard->capacity = INITIAL_SHARD_CAPACITY;
-    shard->elems = (interned_metadata**)gpr_zalloc(sizeof(*shard->elems) *
-                                                   shard->capacity);
+    shard->elems = static_cast<interned_metadata**>(
+        gpr_zalloc(sizeof(*shard->elems) * shard->capacity));
   }
 }
 
@@ -166,12 +166,13 @@ static void ref_md_locked(mdtab_shard* shard,
 }
 
 static void gc_mdtab(mdtab_shard* shard) {
+  GPR_TIMER_SCOPE("gc_mdtab", 0);
+
   size_t i;
   interned_metadata** prev_next;
   interned_metadata *md, *next;
   gpr_atm num_freed = 0;
 
-  GPR_TIMER_BEGIN("gc_mdtab", 0);
   for (i = 0; i < shard->capacity; i++) {
     prev_next = &shard->elems[i];
     for (md = shard->elems[i]; md; md = next) {
@@ -194,20 +195,19 @@ static void gc_mdtab(mdtab_shard* shard) {
     }
   }
   gpr_atm_no_barrier_fetch_add(&shard->free_estimate, -num_freed);
-  GPR_TIMER_END("gc_mdtab", 0);
 }
 
 static void grow_mdtab(mdtab_shard* shard) {
+  GPR_TIMER_SCOPE("grow_mdtab", 0);
+
   size_t capacity = shard->capacity * 2;
   size_t i;
   interned_metadata** mdtab;
   interned_metadata *md, *next;
   uint32_t hash;
 
-  GPR_TIMER_BEGIN("grow_mdtab", 0);
-
-  mdtab =
-      (interned_metadata**)gpr_zalloc(sizeof(interned_metadata*) * capacity);
+  mdtab = static_cast<interned_metadata**>(
+      gpr_zalloc(sizeof(interned_metadata*) * capacity));
 
   for (i = 0; i < shard->capacity; i++) {
     for (md = shard->elems[i]; md; md = next) {
@@ -220,17 +220,14 @@ static void grow_mdtab(mdtab_shard* shard) {
       mdtab[idx] = md;
     }
   }
-
   gpr_free(shard->elems);
   shard->elems = mdtab;
   shard->capacity = capacity;
-
-  GPR_TIMER_END("grow_mdtab", 0);
 }
 
 static void rehash_mdtab(mdtab_shard* shard) {
   if (gpr_atm_no_barrier_load(&shard->free_estimate) >
-      (gpr_atm)(shard->capacity / 4)) {
+      static_cast<gpr_atm>(shard->capacity / 4)) {
     gc_mdtab(shard);
   } else {
     grow_mdtab(shard);
@@ -247,7 +244,7 @@ grpc_mdelem grpc_mdelem_create(
     }
 
     allocated_metadata* allocated =
-        (allocated_metadata*)gpr_malloc(sizeof(*allocated));
+        static_cast<allocated_metadata*>(gpr_malloc(sizeof(*allocated)));
     allocated->key = grpc_slice_ref_internal(key);
     allocated->value = grpc_slice_ref_internal(value);
     gpr_atm_rel_store(&allocated->refcnt, 1);
@@ -280,7 +277,7 @@ grpc_mdelem grpc_mdelem_create(
   mdtab_shard* shard = &g_shards[SHARD_IDX(hash)];
   size_t idx;
 
-  GPR_TIMER_BEGIN("grpc_mdelem_from_metadata_strings", 0);
+  GPR_TIMER_SCOPE("grpc_mdelem_from_metadata_strings", 0);
 
   gpr_mu_lock(&shard->mu);
 
@@ -290,13 +287,12 @@ grpc_mdelem grpc_mdelem_create(
     if (grpc_slice_eq(key, md->key) && grpc_slice_eq(value, md->value)) {
       REF_MD_LOCKED(shard, md);
       gpr_mu_unlock(&shard->mu);
-      GPR_TIMER_END("grpc_mdelem_from_metadata_strings", 0);
       return GRPC_MAKE_MDELEM(md, GRPC_MDELEM_STORAGE_INTERNED);
     }
   }
 
   /* not found: create a new pair */
-  md = (interned_metadata*)gpr_malloc(sizeof(interned_metadata));
+  md = static_cast<interned_metadata*>(gpr_malloc(sizeof(interned_metadata)));
   gpr_atm_rel_store(&md->refcnt, 1);
   md->key = grpc_slice_ref_internal(key);
   md->value = grpc_slice_ref_internal(value);
@@ -323,8 +319,6 @@ grpc_mdelem grpc_mdelem_create(
 
   gpr_mu_unlock(&shard->mu);
 
-  GPR_TIMER_END("grpc_mdelem_from_metadata_strings", 0);
-
   return GRPC_MAKE_MDELEM(md, GRPC_MDELEM_STORAGE_INTERNED);
 }
 
@@ -341,8 +335,9 @@ grpc_mdelem grpc_mdelem_from_grpc_metadata(grpc_metadata* metadata) {
       grpc_slice_maybe_static_intern(metadata->key, &changed);
   grpc_slice value_slice =
       grpc_slice_maybe_static_intern(metadata->value, &changed);
-  return grpc_mdelem_create(key_slice, value_slice,
-                            changed ? nullptr : (grpc_mdelem_data*)metadata);
+  return grpc_mdelem_create(
+      key_slice, value_slice,
+      changed ? nullptr : reinterpret_cast<grpc_mdelem_data*>(metadata));
 }
 
 static size_t get_base64_encoded_size(size_t raw_length) {
@@ -369,7 +364,8 @@ grpc_mdelem grpc_mdelem_ref(grpc_mdelem gmd DEBUG_ARGS) {
     case GRPC_MDELEM_STORAGE_STATIC:
       break;
     case GRPC_MDELEM_STORAGE_INTERNED: {
-      interned_metadata* md = (interned_metadata*)GRPC_MDELEM_DATA(gmd);
+      interned_metadata* md =
+          reinterpret_cast<interned_metadata*> GRPC_MDELEM_DATA(gmd);
 #ifndef NDEBUG
       if (grpc_trace_metadata.enabled()) {
         char* key_str = grpc_slice_to_c_string(md->key);
@@ -391,7 +387,8 @@ grpc_mdelem grpc_mdelem_ref(grpc_mdelem gmd DEBUG_ARGS) {
       break;
     }
     case GRPC_MDELEM_STORAGE_ALLOCATED: {
-      allocated_metadata* md = (allocated_metadata*)GRPC_MDELEM_DATA(gmd);
+      allocated_metadata* md =
+          reinterpret_cast<allocated_metadata*> GRPC_MDELEM_DATA(gmd);
 #ifndef NDEBUG
       if (grpc_trace_metadata.enabled()) {
         char* key_str = grpc_slice_to_c_string(md->key);
@@ -421,7 +418,8 @@ void grpc_mdelem_unref(grpc_mdelem gmd DEBUG_ARGS) {
     case GRPC_MDELEM_STORAGE_STATIC:
       break;
     case GRPC_MDELEM_STORAGE_INTERNED: {
-      interned_metadata* md = (interned_metadata*)GRPC_MDELEM_DATA(gmd);
+      interned_metadata* md =
+          reinterpret_cast<interned_metadata*> GRPC_MDELEM_DATA(gmd);
 #ifndef NDEBUG
       if (grpc_trace_metadata.enabled()) {
         char* key_str = grpc_slice_to_c_string(md->key);
@@ -447,7 +445,8 @@ void grpc_mdelem_unref(grpc_mdelem gmd DEBUG_ARGS) {
       break;
     }
     case GRPC_MDELEM_STORAGE_ALLOCATED: {
-      allocated_metadata* md = (allocated_metadata*)GRPC_MDELEM_DATA(gmd);
+      allocated_metadata* md =
+          reinterpret_cast<allocated_metadata*> GRPC_MDELEM_DATA(gmd);
 #ifndef NDEBUG
       if (grpc_trace_metadata.enabled()) {
         char* key_str = grpc_slice_to_c_string(md->key);
@@ -481,7 +480,8 @@ void* grpc_mdelem_get_user_data(grpc_mdelem md, void (*destroy_func)(void*)) {
       return (void*)grpc_static_mdelem_user_data[GRPC_MDELEM_DATA(md) -
                                                  grpc_static_mdelem_table];
     case GRPC_MDELEM_STORAGE_INTERNED: {
-      interned_metadata* im = (interned_metadata*)GRPC_MDELEM_DATA(md);
+      interned_metadata* im =
+          reinterpret_cast<interned_metadata*> GRPC_MDELEM_DATA(md);
       void* result;
       if (gpr_atm_acq_load(&im->destroy_user_data) == (gpr_atm)destroy_func) {
         return (void*)gpr_atm_no_barrier_load(&im->user_data);
@@ -506,7 +506,8 @@ void* grpc_mdelem_set_user_data(grpc_mdelem md, void (*destroy_func)(void*),
       return (void*)grpc_static_mdelem_user_data[GRPC_MDELEM_DATA(md) -
                                                  grpc_static_mdelem_table];
     case GRPC_MDELEM_STORAGE_INTERNED: {
-      interned_metadata* im = (interned_metadata*)GRPC_MDELEM_DATA(md);
+      interned_metadata* im =
+          reinterpret_cast<interned_metadata*> GRPC_MDELEM_DATA(md);
       GPR_ASSERT(!is_mdelem_static(md));
       GPR_ASSERT((user_data == nullptr) == (destroy_func == nullptr));
       gpr_mu_lock(&im->mu_user_data);

data/src/core/lib/transport/metadata.h

@@ -21,8 +21,8 @@
 
 #include <grpc/grpc.h>
 #include <grpc/slice.h>
-#include <grpc/support/useful.h>
 
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
 extern grpc_core::DebugOnlyTraceFlag grpc_trace_metadata;

data/src/core/lib/transport/pid_controller.cc

@@ -17,7 +17,8 @@
  */
 
 #include "src/core/lib/transport/pid_controller.h"
-#include <grpc/support/useful.h>
+
+#include "src/core/lib/gpr/useful.h"
 
 namespace grpc_core {
 

data/src/core/lib/transport/service_config.cc

@@ -60,7 +60,7 @@ struct grpc_service_config {
 
 grpc_service_config* grpc_service_config_create(const char* json_string) {
   grpc_service_config* service_config =
-      (grpc_service_config*)gpr_malloc(sizeof(*service_config));
+      static_cast<grpc_service_config*>(gpr_malloc(sizeof(*service_config)));
   service_config->json_string = gpr_strdup(json_string);
   service_config->json_tree =
       grpc_json_parse_string(service_config->json_string);
@@ -209,8 +209,8 @@ grpc_slice_hash_table* grpc_service_config_create_method_config_table(
         num_entries += count;
       }
       // Populate method config table entries.
-      entries = (grpc_slice_hash_table_entry*)gpr_malloc(
-          num_entries * sizeof(grpc_slice_hash_table_entry));
+      entries = static_cast<grpc_slice_hash_table_entry*>(
+          gpr_malloc(num_entries * sizeof(grpc_slice_hash_table_entry)));
       size_t idx = 0;
       for (grpc_json* method = field->child; method != nullptr;
            method = method->next) {
@@ -245,8 +245,8 @@ void* grpc_method_config_table_get(const grpc_slice_hash_table* table,
   if (value == nullptr) {
     char* path_str = grpc_slice_to_c_string(path);
     const char* sep = strrchr(path_str, '/') + 1;
-    const size_t len = (size_t)(sep - path_str);
-    char* buf = (char*)gpr_malloc(len + 2);  // '*' and NUL
+    const size_t len = static_cast<size_t>(sep - path_str);
+    char* buf = static_cast<char*>(gpr_malloc(len + 2));  // '*' and NUL
     memcpy(buf, path_str, len);
     buf[len] = '*';
     buf[len + 1] = '\0';