grpc 1.7.3 → 1.8.0

data/src/core/ext/filters/http/message_compress/message_compress_filter.h

@@ -23,6 +23,10 @@
 
 #include "src/core/lib/channel/channel_stack.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /** Compression filter for outgoing data.
  *
  * See <grpc/compression.h> for the available compression settings.
@@ -47,5 +51,9 @@
 
 extern const grpc_channel_filter grpc_message_compress_filter;
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_EXT_FILTERS_HTTP_MESSAGE_COMPRESS_MESSAGE_COMPRESS_FILTER_H \
-          */
+        */

data/src/core/ext/filters/http/server/{http_server_filter.c → http_server_filter.cc}

@@ -32,7 +32,7 @@
 #define EXPECTED_CONTENT_TYPE_LENGTH sizeof(EXPECTED_CONTENT_TYPE) - 1
 
 typedef struct call_data {
-  grpc_call_combiner *call_combiner;
+  grpc_call_combiner* call_combiner;
 
   grpc_linked_mdelem status;
   grpc_linked_mdelem content_type;
@@ -42,15 +42,15 @@ typedef struct call_data {
   /* flag to ensure payload_bin is delivered only once */
   bool payload_bin_delivered;
 
-  grpc_metadata_batch *recv_initial_metadata;
-  uint32_t *recv_initial_metadata_flags;
+  grpc_metadata_batch* recv_initial_metadata;
+  uint32_t* recv_initial_metadata_flags;
   /** Closure to call when finished with the hs_on_recv hook */
-  grpc_closure *on_done_recv;
+  grpc_closure* on_done_recv;
   /** Closure to call when we retrieve read message from the path URI
    */
-  grpc_closure *recv_message_ready;
-  grpc_closure *on_complete;
-  grpc_byte_stream **pp_recv_message;
+  grpc_closure* recv_message_ready;
+  grpc_closure* on_complete;
+  grpc_byte_stream** pp_recv_message;
   grpc_slice_buffer read_slice_buffer;
   grpc_slice_buffer_stream read_stream;
 
@@ -62,12 +62,14 @@ typedef struct call_data {
   grpc_closure hs_recv_message_ready;
 } call_data;
 
-typedef struct channel_data { uint8_t unused; } channel_data;
+typedef struct channel_data {
+  uint8_t unused;
+} channel_data;
 
-static grpc_error *server_filter_outgoing_metadata(grpc_exec_ctx *exec_ctx,
-                                                   grpc_call_element *elem,
-                                                   grpc_metadata_batch *b) {
-  if (b->idx.named.grpc_message != NULL) {
+static grpc_error* server_filter_outgoing_metadata(grpc_exec_ctx* exec_ctx,
+                                                   grpc_call_element* elem,
+                                                   grpc_metadata_batch* b) {
+  if (b->idx.named.grpc_message != nullptr) {
     grpc_slice pct_encoded_msg = grpc_percent_encode_slice(
         GRPC_MDVALUE(b->idx.named.grpc_message->md),
         grpc_compatible_percent_encoding_unreserved_bytes);
@@ -82,8 +84,8 @@ static grpc_error *server_filter_outgoing_metadata(grpc_exec_ctx *exec_ctx,
   return GRPC_ERROR_NONE;
 }
 
-static void add_error(const char *error_name, grpc_error **cumulative,
-                      grpc_error *new_err) {
+static void add_error(const char* error_name, grpc_error** cumulative,
+                      grpc_error* new_err) {
   if (new_err == GRPC_ERROR_NONE) return;
   if (*cumulative == GRPC_ERROR_NONE) {
     *cumulative = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_name);
@@ -91,14 +93,14 @@ static void add_error(const char *error_name, grpc_error **cumulative,
   *cumulative = grpc_error_add_child(*cumulative, new_err);
 }
 
-static grpc_error *server_filter_incoming_metadata(grpc_exec_ctx *exec_ctx,
-                                                   grpc_call_element *elem,
-                                                   grpc_metadata_batch *b) {
-  call_data *calld = (call_data *)elem->call_data;
-  grpc_error *error = GRPC_ERROR_NONE;
-  static const char *error_name = "Failed processing incoming headers";
+static grpc_error* server_filter_incoming_metadata(grpc_exec_ctx* exec_ctx,
+                                                   grpc_call_element* elem,
+                                                   grpc_metadata_batch* b) {
+  call_data* calld = (call_data*)elem->call_data;
+  grpc_error* error = GRPC_ERROR_NONE;
+  static const char* error_name = "Failed processing incoming headers";
 
-  if (b->idx.named.method != NULL) {
+  if (b->idx.named.method != nullptr) {
     if (grpc_mdelem_eq(b->idx.named.method->md, GRPC_MDELEM_METHOD_POST)) {
       *calld->recv_initial_metadata_flags &=
           ~(GRPC_INITIAL_METADATA_CACHEABLE_REQUEST |
@@ -130,7 +132,7 @@ static grpc_error *server_filter_incoming_metadata(grpc_exec_ctx *exec_ctx,
             GRPC_ERROR_STR_KEY, grpc_slice_from_static_string(":method")));
   }
 
-  if (b->idx.named.te != NULL) {
+  if (b->idx.named.te != nullptr) {
     if (!grpc_mdelem_eq(b->idx.named.te->md, GRPC_MDELEM_TE_TRAILERS)) {
       add_error(error_name, &error,
                 grpc_attach_md_to_error(
@@ -145,7 +147,7 @@ static grpc_error *server_filter_incoming_metadata(grpc_exec_ctx *exec_ctx,
                   GRPC_ERROR_STR_KEY, grpc_slice_from_static_string("te")));
   }
 
-  if (b->idx.named.scheme != NULL) {
+  if (b->idx.named.scheme != nullptr) {
     if (!grpc_mdelem_eq(b->idx.named.scheme->md, GRPC_MDELEM_SCHEME_HTTP) &&
         !grpc_mdelem_eq(b->idx.named.scheme->md, GRPC_MDELEM_SCHEME_HTTPS) &&
         !grpc_mdelem_eq(b->idx.named.scheme->md, GRPC_MDELEM_SCHEME_GRPC)) {
@@ -163,7 +165,7 @@ static grpc_error *server_filter_incoming_metadata(grpc_exec_ctx *exec_ctx,
             GRPC_ERROR_STR_KEY, grpc_slice_from_static_string(":scheme")));
   }
 
-  if (b->idx.named.content_type != NULL) {
+  if (b->idx.named.content_type != nullptr) {
     if (!grpc_mdelem_eq(b->idx.named.content_type->md,
                         GRPC_MDELEM_CONTENT_TYPE_APPLICATION_SLASH_GRPC)) {
       if (grpc_slice_buf_start_eq(GRPC_MDVALUE(b->idx.named.content_type->md),
@@ -183,7 +185,7 @@ static grpc_error *server_filter_incoming_metadata(grpc_exec_ctx *exec_ctx,
       } else {
         /* TODO(klempner): We're currently allowing this, but we shouldn't
            see it without a proxy so log for now. */
-        char *val = grpc_dump_slice(GRPC_MDVALUE(b->idx.named.content_type->md),
+        char* val = grpc_dump_slice(GRPC_MDVALUE(b->idx.named.content_type->md),
                                     GPR_DUMP_ASCII);
         gpr_log(GPR_INFO, "Unexpected content-type '%s'", val);
         gpr_free(val);
@@ -192,7 +194,7 @@ static grpc_error *server_filter_incoming_metadata(grpc_exec_ctx *exec_ctx,
     grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.content_type);
   }
 
-  if (b->idx.named.path == NULL) {
+  if (b->idx.named.path == nullptr) {
     add_error(error_name, &error,
               grpc_error_set_str(
                   GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
@@ -203,7 +205,7 @@ static grpc_error *server_filter_incoming_metadata(grpc_exec_ctx *exec_ctx,
      * query parameter which is base64 encoded request payload. */
     const char k_query_separator = '?';
     grpc_slice path_slice = GRPC_MDVALUE(b->idx.named.path->md);
-    uint8_t *path_ptr = (uint8_t *)GRPC_SLICE_START_PTR(path_slice);
+    uint8_t* path_ptr = (uint8_t*)GRPC_SLICE_START_PTR(path_slice);
     size_t path_length = GRPC_SLICE_LENGTH(path_slice);
     /* offset of the character '?' */
     size_t offset = 0;
@@ -226,7 +228,7 @@ static grpc_error *server_filter_incoming_metadata(grpc_exec_ctx *exec_ctx,
       grpc_slice_buffer_add(
           &calld->read_slice_buffer,
           grpc_base64_decode_with_len(
-              exec_ctx, (const char *)GRPC_SLICE_START_PTR(query_slice),
+              exec_ctx, (const char*)GRPC_SLICE_START_PTR(query_slice),
               GRPC_SLICE_LENGTH(query_slice), k_url_safe));
       grpc_slice_buffer_stream_init(&calld->read_stream,
                                     &calld->read_slice_buffer, 0);
@@ -237,20 +239,20 @@ static grpc_error *server_filter_incoming_metadata(grpc_exec_ctx *exec_ctx,
     }
   }
 
-  if (b->idx.named.host != NULL && b->idx.named.authority == NULL) {
-    grpc_linked_mdelem *el = b->idx.named.host;
+  if (b->idx.named.host != nullptr && b->idx.named.authority == nullptr) {
+    grpc_linked_mdelem* el = b->idx.named.host;
     grpc_mdelem md = GRPC_MDELEM_REF(el->md);
     grpc_metadata_batch_remove(exec_ctx, b, el);
-    add_error(
-        error_name, &error,
-        grpc_metadata_batch_add_head(
-            exec_ctx, b, el, grpc_mdelem_from_slices(
-                                 exec_ctx, GRPC_MDSTR_AUTHORITY,
-                                 grpc_slice_ref_internal(GRPC_MDVALUE(md)))));
+    add_error(error_name, &error,
+              grpc_metadata_batch_add_head(
+                  exec_ctx, b, el,
+                  grpc_mdelem_from_slices(
+                      exec_ctx, GRPC_MDSTR_AUTHORITY,
+                      grpc_slice_ref_internal(GRPC_MDVALUE(md)))));
     GRPC_MDELEM_UNREF(exec_ctx, md);
   }
 
-  if (b->idx.named.authority == NULL) {
+  if (b->idx.named.authority == nullptr) {
     add_error(
         error_name, &error,
         grpc_error_set_str(
@@ -261,10 +263,10 @@ static grpc_error *server_filter_incoming_metadata(grpc_exec_ctx *exec_ctx,
   return error;
 }
 
-static void hs_on_recv(grpc_exec_ctx *exec_ctx, void *user_data,
-                       grpc_error *err) {
-  grpc_call_element *elem = (grpc_call_element *)user_data;
-  call_data *calld = (call_data *)elem->call_data;
+static void hs_on_recv(grpc_exec_ctx* exec_ctx, void* user_data,
+                       grpc_error* err) {
+  grpc_call_element* elem = (grpc_call_element*)user_data;
+  call_data* calld = (call_data*)elem->call_data;
   if (err == GRPC_ERROR_NONE) {
     err = server_filter_incoming_metadata(exec_ctx, elem,
                                           calld->recv_initial_metadata);
@@ -274,30 +276,30 @@ static void hs_on_recv(grpc_exec_ctx *exec_ctx, void *user_data,
   GRPC_CLOSURE_RUN(exec_ctx, calld->on_done_recv, err);
 }
 
-static void hs_on_complete(grpc_exec_ctx *exec_ctx, void *user_data,
-                           grpc_error *err) {
-  grpc_call_element *elem = (grpc_call_element *)user_data;
-  call_data *calld = (call_data *)elem->call_data;
+static void hs_on_complete(grpc_exec_ctx* exec_ctx, void* user_data,
+                           grpc_error* err) {
+  grpc_call_element* elem = (grpc_call_element*)user_data;
+  call_data* calld = (call_data*)elem->call_data;
   /* Call recv_message_ready if we got the payload via the path field */
-  if (calld->seen_path_with_query && calld->recv_message_ready != NULL) {
+  if (calld->seen_path_with_query && calld->recv_message_ready != nullptr) {
     *calld->pp_recv_message = calld->payload_bin_delivered
-                                  ? NULL
-                                  : (grpc_byte_stream *)&calld->read_stream;
+                                  ? nullptr
+                                  : (grpc_byte_stream*)&calld->read_stream;
     // Re-enter call combiner for recv_message_ready, since the surface
     // code will release the call combiner for each callback it receives.
     GRPC_CALL_COMBINER_START(exec_ctx, calld->call_combiner,
                              calld->recv_message_ready, GRPC_ERROR_REF(err),
                              "resuming recv_message_ready from on_complete");
-    calld->recv_message_ready = NULL;
+    calld->recv_message_ready = nullptr;
     calld->payload_bin_delivered = true;
   }
   GRPC_CLOSURE_RUN(exec_ctx, calld->on_complete, GRPC_ERROR_REF(err));
 }
 
-static void hs_recv_message_ready(grpc_exec_ctx *exec_ctx, void *user_data,
-                                  grpc_error *err) {
-  grpc_call_element *elem = (grpc_call_element *)user_data;
-  call_data *calld = (call_data *)elem->call_data;
+static void hs_recv_message_ready(grpc_exec_ctx* exec_ctx, void* user_data,
+                                  grpc_error* err) {
+  grpc_call_element* elem = (grpc_call_element*)user_data;
+  call_data* calld = (call_data*)elem->call_data;
   if (calld->seen_path_with_query) {
     // Do nothing. This is probably a GET request, and payload will be
     // returned in hs_on_complete callback.
@@ -310,15 +312,15 @@ static void hs_recv_message_ready(grpc_exec_ctx *exec_ctx, void *user_data,
   }
 }
 
-static grpc_error *hs_mutate_op(grpc_exec_ctx *exec_ctx,
-                                grpc_call_element *elem,
-                                grpc_transport_stream_op_batch *op) {
+static grpc_error* hs_mutate_op(grpc_exec_ctx* exec_ctx,
+                                grpc_call_element* elem,
+                                grpc_transport_stream_op_batch* op) {
   /* grab pointers to our data from the call element */
-  call_data *calld = (call_data *)elem->call_data;
+  call_data* calld = (call_data*)elem->call_data;
 
   if (op->send_initial_metadata) {
-    grpc_error *error = GRPC_ERROR_NONE;
-    static const char *error_name = "Failed sending initial metadata";
+    grpc_error* error = GRPC_ERROR_NONE;
+    static const char* error_name = "Failed sending initial metadata";
     add_error(
         error_name, &error,
         grpc_metadata_batch_add_head(
@@ -339,7 +341,7 @@ static grpc_error *hs_mutate_op(grpc_exec_ctx *exec_ctx,
 
   if (op->recv_initial_metadata) {
     /* substitute our callback for the higher callback */
-    GPR_ASSERT(op->payload->recv_initial_metadata.recv_flags != NULL);
+    GPR_ASSERT(op->payload->recv_initial_metadata.recv_flags != nullptr);
     calld->recv_initial_metadata =
         op->payload->recv_initial_metadata.recv_initial_metadata;
     calld->recv_initial_metadata_flags =
@@ -364,7 +366,7 @@ static grpc_error *hs_mutate_op(grpc_exec_ctx *exec_ctx,
   }
 
   if (op->send_trailing_metadata) {
-    grpc_error *error = server_filter_outgoing_metadata(
+    grpc_error* error = server_filter_outgoing_metadata(
         exec_ctx, elem,
         op->payload->send_trailing_metadata.send_trailing_metadata);
     if (error != GRPC_ERROR_NONE) return error;
@@ -374,11 +376,11 @@ static grpc_error *hs_mutate_op(grpc_exec_ctx *exec_ctx,
 }
 
 static void hs_start_transport_stream_op_batch(
-    grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-    grpc_transport_stream_op_batch *op) {
-  call_data *calld = (call_data *)elem->call_data;
+    grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+    grpc_transport_stream_op_batch* op) {
+  call_data* calld = (call_data*)elem->call_data;
   GPR_TIMER_BEGIN("hs_start_transport_stream_op_batch", 0);
-  grpc_error *error = hs_mutate_op(exec_ctx, elem, op);
+  grpc_error* error = hs_mutate_op(exec_ctx, elem, op);
   if (error != GRPC_ERROR_NONE) {
     grpc_transport_stream_op_batch_finish_with_failure(exec_ctx, op, error,
                                                        calld->call_combiner);
@@ -389,11 +391,11 @@ static void hs_start_transport_stream_op_batch(
 }
 
 /* Constructor for call_data */
-static grpc_error *init_call_elem(grpc_exec_ctx *exec_ctx,
-                                  grpc_call_element *elem,
-                                  const grpc_call_element_args *args) {
+static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
+                                  grpc_call_element* elem,
+                                  const grpc_call_element_args* args) {
   /* grab pointers to our data from the call element */
-  call_data *calld = (call_data *)elem->call_data;
+  call_data* calld = (call_data*)elem->call_data;
   /* initialize members */
   calld->call_combiner = args->call_combiner;
   GRPC_CLOSURE_INIT(&calld->hs_on_recv, hs_on_recv, elem,
@@ -407,24 +409,24 @@ static grpc_error *init_call_elem(grpc_exec_ctx *exec_ctx,
 }
 
 /* Destructor for call_data */
-static void destroy_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-                              const grpc_call_final_info *final_info,
-                              grpc_closure *ignored) {
-  call_data *calld = (call_data *)elem->call_data;
+static void destroy_call_elem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+                              const grpc_call_final_info* final_info,
+                              grpc_closure* ignored) {
+  call_data* calld = (call_data*)elem->call_data;
   grpc_slice_buffer_destroy_internal(exec_ctx, &calld->read_slice_buffer);
 }
 
 /* Constructor for channel_data */
-static grpc_error *init_channel_elem(grpc_exec_ctx *exec_ctx,
-                                     grpc_channel_element *elem,
-                                     grpc_channel_element_args *args) {
+static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
+                                     grpc_channel_element* elem,
+                                     grpc_channel_element_args* args) {
   GPR_ASSERT(!args->is_last);
   return GRPC_ERROR_NONE;
 }
 
 /* Destructor for channel data */
-static void destroy_channel_elem(grpc_exec_ctx *exec_ctx,
-                                 grpc_channel_element *elem) {}
+static void destroy_channel_elem(grpc_exec_ctx* exec_ctx,
+                                 grpc_channel_element* elem) {}
 
 const grpc_channel_filter grpc_http_server_filter = {
     hs_start_transport_stream_op_batch,

data/src/core/ext/filters/http/server/http_server_filter.h

@@ -21,7 +21,15 @@
 
 #include "src/core/lib/channel/channel_stack.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* Processes metadata on the client side for HTTP2 transports */
 extern const grpc_channel_filter grpc_http_server_filter;
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_EXT_FILTERS_HTTP_SERVER_HTTP_SERVER_FILTER_H */

data/src/core/ext/filters/load_reporting/{server_load_reporting_filter.c → server_load_reporting_filter.cc}

@@ -43,24 +43,24 @@ typedef struct call_data {
   /* stores the recv_initial_metadata op's ready closure, which we wrap with our
    * own (on_initial_md_ready) in order to capture the incoming initial metadata
    * */
-  grpc_closure *ops_recv_initial_metadata_ready;
+  grpc_closure* ops_recv_initial_metadata_ready;
 
   /* to get notified of the availability of the incoming initial metadata. */
   grpc_closure on_initial_md_ready;
-  grpc_metadata_batch *recv_initial_metadata;
+  grpc_metadata_batch* recv_initial_metadata;
 } call_data;
 
 typedef struct channel_data {
   intptr_t id; /**< an id unique to the channel */
 } channel_data;
 
-static void on_initial_md_ready(grpc_exec_ctx *exec_ctx, void *user_data,
-                                grpc_error *err) {
-  grpc_call_element *elem = (grpc_call_element *)user_data;
-  call_data *calld = (call_data *)elem->call_data;
+static void on_initial_md_ready(grpc_exec_ctx* exec_ctx, void* user_data,
+                                grpc_error* err) {
+  grpc_call_element* elem = (grpc_call_element*)user_data;
+  call_data* calld = (call_data*)elem->call_data;
 
   if (err == GRPC_ERROR_NONE) {
-    if (calld->recv_initial_metadata->idx.named.path != NULL) {
+    if (calld->recv_initial_metadata->idx.named.path != nullptr) {
       calld->service_method = grpc_slice_ref_internal(
           GRPC_MDVALUE(calld->recv_initial_metadata->idx.named.path->md));
       calld->have_service_method = true;
@@ -68,7 +68,7 @@ static void on_initial_md_ready(grpc_exec_ctx *exec_ctx, void *user_data,
       err = grpc_error_add_child(
           err, GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing :path header"));
     }
-    if (calld->recv_initial_metadata->idx.named.lb_token != NULL) {
+    if (calld->recv_initial_metadata->idx.named.lb_token != nullptr) {
       calld->initial_md_string = grpc_slice_ref_internal(
           GRPC_MDVALUE(calld->recv_initial_metadata->idx.named.lb_token->md));
       calld->have_initial_md_string = true;
@@ -85,10 +85,10 @@ static void on_initial_md_ready(grpc_exec_ctx *exec_ctx, void *user_data,
 }
 
 /* Constructor for call_data */
-static grpc_error *init_call_elem(grpc_exec_ctx *exec_ctx,
-                                  grpc_call_element *elem,
-                                  const grpc_call_element_args *args) {
-  call_data *calld = (call_data *)elem->call_data;
+static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
+                                  grpc_call_element* elem,
+                                  const grpc_call_element_args* args) {
+  call_data* calld = (call_data*)elem->call_data;
   calld->id = (intptr_t)args->call_stack;
   GRPC_CLOSURE_INIT(&calld->on_initial_md_ready, on_initial_md_ready, elem,
                     grpc_schedule_on_exec_ctx);
@@ -108,10 +108,10 @@ static grpc_error *init_call_elem(grpc_exec_ctx *exec_ctx,
 }
 
 /* Destructor for call_data */
-static void destroy_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-                              const grpc_call_final_info *final_info,
-                              grpc_closure *ignored) {
-  call_data *calld = (call_data *)elem->call_data;
+static void destroy_call_elem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+                              const grpc_call_final_info* final_info,
+                              grpc_closure* ignored) {
+  call_data* calld = (call_data*)elem->call_data;
 
   /* TODO(dgq): do something with the data
   channel_data *chand = elem->channel_data;
@@ -136,12 +136,12 @@ static void destroy_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
 }
 
 /* Constructor for channel_data */
-static grpc_error *init_channel_elem(grpc_exec_ctx *exec_ctx,
-                                     grpc_channel_element *elem,
-                                     grpc_channel_element_args *args) {
+static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
+                                     grpc_channel_element* elem,
+                                     grpc_channel_element_args* args) {
   GPR_ASSERT(!args->is_last);
 
-  channel_data *chand = (channel_data *)elem->channel_data;
+  channel_data* chand = (channel_data*)elem->channel_data;
   chand->id = (intptr_t)args->channel_stack;
 
   /* TODO(dgq): do something with the data
@@ -158,8 +158,8 @@ static grpc_error *init_channel_elem(grpc_exec_ctx *exec_ctx,
 }
 
 /* Destructor for channel data */
-static void destroy_channel_elem(grpc_exec_ctx *exec_ctx,
-                                 grpc_channel_element *elem) {
+static void destroy_channel_elem(grpc_exec_ctx* exec_ctx,
+                                 grpc_channel_element* elem) {
   /* TODO(dgq): do something with the data
   channel_data *chand = elem->channel_data;
   grpc_load_reporting_call_data lr_call_data = {
@@ -173,11 +173,11 @@ static void destroy_channel_elem(grpc_exec_ctx *exec_ctx,
   */
 }
 
-static grpc_filtered_mdelem lr_trailing_md_filter(grpc_exec_ctx *exec_ctx,
-                                                  void *user_data,
+static grpc_filtered_mdelem lr_trailing_md_filter(grpc_exec_ctx* exec_ctx,
+                                                  void* user_data,
                                                   grpc_mdelem md) {
-  grpc_call_element *elem = (grpc_call_element *)user_data;
-  call_data *calld = (call_data *)elem->call_data;
+  grpc_call_element* elem = (grpc_call_element*)user_data;
+  call_data* calld = (call_data*)elem->call_data;
   if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_LB_COST_BIN)) {
     calld->trailing_md_string = GRPC_MDVALUE(md);
     return GRPC_FILTERED_REMOVE();
@@ -186,10 +186,10 @@ static grpc_filtered_mdelem lr_trailing_md_filter(grpc_exec_ctx *exec_ctx,
 }
 
 static void lr_start_transport_stream_op_batch(
-    grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-    grpc_transport_stream_op_batch *op) {
+    grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+    grpc_transport_stream_op_batch* op) {
   GPR_TIMER_BEGIN("lr_start_transport_stream_op_batch", 0);
-  call_data *calld = (call_data *)elem->call_data;
+  call_data* calld = (call_data*)elem->call_data;
 
   if (op->recv_initial_metadata) {
     /* substitute our callback for the higher callback */