grpc 1.9.1 → 1.10.0.pre1

data/src/core/lib/surface/call_test_only.h

@@ -21,7 +21,7 @@
 
 #include <grpc/grpc.h>
 
-/** Return the compression algorithm from \a call.
+/** Return the message compression algorithm from \a call.
  *
  * \warning This function should \b only be used in test code. */
 grpc_compression_algorithm grpc_call_test_only_get_compression_algorithm(
@@ -38,16 +38,4 @@ uint32_t grpc_call_test_only_get_message_flags(grpc_call* call);
  * To be indexed by grpc_compression_algorithm enum values. */
 uint32_t grpc_call_test_only_get_encodings_accepted_by_peer(grpc_call* call);
 
-/** Returns a bitset for the stream encodings (stream compression algorithms)
- * supported by \a call's peer.
- *
- * To be indexed by grpc_stream_compression_algorithm enum values. */
-uint32_t grpc_call_test_only_get_stream_encodings_accepted_by_peer(
-    grpc_call* call);
-
-/** Returns the incoming stream compression algorithm (content-encoding header)
- * received by a call. */
-grpc_stream_compression_algorithm
-grpc_call_test_only_get_incoming_stream_encodings(grpc_call* call);
-
 #endif /* GRPC_CORE_LIB_SURFACE_CALL_TEST_ONLY_H */

data/src/core/lib/surface/channel.cc

@@ -85,7 +85,7 @@ grpc_channel* grpc_channel_create_with_builder(
   }
   grpc_error* error = grpc_channel_stack_builder_finish(
       builder, sizeof(grpc_channel), 1, destroy_channel, nullptr,
-      (void**)&channel);
+      reinterpret_cast<void**>(&channel));
   if (error != GRPC_ERROR_NONE) {
     gpr_log(GPR_ERROR, "channel stack builder failed: %s",
             grpc_error_string(error));
@@ -142,49 +142,22 @@ grpc_channel* grpc_channel_create_with_builder(
                            GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL)) {
       channel->compression_options.default_level.is_set = true;
       channel->compression_options.default_level.level =
-          (grpc_compression_level)grpc_channel_arg_get_integer(
+          static_cast<grpc_compression_level>(grpc_channel_arg_get_integer(
               &args->args[i],
               {GRPC_COMPRESS_LEVEL_NONE, GRPC_COMPRESS_LEVEL_NONE,
-               GRPC_COMPRESS_LEVEL_COUNT - 1});
-    } else if (0 == strcmp(args->args[i].key,
-                           GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_LEVEL)) {
-      channel->compression_options.default_stream_compression_level.is_set =
-          true;
-      channel->compression_options.default_stream_compression_level.level =
-          (grpc_stream_compression_level)grpc_channel_arg_get_integer(
-              &args->args[i],
-              {GRPC_STREAM_COMPRESS_LEVEL_NONE, GRPC_STREAM_COMPRESS_LEVEL_NONE,
-               GRPC_STREAM_COMPRESS_LEVEL_COUNT - 1});
+               GRPC_COMPRESS_LEVEL_COUNT - 1}));
     } else if (0 == strcmp(args->args[i].key,
                            GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM)) {
       channel->compression_options.default_algorithm.is_set = true;
       channel->compression_options.default_algorithm.algorithm =
-          (grpc_compression_algorithm)grpc_channel_arg_get_integer(
+          static_cast<grpc_compression_algorithm>(grpc_channel_arg_get_integer(
               &args->args[i], {GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
-                               GRPC_COMPRESS_ALGORITHMS_COUNT - 1});
-    } else if (0 == strcmp(args->args[i].key,
-                           GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM)) {
-      channel->compression_options.default_stream_compression_algorithm.is_set =
-          true;
-      channel->compression_options.default_stream_compression_algorithm
-          .algorithm =
-          (grpc_stream_compression_algorithm)grpc_channel_arg_get_integer(
-              &args->args[i],
-              {GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_NONE,
-               GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT - 1});
+                               GRPC_COMPRESS_ALGORITHMS_COUNT - 1}));
     } else if (0 ==
                strcmp(args->args[i].key,
                       GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET)) {
       channel->compression_options.enabled_algorithms_bitset =
-          (uint32_t)args->args[i].value.integer |
-          0x1; /* always support no compression */
-    } else if (0 ==
-               strcmp(
-                   args->args[i].key,
-                   GRPC_STREAM_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET)) {
-      channel->compression_options
-          .enabled_stream_compression_algorithms_bitset =
-          (uint32_t)args->args[i].value.integer |
+          static_cast<uint32_t>(args->args[i].value.integer) |
           0x1; /* always support no compression */
     }
   }
@@ -217,26 +190,29 @@ size_t grpc_channel_get_call_size_estimate(grpc_channel* channel) {
          (which is common) - which tends to help most allocators reuse memory
       2. a small amount of allowed growth over the estimate without hitting
          the arena size doubling case, reducing overall memory usage */
-  return ((size_t)gpr_atm_no_barrier_load(&channel->call_size_estimate) +
+  return (static_cast<size_t>(
+              gpr_atm_no_barrier_load(&channel->call_size_estimate)) +
           2 * ROUND_UP_SIZE) &
-         ~(size_t)(ROUND_UP_SIZE - 1);
+         ~static_cast<size_t>(ROUND_UP_SIZE - 1);
 }
 
 void grpc_channel_update_call_size_estimate(grpc_channel* channel,
                                             size_t size) {
-  size_t cur = (size_t)gpr_atm_no_barrier_load(&channel->call_size_estimate);
+  size_t cur = static_cast<size_t>(
+      gpr_atm_no_barrier_load(&channel->call_size_estimate));
   if (cur < size) {
     /* size grew: update estimate */
-    gpr_atm_no_barrier_cas(&channel->call_size_estimate, (gpr_atm)cur,
-                           (gpr_atm)size);
+    gpr_atm_no_barrier_cas(&channel->call_size_estimate,
+                           static_cast<gpr_atm>(cur),
+                           static_cast<gpr_atm>(size));
     /* if we lose: never mind, something else will likely update soon enough */
   } else if (cur == size) {
     /* no change: holding pattern */
   } else if (cur > 0) {
     /* size shrank: decrease estimate */
     gpr_atm_no_barrier_cas(
-        &channel->call_size_estimate, (gpr_atm)cur,
-        (gpr_atm)(GPR_MIN(cur - 1, (255 * cur + size) / 256)));
+        &channel->call_size_estimate, static_cast<gpr_atm>(cur),
+        static_cast<gpr_atm>(GPR_MIN(cur - 1, (255 * cur + size) / 256)));
     /* if we lose: never mind, something else will likely update soon enough */
   }
 }
@@ -324,7 +300,8 @@ grpc_call* grpc_channel_create_pollset_set_call(
 
 void* grpc_channel_register_call(grpc_channel* channel, const char* method,
                                  const char* host, void* reserved) {
-  registered_call* rc = (registered_call*)gpr_malloc(sizeof(registered_call));
+  registered_call* rc =
+      static_cast<registered_call*>(gpr_malloc(sizeof(registered_call)));
   GRPC_API_TRACE(
       "grpc_channel_register_call(channel=%p, method=%s, host=%s, reserved=%p)",
       4, (channel, method, host, reserved));
@@ -351,7 +328,7 @@ grpc_call* grpc_channel_create_registered_call(
     grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
     grpc_completion_queue* completion_queue, void* registered_call_handle,
     gpr_timespec deadline, void* reserved) {
-  registered_call* rc = (registered_call*)registered_call_handle;
+  registered_call* rc = static_cast<registered_call*>(registered_call_handle);
   GRPC_API_TRACE(
       "grpc_channel_create_registered_call("
       "channel=%p, parent_call=%p, propagation_mask=%x, completion_queue=%p, "
@@ -389,7 +366,7 @@ void grpc_channel_internal_unref(grpc_channel* c REF_ARG) {
 }
 
 static void destroy_channel(void* arg, grpc_error* error) {
-  grpc_channel* channel = (grpc_channel*)arg;
+  grpc_channel* channel = static_cast<grpc_channel*>(arg);
   grpc_channel_stack_destroy(CHANNEL_STACK_FROM_CHANNEL(channel));
   while (channel->registered_calls) {
     registered_call* rc = channel->registered_calls;

data/src/core/lib/surface/channel_init.cc

@@ -19,7 +19,6 @@
 #include "src/core/lib/surface/channel_init.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/useful.h>
 
 typedef struct stage_slot {
   grpc_channel_init_stage fn;
@@ -53,9 +52,9 @@ void grpc_channel_init_register_stage(grpc_channel_stack_type type,
   GPR_ASSERT(!g_finalized);
   if (g_slots[type].cap_slots == g_slots[type].num_slots) {
     g_slots[type].cap_slots = GPR_MAX(8, 3 * g_slots[type].cap_slots / 2);
-    g_slots[type].slots = (stage_slot*)gpr_realloc(
-        g_slots[type].slots,
-        g_slots[type].cap_slots * sizeof(*g_slots[type].slots));
+    g_slots[type].slots = static_cast<stage_slot*>(
+        gpr_realloc(g_slots[type].slots,
+                    g_slots[type].cap_slots * sizeof(*g_slots[type].slots)));
   }
   stage_slot* s = &g_slots[type].slots[g_slots[type].num_slots++];
   s->insertion_order = g_slots[type].num_slots;
@@ -65,8 +64,8 @@ void grpc_channel_init_register_stage(grpc_channel_stack_type type,
 }
 
 static int compare_slots(const void* a, const void* b) {
-  const stage_slot* sa = (const stage_slot*)a;
-  const stage_slot* sb = (const stage_slot*)b;
+  const stage_slot* sa = static_cast<const stage_slot*>(a);
+  const stage_slot* sb = static_cast<const stage_slot*>(b);
 
   int c = GPR_ICMP(sa->priority, sb->priority);
   if (c != 0) return c;
@@ -85,7 +84,8 @@ void grpc_channel_init_finalize(void) {
 void grpc_channel_init_shutdown(void) {
   for (int i = 0; i < GRPC_NUM_CHANNEL_STACK_TYPES; i++) {
     gpr_free(g_slots[i].slots);
-    g_slots[i].slots = (stage_slot*)(void*)(uintptr_t)0xdeadbeef;
+    g_slots[i].slots =
+        static_cast<stage_slot*>((void*)static_cast<uintptr_t>(0xdeadbeef));
   }
 }
 

data/src/core/lib/surface/channel_ping.cc

@@ -38,7 +38,7 @@ static void ping_destroy(void* arg, grpc_cq_completion* storage) {
 }
 
 static void ping_done(void* arg, grpc_error* error) {
-  ping_result* pr = (ping_result*)arg;
+  ping_result* pr = static_cast<ping_result*>(arg);
   grpc_cq_end_op(pr->cq, pr->tag, GRPC_ERROR_REF(error), ping_destroy, pr,
                  &pr->completion_storage);
 }
@@ -48,7 +48,7 @@ void grpc_channel_ping(grpc_channel* channel, grpc_completion_queue* cq,
   GRPC_API_TRACE("grpc_channel_ping(channel=%p, cq=%p, tag=%p, reserved=%p)", 4,
                  (channel, cq, tag, reserved));
   grpc_transport_op* op = grpc_make_transport_op(nullptr);
-  ping_result* pr = (ping_result*)gpr_malloc(sizeof(*pr));
+  ping_result* pr = static_cast<ping_result*>(gpr_malloc(sizeof(*pr)));
   grpc_channel_element* top_elem =
       grpc_channel_stack_element(grpc_channel_get_channel_stack(channel), 0);
   grpc_core::ExecCtx exec_ctx;

data/src/core/lib/surface/completion_queue.cc

@@ -28,11 +28,11 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
-#include <grpc/support/tls.h>
 
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/gpr/spinlock.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/profiling/timers.h"
@@ -88,24 +88,24 @@ static size_t non_polling_poller_size(void) {
 }
 
 static void non_polling_poller_init(grpc_pollset* pollset, gpr_mu** mu) {
-  non_polling_poller* npp = (non_polling_poller*)pollset;
+  non_polling_poller* npp = reinterpret_cast<non_polling_poller*>(pollset);
   gpr_mu_init(&npp->mu);
   *mu = &npp->mu;
 }
 
 static void non_polling_poller_destroy(grpc_pollset* pollset) {
-  non_polling_poller* npp = (non_polling_poller*)pollset;
+  non_polling_poller* npp = reinterpret_cast<non_polling_poller*>(pollset);
   gpr_mu_destroy(&npp->mu);
 }
 
 static grpc_error* non_polling_poller_work(grpc_pollset* pollset,
                                            grpc_pollset_worker** worker,
                                            grpc_millis deadline) {
-  non_polling_poller* npp = (non_polling_poller*)pollset;
+  non_polling_poller* npp = reinterpret_cast<non_polling_poller*>(pollset);
   if (npp->shutdown) return GRPC_ERROR_NONE;
   non_polling_worker w;
   gpr_cv_init(&w.cv);
-  if (worker != nullptr) *worker = (grpc_pollset_worker*)&w;
+  if (worker != nullptr) *worker = reinterpret_cast<grpc_pollset_worker*>(&w);
   if (npp->root == nullptr) {
     npp->root = w.next = w.prev = &w;
   } else {
@@ -138,11 +138,12 @@ static grpc_error* non_polling_poller_work(grpc_pollset* pollset,
 
 static grpc_error* non_polling_poller_kick(
     grpc_pollset* pollset, grpc_pollset_worker* specific_worker) {
-  non_polling_poller* p = (non_polling_poller*)pollset;
+  non_polling_poller* p = reinterpret_cast<non_polling_poller*>(pollset);
   if (specific_worker == nullptr)
-    specific_worker = (grpc_pollset_worker*)p->root;
+    specific_worker = reinterpret_cast<grpc_pollset_worker*>(p->root);
   if (specific_worker != nullptr) {
-    non_polling_worker* w = (non_polling_worker*)specific_worker;
+    non_polling_worker* w =
+        reinterpret_cast<non_polling_worker*>(specific_worker);
     if (!w->kicked) {
       w->kicked = true;
       gpr_cv_signal(&w->cv);
@@ -153,7 +154,7 @@ static grpc_error* non_polling_poller_kick(
 
 static void non_polling_poller_shutdown(grpc_pollset* pollset,
                                         grpc_closure* closure) {
-  non_polling_poller* p = (non_polling_poller*)pollset;
+  non_polling_poller* p = reinterpret_cast<non_polling_poller*>(pollset);
   GPR_ASSERT(closure != nullptr);
   p->shutdown = closure;
   if (p->root == nullptr) {
@@ -354,10 +355,10 @@ int grpc_completion_queue_thread_local_cache_flush(grpc_completion_queue* cq,
       (grpc_completion_queue*)gpr_tls_get(&g_cached_cq) == cq) {
     *tag = storage->tag;
     grpc_core::ExecCtx exec_ctx;
-    *ok = (storage->next & (uintptr_t)(1)) == 1;
+    *ok = (storage->next & static_cast<uintptr_t>(1)) == 1;
     storage->done(storage->done_arg, storage);
     ret = 1;
-    cq_next_data* cqd = (cq_next_data*)DATA_FROM_CQ(cq);
+    cq_next_data* cqd = static_cast<cq_next_data*> DATA_FROM_CQ(cq);
     if (gpr_atm_full_fetch_add(&cqd->pending_events, -1) == 1) {
       GRPC_CQ_INTERNAL_REF(cq, "shutting_down");
       gpr_mu_lock(cq->mu);
@@ -383,7 +384,7 @@ static void cq_event_queue_destroy(grpc_cq_event_queue* q) {
 }
 
 static bool cq_event_queue_push(grpc_cq_event_queue* q, grpc_cq_completion* c) {
-  gpr_mpscq_push(&q->queue, (gpr_mpscq_node*)c);
+  gpr_mpscq_push(&q->queue, reinterpret_cast<gpr_mpscq_node*>(c));
   return gpr_atm_no_barrier_fetch_add(&q->num_queue_items, 1) == 0;
 }
 
@@ -395,7 +396,8 @@ static grpc_cq_completion* cq_event_queue_pop(grpc_cq_event_queue* q) {
     GRPC_STATS_INC_CQ_EV_QUEUE_TRYLOCK_SUCCESSES();
 
     bool is_empty = false;
-    c = (grpc_cq_completion*)gpr_mpscq_pop_and_check_end(&q->queue, &is_empty);
+    c = reinterpret_cast<grpc_cq_completion*>(
+        gpr_mpscq_pop_and_check_end(&q->queue, &is_empty));
     gpr_spinlock_unlock(&q->queue_lock);
 
     if (c == nullptr && !is_empty) {
@@ -415,15 +417,15 @@ static grpc_cq_completion* cq_event_queue_pop(grpc_cq_event_queue* q) {
 /* Note: The counter is not incremented/decremented atomically with push/pop.
  * The count is only eventually consistent */
 static long cq_event_queue_num_items(grpc_cq_event_queue* q) {
-  return (long)gpr_atm_no_barrier_load(&q->num_queue_items);
+  return static_cast<long>(gpr_atm_no_barrier_load(&q->num_queue_items));
 }
 
 grpc_completion_queue* grpc_completion_queue_create_internal(
     grpc_cq_completion_type completion_type,
     grpc_cq_polling_type polling_type) {
-  grpc_completion_queue* cq;
+  GPR_TIMER_SCOPE("grpc_completion_queue_create_internal", 0);
 
-  GPR_TIMER_BEGIN("grpc_completion_queue_create_internal", 0);
+  grpc_completion_queue* cq;
 
   GRPC_API_TRACE(
       "grpc_completion_queue_create_internal(completion_type=%d, "
@@ -437,9 +439,9 @@ grpc_completion_queue* grpc_completion_queue_create_internal(
   grpc_core::ExecCtx exec_ctx;
   GRPC_STATS_INC_CQS_CREATED();
 
-  cq = (grpc_completion_queue*)gpr_zalloc(sizeof(grpc_completion_queue) +
-                                          vtable->data_size +
-                                          poller_vtable->size());
+  cq = static_cast<grpc_completion_queue*>(
+      gpr_zalloc(sizeof(grpc_completion_queue) + vtable->data_size +
+                 poller_vtable->size()));
 
   cq->vtable = vtable;
   cq->poller_vtable = poller_vtable;
@@ -452,14 +454,11 @@ grpc_completion_queue* grpc_completion_queue_create_internal(
 
   GRPC_CLOSURE_INIT(&cq->pollset_shutdown_done, on_pollset_shutdown_done, cq,
                     grpc_schedule_on_exec_ctx);
-
-  GPR_TIMER_END("grpc_completion_queue_create_internal", 0);
-
   return cq;
 }
 
 static void cq_init_next(void* ptr) {
-  cq_next_data* cqd = (cq_next_data*)ptr;
+  cq_next_data* cqd = static_cast<cq_next_data*>(ptr);
   /* Initial count is dropped by grpc_completion_queue_shutdown */
   gpr_atm_no_barrier_store(&cqd->pending_events, 1);
   cqd->shutdown_called = false;
@@ -468,13 +467,13 @@ static void cq_init_next(void* ptr) {
 }
 
 static void cq_destroy_next(void* ptr) {
-  cq_next_data* cqd = (cq_next_data*)ptr;
+  cq_next_data* cqd = static_cast<cq_next_data*>(ptr);
   GPR_ASSERT(cq_event_queue_num_items(&cqd->queue) == 0);
   cq_event_queue_destroy(&cqd->queue);
 }
 
 static void cq_init_pluck(void* ptr) {
-  cq_pluck_data* cqd = (cq_pluck_data*)ptr;
+  cq_pluck_data* cqd = static_cast<cq_pluck_data*>(ptr);
   /* Initial count is dropped by grpc_completion_queue_shutdown */
   gpr_atm_no_barrier_store(&cqd->pending_events, 1);
   cqd->completed_tail = &cqd->completed_head;
@@ -486,7 +485,7 @@ static void cq_init_pluck(void* ptr) {
 }
 
 static void cq_destroy_pluck(void* ptr) {
-  cq_pluck_data* cqd = (cq_pluck_data*)ptr;
+  cq_pluck_data* cqd = static_cast<cq_pluck_data*>(ptr);
   GPR_ASSERT(cqd->completed_head.next == (uintptr_t)&cqd->completed_head);
 }
 
@@ -518,7 +517,7 @@ void grpc_cq_internal_ref(grpc_completion_queue* cq) {
 }
 
 static void on_pollset_shutdown_done(void* arg, grpc_error* error) {
-  grpc_completion_queue* cq = (grpc_completion_queue*)arg;
+  grpc_completion_queue* cq = static_cast<grpc_completion_queue*>(arg);
   GRPC_CQ_INTERNAL_UNREF(cq, "pollset_destroy");
 }
 
@@ -551,7 +550,7 @@ static void cq_check_tag(grpc_completion_queue* cq, void* tag, bool lock_cq) {
     gpr_mu_lock(cq->mu);
   }
 
-  for (int i = 0; i < (int)cq->outstanding_tag_count; i++) {
+  for (int i = 0; i < static_cast<int>(cq->outstanding_tag_count); i++) {
     if (cq->outstanding_tags[i] == tag) {
       cq->outstanding_tag_count--;
       GPR_SWAP(void*, cq->outstanding_tags[i],
@@ -590,12 +589,12 @@ static bool atm_inc_if_nonzero(gpr_atm* counter) {
 }
 
 static bool cq_begin_op_for_next(grpc_completion_queue* cq, void* tag) {
-  cq_next_data* cqd = (cq_next_data*)DATA_FROM_CQ(cq);
+  cq_next_data* cqd = static_cast<cq_next_data*> DATA_FROM_CQ(cq);
   return atm_inc_if_nonzero(&cqd->pending_events);
 }
 
 static bool cq_begin_op_for_pluck(grpc_completion_queue* cq, void* tag) {
-  cq_pluck_data* cqd = (cq_pluck_data*)DATA_FROM_CQ(cq);
+  cq_pluck_data* cqd = static_cast<cq_pluck_data*> DATA_FROM_CQ(cq);
   return atm_inc_if_nonzero(&cqd->pending_events);
 }
 
@@ -604,9 +603,9 @@ bool grpc_cq_begin_op(grpc_completion_queue* cq, void* tag) {
   gpr_mu_lock(cq->mu);
   if (cq->outstanding_tag_count == cq->outstanding_tag_capacity) {
     cq->outstanding_tag_capacity = GPR_MAX(4, 2 * cq->outstanding_tag_capacity);
-    cq->outstanding_tags = (void**)gpr_realloc(
+    cq->outstanding_tags = static_cast<void**>(gpr_realloc(
         cq->outstanding_tags,
-        sizeof(*cq->outstanding_tags) * cq->outstanding_tag_capacity);
+        sizeof(*cq->outstanding_tags) * cq->outstanding_tag_capacity));
   }
   cq->outstanding_tags[cq->outstanding_tag_count++] = tag;
   gpr_mu_unlock(cq->mu);
@@ -622,7 +621,7 @@ static void cq_end_op_for_next(grpc_completion_queue* cq, void* tag,
                                void (*done)(void* done_arg,
                                             grpc_cq_completion* storage),
                                void* done_arg, grpc_cq_completion* storage) {
-  GPR_TIMER_BEGIN("cq_end_op_for_next", 0);
+  GPR_TIMER_SCOPE("cq_end_op_for_next", 0);
 
   if (grpc_api_trace.enabled() ||
       (grpc_trace_operation_failures.enabled() && error != GRPC_ERROR_NONE)) {
@@ -635,13 +634,13 @@ static void cq_end_op_for_next(grpc_completion_queue* cq, void* tag,
       gpr_log(GPR_ERROR, "Operation failed: tag=%p, error=%s", tag, errmsg);
     }
   }
-  cq_next_data* cqd = (cq_next_data*)DATA_FROM_CQ(cq);
+  cq_next_data* cqd = static_cast<cq_next_data*> DATA_FROM_CQ(cq);
   int is_success = (error == GRPC_ERROR_NONE);
 
   storage->tag = tag;
   storage->done = done;
   storage->done_arg = done_arg;
-  storage->next = (uintptr_t)(is_success);
+  storage->next = static_cast<uintptr_t>(is_success);
 
   cq_check_tag(cq, tag, true); /* Used in debug builds only */
 
@@ -691,8 +690,6 @@ static void cq_end_op_for_next(grpc_completion_queue* cq, void* tag,
     }
   }
 
-  GPR_TIMER_END("cq_end_op_for_next", 0);
-
   GRPC_ERROR_UNREF(error);
 }
 
@@ -704,10 +701,10 @@ static void cq_end_op_for_pluck(grpc_completion_queue* cq, void* tag,
                                 void (*done)(void* done_arg,
                                              grpc_cq_completion* storage),
                                 void* done_arg, grpc_cq_completion* storage) {
-  cq_pluck_data* cqd = (cq_pluck_data*)DATA_FROM_CQ(cq);
-  int is_success = (error == GRPC_ERROR_NONE);
+  GPR_TIMER_SCOPE("cq_end_op_for_pluck", 0);
 
-  GPR_TIMER_BEGIN("cq_end_op_for_pluck", 0);
+  cq_pluck_data* cqd = static_cast<cq_pluck_data*> DATA_FROM_CQ(cq);
+  int is_success = (error == GRPC_ERROR_NONE);
 
   if (grpc_api_trace.enabled() ||
       (grpc_trace_operation_failures.enabled() && error != GRPC_ERROR_NONE)) {
@@ -724,7 +721,8 @@ static void cq_end_op_for_pluck(grpc_completion_queue* cq, void* tag,
   storage->tag = tag;
   storage->done = done;
   storage->done_arg = done_arg;
-  storage->next = ((uintptr_t)&cqd->completed_head) | ((uintptr_t)(is_success));
+  storage->next =
+      ((uintptr_t)&cqd->completed_head) | (static_cast<uintptr_t>(is_success));
 
   gpr_mu_lock(cq->mu);
   cq_check_tag(cq, tag, false); /* Used in debug builds only */
@@ -732,7 +730,7 @@ static void cq_end_op_for_pluck(grpc_completion_queue* cq, void* tag,
   /* Add to the list of completions */
   gpr_atm_no_barrier_fetch_add(&cqd->things_queued_ever, 1);
   cqd->completed_tail->next =
-      ((uintptr_t)storage) | (1u & (uintptr_t)cqd->completed_tail->next);
+      ((uintptr_t)storage) | (1u & cqd->completed_tail->next);
   cqd->completed_tail = storage;
 
   if (gpr_atm_full_fetch_add(&cqd->pending_events, -1) == 1) {
@@ -760,8 +758,6 @@ static void cq_end_op_for_pluck(grpc_completion_queue* cq, void* tag,
     }
   }
 
-  GPR_TIMER_END("cq_end_op_for_pluck", 0);
-
   GRPC_ERROR_UNREF(error);
 }
 
@@ -785,9 +781,10 @@ class ExecCtxNext : public grpc_core::ExecCtx {
   ExecCtxNext(void* arg) : ExecCtx(0), check_ready_to_finish_arg_(arg) {}
 
   bool CheckReadyToFinish() override {
-    cq_is_finished_arg* a = (cq_is_finished_arg*)check_ready_to_finish_arg_;
+    cq_is_finished_arg* a =
+        static_cast<cq_is_finished_arg*>(check_ready_to_finish_arg_);
     grpc_completion_queue* cq = a->cq;
-    cq_next_data* cqd = (cq_next_data*)DATA_FROM_CQ(cq);
+    cq_next_data* cqd = static_cast<cq_next_data*> DATA_FROM_CQ(cq);
     GPR_ASSERT(a->stolen_completion == nullptr);
 
     gpr_atm current_last_seen_things_queued_ever =
@@ -840,10 +837,10 @@ static void dump_pending_tags(grpc_completion_queue* cq) {}
 
 static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
                           void* reserved) {
-  grpc_event ret;
-  cq_next_data* cqd = (cq_next_data*)DATA_FROM_CQ(cq);
+  GPR_TIMER_SCOPE("grpc_completion_queue_next", 0);
 
-  GPR_TIMER_BEGIN("grpc_completion_queue_next", 0);
+  grpc_event ret;
+  cq_next_data* cqd = static_cast<cq_next_data*> DATA_FROM_CQ(cq);
 
   GRPC_API_TRACE(
       "grpc_completion_queue_next("
@@ -958,8 +955,6 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
 
   GPR_ASSERT(is_finished_arg.stolen_completion == nullptr);
 
-  GPR_TIMER_END("grpc_completion_queue_next", 0);
-
   return ret;
 }
 
@@ -970,7 +965,7 @@ static grpc_event cq_next(grpc_completion_queue* cq, gpr_timespec deadline,
    - grpc_completion_queue_shutdown() MUST have been called before calling
    this function */
 static void cq_finish_shutdown_next(grpc_completion_queue* cq) {
-  cq_next_data* cqd = (cq_next_data*)DATA_FROM_CQ(cq);
+  cq_next_data* cqd = static_cast<cq_next_data*> DATA_FROM_CQ(cq);
 
   GPR_ASSERT(cqd->shutdown_called);
   GPR_ASSERT(gpr_atm_no_barrier_load(&cqd->pending_events) == 0);
@@ -979,7 +974,7 @@ static void cq_finish_shutdown_next(grpc_completion_queue* cq) {
 }
 
 static void cq_shutdown_next(grpc_completion_queue* cq) {
-  cq_next_data* cqd = (cq_next_data*)DATA_FROM_CQ(cq);
+  cq_next_data* cqd = static_cast<cq_next_data*> DATA_FROM_CQ(cq);
 
   /* Need an extra ref for cq here because:
    * We call cq_finish_shutdown_next() below, that would call pollset shutdown.
@@ -1012,7 +1007,7 @@ grpc_event grpc_completion_queue_next(grpc_completion_queue* cq,
 
 static int add_plucker(grpc_completion_queue* cq, void* tag,
                        grpc_pollset_worker** worker) {
-  cq_pluck_data* cqd = (cq_pluck_data*)DATA_FROM_CQ(cq);
+  cq_pluck_data* cqd = static_cast<cq_pluck_data*> DATA_FROM_CQ(cq);
   if (cqd->num_pluckers == GRPC_MAX_COMPLETION_QUEUE_PLUCKERS) {
     return 0;
   }
@@ -1024,7 +1019,7 @@ static int add_plucker(grpc_completion_queue* cq, void* tag,
 
 static void del_plucker(grpc_completion_queue* cq, void* tag,
                         grpc_pollset_worker** worker) {
-  cq_pluck_data* cqd = (cq_pluck_data*)DATA_FROM_CQ(cq);
+  cq_pluck_data* cqd = static_cast<cq_pluck_data*> DATA_FROM_CQ(cq);
   for (int i = 0; i < cqd->num_pluckers; i++) {
     if (cqd->pluckers[i].tag == tag && cqd->pluckers[i].worker == worker) {
       cqd->num_pluckers--;
@@ -1040,9 +1035,10 @@ class ExecCtxPluck : public grpc_core::ExecCtx {
   ExecCtxPluck(void* arg) : ExecCtx(0), check_ready_to_finish_arg_(arg) {}
 
   bool CheckReadyToFinish() override {
-    cq_is_finished_arg* a = (cq_is_finished_arg*)check_ready_to_finish_arg_;
+    cq_is_finished_arg* a =
+        static_cast<cq_is_finished_arg*>(check_ready_to_finish_arg_);
     grpc_completion_queue* cq = a->cq;
-    cq_pluck_data* cqd = (cq_pluck_data*)DATA_FROM_CQ(cq);
+    cq_pluck_data* cqd = static_cast<cq_pluck_data*> DATA_FROM_CQ(cq);
 
     GPR_ASSERT(a->stolen_completion == nullptr);
     gpr_atm current_last_seen_things_queued_ever =
@@ -1054,10 +1050,12 @@ class ExecCtxPluck : public grpc_core::ExecCtx {
           gpr_atm_no_barrier_load(&cqd->things_queued_ever);
       grpc_cq_completion* c;
       grpc_cq_completion* prev = &cqd->completed_head;
-      while ((c = (grpc_cq_completion*)(prev->next & ~(uintptr_t)1)) !=
+      while ((c = (grpc_cq_completion*)(prev->next &
+                                        ~static_cast<uintptr_t>(1))) !=
              &cqd->completed_head) {
         if (c->tag == a->tag) {
-          prev->next = (prev->next & (uintptr_t)1) | (c->next & ~(uintptr_t)1);
+          prev->next = (prev->next & static_cast<uintptr_t>(1)) |
+                       (c->next & ~static_cast<uintptr_t>(1));
           if (c == cqd->completed_tail) {
             cqd->completed_tail = prev;
           }
@@ -1078,13 +1076,13 @@ class ExecCtxPluck : public grpc_core::ExecCtx {
 
 static grpc_event cq_pluck(grpc_completion_queue* cq, void* tag,
                            gpr_timespec deadline, void* reserved) {
+  GPR_TIMER_SCOPE("grpc_completion_queue_pluck", 0);
+
   grpc_event ret;
   grpc_cq_completion* c;
   grpc_cq_completion* prev;
   grpc_pollset_worker* worker = nullptr;
-  cq_pluck_data* cqd = (cq_pluck_data*)DATA_FROM_CQ(cq);
-
-  GPR_TIMER_BEGIN("grpc_completion_queue_pluck", 0);
+  cq_pluck_data* cqd = static_cast<cq_pluck_data*> DATA_FROM_CQ(cq);
 
   if (grpc_cq_pluck_trace.enabled()) {
     GRPC_API_TRACE(
@@ -1124,10 +1122,12 @@ static grpc_event cq_pluck(grpc_completion_queue* cq, void* tag,
       break;
     }
     prev = &cqd->completed_head;
-    while ((c = (grpc_cq_completion*)(prev->next & ~(uintptr_t)1)) !=
-           &cqd->completed_head) {
+    while (
+        (c = (grpc_cq_completion*)(prev->next & ~static_cast<uintptr_t>(1))) !=
+        &cqd->completed_head) {
       if (c->tag == tag) {
-        prev->next = (prev->next & (uintptr_t)1) | (c->next & ~(uintptr_t)1);
+        prev->next = (prev->next & static_cast<uintptr_t>(1)) |
+                     (c->next & ~static_cast<uintptr_t>(1));
         if (c == cqd->completed_tail) {
           cqd->completed_tail = prev;
         }
@@ -1191,8 +1191,6 @@ done:
 
   GPR_ASSERT(is_finished_arg.stolen_completion == nullptr);
 
-  GPR_TIMER_END("grpc_completion_queue_pluck", 0);
-
   return ret;
 }
 
@@ -1202,7 +1200,7 @@ grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq, void* tag,
 }
 
 static void cq_finish_shutdown_pluck(grpc_completion_queue* cq) {
-  cq_pluck_data* cqd = (cq_pluck_data*)DATA_FROM_CQ(cq);
+  cq_pluck_data* cqd = static_cast<cq_pluck_data*> DATA_FROM_CQ(cq);
 
   GPR_ASSERT(cqd->shutdown_called);
   GPR_ASSERT(!gpr_atm_no_barrier_load(&cqd->shutdown));
@@ -1214,7 +1212,7 @@ static void cq_finish_shutdown_pluck(grpc_completion_queue* cq) {
 /* NOTE: This function is almost exactly identical to cq_shutdown_next() but
  * merging them is a bit tricky and probably not worth it */
 static void cq_shutdown_pluck(grpc_completion_queue* cq) {
-  cq_pluck_data* cqd = (cq_pluck_data*)DATA_FROM_CQ(cq);
+  cq_pluck_data* cqd = static_cast<cq_pluck_data*> DATA_FROM_CQ(cq);
 
   /* Need an extra ref for cq here because:
    * We call cq_finish_shutdown_pluck() below, that would call pollset shutdown.
@@ -1240,23 +1238,19 @@ static void cq_shutdown_pluck(grpc_completion_queue* cq) {
 /* Shutdown simply drops a ref that we reserved at creation time; if we drop
    to zero here, then enter shutdown mode and wake up any waiters */
 void grpc_completion_queue_shutdown(grpc_completion_queue* cq) {
+  GPR_TIMER_SCOPE("grpc_completion_queue_shutdown", 0);
   grpc_core::ExecCtx exec_ctx;
-  GPR_TIMER_BEGIN("grpc_completion_queue_shutdown", 0);
   GRPC_API_TRACE("grpc_completion_queue_shutdown(cq=%p)", 1, (cq));
   cq->vtable->shutdown(cq);
-
-  GPR_TIMER_END("grpc_completion_queue_shutdown", 0);
 }
 
 void grpc_completion_queue_destroy(grpc_completion_queue* cq) {
+  GPR_TIMER_SCOPE("grpc_completion_queue_destroy", 0);
   GRPC_API_TRACE("grpc_completion_queue_destroy(cq=%p)", 1, (cq));
-  GPR_TIMER_BEGIN("grpc_completion_queue_destroy", 0);
   grpc_completion_queue_shutdown(cq);
 
   grpc_core::ExecCtx exec_ctx;
   GRPC_CQ_INTERNAL_UNREF(cq, "destroy");
-
-  GPR_TIMER_END("grpc_completion_queue_destroy", 0);
 }
 
 grpc_pollset* grpc_cq_pollset(grpc_completion_queue* cq) {