grpc 1.7.3 → 1.8.0

data/src/core/plugin_registry/{grpc_plugin_registry.c → grpc_plugin_registry.cc}

@@ -18,42 +18,40 @@
 
 #include <grpc/grpc.h>
 
-extern void grpc_http_filters_init(void);
-extern void grpc_http_filters_shutdown(void);
-extern void grpc_chttp2_plugin_init(void);
-extern void grpc_chttp2_plugin_shutdown(void);
-extern void grpc_tsi_gts_init(void);
-extern void grpc_tsi_gts_shutdown(void);
-extern void grpc_deadline_filter_init(void);
-extern void grpc_deadline_filter_shutdown(void);
-extern void grpc_client_channel_init(void);
-extern void grpc_client_channel_shutdown(void);
-extern void grpc_inproc_plugin_init(void);
-extern void grpc_inproc_plugin_shutdown(void);
-extern void grpc_resolver_fake_init(void);
-extern void grpc_resolver_fake_shutdown(void);
-extern void grpc_lb_policy_grpclb_init(void);
-extern void grpc_lb_policy_grpclb_shutdown(void);
-extern void grpc_lb_policy_pick_first_init(void);
-extern void grpc_lb_policy_pick_first_shutdown(void);
-extern void grpc_lb_policy_round_robin_init(void);
-extern void grpc_lb_policy_round_robin_shutdown(void);
-extern void grpc_resolver_dns_ares_init(void);
-extern void grpc_resolver_dns_ares_shutdown(void);
-extern void grpc_resolver_dns_native_init(void);
-extern void grpc_resolver_dns_native_shutdown(void);
-extern void grpc_resolver_sockaddr_init(void);
-extern void grpc_resolver_sockaddr_shutdown(void);
-extern void grpc_server_load_reporting_plugin_init(void);
-extern void grpc_server_load_reporting_plugin_shutdown(void);
-extern void census_grpc_plugin_init(void);
-extern void census_grpc_plugin_shutdown(void);
-extern void grpc_max_age_filter_init(void);
-extern void grpc_max_age_filter_shutdown(void);
-extern void grpc_message_size_filter_init(void);
-extern void grpc_message_size_filter_shutdown(void);
-extern void grpc_workaround_cronet_compression_filter_init(void);
-extern void grpc_workaround_cronet_compression_filter_shutdown(void);
+extern "C" void grpc_http_filters_init(void);
+extern "C" void grpc_http_filters_shutdown(void);
+extern "C" void grpc_chttp2_plugin_init(void);
+extern "C" void grpc_chttp2_plugin_shutdown(void);
+extern "C" void grpc_tsi_gts_init(void);
+extern "C" void grpc_tsi_gts_shutdown(void);
+extern "C" void grpc_deadline_filter_init(void);
+extern "C" void grpc_deadline_filter_shutdown(void);
+extern "C" void grpc_client_channel_init(void);
+extern "C" void grpc_client_channel_shutdown(void);
+extern "C" void grpc_inproc_plugin_init(void);
+extern "C" void grpc_inproc_plugin_shutdown(void);
+extern "C" void grpc_resolver_fake_init(void);
+extern "C" void grpc_resolver_fake_shutdown(void);
+extern "C" void grpc_lb_policy_grpclb_init(void);
+extern "C" void grpc_lb_policy_grpclb_shutdown(void);
+extern "C" void grpc_lb_policy_pick_first_init(void);
+extern "C" void grpc_lb_policy_pick_first_shutdown(void);
+extern "C" void grpc_lb_policy_round_robin_init(void);
+extern "C" void grpc_lb_policy_round_robin_shutdown(void);
+extern "C" void grpc_resolver_dns_ares_init(void);
+extern "C" void grpc_resolver_dns_ares_shutdown(void);
+extern "C" void grpc_resolver_dns_native_init(void);
+extern "C" void grpc_resolver_dns_native_shutdown(void);
+extern "C" void grpc_resolver_sockaddr_init(void);
+extern "C" void grpc_resolver_sockaddr_shutdown(void);
+extern "C" void grpc_server_load_reporting_plugin_init(void);
+extern "C" void grpc_server_load_reporting_plugin_shutdown(void);
+extern "C" void grpc_max_age_filter_init(void);
+extern "C" void grpc_max_age_filter_shutdown(void);
+extern "C" void grpc_message_size_filter_init(void);
+extern "C" void grpc_message_size_filter_shutdown(void);
+extern "C" void grpc_workaround_cronet_compression_filter_init(void);
+extern "C" void grpc_workaround_cronet_compression_filter_shutdown(void);
 
 void grpc_register_built_in_plugins(void) {
   grpc_register_plugin(grpc_http_filters_init,
@@ -84,8 +82,6 @@ void grpc_register_built_in_plugins(void) {
                        grpc_resolver_sockaddr_shutdown);
   grpc_register_plugin(grpc_server_load_reporting_plugin_init,
                        grpc_server_load_reporting_plugin_shutdown);
-  grpc_register_plugin(census_grpc_plugin_init,
-                       census_grpc_plugin_shutdown);
   grpc_register_plugin(grpc_max_age_filter_init,
                        grpc_max_age_filter_shutdown);
   grpc_register_plugin(grpc_message_size_filter_init,

data/src/core/tsi/{fake_transport_security.c → fake_transport_security.cc}

@@ -41,7 +41,7 @@
    where the size field value is the size of the size field plus the size of
    the data encoded in little endian on 4 bytes.  */
 typedef struct {
-  unsigned char *data;
+  unsigned char* data;
   size_t size;
   size_t allocated_size;
   size_t offset;
@@ -63,7 +63,7 @@ typedef struct {
   int needs_incoming_message;
   tsi_fake_frame incoming_frame;
   tsi_fake_frame outgoing_frame;
-  unsigned char *outgoing_bytes_buffer;
+  unsigned char* outgoing_bytes_buffer;
   size_t outgoing_bytes_buffer_size;
   tsi_result result;
 } tsi_fake_handshaker;
@@ -85,10 +85,10 @@ typedef struct {
 
 /* --- Utils. ---*/
 
-static const char *tsi_fake_handshake_message_strings[] = {
+static const char* tsi_fake_handshake_message_strings[] = {
     "CLIENT_INIT", "SERVER_INIT", "CLIENT_FINISHED", "SERVER_FINISHED"};
 
-static const char *tsi_fake_handshake_message_to_string(int msg) {
+static const char* tsi_fake_handshake_message_to_string(int msg) {
   if (msg < 0 || msg >= TSI_FAKE_HANDSHAKE_MESSAGE_MAX) {
     gpr_log(GPR_ERROR, "Invalid message %d", msg);
     return "UNKNOWN";
@@ -97,12 +97,11 @@ static const char *tsi_fake_handshake_message_to_string(int msg) {
 }
 
 static tsi_result tsi_fake_handshake_message_from_string(
-    const char *msg_string, tsi_fake_handshake_message *msg) {
-  tsi_fake_handshake_message i;
-  for (i = 0; i < TSI_FAKE_HANDSHAKE_MESSAGE_MAX; i++) {
+    const char* msg_string, tsi_fake_handshake_message* msg) {
+  for (int i = 0; i < TSI_FAKE_HANDSHAKE_MESSAGE_MAX; i++) {
     if (strncmp(msg_string, tsi_fake_handshake_message_strings[i],
                 strlen(tsi_fake_handshake_message_strings[i])) == 0) {
-      *msg = i;
+      *msg = (tsi_fake_handshake_message)i;
       return TSI_OK;
     }
   }
@@ -110,22 +109,22 @@ static tsi_result tsi_fake_handshake_message_from_string(
   return TSI_DATA_CORRUPTED;
 }
 
-static uint32_t load32_little_endian(const unsigned char *buf) {
+static uint32_t load32_little_endian(const unsigned char* buf) {
   return ((uint32_t)(buf[0]) | (uint32_t)(buf[1] << 8) |
           (uint32_t)(buf[2] << 16) | (uint32_t)(buf[3] << 24));
 }
 
-static void store32_little_endian(uint32_t value, unsigned char *buf) {
+static void store32_little_endian(uint32_t value, unsigned char* buf) {
   buf[3] = (unsigned char)((value >> 24) & 0xFF);
   buf[2] = (unsigned char)((value >> 16) & 0xFF);
   buf[1] = (unsigned char)((value >> 8) & 0xFF);
   buf[0] = (unsigned char)((value)&0xFF);
 }
 
-static uint32_t read_frame_size(const grpc_slice_buffer *sb) {
-  GPR_ASSERT(sb != NULL && sb->length >= TSI_FAKE_FRAME_HEADER_SIZE);
+static uint32_t read_frame_size(const grpc_slice_buffer* sb) {
+  GPR_ASSERT(sb != nullptr && sb->length >= TSI_FAKE_FRAME_HEADER_SIZE);
   uint8_t frame_size_buffer[TSI_FAKE_FRAME_HEADER_SIZE];
-  uint8_t *buf = frame_size_buffer;
+  uint8_t* buf = frame_size_buffer;
   /* Copies the first 4 bytes to a temporary buffer.  */
   size_t remaining = TSI_FAKE_FRAME_HEADER_SIZE;
   for (size_t i = 0; i < sb->count; i++) {
@@ -144,7 +143,7 @@ static uint32_t read_frame_size(const grpc_slice_buffer *sb) {
   return load32_little_endian(frame_size_buffer);
 }
 
-static void tsi_fake_frame_reset(tsi_fake_frame *frame, int needs_draining) {
+static void tsi_fake_frame_reset(tsi_fake_frame* frame, int needs_draining) {
   frame->offset = 0;
   frame->needs_draining = needs_draining;
   if (!needs_draining) frame->size = 0;
@@ -152,12 +151,13 @@ static void tsi_fake_frame_reset(tsi_fake_frame *frame, int needs_draining) {
 
 /* Checks if the frame's allocated size is at least frame->size, and reallocs
  * more memory if necessary. */
-static void tsi_fake_frame_ensure_size(tsi_fake_frame *frame) {
-  if (frame->data == NULL) {
+static void tsi_fake_frame_ensure_size(tsi_fake_frame* frame) {
+  if (frame->data == nullptr) {
     frame->allocated_size = frame->size;
-    frame->data = gpr_malloc(frame->allocated_size);
+    frame->data = (unsigned char*)gpr_malloc(frame->allocated_size);
   } else if (frame->size > frame->allocated_size) {
-    unsigned char *new_data = gpr_realloc(frame->data, frame->size);
+    unsigned char* new_data =
+        (unsigned char*)gpr_realloc(frame->data, frame->size);
     frame->data = new_data;
     frame->allocated_size = frame->size;
   }
@@ -166,17 +166,17 @@ static void tsi_fake_frame_ensure_size(tsi_fake_frame *frame) {
 /* Decodes the serialized fake frame contained in incoming_bytes, and fills
  * frame with the contents of the decoded frame.
  * This method should not be called if frame->needs_framing is not 0.  */
-static tsi_result tsi_fake_frame_decode(const unsigned char *incoming_bytes,
-                                        size_t *incoming_bytes_size,
-                                        tsi_fake_frame *frame) {
+static tsi_result tsi_fake_frame_decode(const unsigned char* incoming_bytes,
+                                        size_t* incoming_bytes_size,
+                                        tsi_fake_frame* frame) {
   size_t available_size = *incoming_bytes_size;
   size_t to_read_size = 0;
-  const unsigned char *bytes_cursor = incoming_bytes;
+  const unsigned char* bytes_cursor = incoming_bytes;
 
   if (frame->needs_draining) return TSI_INTERNAL_ERROR;
-  if (frame->data == NULL) {
+  if (frame->data == nullptr) {
     frame->allocated_size = TSI_FAKE_FRAME_INITIAL_ALLOCATED_SIZE;
-    frame->data = gpr_malloc(frame->allocated_size);
+    frame->data = (unsigned char*)gpr_malloc(frame->allocated_size);
   }
 
   if (frame->offset < TSI_FAKE_FRAME_HEADER_SIZE) {
@@ -215,9 +215,9 @@ static tsi_result tsi_fake_frame_decode(const unsigned char *incoming_bytes,
 /* Encodes a fake frame into its wire format and places the result in
  * outgoing_bytes. outgoing_bytes_size indicates the size of the encoded frame.
  * This method should not be called if frame->needs_framing is 0.  */
-static tsi_result tsi_fake_frame_encode(unsigned char *outgoing_bytes,
-                                        size_t *outgoing_bytes_size,
-                                        tsi_fake_frame *frame) {
+static tsi_result tsi_fake_frame_encode(unsigned char* outgoing_bytes,
+                                        size_t* outgoing_bytes_size,
+                                        tsi_fake_frame* frame) {
   size_t to_write_size = frame->size - frame->offset;
   if (!frame->needs_draining) return TSI_INTERNAL_ERROR;
   if (*outgoing_bytes_size < to_write_size) {
@@ -233,8 +233,8 @@ static tsi_result tsi_fake_frame_encode(unsigned char *outgoing_bytes,
 
 /* Sets the payload of a fake frame to contain the given data blob, where
  * data_size indicates the size of data. */
-static tsi_result tsi_fake_frame_set_data(unsigned char *data, size_t data_size,
-                                          tsi_fake_frame *frame) {
+static tsi_result tsi_fake_frame_set_data(unsigned char* data, size_t data_size,
+                                          tsi_fake_frame* frame) {
   frame->offset = 0;
   frame->size = data_size + TSI_FAKE_FRAME_HEADER_SIZE;
   tsi_fake_frame_ensure_size(frame);
@@ -245,24 +245,24 @@ static tsi_result tsi_fake_frame_set_data(unsigned char *data, size_t data_size,
 }
 
 /* Destroys the contents of a fake frame. */
-static void tsi_fake_frame_destruct(tsi_fake_frame *frame) {
-  if (frame->data != NULL) gpr_free(frame->data);
+static void tsi_fake_frame_destruct(tsi_fake_frame* frame) {
+  if (frame->data != nullptr) gpr_free(frame->data);
 }
 
 /* --- tsi_frame_protector methods implementation. ---*/
 
-static tsi_result fake_protector_protect(tsi_frame_protector *self,
-                                         const unsigned char *unprotected_bytes,
-                                         size_t *unprotected_bytes_size,
-                                         unsigned char *protected_output_frames,
-                                         size_t *protected_output_frames_size) {
+static tsi_result fake_protector_protect(tsi_frame_protector* self,
+                                         const unsigned char* unprotected_bytes,
+                                         size_t* unprotected_bytes_size,
+                                         unsigned char* protected_output_frames,
+                                         size_t* protected_output_frames_size) {
   tsi_result result = TSI_OK;
-  tsi_fake_frame_protector *impl = (tsi_fake_frame_protector *)self;
+  tsi_fake_frame_protector* impl = (tsi_fake_frame_protector*)self;
   unsigned char frame_header[TSI_FAKE_FRAME_HEADER_SIZE];
-  tsi_fake_frame *frame = &impl->protect_frame;
+  tsi_fake_frame* frame = &impl->protect_frame;
   size_t saved_output_size = *protected_output_frames_size;
   size_t drained_size = 0;
-  size_t *num_bytes_written = protected_output_frames_size;
+  size_t* num_bytes_written = protected_output_frames_size;
   *num_bytes_written = 0;
 
   /* Try to drain first. */
@@ -313,11 +313,11 @@ static tsi_result fake_protector_protect(tsi_frame_protector *self,
 }
 
 static tsi_result fake_protector_protect_flush(
-    tsi_frame_protector *self, unsigned char *protected_output_frames,
-    size_t *protected_output_frames_size, size_t *still_pending_size) {
+    tsi_frame_protector* self, unsigned char* protected_output_frames,
+    size_t* protected_output_frames_size, size_t* still_pending_size) {
   tsi_result result = TSI_OK;
-  tsi_fake_frame_protector *impl = (tsi_fake_frame_protector *)self;
-  tsi_fake_frame *frame = &impl->protect_frame;
+  tsi_fake_frame_protector* impl = (tsi_fake_frame_protector*)self;
+  tsi_fake_frame* frame = &impl->protect_frame;
   if (!frame->needs_draining) {
     /* Create a short frame. */
     frame->size = frame->offset;
@@ -334,15 +334,15 @@ static tsi_result fake_protector_protect_flush(
 }
 
 static tsi_result fake_protector_unprotect(
-    tsi_frame_protector *self, const unsigned char *protected_frames_bytes,
-    size_t *protected_frames_bytes_size, unsigned char *unprotected_bytes,
-    size_t *unprotected_bytes_size) {
+    tsi_frame_protector* self, const unsigned char* protected_frames_bytes,
+    size_t* protected_frames_bytes_size, unsigned char* unprotected_bytes,
+    size_t* unprotected_bytes_size) {
   tsi_result result = TSI_OK;
-  tsi_fake_frame_protector *impl = (tsi_fake_frame_protector *)self;
-  tsi_fake_frame *frame = &impl->unprotect_frame;
+  tsi_fake_frame_protector* impl = (tsi_fake_frame_protector*)self;
+  tsi_fake_frame* frame = &impl->unprotect_frame;
   size_t saved_output_size = *unprotected_bytes_size;
   size_t drained_size = 0;
-  size_t *num_bytes_written = unprotected_bytes_size;
+  size_t* num_bytes_written = unprotected_bytes_size;
   *num_bytes_written = 0;
 
   /* Try to drain first. */
@@ -382,29 +382,32 @@ static tsi_result fake_protector_unprotect(
   return result;
 }
 
-static void fake_protector_destroy(tsi_frame_protector *self) {
-  tsi_fake_frame_protector *impl = (tsi_fake_frame_protector *)self;
+static void fake_protector_destroy(tsi_frame_protector* self) {
+  tsi_fake_frame_protector* impl = (tsi_fake_frame_protector*)self;
   tsi_fake_frame_destruct(&impl->protect_frame);
   tsi_fake_frame_destruct(&impl->unprotect_frame);
   gpr_free(self);
 }
 
 static const tsi_frame_protector_vtable frame_protector_vtable = {
-    fake_protector_protect, fake_protector_protect_flush,
-    fake_protector_unprotect, fake_protector_destroy,
+    fake_protector_protect,
+    fake_protector_protect_flush,
+    fake_protector_unprotect,
+    fake_protector_destroy,
 };
 
 /* --- tsi_zero_copy_grpc_protector methods implementation. ---*/
 
 static tsi_result fake_zero_copy_grpc_protector_protect(
-    grpc_exec_ctx *exec_ctx, tsi_zero_copy_grpc_protector *self,
-    grpc_slice_buffer *unprotected_slices,
-    grpc_slice_buffer *protected_slices) {
-  if (self == NULL || unprotected_slices == NULL || protected_slices == NULL) {
+    grpc_exec_ctx* exec_ctx, tsi_zero_copy_grpc_protector* self,
+    grpc_slice_buffer* unprotected_slices,
+    grpc_slice_buffer* protected_slices) {
+  if (self == nullptr || unprotected_slices == nullptr ||
+      protected_slices == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
-  tsi_fake_zero_copy_grpc_protector *impl =
-      (tsi_fake_zero_copy_grpc_protector *)self;
+  tsi_fake_zero_copy_grpc_protector* impl =
+      (tsi_fake_zero_copy_grpc_protector*)self;
   /* Protects each frame. */
   while (unprotected_slices->length > 0) {
     size_t frame_length =
@@ -421,14 +424,15 @@ static tsi_result fake_zero_copy_grpc_protector_protect(
 }
 
 static tsi_result fake_zero_copy_grpc_protector_unprotect(
-    grpc_exec_ctx *exec_ctx, tsi_zero_copy_grpc_protector *self,
-    grpc_slice_buffer *protected_slices,
-    grpc_slice_buffer *unprotected_slices) {
-  if (self == NULL || unprotected_slices == NULL || protected_slices == NULL) {
+    grpc_exec_ctx* exec_ctx, tsi_zero_copy_grpc_protector* self,
+    grpc_slice_buffer* protected_slices,
+    grpc_slice_buffer* unprotected_slices) {
+  if (self == nullptr || unprotected_slices == nullptr ||
+      protected_slices == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
-  tsi_fake_zero_copy_grpc_protector *impl =
-      (tsi_fake_zero_copy_grpc_protector *)self;
+  tsi_fake_zero_copy_grpc_protector* impl =
+      (tsi_fake_zero_copy_grpc_protector*)self;
   grpc_slice_buffer_move_into(protected_slices, &impl->protected_sb);
   /* Unprotect each frame, if we get a full frame. */
   while (impl->protected_sb.length >= TSI_FAKE_FRAME_HEADER_SIZE) {
@@ -456,10 +460,10 @@ static tsi_result fake_zero_copy_grpc_protector_unprotect(
 }
 
 static void fake_zero_copy_grpc_protector_destroy(
-    grpc_exec_ctx *exec_ctx, tsi_zero_copy_grpc_protector *self) {
-  if (self == NULL) return;
-  tsi_fake_zero_copy_grpc_protector *impl =
-      (tsi_fake_zero_copy_grpc_protector *)self;
+    grpc_exec_ctx* exec_ctx, tsi_zero_copy_grpc_protector* self) {
+  if (self == nullptr) return;
+  tsi_fake_zero_copy_grpc_protector* impl =
+      (tsi_fake_zero_copy_grpc_protector*)self;
   grpc_slice_buffer_destroy_internal(exec_ctx, &impl->header_sb);
   grpc_slice_buffer_destroy_internal(exec_ctx, &impl->protected_sb);
   gpr_free(impl);
@@ -476,12 +480,12 @@ static const tsi_zero_copy_grpc_protector_vtable
 
 typedef struct {
   tsi_handshaker_result base;
-  unsigned char *unused_bytes;
+  unsigned char* unused_bytes;
   size_t unused_bytes_size;
 } fake_handshaker_result;
 
 static tsi_result fake_handshaker_result_extract_peer(
-    const tsi_handshaker_result *self, tsi_peer *peer) {
+    const tsi_handshaker_result* self, tsi_peer* peer) {
   /* Construct a tsi_peer with 1 property: certificate type. */
   tsi_result result = tsi_construct_peer(1, peer);
   if (result != TSI_OK) return result;
@@ -493,32 +497,32 @@ static tsi_result fake_handshaker_result_extract_peer(
 }
 
 static tsi_result fake_handshaker_result_create_zero_copy_grpc_protector(
-    void *exec_ctx, const tsi_handshaker_result *self,
-    size_t *max_output_protected_frame_size,
-    tsi_zero_copy_grpc_protector **protector) {
+    void* exec_ctx, const tsi_handshaker_result* self,
+    size_t* max_output_protected_frame_size,
+    tsi_zero_copy_grpc_protector** protector) {
   *protector =
       tsi_create_fake_zero_copy_grpc_protector(max_output_protected_frame_size);
   return TSI_OK;
 }
 
 static tsi_result fake_handshaker_result_create_frame_protector(
-    const tsi_handshaker_result *self, size_t *max_output_protected_frame_size,
-    tsi_frame_protector **protector) {
+    const tsi_handshaker_result* self, size_t* max_output_protected_frame_size,
+    tsi_frame_protector** protector) {
   *protector = tsi_create_fake_frame_protector(max_output_protected_frame_size);
   return TSI_OK;
 }
 
 static tsi_result fake_handshaker_result_get_unused_bytes(
-    const tsi_handshaker_result *self, const unsigned char **bytes,
-    size_t *bytes_size) {
-  fake_handshaker_result *result = (fake_handshaker_result *)self;
+    const tsi_handshaker_result* self, const unsigned char** bytes,
+    size_t* bytes_size) {
+  fake_handshaker_result* result = (fake_handshaker_result*)self;
   *bytes_size = result->unused_bytes_size;
   *bytes = result->unused_bytes;
   return TSI_OK;
 }
 
-static void fake_handshaker_result_destroy(tsi_handshaker_result *self) {
-  fake_handshaker_result *result = (fake_handshaker_result *)self;
+static void fake_handshaker_result_destroy(tsi_handshaker_result* self) {
+  fake_handshaker_result* result = (fake_handshaker_result*)self;
   gpr_free(result->unused_bytes);
   gpr_free(self);
 }
@@ -532,16 +536,17 @@ static const tsi_handshaker_result_vtable handshaker_result_vtable = {
 };
 
 static tsi_result fake_handshaker_result_create(
-    const unsigned char *unused_bytes, size_t unused_bytes_size,
-    tsi_handshaker_result **handshaker_result) {
-  if ((unused_bytes_size > 0 && unused_bytes == NULL) ||
-      handshaker_result == NULL) {
+    const unsigned char* unused_bytes, size_t unused_bytes_size,
+    tsi_handshaker_result** handshaker_result) {
+  if ((unused_bytes_size > 0 && unused_bytes == nullptr) ||
+      handshaker_result == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
-  fake_handshaker_result *result = gpr_zalloc(sizeof(*result));
+  fake_handshaker_result* result =
+      (fake_handshaker_result*)gpr_zalloc(sizeof(*result));
   result->base.vtable = &handshaker_result_vtable;
   if (unused_bytes_size > 0) {
-    result->unused_bytes = gpr_malloc(unused_bytes_size);
+    result->unused_bytes = (unsigned char*)gpr_malloc(unused_bytes_size);
     memcpy(result->unused_bytes, unused_bytes, unused_bytes_size);
   }
   result->unused_bytes_size = unused_bytes_size;
@@ -552,8 +557,8 @@ static tsi_result fake_handshaker_result_create(
 /* --- tsi_handshaker methods implementation. ---*/
 
 static tsi_result fake_handshaker_get_bytes_to_send_to_peer(
-    tsi_handshaker *self, unsigned char *bytes, size_t *bytes_size) {
-  tsi_fake_handshaker *impl = (tsi_fake_handshaker *)self;
+    tsi_handshaker* self, unsigned char* bytes, size_t* bytes_size) {
+  tsi_fake_handshaker* impl = (tsi_fake_handshaker*)self;
   tsi_result result = TSI_OK;
   if (impl->needs_incoming_message || impl->result == TSI_OK) {
     *bytes_size = 0;
@@ -561,16 +566,16 @@ static tsi_result fake_handshaker_get_bytes_to_send_to_peer(
   }
   if (!impl->outgoing_frame.needs_draining) {
     tsi_fake_handshake_message next_message_to_send =
-        impl->next_message_to_send + 2;
-    const char *msg_string =
+        (tsi_fake_handshake_message)(impl->next_message_to_send + 2);
+    const char* msg_string =
         tsi_fake_handshake_message_to_string(impl->next_message_to_send);
-    result = tsi_fake_frame_set_data((unsigned char *)msg_string,
+    result = tsi_fake_frame_set_data((unsigned char*)msg_string,
                                      strlen(msg_string), &impl->outgoing_frame);
     if (result != TSI_OK) return result;
     if (next_message_to_send > TSI_FAKE_HANDSHAKE_MESSAGE_MAX) {
       next_message_to_send = TSI_FAKE_HANDSHAKE_MESSAGE_MAX;
     }
-    if (GRPC_TRACER_ON(tsi_tracing_enabled)) {
+    if (tsi_tracing_enabled.enabled()) {
       gpr_log(GPR_INFO, "%s prepared %s.",
               impl->is_client ? "Client" : "Server",
               tsi_fake_handshake_message_to_string(impl->next_message_to_send));
@@ -582,7 +587,7 @@ static tsi_result fake_handshaker_get_bytes_to_send_to_peer(
   if (!impl->is_client &&
       impl->next_message_to_send == TSI_FAKE_HANDSHAKE_MESSAGE_MAX) {
     /* We're done. */
-    if (GRPC_TRACER_ON(tsi_tracing_enabled)) {
+    if (tsi_tracing_enabled.enabled()) {
       gpr_log(GPR_INFO, "Server is done.");
     }
     impl->result = TSI_OK;
@@ -593,10 +598,11 @@ static tsi_result fake_handshaker_get_bytes_to_send_to_peer(
 }
 
 static tsi_result fake_handshaker_process_bytes_from_peer(
-    tsi_handshaker *self, const unsigned char *bytes, size_t *bytes_size) {
+    tsi_handshaker* self, const unsigned char* bytes, size_t* bytes_size) {
   tsi_result result = TSI_OK;
-  tsi_fake_handshaker *impl = (tsi_fake_handshaker *)self;
-  tsi_fake_handshake_message expected_msg = impl->next_message_to_send - 1;
+  tsi_fake_handshaker* impl = (tsi_fake_handshaker*)self;
+  tsi_fake_handshake_message expected_msg =
+      (tsi_fake_handshake_message)(impl->next_message_to_send - 1);
   tsi_fake_handshake_message received_msg;
 
   if (!impl->needs_incoming_message || impl->result == TSI_OK) {
@@ -608,7 +614,7 @@ static tsi_result fake_handshaker_process_bytes_from_peer(
 
   /* We now have a complete frame. */
   result = tsi_fake_handshake_message_from_string(
-      (const char *)impl->incoming_frame.data + TSI_FAKE_FRAME_HEADER_SIZE,
+      (const char*)impl->incoming_frame.data + TSI_FAKE_FRAME_HEADER_SIZE,
       &received_msg);
   if (result != TSI_OK) {
     impl->result = result;
@@ -619,7 +625,7 @@ static tsi_result fake_handshaker_process_bytes_from_peer(
             tsi_fake_handshake_message_to_string(received_msg),
             tsi_fake_handshake_message_to_string(expected_msg));
   }
-  if (GRPC_TRACER_ON(tsi_tracing_enabled)) {
+  if (tsi_tracing_enabled.enabled()) {
     gpr_log(GPR_INFO, "%s received %s.", impl->is_client ? "Client" : "Server",
             tsi_fake_handshake_message_to_string(received_msg));
   }
@@ -627,7 +633,7 @@ static tsi_result fake_handshaker_process_bytes_from_peer(
   impl->needs_incoming_message = 0;
   if (impl->next_message_to_send == TSI_FAKE_HANDSHAKE_MESSAGE_MAX) {
     /* We're done. */
-    if (GRPC_TRACER_ON(tsi_tracing_enabled)) {
+    if (tsi_tracing_enabled.enabled()) {
       gpr_log(GPR_INFO, "%s is done.", impl->is_client ? "Client" : "Server");
     }
     impl->result = TSI_OK;
@@ -635,13 +641,13 @@ static tsi_result fake_handshaker_process_bytes_from_peer(
   return TSI_OK;
 }
 
-static tsi_result fake_handshaker_get_result(tsi_handshaker *self) {
-  tsi_fake_handshaker *impl = (tsi_fake_handshaker *)self;
+static tsi_result fake_handshaker_get_result(tsi_handshaker* self) {
+  tsi_fake_handshaker* impl = (tsi_fake_handshaker*)self;
   return impl->result;
 }
 
-static void fake_handshaker_destroy(tsi_handshaker *self) {
-  tsi_fake_handshaker *impl = (tsi_fake_handshaker *)self;
+static void fake_handshaker_destroy(tsi_handshaker* self) {
+  tsi_fake_handshaker* impl = (tsi_fake_handshaker*)self;
   tsi_fake_frame_destruct(&impl->incoming_frame);
   tsi_fake_frame_destruct(&impl->outgoing_frame);
   gpr_free(impl->outgoing_bytes_buffer);
@@ -649,17 +655,17 @@ static void fake_handshaker_destroy(tsi_handshaker *self) {
 }
 
 static tsi_result fake_handshaker_next(
-    tsi_handshaker *self, const unsigned char *received_bytes,
-    size_t received_bytes_size, const unsigned char **bytes_to_send,
-    size_t *bytes_to_send_size, tsi_handshaker_result **handshaker_result,
-    tsi_handshaker_on_next_done_cb cb, void *user_data) {
+    tsi_handshaker* self, const unsigned char* received_bytes,
+    size_t received_bytes_size, const unsigned char** bytes_to_send,
+    size_t* bytes_to_send_size, tsi_handshaker_result** handshaker_result,
+    tsi_handshaker_on_next_done_cb cb, void* user_data) {
   /* Sanity check the arguments. */
-  if ((received_bytes_size > 0 && received_bytes == NULL) ||
-      bytes_to_send == NULL || bytes_to_send_size == NULL ||
-      handshaker_result == NULL) {
+  if ((received_bytes_size > 0 && received_bytes == nullptr) ||
+      bytes_to_send == nullptr || bytes_to_send_size == nullptr ||
+      handshaker_result == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
-  tsi_fake_handshaker *handshaker = (tsi_fake_handshaker *)self;
+  tsi_fake_handshaker* handshaker = (tsi_fake_handshaker*)self;
   tsi_result result = TSI_OK;
 
   /* Decode and process a handshake frame from the peer. */
@@ -681,8 +687,8 @@ static tsi_result fake_handshaker_next(
     if (result == TSI_INCOMPLETE_DATA) {
       handshaker->outgoing_bytes_buffer_size *= 2;
       handshaker->outgoing_bytes_buffer =
-          gpr_realloc(handshaker->outgoing_bytes_buffer,
-                      handshaker->outgoing_bytes_buffer_size);
+          (unsigned char*)gpr_realloc(handshaker->outgoing_bytes_buffer,
+                                      handshaker->outgoing_bytes_buffer_size);
     }
   } while (result == TSI_INCOMPLETE_DATA);
   if (result != TSI_OK) return result;
@@ -691,10 +697,10 @@ static tsi_result fake_handshaker_next(
 
   /* Check if the handshake was completed. */
   if (fake_handshaker_get_result(self) == TSI_HANDSHAKE_IN_PROGRESS) {
-    *handshaker_result = NULL;
+    *handshaker_result = nullptr;
   } else {
     /* Calculate the unused bytes. */
-    const unsigned char *unused_bytes = NULL;
+    const unsigned char* unused_bytes = nullptr;
     size_t unused_bytes_size = received_bytes_size - consumed_bytes_size;
     if (unused_bytes_size > 0) {
       unused_bytes = received_bytes + consumed_bytes_size;
@@ -713,23 +719,24 @@ static tsi_result fake_handshaker_next(
 }
 
 static const tsi_handshaker_vtable handshaker_vtable = {
-    NULL, /* get_bytes_to_send_to_peer -- deprecated */
-    NULL, /* process_bytes_from_peer   -- deprecated */
-    NULL, /* get_result                -- deprecated */
-    NULL, /* extract_peer              -- deprecated */
-    NULL, /* create_frame_protector    -- deprecated */
+    nullptr, /* get_bytes_to_send_to_peer -- deprecated */
+    nullptr, /* process_bytes_from_peer   -- deprecated */
+    nullptr, /* get_result                -- deprecated */
+    nullptr, /* extract_peer              -- deprecated */
+    nullptr, /* create_frame_protector    -- deprecated */
     fake_handshaker_destroy,
     fake_handshaker_next,
 };
 
-tsi_handshaker *tsi_create_fake_handshaker(int is_client) {
-  tsi_fake_handshaker *impl = gpr_zalloc(sizeof(*impl));
+tsi_handshaker* tsi_create_fake_handshaker(int is_client) {
+  tsi_fake_handshaker* impl = (tsi_fake_handshaker*)gpr_zalloc(sizeof(*impl));
   impl->base.vtable = &handshaker_vtable;
   impl->is_client = is_client;
   impl->result = TSI_HANDSHAKE_IN_PROGRESS;
   impl->outgoing_bytes_buffer_size =
       TSI_FAKE_HANDSHAKER_OUTGOING_BUFFER_INITIAL_SIZE;
-  impl->outgoing_bytes_buffer = gpr_malloc(impl->outgoing_bytes_buffer_size);
+  impl->outgoing_bytes_buffer =
+      (unsigned char*)gpr_malloc(impl->outgoing_bytes_buffer_size);
   if (is_client) {
     impl->needs_incoming_message = 0;
     impl->next_message_to_send = TSI_FAKE_CLIENT_INIT;
@@ -740,22 +747,24 @@ tsi_handshaker *tsi_create_fake_handshaker(int is_client) {
   return &impl->base;
 }
 
-tsi_frame_protector *tsi_create_fake_frame_protector(
-    size_t *max_protected_frame_size) {
-  tsi_fake_frame_protector *impl = gpr_zalloc(sizeof(*impl));
-  impl->max_frame_size = (max_protected_frame_size == NULL)
+tsi_frame_protector* tsi_create_fake_frame_protector(
+    size_t* max_protected_frame_size) {
+  tsi_fake_frame_protector* impl =
+      (tsi_fake_frame_protector*)gpr_zalloc(sizeof(*impl));
+  impl->max_frame_size = (max_protected_frame_size == nullptr)
                              ? TSI_FAKE_DEFAULT_FRAME_SIZE
                              : *max_protected_frame_size;
   impl->base.vtable = &frame_protector_vtable;
   return &impl->base;
 }
 
-tsi_zero_copy_grpc_protector *tsi_create_fake_zero_copy_grpc_protector(
-    size_t *max_protected_frame_size) {
-  tsi_fake_zero_copy_grpc_protector *impl = gpr_zalloc(sizeof(*impl));
+tsi_zero_copy_grpc_protector* tsi_create_fake_zero_copy_grpc_protector(
+    size_t* max_protected_frame_size) {
+  tsi_fake_zero_copy_grpc_protector* impl =
+      (tsi_fake_zero_copy_grpc_protector*)gpr_zalloc(sizeof(*impl));
   grpc_slice_buffer_init(&impl->header_sb);
   grpc_slice_buffer_init(&impl->protected_sb);
-  impl->max_frame_size = (max_protected_frame_size == NULL)
+  impl->max_frame_size = (max_protected_frame_size == nullptr)
                              ? TSI_FAKE_DEFAULT_FRAME_SIZE
                              : *max_protected_frame_size;
   impl->parsed_frame_size = 0;