More edits for C to CC

src/core/ext/census/context.c

@@ -141,7 +141,7 @@ static char *decode_tag(struct raw_tag *tag, char *header, int offset) {
 // Make a copy (in 'to') of an existing tag_set.
 static void tag_set_copy(struct tag_set *to, const struct tag_set *from) {
   memcpy(to, from, sizeof(struct tag_set));
-  to->kvm = gpr_malloc(to->kvm_size);
+  to->kvm = (char *)gpr_malloc(to->kvm_size);
   memcpy(to->kvm, from->kvm, from->kvm_used);
 }
 
@@ -184,7 +184,7 @@ static bool tag_set_add_tag(struct tag_set *tags, const census_tag *tag,
   if (tags->kvm_used + tag_size > tags->kvm_size) {
     // allocate new memory if needed
     tags->kvm_size += 2 * CENSUS_MAX_TAG_KV_LEN + TAG_HEADER_SIZE;
-    char *new_kvm = gpr_malloc(tags->kvm_size);
+    char *new_kvm = (char *)gpr_malloc(tags->kvm_size);
     if (tags->kvm_used > 0) memcpy(new_kvm, tags->kvm, tags->kvm_used);
     gpr_free(tags->kvm);
     tags->kvm = new_kvm;
@@ -274,7 +274,8 @@ static void tag_set_flatten(struct tag_set *tags) {
 census_context *census_context_create(const census_context *base,
                                       const census_tag *tags, int ntags,
                                       census_context_status const **status) {
-  census_context *context = gpr_malloc(sizeof(census_context));
+  census_context *context =
+      (census_context *)gpr_malloc(sizeof(census_context));
   // If we are given a base, copy it into our new tag set. Otherwise set it
   // to zero/NULL everything.
   if (base == NULL) {
@@ -459,7 +460,7 @@ static void tag_set_decode(struct tag_set *tags, const char *buffer,
   }
   tags->kvm_used = size - header_size;
   tags->kvm_size = tags->kvm_used + CENSUS_MAX_TAG_KV_LEN;
-  tags->kvm = gpr_malloc(tags->kvm_size);
+  tags->kvm = (char *)gpr_malloc(tags->kvm_size);
   if (tag_header_size != TAG_HEADER_SIZE) {
     // something new in the tag information. I don't understand it, so
     // don't copy it over.
@@ -481,7 +482,8 @@ static void tag_set_decode(struct tag_set *tags, const char *buffer,
 }
 
 census_context *census_context_decode(const char *buffer, size_t size) {
-  census_context *context = gpr_malloc(sizeof(census_context));
+  census_context *context =
+      (census_context *)gpr_malloc(sizeof(census_context));
   memset(&context->tags[LOCAL_TAGS], 0, sizeof(struct tag_set));
   if (buffer == NULL) {
     memset(&context->tags[PROPAGATED_TAGS], 0, sizeof(struct tag_set));

src/core/ext/census/grpc_filter.c

@@ -60,8 +60,8 @@ static void extract_and_annotate_method_tag(grpc_metadata_batch *md,
 
 static void client_mutate_op(grpc_call_element *elem,
                              grpc_transport_stream_op_batch *op) {
-  call_data *calld = (call_data *) elem->call_data;
-  channel_data *chand = (channel_data *) elem->channel_data;
+  call_data *calld = (call_data *)elem->call_data;
+  channel_data *chand = (channel_data *)elem->channel_data;
   if (op->send_initial_metadata) {
     extract_and_annotate_method_tag(
         op->payload->send_initial_metadata.send_initial_metadata, calld, chand);
@@ -78,9 +78,9 @@ static void client_start_transport_op(grpc_exec_ctx *exec_ctx,
 static void server_on_done_recv(grpc_exec_ctx *exec_ctx, void *ptr,
                                 grpc_error *error) {
   GPR_TIMER_BEGIN("census-server:server_on_done_recv", 0);
-  grpc_call_element *elem = (grpc_call_element *) ptr;
-  call_data *calld = (call_data *) elem->call_data;
-  channel_data *chand = (channel_data *) elem->channel_data;
+  grpc_call_element *elem = (grpc_call_element *)ptr;
+  call_data *calld = (call_data *)elem->call_data;
+  channel_data *chand = (channel_data *)elem->channel_data;
   if (error == GRPC_ERROR_NONE) {
     extract_and_annotate_method_tag(calld->recv_initial_metadata, calld, chand);
   }
@@ -90,7 +90,7 @@ static void server_on_done_recv(grpc_exec_ctx *exec_ctx, void *ptr,
 
 static void server_mutate_op(grpc_call_element *elem,
                              grpc_transport_stream_op_batch *op) {
-  call_data *calld = elem->call_data;
+  call_data *calld = (call_data *)elem->call_data;
   if (op->recv_initial_metadata) {
     /* substitute our callback for the op callback */
     calld->recv_initial_metadata =
@@ -117,7 +117,7 @@ static void server_start_transport_op(grpc_exec_ctx *exec_ctx,
 static grpc_error *client_init_call_elem(grpc_exec_ctx *exec_ctx,
                                          grpc_call_element *elem,
                                          const grpc_call_element_args *args) {
-  call_data *d = elem->call_data;
+  call_data *d = (call_data *)elem->call_data;
   GPR_ASSERT(d != NULL);
   memset(d, 0, sizeof(*d));
   d->start_ts = args->start_time;
@@ -128,7 +128,7 @@ static void client_destroy_call_elem(grpc_exec_ctx *exec_ctx,
                                      grpc_call_element *elem,
                                      const grpc_call_final_info *final_info,
                                      grpc_closure *ignored) {
-  call_data *d = (call_data *) elem->call_data;
+  call_data *d = (call_data *)elem->call_data;
   GPR_ASSERT(d != NULL);
   /* TODO(hongyu): record rpc client stats and census_rpc_end_op here */
 }
@@ -136,7 +136,7 @@ static void client_destroy_call_elem(grpc_exec_ctx *exec_ctx,
 static grpc_error *server_init_call_elem(grpc_exec_ctx *exec_ctx,
                                          grpc_call_element *elem,
                                          const grpc_call_element_args *args) {
-  call_data *d = (call_data *) elem->call_data;
+  call_data *d = (call_data *)elem->call_data;
   GPR_ASSERT(d != NULL);
   memset(d, 0, sizeof(*d));
   d->start_ts = args->start_time;
@@ -150,7 +150,7 @@ static void server_destroy_call_elem(grpc_exec_ctx *exec_ctx,
                                      grpc_call_element *elem,
                                      const grpc_call_final_info *final_info,
                                      grpc_closure *ignored) {
-  call_data *d = (call_data *) elem->call_data;
+  call_data *d = (call_data *)elem->call_data;
   GPR_ASSERT(d != NULL);
   /* TODO(hongyu): record rpc server stats and census_tracing_end_op here */
 }
@@ -158,14 +158,14 @@ static void server_destroy_call_elem(grpc_exec_ctx *exec_ctx,
 static grpc_error *init_channel_elem(grpc_exec_ctx *exec_ctx,
                                      grpc_channel_element *elem,
                                      grpc_channel_element_args *args) {
-  channel_data *chand = (channel_data *) elem->channel_data;
+  channel_data *chand = (channel_data *)elem->channel_data;
   GPR_ASSERT(chand != NULL);
   return GRPC_ERROR_NONE;
 }
 
 static void destroy_channel_elem(grpc_exec_ctx *exec_ctx,
                                  grpc_channel_element *elem) {
-  channel_data *chand = (channel_data *) elem->channel_data;
+  channel_data *chand = (channel_data *)elem->channel_data;
   GPR_ASSERT(chand != NULL);
 }
 

src/core/ext/census/mlog.c

@@ -467,7 +467,8 @@ void census_log_initialize(size_t size_in_mb, int discard_old_records) {
   g_log.blocks = (cl_block*)gpr_malloc_aligned(
       g_log.num_blocks * sizeof(cl_block), GPR_CACHELINE_SIZE_LOG);
   memset(g_log.blocks, 0, g_log.num_blocks * sizeof(cl_block));
-  g_log.buffer = (char *) gpr_malloc(g_log.num_blocks * CENSUS_LOG_MAX_RECORD_SIZE);
+  g_log.buffer =
+      (char*)gpr_malloc(g_log.num_blocks * CENSUS_LOG_MAX_RECORD_SIZE);
   memset(g_log.buffer, 0, g_log.num_blocks * CENSUS_LOG_MAX_RECORD_SIZE);
   cl_block_list_initialize(&g_log.free_block_list);
   cl_block_list_initialize(&g_log.dirty_block_list);

src/core/ext/census/resource.c

@@ -87,7 +87,7 @@ static bool validate_string(pb_istream_t *stream, const pb_field_t *field,
         gpr_log(GPR_INFO, "Zero-length Resource name.");
         return false;
       }
-      vresource->name = (char *) gpr_malloc(stream->bytes_left + 1);
+      vresource->name = (char *)gpr_malloc(stream->bytes_left + 1);
       vresource->name[stream->bytes_left] = '\0';
       if (!pb_read(stream, (uint8_t *)vresource->name, stream->bytes_left)) {
         return false;
@@ -106,7 +106,7 @@ static bool validate_string(pb_istream_t *stream, const pb_field_t *field,
       if (stream->bytes_left == 0) {
         return true;
       }
-      vresource->description = (char *) gpr_malloc(stream->bytes_left + 1);
+      vresource->description = (char *)gpr_malloc(stream->bytes_left + 1);
       vresource->description[stream->bytes_left] = '\0';
       if (!pb_read(stream, (uint8_t *)vresource->description,
                    stream->bytes_left)) {
@@ -133,8 +133,9 @@ static bool validate_units_helper(pb_istream_t *stream, int *count,
     (*count)++;
     // Have to allocate a new array of values. Normal case is 0 or 1, so
     // this should normally not be an issue.
-    google_census_Resource_BasicUnit *new_bup = (google_census_Resource_BasicUnit *)
-        gpr_malloc((size_t)*count * sizeof(google_census_Resource_BasicUnit));
+    google_census_Resource_BasicUnit *new_bup =
+        (google_census_Resource_BasicUnit *)gpr_malloc(
+            (size_t)*count * sizeof(google_census_Resource_BasicUnit));
     if (*count != 1) {
       memcpy(new_bup, *bup,
              (size_t)(*count - 1) * sizeof(google_census_Resource_BasicUnit));
@@ -207,7 +208,8 @@ size_t allocate_resource(void) {
   // Expand resources if needed.
   if (n_resources == n_defined_resources) {
     size_t new_n_resources = n_resources ? n_resources * 2 : 2;
-    resource **new_resources = (resource **) gpr_malloc(new_n_resources * sizeof(resource *));
+    resource **new_resources =
+        (resource **)gpr_malloc(new_n_resources * sizeof(resource *));
     if (n_resources != 0) {
       memcpy(new_resources, resources, n_resources * sizeof(resource *));
     }
@@ -226,7 +228,7 @@ size_t allocate_resource(void) {
     }
   }
   GPR_ASSERT(id < n_resources && resources[id] == NULL);
-  resources[id] = (resource *) gpr_malloc(sizeof(resource));
+  resources[id] = (resource *)gpr_malloc(sizeof(resource));
   memset(resources[id], 0, sizeof(resource));
   n_defined_resources++;
   next_id = (id + 1) % n_resources;
@@ -276,22 +278,24 @@ int32_t define_resource(const resource *base) {
   gpr_mu_lock(&resource_lock);
   size_t id = allocate_resource();
   size_t len = strlen(base->name) + 1;
-  resources[id]->name = (char *) gpr_malloc(len);
+  resources[id]->name = (char *)gpr_malloc(len);
   memcpy(resources[id]->name, base->name, len);
   if (base->description) {
     len = strlen(base->description) + 1;
-    resources[id]->description = (char *) gpr_malloc(len);
+    resources[id]->description = (char *)gpr_malloc(len);
     memcpy(resources[id]->description, base->description, len);
   }
   resources[id]->prefix = base->prefix;
   resources[id]->n_numerators = base->n_numerators;
   len = (size_t)base->n_numerators * sizeof(*base->numerators);
-  resources[id]->numerators = (google_census_Resource_BasicUnit *) gpr_malloc(len);
+  resources[id]->numerators =
+      (google_census_Resource_BasicUnit *)gpr_malloc(len);
   memcpy(resources[id]->numerators, base->numerators, len);
   resources[id]->n_denominators = base->n_denominators;
   if (base->n_denominators != 0) {
     len = (size_t)base->n_denominators * sizeof(*base->denominators);
-    resources[id]->denominators = (google_census_Resource_BasicUnit *) gpr_malloc(len);
+    resources[id]->denominators =
+        (google_census_Resource_BasicUnit *)gpr_malloc(len);
     memcpy(resources[id]->denominators, base->denominators, len);
   }
   gpr_mu_unlock(&resource_lock);

src/core/ext/filters/max_age/max_age_filter.c

@@ -273,7 +273,7 @@ static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
 static void destroy_call_elem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
                               const grpc_call_final_info* final_info,
                               grpc_closure* ignored) {
-  channel_data* chand = (channel_data *) elem->channel_data;
+  channel_data* chand = (channel_data*)elem->channel_data;
   decrease_call_count(exec_ctx, chand);
 }