grpc 1.7.3 → 1.8.0

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

@@ -30,90 +30,89 @@ extern "C" {
 #include <grpc/grpc.h>
 #include <grpc/impl/codegen/compression_types.h>
 
-typedef void (*grpc_ioreq_completion_func)(grpc_exec_ctx *exec_ctx,
-                                           grpc_call *call, int success,
-                                           void *user_data);
+typedef void (*grpc_ioreq_completion_func)(grpc_exec_ctx* exec_ctx,
+                                           grpc_call* call, int success,
+                                           void* user_data);
 
 typedef struct grpc_call_create_args {
-  grpc_channel *channel;
+  grpc_channel* channel;
 
-  grpc_call *parent;
+  grpc_call* parent;
   uint32_t propagation_mask;
 
-  grpc_completion_queue *cq;
+  grpc_completion_queue* cq;
   /* if not NULL, it'll be used in lieu of cq */
-  grpc_pollset_set *pollset_set_alternative;
+  grpc_pollset_set* pollset_set_alternative;
 
-  const void *server_transport_data;
+  const void* server_transport_data;
 
-  grpc_mdelem *add_initial_metadata;
+  grpc_mdelem* add_initial_metadata;
   size_t add_initial_metadata_count;
 
-  gpr_timespec send_deadline;
+  grpc_millis send_deadline;
 } grpc_call_create_args;
 
 /* Create a new call based on \a args.
    Regardless of success or failure, always returns a valid new call into *call
    */
-grpc_error *grpc_call_create(grpc_exec_ctx *exec_ctx,
-                             const grpc_call_create_args *args,
-                             grpc_call **call);
+grpc_error* grpc_call_create(grpc_exec_ctx* exec_ctx,
+                             const grpc_call_create_args* args,
+                             grpc_call** call);
 
-void grpc_call_set_completion_queue(grpc_exec_ctx *exec_ctx, grpc_call *call,
-                                    grpc_completion_queue *cq);
+void grpc_call_set_completion_queue(grpc_exec_ctx* exec_ctx, grpc_call* call,
+                                    grpc_completion_queue* cq);
 
 #ifndef NDEBUG
-void grpc_call_internal_ref(grpc_call *call, const char *reason);
-void grpc_call_internal_unref(grpc_exec_ctx *exec_ctx, grpc_call *call,
-                              const char *reason);
+void grpc_call_internal_ref(grpc_call* call, const char* reason);
+void grpc_call_internal_unref(grpc_exec_ctx* exec_ctx, grpc_call* call,
+                              const char* reason);
 #define GRPC_CALL_INTERNAL_REF(call, reason) \
   grpc_call_internal_ref(call, reason)
 #define GRPC_CALL_INTERNAL_UNREF(exec_ctx, call, reason) \
   grpc_call_internal_unref(exec_ctx, call, reason)
 #else
-void grpc_call_internal_ref(grpc_call *call);
-void grpc_call_internal_unref(grpc_exec_ctx *exec_ctx, grpc_call *call);
+void grpc_call_internal_ref(grpc_call* call);
+void grpc_call_internal_unref(grpc_exec_ctx* exec_ctx, grpc_call* call);
 #define GRPC_CALL_INTERNAL_REF(call, reason) grpc_call_internal_ref(call)
 #define GRPC_CALL_INTERNAL_UNREF(exec_ctx, call, reason) \
   grpc_call_internal_unref(exec_ctx, call)
 #endif
 
-grpc_call_stack *grpc_call_get_call_stack(grpc_call *call);
+grpc_call_stack* grpc_call_get_call_stack(grpc_call* call);
 
-grpc_call_error grpc_call_start_batch_and_execute(grpc_exec_ctx *exec_ctx,
-                                                  grpc_call *call,
-                                                  const grpc_op *ops,
+grpc_call_error grpc_call_start_batch_and_execute(grpc_exec_ctx* exec_ctx,
+                                                  grpc_call* call,
+                                                  const grpc_op* ops,
                                                   size_t nops,
-                                                  grpc_closure *closure);
+                                                  grpc_closure* closure);
 
 /* Given the top call_element, get the call object. */
-grpc_call *grpc_call_from_top_element(grpc_call_element *surface_element);
+grpc_call* grpc_call_from_top_element(grpc_call_element* surface_element);
 
-void grpc_call_log_batch(const char *file, int line, gpr_log_severity severity,
-                         grpc_call *call, const grpc_op *ops, size_t nops,
-                         void *tag);
+void grpc_call_log_batch(const char* file, int line, gpr_log_severity severity,
+                         grpc_call* call, const grpc_op* ops, size_t nops,
+                         void* tag);
 
 /* Set a context pointer.
    No thread safety guarantees are made wrt this value. */
 /* TODO(#9731): add exec_ctx to destroy */
-void grpc_call_context_set(grpc_call *call, grpc_context_index elem,
-                           void *value, void (*destroy)(void *value));
+void grpc_call_context_set(grpc_call* call, grpc_context_index elem,
+                           void* value, void (*destroy)(void* value));
 /* Get a context pointer. */
-void *grpc_call_context_get(grpc_call *call, grpc_context_index elem);
+void* grpc_call_context_get(grpc_call* call, grpc_context_index elem);
 
 #define GRPC_CALL_LOG_BATCH(sev, call, ops, nops, tag) \
-  if (GRPC_TRACER_ON(grpc_api_trace))                  \
-  grpc_call_log_batch(sev, call, ops, nops, tag)
+  if (grpc_api_trace.enabled()) grpc_call_log_batch(sev, call, ops, nops, tag)
 
-uint8_t grpc_call_is_client(grpc_call *call);
+uint8_t grpc_call_is_client(grpc_call* call);
 
 /* Return an appropriate compression algorithm for the requested compression \a
  * level in the context of \a call. */
 grpc_compression_algorithm grpc_call_compression_for_level(
-    grpc_call *call, grpc_compression_level level);
+    grpc_call* call, grpc_compression_level level);
 
-extern grpc_tracer_flag grpc_call_error_trace;
-extern grpc_tracer_flag grpc_compression_trace;
+extern grpc_core::TraceFlag grpc_call_error_trace;
+extern grpc_core::TraceFlag grpc_compression_trace;
 
 #ifdef __cplusplus
 }

data/src/core/lib/surface/{call_log_batch.c → call_log_batch.cc}

@@ -18,14 +18,16 @@
 
 #include "src/core/lib/surface/call.h"
 
+#include <inttypes.h>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/support/string.h"
 
-static void add_metadata(gpr_strvec *b, const grpc_metadata *md, size_t count) {
+static void add_metadata(gpr_strvec* b, const grpc_metadata* md, size_t count) {
   size_t i;
-  if (md == NULL) {
+  if (md == nullptr) {
     gpr_strvec_add(b, gpr_strdup("(nil)"));
     return;
   }
@@ -39,9 +41,9 @@ static void add_metadata(gpr_strvec *b, const grpc_metadata *md, size_t count) {
   }
 }
 
-char *grpc_op_string(const grpc_op *op) {
-  char *tmp;
-  char *out;
+char* grpc_op_string(const grpc_op* op) {
+  char* tmp;
+  char* out;
 
   gpr_strvec b;
   gpr_strvec_init(&b);
@@ -64,7 +66,7 @@ char *grpc_op_string(const grpc_op *op) {
       gpr_asprintf(&tmp, "SEND_STATUS_FROM_SERVER status=%d details=",
                    op->data.send_status_from_server.status);
       gpr_strvec_add(&b, tmp);
-      if (op->data.send_status_from_server.status_details != NULL) {
+      if (op->data.send_status_from_server.status_details != nullptr) {
         gpr_strvec_add(&b, grpc_dump_slice(
                                *op->data.send_status_from_server.status_details,
                                GPR_DUMP_ASCII));
@@ -97,16 +99,16 @@ char *grpc_op_string(const grpc_op *op) {
                    op->data.recv_close_on_server.cancelled);
       gpr_strvec_add(&b, tmp);
   }
-  out = gpr_strvec_flatten(&b, NULL);
+  out = gpr_strvec_flatten(&b, nullptr);
   gpr_strvec_destroy(&b);
 
   return out;
 }
 
-void grpc_call_log_batch(const char *file, int line, gpr_log_severity severity,
-                         grpc_call *call, const grpc_op *ops, size_t nops,
-                         void *tag) {
-  char *tmp;
+void grpc_call_log_batch(const char* file, int line, gpr_log_severity severity,
+                         grpc_call* call, const grpc_op* ops, size_t nops,
+                         void* tag) {
+  char* tmp;
   size_t i;
   for (i = 0; i < nops; i++) {
     tmp = grpc_op_string(&ops[i]);

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

@@ -29,30 +29,30 @@ extern "C" {
  *
  * \warning This function should \b only be used in test code. */
 grpc_compression_algorithm grpc_call_test_only_get_compression_algorithm(
-    grpc_call *call);
+    grpc_call* call);
 
 /** Return the message flags from \a call.
  *
  * \warning This function should \b only be used in test code. */
-uint32_t grpc_call_test_only_get_message_flags(grpc_call *call);
+uint32_t grpc_call_test_only_get_message_flags(grpc_call* call);
 
 /** Returns a bitset for the encodings (compression algorithms) supported by \a
  * call's peer.
  *
  * To be indexed by grpc_compression_algorithm enum values. */
-uint32_t grpc_call_test_only_get_encodings_accepted_by_peer(grpc_call *call);
+uint32_t grpc_call_test_only_get_encodings_accepted_by_peer(grpc_call* call);
 
 /** Returns a bitset for the stream encodings (stream compression algorithms)
  * supported by \a call's peer.
  *
  * To be indexed by grpc_stream_compression_algorithm enum values. */
 uint32_t grpc_call_test_only_get_stream_encodings_accepted_by_peer(
-    grpc_call *call);
+    grpc_call* call);
 
 /** Returns the incoming stream compression algorithm (content-encoding header)
  * received by a call. */
 grpc_stream_compression_algorithm
-grpc_call_test_only_get_incoming_stream_encodings(grpc_call *call);
+grpc_call_test_only_get_incoming_stream_encodings(grpc_call* call);
 
 #ifdef __cplusplus
 }

data/src/core/lib/surface/{channel.c → channel.cc}

@@ -18,6 +18,7 @@
 
 #include "src/core/lib/surface/channel.h"
 
+#include <inttypes.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -46,7 +47,7 @@
 typedef struct registered_call {
   grpc_mdelem path;
   grpc_mdelem authority;
-  struct registered_call *next;
+  struct registered_call* next;
 } registered_call;
 
 struct grpc_channel {
@@ -57,35 +58,35 @@ struct grpc_channel {
   gpr_atm call_size_estimate;
 
   gpr_mu registered_call_mu;
-  registered_call *registered_calls;
+  registered_call* registered_calls;
 
-  char *target;
+  char* target;
 };
 
-#define CHANNEL_STACK_FROM_CHANNEL(c) ((grpc_channel_stack *)((c) + 1))
+#define CHANNEL_STACK_FROM_CHANNEL(c) ((grpc_channel_stack*)((c) + 1))
 #define CHANNEL_FROM_CHANNEL_STACK(channel_stack) \
-  (((grpc_channel *)(channel_stack)) - 1)
+  (((grpc_channel*)(channel_stack)) - 1)
 #define CHANNEL_FROM_TOP_ELEM(top_elem) \
   CHANNEL_FROM_CHANNEL_STACK(grpc_channel_stack_from_top_element(top_elem))
 
-static void destroy_channel(grpc_exec_ctx *exec_ctx, void *arg,
-                            grpc_error *error);
+static void destroy_channel(grpc_exec_ctx* exec_ctx, void* arg,
+                            grpc_error* error);
 
-grpc_channel *grpc_channel_create_with_builder(
-    grpc_exec_ctx *exec_ctx, grpc_channel_stack_builder *builder,
+grpc_channel* grpc_channel_create_with_builder(
+    grpc_exec_ctx* exec_ctx, grpc_channel_stack_builder* builder,
     grpc_channel_stack_type channel_stack_type) {
-  char *target = gpr_strdup(grpc_channel_stack_builder_get_target(builder));
-  grpc_channel_args *args = grpc_channel_args_copy(
+  char* target = gpr_strdup(grpc_channel_stack_builder_get_target(builder));
+  grpc_channel_args* args = grpc_channel_args_copy(
       grpc_channel_stack_builder_get_channel_arguments(builder));
-  grpc_channel *channel;
+  grpc_channel* channel;
   if (channel_stack_type == GRPC_SERVER_CHANNEL) {
     GRPC_STATS_INC_SERVER_CHANNELS_CREATED(exec_ctx);
   } else {
     GRPC_STATS_INC_CLIENT_CHANNELS_CREATED(exec_ctx);
   }
-  grpc_error *error = grpc_channel_stack_builder_finish(
-      exec_ctx, builder, sizeof(grpc_channel), 1, destroy_channel, NULL,
-      (void **)&channel);
+  grpc_error* error = grpc_channel_stack_builder_finish(
+      exec_ctx, builder, sizeof(grpc_channel), 1, destroy_channel, nullptr,
+      (void**)&channel);
   if (error != GRPC_ERROR_NONE) {
     gpr_log(GPR_ERROR, "channel stack builder failed: %s",
             grpc_error_string(error));
@@ -98,7 +99,7 @@ grpc_channel *grpc_channel_create_with_builder(
   channel->target = target;
   channel->is_client = grpc_channel_stack_type_is_client(channel_stack_type);
   gpr_mu_init(&channel->registered_call_mu);
-  channel->registered_calls = NULL;
+  channel->registered_calls = nullptr;
 
   gpr_atm_no_barrier_store(
       &channel->call_size_estimate,
@@ -144,9 +145,8 @@ grpc_channel *grpc_channel_create_with_builder(
       channel->compression_options.default_level.level =
           (grpc_compression_level)grpc_channel_arg_get_integer(
               &args->args[i],
-              (grpc_integer_options){GRPC_COMPRESS_LEVEL_NONE,
-                                     GRPC_COMPRESS_LEVEL_NONE,
-                                     GRPC_COMPRESS_LEVEL_COUNT - 1});
+              {GRPC_COMPRESS_LEVEL_NONE, GRPC_COMPRESS_LEVEL_NONE,
+               GRPC_COMPRESS_LEVEL_COUNT - 1});
     } else if (0 == strcmp(args->args[i].key,
                            GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_LEVEL)) {
       channel->compression_options.default_stream_compression_level.is_set =
@@ -154,17 +154,15 @@ grpc_channel *grpc_channel_create_with_builder(
       channel->compression_options.default_stream_compression_level.level =
           (grpc_stream_compression_level)grpc_channel_arg_get_integer(
               &args->args[i],
-              (grpc_integer_options){GRPC_STREAM_COMPRESS_LEVEL_NONE,
-                                     GRPC_STREAM_COMPRESS_LEVEL_NONE,
-                                     GRPC_STREAM_COMPRESS_LEVEL_COUNT - 1});
+              {GRPC_STREAM_COMPRESS_LEVEL_NONE, GRPC_STREAM_COMPRESS_LEVEL_NONE,
+               GRPC_STREAM_COMPRESS_LEVEL_COUNT - 1});
     } else if (0 == strcmp(args->args[i].key,
                            GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM)) {
       channel->compression_options.default_algorithm.is_set = true;
       channel->compression_options.default_algorithm.algorithm =
           (grpc_compression_algorithm)grpc_channel_arg_get_integer(
-              &args->args[i],
-              (grpc_integer_options){GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
-                                     GRPC_COMPRESS_ALGORITHMS_COUNT - 1});
+              &args->args[i], {GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
+                               GRPC_COMPRESS_ALGORITHMS_COUNT - 1});
     } else if (0 == strcmp(args->args[i].key,
                            GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM)) {
       channel->compression_options.default_stream_compression_algorithm.is_set =
@@ -173,9 +171,8 @@ grpc_channel *grpc_channel_create_with_builder(
           .algorithm =
           (grpc_stream_compression_algorithm)grpc_channel_arg_get_integer(
               &args->args[i],
-              (grpc_integer_options){
-                  GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_NONE,
-                  GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT - 1});
+              {GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_NONE,
+               GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT - 1});
     } else if (0 ==
                strcmp(args->args[i].key,
                       GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET)) {
@@ -198,24 +195,24 @@ done:
   return channel;
 }
 
-grpc_channel *grpc_channel_create(grpc_exec_ctx *exec_ctx, const char *target,
-                                  const grpc_channel_args *input_args,
+grpc_channel* grpc_channel_create(grpc_exec_ctx* exec_ctx, const char* target,
+                                  const grpc_channel_args* input_args,
                                   grpc_channel_stack_type channel_stack_type,
-                                  grpc_transport *optional_transport) {
-  grpc_channel_stack_builder *builder = grpc_channel_stack_builder_create();
+                                  grpc_transport* optional_transport) {
+  grpc_channel_stack_builder* builder = grpc_channel_stack_builder_create();
   grpc_channel_stack_builder_set_channel_arguments(exec_ctx, builder,
                                                    input_args);
   grpc_channel_stack_builder_set_target(builder, target);
   grpc_channel_stack_builder_set_transport(builder, optional_transport);
   if (!grpc_channel_init_create_stack(exec_ctx, builder, channel_stack_type)) {
     grpc_channel_stack_builder_destroy(exec_ctx, builder);
-    return NULL;
+    return nullptr;
   }
   return grpc_channel_create_with_builder(exec_ctx, builder,
                                           channel_stack_type);
 }
 
-size_t grpc_channel_get_call_size_estimate(grpc_channel *channel) {
+size_t grpc_channel_get_call_size_estimate(grpc_channel* channel) {
 #define ROUND_UP_SIZE 256
   /* We round up our current estimate to the NEXT value of ROUND_UP_SIZE.
      This ensures:
@@ -228,7 +225,7 @@ size_t grpc_channel_get_call_size_estimate(grpc_channel *channel) {
          ~(size_t)(ROUND_UP_SIZE - 1);
 }
 
-void grpc_channel_update_call_size_estimate(grpc_channel *channel,
+void grpc_channel_update_call_size_estimate(grpc_channel* channel,
                                             size_t size) {
   size_t cur = (size_t)gpr_atm_no_barrier_load(&channel->call_size_estimate);
   if (cur < size) {
@@ -247,30 +244,30 @@ void grpc_channel_update_call_size_estimate(grpc_channel *channel,
   }
 }
 
-char *grpc_channel_get_target(grpc_channel *channel) {
+char* grpc_channel_get_target(grpc_channel* channel) {
   GRPC_API_TRACE("grpc_channel_get_target(channel=%p)", 1, (channel));
   return gpr_strdup(channel->target);
 }
 
-void grpc_channel_get_info(grpc_channel *channel,
-                           const grpc_channel_info *channel_info) {
+void grpc_channel_get_info(grpc_channel* channel,
+                           const grpc_channel_info* channel_info) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_channel_element *elem =
+  grpc_channel_element* elem =
       grpc_channel_stack_element(CHANNEL_STACK_FROM_CHANNEL(channel), 0);
   elem->filter->get_channel_info(&exec_ctx, elem, channel_info);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static grpc_call *grpc_channel_create_call_internal(
-    grpc_exec_ctx *exec_ctx, grpc_channel *channel, grpc_call *parent_call,
-    uint32_t propagation_mask, grpc_completion_queue *cq,
-    grpc_pollset_set *pollset_set_alternative, grpc_mdelem path_mdelem,
-    grpc_mdelem authority_mdelem, gpr_timespec deadline) {
+static grpc_call* grpc_channel_create_call_internal(
+    grpc_exec_ctx* exec_ctx, grpc_channel* channel, grpc_call* parent_call,
+    uint32_t propagation_mask, grpc_completion_queue* cq,
+    grpc_pollset_set* pollset_set_alternative, grpc_mdelem path_mdelem,
+    grpc_mdelem authority_mdelem, grpc_millis deadline) {
   grpc_mdelem send_metadata[2];
   size_t num_metadata = 0;
 
   GPR_ASSERT(channel->is_client);
-  GPR_ASSERT(!(cq != NULL && pollset_set_alternative != NULL));
+  GPR_ASSERT(!(cq != nullptr && pollset_set_alternative != nullptr));
 
   send_metadata[num_metadata++] = path_mdelem;
   if (!GRPC_MDISNULL(authority_mdelem)) {
@@ -286,54 +283,54 @@ static grpc_call *grpc_channel_create_call_internal(
   args.propagation_mask = propagation_mask;
   args.cq = cq;
   args.pollset_set_alternative = pollset_set_alternative;
-  args.server_transport_data = NULL;
+  args.server_transport_data = nullptr;
   args.add_initial_metadata = send_metadata;
   args.add_initial_metadata_count = num_metadata;
   args.send_deadline = deadline;
 
-  grpc_call *call;
+  grpc_call* call;
   GRPC_LOG_IF_ERROR("call_create", grpc_call_create(exec_ctx, &args, &call));
   return call;
 }
 
-grpc_call *grpc_channel_create_call(grpc_channel *channel,
-                                    grpc_call *parent_call,
+grpc_call* grpc_channel_create_call(grpc_channel* channel,
+                                    grpc_call* parent_call,
                                     uint32_t propagation_mask,
-                                    grpc_completion_queue *cq,
-                                    grpc_slice method, const grpc_slice *host,
-                                    gpr_timespec deadline, void *reserved) {
+                                    grpc_completion_queue* cq,
+                                    grpc_slice method, const grpc_slice* host,
+                                    gpr_timespec deadline, void* reserved) {
   GPR_ASSERT(!reserved);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_call *call = grpc_channel_create_call_internal(
-      &exec_ctx, channel, parent_call, propagation_mask, cq, NULL,
+  grpc_call* call = grpc_channel_create_call_internal(
+      &exec_ctx, channel, parent_call, propagation_mask, cq, nullptr,
       grpc_mdelem_from_slices(&exec_ctx, GRPC_MDSTR_PATH,
                               grpc_slice_ref_internal(method)),
-      host != NULL ? grpc_mdelem_from_slices(&exec_ctx, GRPC_MDSTR_AUTHORITY,
-                                             grpc_slice_ref_internal(*host))
-                   : GRPC_MDNULL,
-      deadline);
+      host != nullptr ? grpc_mdelem_from_slices(&exec_ctx, GRPC_MDSTR_AUTHORITY,
+                                                grpc_slice_ref_internal(*host))
+                      : GRPC_MDNULL,
+      grpc_timespec_to_millis_round_up(deadline));
   grpc_exec_ctx_finish(&exec_ctx);
   return call;
 }
 
-grpc_call *grpc_channel_create_pollset_set_call(
-    grpc_exec_ctx *exec_ctx, grpc_channel *channel, grpc_call *parent_call,
-    uint32_t propagation_mask, grpc_pollset_set *pollset_set, grpc_slice method,
-    const grpc_slice *host, gpr_timespec deadline, void *reserved) {
+grpc_call* grpc_channel_create_pollset_set_call(
+    grpc_exec_ctx* exec_ctx, grpc_channel* channel, grpc_call* parent_call,
+    uint32_t propagation_mask, grpc_pollset_set* pollset_set, grpc_slice method,
+    const grpc_slice* host, grpc_millis deadline, void* reserved) {
   GPR_ASSERT(!reserved);
   return grpc_channel_create_call_internal(
-      exec_ctx, channel, parent_call, propagation_mask, NULL, pollset_set,
+      exec_ctx, channel, parent_call, propagation_mask, nullptr, pollset_set,
       grpc_mdelem_from_slices(exec_ctx, GRPC_MDSTR_PATH,
                               grpc_slice_ref_internal(method)),
-      host != NULL ? grpc_mdelem_from_slices(exec_ctx, GRPC_MDSTR_AUTHORITY,
-                                             grpc_slice_ref_internal(*host))
-                   : GRPC_MDNULL,
+      host != nullptr ? grpc_mdelem_from_slices(exec_ctx, GRPC_MDSTR_AUTHORITY,
+                                                grpc_slice_ref_internal(*host))
+                      : GRPC_MDNULL,
       deadline);
 }
 
-void *grpc_channel_register_call(grpc_channel *channel, const char *method,
-                                 const char *host, void *reserved) {
-  registered_call *rc = (registered_call *)gpr_malloc(sizeof(registered_call));
+void* grpc_channel_register_call(grpc_channel* channel, const char* method,
+                                 const char* host, void* reserved) {
+  registered_call* rc = (registered_call*)gpr_malloc(sizeof(registered_call));
   GRPC_API_TRACE(
       "grpc_channel_register_call(channel=%p, method=%s, host=%s, reserved=%p)",
       4, (channel, method, host, reserved));
@@ -356,11 +353,11 @@ void *grpc_channel_register_call(grpc_channel *channel, const char *method,
   return rc;
 }
 
-grpc_call *grpc_channel_create_registered_call(
-    grpc_channel *channel, grpc_call *parent_call, uint32_t propagation_mask,
-    grpc_completion_queue *completion_queue, void *registered_call_handle,
-    gpr_timespec deadline, void *reserved) {
-  registered_call *rc = (registered_call *)registered_call_handle;
+grpc_call* grpc_channel_create_registered_call(
+    grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
+    grpc_completion_queue* completion_queue, void* registered_call_handle,
+    gpr_timespec deadline, void* reserved) {
+  registered_call* rc = (registered_call*)registered_call_handle;
   GRPC_API_TRACE(
       "grpc_channel_create_registered_call("
       "channel=%p, parent_call=%p, propagation_mask=%x, completion_queue=%p, "
@@ -368,40 +365,42 @@ grpc_call *grpc_channel_create_registered_call(
       "deadline=gpr_timespec { tv_sec: %" PRId64
       ", tv_nsec: %d, clock_type: %d }, "
       "reserved=%p)",
-      9, (channel, parent_call, (unsigned)propagation_mask, completion_queue,
-          registered_call_handle, deadline.tv_sec, deadline.tv_nsec,
-          (int)deadline.clock_type, reserved));
+      9,
+      (channel, parent_call, (unsigned)propagation_mask, completion_queue,
+       registered_call_handle, deadline.tv_sec, deadline.tv_nsec,
+       (int)deadline.clock_type, reserved));
   GPR_ASSERT(!reserved);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_call *call = grpc_channel_create_call_internal(
-      &exec_ctx, channel, parent_call, propagation_mask, completion_queue, NULL,
-      GRPC_MDELEM_REF(rc->path), GRPC_MDELEM_REF(rc->authority), deadline);
+  grpc_call* call = grpc_channel_create_call_internal(
+      &exec_ctx, channel, parent_call, propagation_mask, completion_queue,
+      nullptr, GRPC_MDELEM_REF(rc->path), GRPC_MDELEM_REF(rc->authority),
+      grpc_timespec_to_millis_round_up(deadline));
   grpc_exec_ctx_finish(&exec_ctx);
   return call;
 }
 
 #ifndef NDEBUG
 #define REF_REASON reason
-#define REF_ARG , const char *reason
+#define REF_ARG , const char* reason
 #else
 #define REF_REASON ""
 #define REF_ARG
 #endif
-void grpc_channel_internal_ref(grpc_channel *c REF_ARG) {
+void grpc_channel_internal_ref(grpc_channel* c REF_ARG) {
   GRPC_CHANNEL_STACK_REF(CHANNEL_STACK_FROM_CHANNEL(c), REF_REASON);
 }
 
-void grpc_channel_internal_unref(grpc_exec_ctx *exec_ctx,
-                                 grpc_channel *c REF_ARG) {
+void grpc_channel_internal_unref(grpc_exec_ctx* exec_ctx,
+                                 grpc_channel* c REF_ARG) {
   GRPC_CHANNEL_STACK_UNREF(exec_ctx, CHANNEL_STACK_FROM_CHANNEL(c), REF_REASON);
 }
 
-static void destroy_channel(grpc_exec_ctx *exec_ctx, void *arg,
-                            grpc_error *error) {
-  grpc_channel *channel = (grpc_channel *)arg;
+static void destroy_channel(grpc_exec_ctx* exec_ctx, void* arg,
+                            grpc_error* error) {
+  grpc_channel* channel = (grpc_channel*)arg;
   grpc_channel_stack_destroy(exec_ctx, CHANNEL_STACK_FROM_CHANNEL(channel));
   while (channel->registered_calls) {
-    registered_call *rc = channel->registered_calls;
+    registered_call* rc = channel->registered_calls;
     channel->registered_calls = rc->next;
     GRPC_MDELEM_UNREF(exec_ctx, rc->path);
     GRPC_MDELEM_UNREF(exec_ctx, rc->authority);
@@ -413,9 +412,9 @@ static void destroy_channel(grpc_exec_ctx *exec_ctx, void *arg,
   gpr_free(channel);
 }
 
-void grpc_channel_destroy(grpc_channel *channel) {
-  grpc_transport_op *op = grpc_make_transport_op(NULL);
-  grpc_channel_element *elem;
+void grpc_channel_destroy(grpc_channel* channel) {
+  grpc_transport_op* op = grpc_make_transport_op(nullptr);
+  grpc_channel_element* elem;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   GRPC_API_TRACE("grpc_channel_destroy(channel=%p)", 1, (channel));
   op->disconnect_with_error =
@@ -428,17 +427,17 @@ void grpc_channel_destroy(grpc_channel *channel) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-grpc_channel_stack *grpc_channel_get_channel_stack(grpc_channel *channel) {
+grpc_channel_stack* grpc_channel_get_channel_stack(grpc_channel* channel) {
   return CHANNEL_STACK_FROM_CHANNEL(channel);
 }
 
 grpc_compression_options grpc_channel_compression_options(
-    const grpc_channel *channel) {
+    const grpc_channel* channel) {
   return channel->compression_options;
 }
 
-grpc_mdelem grpc_channel_get_reffed_status_elem(grpc_exec_ctx *exec_ctx,
-                                                grpc_channel *channel, int i) {
+grpc_mdelem grpc_channel_get_reffed_status_elem(grpc_exec_ctx* exec_ctx,
+                                                grpc_channel* channel, int i) {
   char tmp[GPR_LTOA_MIN_BUFSIZE];
   switch (i) {
     case 0: