grpc 1.7.3 → 1.8.0

data/src/core/ext/filters/client_channel/uri_parser.h

@@ -22,29 +22,37 @@
 #include <stddef.h>
 #include "src/core/lib/iomgr/exec_ctx.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct {
-  char *scheme;
-  char *authority;
-  char *path;
-  char *query;
+  char* scheme;
+  char* authority;
+  char* path;
+  char* query;
   /** Query substrings separated by '&' */
-  char **query_parts;
+  char** query_parts;
   /** Number of elements in \a query_parts and \a query_parts_values */
   size_t num_query_parts;
   /** Split each query part by '='. NULL if not present. */
-  char **query_parts_values;
-  char *fragment;
+  char** query_parts_values;
+  char* fragment;
 } grpc_uri;
 
 /** parse a uri, return NULL on failure */
-grpc_uri *grpc_uri_parse(grpc_exec_ctx *exec_ctx, const char *uri_text,
+grpc_uri* grpc_uri_parse(grpc_exec_ctx* exec_ctx, const char* uri_text,
                          bool suppress_errors);
 
 /** return the part of a query string after the '=' in "?key=xxx&...", or NULL
  * if key is not present */
-const char *grpc_uri_get_query_arg(const grpc_uri *uri, const char *key);
+const char* grpc_uri_get_query_arg(const grpc_uri* uri, const char* key);
 
 /** destroy a uri */
-void grpc_uri_destroy(grpc_uri *uri);
+void grpc_uri_destroy(grpc_uri* uri);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_URI_PARSER_H */

data/src/core/ext/filters/deadline/{deadline_filter.c → deadline_filter.cc}

@@ -86,13 +86,12 @@ static void timer_callback(grpc_exec_ctx* exec_ctx, void* arg,
 // synchronized.
 static void start_timer_if_needed(grpc_exec_ctx* exec_ctx,
                                   grpc_call_element* elem,
-                                  gpr_timespec deadline) {
-  deadline = gpr_convert_clock_type(deadline, GPR_CLOCK_MONOTONIC);
-  if (gpr_time_cmp(deadline, gpr_inf_future(GPR_CLOCK_MONOTONIC)) == 0) {
+                                  grpc_millis deadline) {
+  if (deadline == GRPC_MILLIS_INF_FUTURE) {
     return;
   }
   grpc_deadline_state* deadline_state = (grpc_deadline_state*)elem->call_data;
-  grpc_closure* closure = NULL;
+  grpc_closure* closure = nullptr;
   switch (deadline_state->timer_state) {
     case GRPC_DEADLINE_STATE_PENDING:
       // Note: We do not start the timer if there is already a timer
@@ -112,10 +111,9 @@ static void start_timer_if_needed(grpc_exec_ctx* exec_ctx,
                             elem, grpc_schedule_on_exec_ctx);
       break;
   }
-  GPR_ASSERT(closure != NULL);
+  GPR_ASSERT(closure != nullptr);
   GRPC_CALL_STACK_REF(deadline_state->call_stack, "deadline_timer");
-  grpc_timer_init(exec_ctx, &deadline_state->timer, deadline, closure,
-                  gpr_now(GPR_CLOCK_MONOTONIC));
+  grpc_timer_init(exec_ctx, &deadline_state->timer, deadline, closure);
 }
 
 // Cancels the deadline timer.
@@ -155,7 +153,7 @@ static void inject_on_complete_cb(grpc_deadline_state* deadline_state,
 struct start_timer_after_init_state {
   bool in_call_combiner;
   grpc_call_element* elem;
-  gpr_timespec deadline;
+  grpc_millis deadline;
   grpc_closure closure;
 };
 static void start_timer_after_init(grpc_exec_ctx* exec_ctx, void* arg,
@@ -182,14 +180,13 @@ static void start_timer_after_init(grpc_exec_ctx* exec_ctx, void* arg,
 void grpc_deadline_state_init(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
                               grpc_call_stack* call_stack,
                               grpc_call_combiner* call_combiner,
-                              gpr_timespec deadline) {
+                              grpc_millis deadline) {
   grpc_deadline_state* deadline_state = (grpc_deadline_state*)elem->call_data;
   deadline_state->call_stack = call_stack;
   deadline_state->call_combiner = call_combiner;
   // Deadline will always be infinite on servers, so the timer will only be
   // set on clients with a finite deadline.
-  deadline = gpr_convert_clock_type(deadline, GPR_CLOCK_MONOTONIC);
-  if (gpr_time_cmp(deadline, gpr_inf_future(GPR_CLOCK_MONOTONIC)) != 0) {
+  if (deadline != GRPC_MILLIS_INF_FUTURE) {
     // When the deadline passes, we indicate the failure by sending down
     // an op with cancel_error set.  However, we can't send down any ops
     // until after the call stack is fully initialized.  If we start the
@@ -214,7 +211,7 @@ void grpc_deadline_state_destroy(grpc_exec_ctx* exec_ctx,
 }
 
 void grpc_deadline_state_reset(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
-                               gpr_timespec new_deadline) {
+                               grpc_millis new_deadline) {
   grpc_deadline_state* deadline_state = (grpc_deadline_state*)elem->call_data;
   cancel_timer_if_needed(exec_ctx, deadline_state);
   start_timer_if_needed(exec_ctx, elem, new_deadline);
@@ -381,11 +378,11 @@ static bool maybe_add_deadline_filter(grpc_exec_ctx* exec_ctx,
   return grpc_deadline_checking_enabled(
              grpc_channel_stack_builder_get_channel_arguments(builder))
              ? grpc_channel_stack_builder_prepend_filter(
-                   builder, (const grpc_channel_filter*)arg, NULL, NULL)
+                   builder, (const grpc_channel_filter*)arg, nullptr, nullptr)
              : true;
 }
 
-void grpc_deadline_filter_init(void) {
+extern "C" void grpc_deadline_filter_init(void) {
   grpc_channel_init_register_stage(
       GRPC_CLIENT_DIRECT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
       maybe_add_deadline_filter, (void*)&grpc_client_deadline_filter);
@@ -394,4 +391,4 @@ void grpc_deadline_filter_init(void) {
       maybe_add_deadline_filter, (void*)&grpc_server_deadline_filter);
 }
 
-void grpc_deadline_filter_shutdown(void) {}
+extern "C" void grpc_deadline_filter_shutdown(void) {}

data/src/core/ext/filters/deadline/deadline_filter.h

@@ -20,6 +20,10 @@
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/iomgr/timer.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef enum grpc_deadline_timer_state {
   GRPC_DEADLINE_STATE_INITIAL,
   GRPC_DEADLINE_STATE_PENDING,
@@ -52,7 +56,8 @@ typedef struct grpc_deadline_state {
 void grpc_deadline_state_init(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
                               grpc_call_stack* call_stack,
                               grpc_call_combiner* call_combiner,
-                              gpr_timespec deadline);
+                              grpc_millis deadline);
+
 void grpc_deadline_state_destroy(grpc_exec_ctx* exec_ctx,
                                  grpc_call_element* elem);
 
@@ -66,7 +71,7 @@ void grpc_deadline_state_destroy(grpc_exec_ctx* exec_ctx,
 //
 // Note: Must be called while holding the call combiner.
 void grpc_deadline_state_reset(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
-                               gpr_timespec new_deadline);
+                               grpc_millis new_deadline);
 
 // To be called from the client-side filter's start_transport_stream_op_batch()
 // method.  Ensures that the deadline timer is cancelled when the call
@@ -89,4 +94,8 @@ bool grpc_deadline_checking_enabled(const grpc_channel_args* args);
 extern const grpc_channel_filter grpc_client_deadline_filter;
 extern const grpc_channel_filter grpc_server_deadline_filter;
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_EXT_FILTERS_DEADLINE_DEADLINE_FILTER_H */

data/src/core/ext/filters/http/client/{http_client_filter.c → http_client_filter.cc}

@@ -36,7 +36,7 @@
 static const size_t kMaxPayloadSizeForGet = 2048;
 
 typedef struct call_data {
-  grpc_call_combiner *call_combiner;
+  grpc_call_combiner* call_combiner;
   // State for handling send_initial_metadata ops.
   grpc_linked_mdelem method;
   grpc_linked_mdelem scheme;
@@ -45,20 +45,20 @@ typedef struct call_data {
   grpc_linked_mdelem content_type;
   grpc_linked_mdelem user_agent;
   // State for handling recv_initial_metadata ops.
-  grpc_metadata_batch *recv_initial_metadata;
-  grpc_closure *original_recv_initial_metadata_ready;
+  grpc_metadata_batch* recv_initial_metadata;
+  grpc_closure* original_recv_initial_metadata_ready;
   grpc_closure recv_initial_metadata_ready;
   // State for handling recv_trailing_metadata ops.
-  grpc_metadata_batch *recv_trailing_metadata;
-  grpc_closure *original_recv_trailing_metadata_on_complete;
+  grpc_metadata_batch* recv_trailing_metadata;
+  grpc_closure* original_recv_trailing_metadata_on_complete;
   grpc_closure recv_trailing_metadata_on_complete;
   // State for handling send_message ops.
-  grpc_transport_stream_op_batch *send_message_batch;
+  grpc_transport_stream_op_batch* send_message_batch;
   size_t send_message_bytes_read;
   grpc_byte_stream_cache send_message_cache;
   grpc_caching_byte_stream send_message_caching_stream;
   grpc_closure on_send_message_next_done;
-  grpc_closure *original_send_message_on_complete;
+  grpc_closure* original_send_message_on_complete;
   grpc_closure send_message_on_complete;
 } call_data;
 
@@ -68,18 +68,18 @@ typedef struct channel_data {
   size_t max_payload_size_for_get;
 } channel_data;
 
-static grpc_error *client_filter_incoming_metadata(grpc_exec_ctx *exec_ctx,
-                                                   grpc_call_element *elem,
-                                                   grpc_metadata_batch *b) {
-  if (b->idx.named.status != NULL) {
+static grpc_error* client_filter_incoming_metadata(grpc_exec_ctx* exec_ctx,
+                                                   grpc_call_element* elem,
+                                                   grpc_metadata_batch* b) {
+  if (b->idx.named.status != nullptr) {
     if (grpc_mdelem_eq(b->idx.named.status->md, GRPC_MDELEM_STATUS_200)) {
       grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.status);
     } else {
-      char *val = grpc_dump_slice(GRPC_MDVALUE(b->idx.named.status->md),
+      char* val = grpc_dump_slice(GRPC_MDVALUE(b->idx.named.status->md),
                                   GPR_DUMP_ASCII);
-      char *msg;
+      char* msg;
       gpr_asprintf(&msg, "Received http2 header with status: %s", val);
-      grpc_error *e = grpc_error_set_str(
+      grpc_error* e = grpc_error_set_str(
           grpc_error_set_int(
               grpc_error_set_str(
                   GRPC_ERROR_CREATE_FROM_STATIC_STRING(
@@ -93,7 +93,7 @@ static grpc_error *client_filter_incoming_metadata(grpc_exec_ctx *exec_ctx,
     }
   }
 
-  if (b->idx.named.grpc_message != NULL) {
+  if (b->idx.named.grpc_message != nullptr) {
     grpc_slice pct_decoded_msg = grpc_permissive_percent_decode_slice(
         GRPC_MDVALUE(b->idx.named.grpc_message->md));
     if (grpc_slice_is_equivalent(pct_decoded_msg,
@@ -105,7 +105,7 @@ static grpc_error *client_filter_incoming_metadata(grpc_exec_ctx *exec_ctx,
     }
   }
 
-  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),
@@ -125,7 +125,7 @@ static grpc_error *client_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);
@@ -137,10 +137,10 @@ static grpc_error *client_filter_incoming_metadata(grpc_exec_ctx *exec_ctx,
   return GRPC_ERROR_NONE;
 }
 
-static void recv_initial_metadata_ready(grpc_exec_ctx *exec_ctx,
-                                        void *user_data, grpc_error *error) {
-  grpc_call_element *elem = (grpc_call_element *)user_data;
-  call_data *calld = (call_data *)elem->call_data;
+static void recv_initial_metadata_ready(grpc_exec_ctx* exec_ctx,
+                                        void* user_data, grpc_error* error) {
+  grpc_call_element* elem = (grpc_call_element*)user_data;
+  call_data* calld = (call_data*)elem->call_data;
   if (error == GRPC_ERROR_NONE) {
     error = client_filter_incoming_metadata(exec_ctx, elem,
                                             calld->recv_initial_metadata);
@@ -151,11 +151,11 @@ static void recv_initial_metadata_ready(grpc_exec_ctx *exec_ctx,
                    error);
 }
 
-static void recv_trailing_metadata_on_complete(grpc_exec_ctx *exec_ctx,
-                                               void *user_data,
-                                               grpc_error *error) {
-  grpc_call_element *elem = (grpc_call_element *)user_data;
-  call_data *calld = (call_data *)elem->call_data;
+static void recv_trailing_metadata_on_complete(grpc_exec_ctx* exec_ctx,
+                                               void* user_data,
+                                               grpc_error* error) {
+  grpc_call_element* elem = (grpc_call_element*)user_data;
+  call_data* calld = (call_data*)elem->call_data;
   if (error == GRPC_ERROR_NONE) {
     error = client_filter_incoming_metadata(exec_ctx, elem,
                                             calld->recv_trailing_metadata);
@@ -166,10 +166,10 @@ static void recv_trailing_metadata_on_complete(grpc_exec_ctx *exec_ctx,
                    error);
 }
 
-static void send_message_on_complete(grpc_exec_ctx *exec_ctx, void *arg,
-                                     grpc_error *error) {
-  grpc_call_element *elem = (grpc_call_element *)arg;
-  call_data *calld = (call_data *)elem->call_data;
+static void send_message_on_complete(grpc_exec_ctx* exec_ctx, void* arg,
+                                     grpc_error* error) {
+  grpc_call_element* elem = (grpc_call_element*)arg;
+  call_data* calld = (call_data*)elem->call_data;
   grpc_byte_stream_cache_destroy(exec_ctx, &calld->send_message_cache);
   GRPC_CLOSURE_RUN(exec_ctx, calld->original_send_message_on_complete,
                    GRPC_ERROR_REF(error));
@@ -177,10 +177,10 @@ static void send_message_on_complete(grpc_exec_ctx *exec_ctx, void *arg,
 
 // Pulls a slice from the send_message byte stream, updating
 // calld->send_message_bytes_read.
-static grpc_error *pull_slice_from_send_message(grpc_exec_ctx *exec_ctx,
-                                                call_data *calld) {
+static grpc_error* pull_slice_from_send_message(grpc_exec_ctx* exec_ctx,
+                                                call_data* calld) {
   grpc_slice incoming_slice;
-  grpc_error *error = grpc_byte_stream_pull(
+  grpc_error* error = grpc_byte_stream_pull(
       exec_ctx, &calld->send_message_caching_stream.base, &incoming_slice);
   if (error == GRPC_ERROR_NONE) {
     calld->send_message_bytes_read += GRPC_SLICE_LENGTH(incoming_slice);
@@ -194,12 +194,12 @@ static grpc_error *pull_slice_from_send_message(grpc_exec_ctx *exec_ctx,
 // calld->send_message_caching_stream.base.length, then we have completed
 // reading from the byte stream; otherwise, an async read has been dispatched
 // and on_send_message_next_done() will be invoked when it is complete.
-static grpc_error *read_all_available_send_message_data(grpc_exec_ctx *exec_ctx,
-                                                        call_data *calld) {
+static grpc_error* read_all_available_send_message_data(grpc_exec_ctx* exec_ctx,
+                                                        call_data* calld) {
   while (grpc_byte_stream_next(exec_ctx,
                                &calld->send_message_caching_stream.base,
                                ~(size_t)0, &calld->on_send_message_next_done)) {
-    grpc_error *error = pull_slice_from_send_message(exec_ctx, calld);
+    grpc_error* error = pull_slice_from_send_message(exec_ctx, calld);
     if (error != GRPC_ERROR_NONE) return error;
     if (calld->send_message_bytes_read ==
         calld->send_message_caching_stream.base.length) {
@@ -210,10 +210,10 @@ static grpc_error *read_all_available_send_message_data(grpc_exec_ctx *exec_ctx,
 }
 
 // Async callback for grpc_byte_stream_next().
-static void on_send_message_next_done(grpc_exec_ctx *exec_ctx, void *arg,
-                                      grpc_error *error) {
-  grpc_call_element *elem = (grpc_call_element *)arg;
-  call_data *calld = (call_data *)elem->call_data;
+static void on_send_message_next_done(grpc_exec_ctx* exec_ctx, void* arg,
+                                      grpc_error* error) {
+  grpc_call_element* elem = (grpc_call_element*)arg;
+  call_data* calld = (call_data*)elem->call_data;
   if (error != GRPC_ERROR_NONE) {
     grpc_transport_stream_op_batch_finish_with_failure(
         exec_ctx, calld->send_message_batch, error, calld->call_combiner);
@@ -233,8 +233,8 @@ static void on_send_message_next_done(grpc_exec_ctx *exec_ctx, void *arg,
   grpc_call_next_op(exec_ctx, elem, calld->send_message_batch);
 }
 
-static char *slice_buffer_to_string(grpc_slice_buffer *slice_buffer) {
-  char *payload_bytes = (char *)gpr_malloc(slice_buffer->length + 1);
+static char* slice_buffer_to_string(grpc_slice_buffer* slice_buffer) {
+  char* payload_bytes = (char*)gpr_malloc(slice_buffer->length + 1);
   size_t offset = 0;
   for (size_t i = 0; i < slice_buffer->count; ++i) {
     memcpy(payload_bytes + offset,
@@ -248,10 +248,10 @@ static char *slice_buffer_to_string(grpc_slice_buffer *slice_buffer) {
 
 // Modifies the path entry in the batch's send_initial_metadata to
 // append the base64-encoded query for a GET request.
-static grpc_error *update_path_for_get(grpc_exec_ctx *exec_ctx,
-                                       grpc_call_element *elem,
-                                       grpc_transport_stream_op_batch *batch) {
-  call_data *calld = (call_data *)elem->call_data;
+static grpc_error* update_path_for_get(grpc_exec_ctx* exec_ctx,
+                                       grpc_call_element* elem,
+                                       grpc_transport_stream_op_batch* batch) {
+  call_data* calld = (call_data*)elem->call_data;
   grpc_slice path_slice =
       GRPC_MDVALUE(batch->payload->send_initial_metadata.send_initial_metadata
                        ->idx.named.path->md);
@@ -264,44 +264,44 @@ static grpc_error *update_path_for_get(grpc_exec_ctx *exec_ctx,
       false /* multi_line */);
   grpc_slice path_with_query_slice = GRPC_SLICE_MALLOC(estimated_len);
   /* memcopy individual pieces into this slice */
-  char *write_ptr = (char *)GRPC_SLICE_START_PTR(path_with_query_slice);
-  char *original_path = (char *)GRPC_SLICE_START_PTR(path_slice);
+  char* write_ptr = (char*)GRPC_SLICE_START_PTR(path_with_query_slice);
+  char* original_path = (char*)GRPC_SLICE_START_PTR(path_slice);
   memcpy(write_ptr, original_path, GRPC_SLICE_LENGTH(path_slice));
   write_ptr += GRPC_SLICE_LENGTH(path_slice);
   *write_ptr++ = '?';
-  char *payload_bytes =
+  char* payload_bytes =
       slice_buffer_to_string(&calld->send_message_cache.cache_buffer);
-  grpc_base64_encode_core((char *)write_ptr, payload_bytes,
+  grpc_base64_encode_core((char*)write_ptr, payload_bytes,
                           batch->payload->send_message.send_message->length,
                           true /* url_safe */, false /* multi_line */);
   gpr_free(payload_bytes);
   /* remove trailing unused memory and add trailing 0 to terminate string */
-  char *t = (char *)GRPC_SLICE_START_PTR(path_with_query_slice);
+  char* t = (char*)GRPC_SLICE_START_PTR(path_with_query_slice);
   /* safe to use strlen since base64_encode will always add '\0' */
   path_with_query_slice =
       grpc_slice_sub_no_ref(path_with_query_slice, 0, strlen(t));
   /* substitute previous path with the new path+query */
   grpc_mdelem mdelem_path_and_query =
       grpc_mdelem_from_slices(exec_ctx, GRPC_MDSTR_PATH, path_with_query_slice);
-  grpc_metadata_batch *b =
+  grpc_metadata_batch* b =
       batch->payload->send_initial_metadata.send_initial_metadata;
   return grpc_metadata_batch_substitute(exec_ctx, b, b->idx.named.path,
                                         mdelem_path_and_query);
 }
 
-static void remove_if_present(grpc_exec_ctx *exec_ctx,
-                              grpc_metadata_batch *batch,
+static void remove_if_present(grpc_exec_ctx* exec_ctx,
+                              grpc_metadata_batch* batch,
                               grpc_metadata_batch_callouts_index idx) {
-  if (batch->idx.array[idx] != NULL) {
+  if (batch->idx.array[idx] != nullptr) {
     grpc_metadata_batch_remove(exec_ctx, batch, batch->idx.array[idx]);
   }
 }
 
 static void hc_start_transport_stream_op_batch(
-    grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-    grpc_transport_stream_op_batch *batch) {
-  call_data *calld = (call_data *)elem->call_data;
-  channel_data *channeld = (channel_data *)elem->channel_data;
+    grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+    grpc_transport_stream_op_batch* batch) {
+  call_data* calld = (call_data*)elem->call_data;
+  channel_data* channeld = (channel_data*)elem->channel_data;
   GPR_TIMER_BEGIN("hc_start_transport_stream_op_batch", 0);
 
   if (batch->recv_initial_metadata) {
@@ -322,7 +322,7 @@ static void hc_start_transport_stream_op_batch(
     batch->on_complete = &calld->recv_trailing_metadata_on_complete;
   }
 
-  grpc_error *error = GRPC_ERROR_NONE;
+  grpc_error* error = GRPC_ERROR_NONE;
   bool batch_will_be_handled_asynchronously = false;
   if (batch->send_initial_metadata) {
     // Decide which HTTP VERB to use. We use GET if the request is marked
@@ -422,10 +422,10 @@ done:
 }
 
 /* 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->call_combiner = args->call_combiner;
   GRPC_CLOSURE_INIT(&calld->recv_initial_metadata_ready,
                     recv_initial_metadata_ready, elem,
@@ -441,16 +441,16 @@ 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) {}
+static void destroy_call_elem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+                              const grpc_call_final_info* final_info,
+                              grpc_closure* ignored) {}
 
-static grpc_mdelem scheme_from_args(const grpc_channel_args *args) {
+static grpc_mdelem scheme_from_args(const grpc_channel_args* args) {
   unsigned i;
   size_t j;
   grpc_mdelem valid_schemes[] = {GRPC_MDELEM_SCHEME_HTTP,
                                  GRPC_MDELEM_SCHEME_HTTPS};
-  if (args != NULL) {
+  if (args != nullptr) {
     for (i = 0; i < args->num_args; ++i) {
       if (args->args[i].type == GRPC_ARG_STRING &&
           strcmp(args->args[i].key, GRPC_ARG_HTTP2_SCHEME) == 0) {
@@ -466,8 +466,8 @@ static grpc_mdelem scheme_from_args(const grpc_channel_args *args) {
   return GRPC_MDELEM_SCHEME_HTTP;
 }
 
-static size_t max_payload_size_from_args(const grpc_channel_args *args) {
-  if (args != NULL) {
+static size_t max_payload_size_from_args(const grpc_channel_args* args) {
+  if (args != nullptr) {
     for (size_t i = 0; i < args->num_args; ++i) {
       if (0 == strcmp(args->args[i].key, GRPC_ARG_MAX_PAYLOAD_SIZE_FOR_GET)) {
         if (args->args[i].type != GRPC_ARG_INTEGER) {
@@ -482,12 +482,12 @@ static size_t max_payload_size_from_args(const grpc_channel_args *args) {
   return kMaxPayloadSizeForGet;
 }
 
-static grpc_slice user_agent_from_args(const grpc_channel_args *args,
-                                       const char *transport_name) {
+static grpc_slice user_agent_from_args(const grpc_channel_args* args,
+                                       const char* transport_name) {
   gpr_strvec v;
   size_t i;
   int is_first = 1;
-  char *tmp;
+  char* tmp;
   grpc_slice result;
 
   gpr_strvec_init(&v);
@@ -524,7 +524,7 @@ static grpc_slice user_agent_from_args(const grpc_channel_args *args,
     }
   }
 
-  tmp = gpr_strvec_flatten(&v, NULL);
+  tmp = gpr_strvec_flatten(&v, nullptr);
   gpr_strvec_destroy(&v);
   result = grpc_slice_intern(grpc_slice_from_static_string(tmp));
   gpr_free(tmp);
@@ -533,12 +533,12 @@ static grpc_slice user_agent_from_args(const grpc_channel_args *args,
 }
 
 /* Constructor for channel_data */
-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;
+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;
   GPR_ASSERT(!args->is_last);
-  GPR_ASSERT(args->optional_transport != NULL);
+  GPR_ASSERT(args->optional_transport != nullptr);
   chand->static_scheme = scheme_from_args(args->channel_args);
   chand->max_payload_size_for_get =
       max_payload_size_from_args(args->channel_args);
@@ -550,9 +550,9 @@ 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) {
-  channel_data *chand = (channel_data *)elem->channel_data;
+static void destroy_channel_elem(grpc_exec_ctx* exec_ctx,
+                                 grpc_channel_element* elem) {
+  channel_data* chand = (channel_data*)elem->channel_data;
   GRPC_MDELEM_UNREF(exec_ctx, chand->user_agent);
 }