grpc 1.7.3 → 1.8.0

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

@@ -22,9 +22,13 @@
 #include <grpc/support/log.h>
 #include "src/core/lib/debug/trace.h"
 
-#ifndef NDEBUG
+extern grpc_core::DebugOnlyTraceFlag grpc_trace_alarm_refcount;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-extern grpc_tracer_flag grpc_trace_alarm_refcount;
+#ifndef NDEBUG
 
 #define GRPC_ALARM_REF(a, reason) alarm_ref_dbg(a, reason, __FILE__, __LINE__)
 #define GRPC_ALARM_UNREF(a, reason) \
@@ -37,4 +41,8 @@ extern grpc_tracer_flag grpc_trace_alarm_refcount;
 
 #endif /* defined(NDEBUG) */
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_SURFACE_ALARM_INTERNAL_H */

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

@@ -19,4 +19,4 @@
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/debug/trace.h"
 
-grpc_tracer_flag grpc_api_trace = GRPC_TRACER_INITIALIZER(false, "api");
+grpc_core::TraceFlag grpc_api_trace(false, "api");

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

@@ -22,7 +22,7 @@
 #include <grpc/support/log.h>
 #include "src/core/lib/debug/trace.h"
 
-extern grpc_tracer_flag grpc_api_trace;
+extern grpc_core::TraceFlag grpc_api_trace;
 
 /* Provide unwrapping macros because we're in C89 and variadic macros weren't
    introduced until C99... */
@@ -43,7 +43,7 @@ extern grpc_tracer_flag grpc_api_trace;
 /* Due to the limitations of C89's preprocessor, the arity of the var-arg list
    'nargs' must be specified. */
 #define GRPC_API_TRACE(fmt, nargs, args)                      \
-  if (GRPC_TRACER_ON(grpc_api_trace)) {                       \
+  if (grpc_api_trace.enabled()) {                             \
     gpr_log(GPR_INFO, fmt GRPC_API_TRACE_UNWRAP##nargs args); \
   }
 

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

@@ -22,18 +22,18 @@
 
 #include "src/core/lib/slice/slice_internal.h"
 
-grpc_byte_buffer *grpc_raw_byte_buffer_create(grpc_slice *slices,
+grpc_byte_buffer* grpc_raw_byte_buffer_create(grpc_slice* slices,
                                               size_t nslices) {
   return grpc_raw_compressed_byte_buffer_create(slices, nslices,
                                                 GRPC_COMPRESS_NONE);
 }
 
-grpc_byte_buffer *grpc_raw_compressed_byte_buffer_create(
-    grpc_slice *slices, size_t nslices,
+grpc_byte_buffer* grpc_raw_compressed_byte_buffer_create(
+    grpc_slice* slices, size_t nslices,
     grpc_compression_algorithm compression) {
   size_t i;
-  grpc_byte_buffer *bb =
-      (grpc_byte_buffer *)gpr_malloc(sizeof(grpc_byte_buffer));
+  grpc_byte_buffer* bb =
+      (grpc_byte_buffer*)gpr_malloc(sizeof(grpc_byte_buffer));
   bb->type = GRPC_BB_RAW;
   bb->data.raw.compression = compression;
   grpc_slice_buffer_init(&bb->data.raw.slice_buffer);
@@ -44,10 +44,10 @@ grpc_byte_buffer *grpc_raw_compressed_byte_buffer_create(
   return bb;
 }
 
-grpc_byte_buffer *grpc_raw_byte_buffer_from_reader(
-    grpc_byte_buffer_reader *reader) {
-  grpc_byte_buffer *bb =
-      (grpc_byte_buffer *)gpr_malloc(sizeof(grpc_byte_buffer));
+grpc_byte_buffer* grpc_raw_byte_buffer_from_reader(
+    grpc_byte_buffer_reader* reader) {
+  grpc_byte_buffer* bb =
+      (grpc_byte_buffer*)gpr_malloc(sizeof(grpc_byte_buffer));
   grpc_slice slice;
   bb->type = GRPC_BB_RAW;
   bb->data.raw.compression = GRPC_COMPRESS_NONE;
@@ -59,17 +59,17 @@ grpc_byte_buffer *grpc_raw_byte_buffer_from_reader(
   return bb;
 }
 
-grpc_byte_buffer *grpc_byte_buffer_copy(grpc_byte_buffer *bb) {
+grpc_byte_buffer* grpc_byte_buffer_copy(grpc_byte_buffer* bb) {
   switch (bb->type) {
     case GRPC_BB_RAW:
       return grpc_raw_compressed_byte_buffer_create(
           bb->data.raw.slice_buffer.slices, bb->data.raw.slice_buffer.count,
           bb->data.raw.compression);
   }
-  GPR_UNREACHABLE_CODE(return NULL);
+  GPR_UNREACHABLE_CODE(return nullptr);
 }
 
-void grpc_byte_buffer_destroy(grpc_byte_buffer *bb) {
+void grpc_byte_buffer_destroy(grpc_byte_buffer* bb) {
   if (!bb) return;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   switch (bb->type) {
@@ -81,7 +81,7 @@ void grpc_byte_buffer_destroy(grpc_byte_buffer *bb) {
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-size_t grpc_byte_buffer_length(grpc_byte_buffer *bb) {
+size_t grpc_byte_buffer_length(grpc_byte_buffer* bb) {
   switch (bb->type) {
     case GRPC_BB_RAW:
       return bb->data.raw.slice_buffer.length;

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

@@ -29,7 +29,7 @@
 #include "src/core/lib/compression/message_compress.h"
 #include "src/core/lib/slice/slice_internal.h"
 
-static int is_compressed(grpc_byte_buffer *buffer) {
+static int is_compressed(grpc_byte_buffer* buffer) {
   switch (buffer->type) {
     case GRPC_BB_RAW:
       if (buffer->data.raw.compression == GRPC_COMPRESS_NONE) {
@@ -40,8 +40,8 @@ static int is_compressed(grpc_byte_buffer *buffer) {
   return 1 /* GPR_TRUE */;
 }
 
-int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader *reader,
-                                 grpc_byte_buffer *buffer) {
+int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader,
+                                 grpc_byte_buffer* buffer) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_slice_buffer decompressed_slices_buffer;
   reader->buffer_in = buffer;
@@ -76,7 +76,7 @@ int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader *reader,
   return 1;
 }
 
-void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader *reader) {
+void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader* reader) {
   switch (reader->buffer_in->type) {
     case GRPC_BB_RAW:
       /* keeping the same if-else structure as in the init function */
@@ -87,11 +87,11 @@ void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader *reader) {
   }
 }
 
-int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader *reader,
-                                 grpc_slice *slice) {
+int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader,
+                                 grpc_slice* slice) {
   switch (reader->buffer_in->type) {
     case GRPC_BB_RAW: {
-      grpc_slice_buffer *slice_buffer;
+      grpc_slice_buffer* slice_buffer;
       slice_buffer = &reader->buffer_out->data.raw.slice_buffer;
       if (reader->current.index < slice_buffer->count) {
         *slice = grpc_slice_ref_internal(
@@ -105,12 +105,12 @@ int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader *reader,
   return 0;
 }
 
-grpc_slice grpc_byte_buffer_reader_readall(grpc_byte_buffer_reader *reader) {
+grpc_slice grpc_byte_buffer_reader_readall(grpc_byte_buffer_reader* reader) {
   grpc_slice in_slice;
   size_t bytes_read = 0;
   const size_t input_size = grpc_byte_buffer_length(reader->buffer_out);
   grpc_slice out_slice = GRPC_SLICE_MALLOC(input_size);
-  uint8_t *const outbuf = GRPC_SLICE_START_PTR(out_slice); /* just an alias */
+  uint8_t* const outbuf = GRPC_SLICE_START_PTR(out_slice); /* just an alias */
 
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   while (grpc_byte_buffer_reader_next(reader, &in_slice) != 0) {

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

@@ -41,6 +41,7 @@
 #include "src/core/lib/support/string.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/call.h"
+#include "src/core/lib/surface/call_test_only.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/surface/validate_metadata.h"
@@ -85,7 +86,7 @@ typedef enum {
 
 typedef struct {
   bool is_set;
-  grpc_error *error;
+  grpc_error* error;
 } received_status;
 
 static gpr_atm pack_received_status(received_status r) {
@@ -93,16 +94,17 @@ static gpr_atm pack_received_status(received_status r) {
 }
 
 static received_status unpack_received_status(gpr_atm atm) {
-  return (atm & 1) == 0
-             ? (received_status){.is_set = false, .error = GRPC_ERROR_NONE}
-             : (received_status){.is_set = true,
-                                 .error = (grpc_error *)(atm & ~(gpr_atm)1)};
+  if ((atm & 1) == 0) {
+    return {false, GRPC_ERROR_NONE};
+  } else {
+    return {true, (grpc_error*)(atm & ~(gpr_atm)1)};
+  }
 }
 
 #define MAX_ERRORS_PER_BATCH 4
 
 typedef struct batch_control {
-  grpc_call *call;
+  grpc_call* call;
   /* Share memory for cq_completion and notify_tag as they are never needed
      simultaneously. Each byte used in this data structure count as six bytes
      per call, so any savings we can make are worthwhile,
@@ -118,7 +120,7 @@ typedef struct batch_control {
          \a is_closure is true, \a tag indicates a closure to be invoked;
          otherwise, \a tag indicates the tag to be used in the notification to
          be sent to the completion queue. */
-      void *tag;
+      void* tag;
       bool is_closure;
     } notify_tag;
   } completion_data;
@@ -126,7 +128,7 @@ typedef struct batch_control {
   grpc_closure finish_batch;
   gpr_refcount steps_to_complete;
 
-  grpc_error *errors[MAX_ERRORS_PER_BATCH];
+  grpc_error* errors[MAX_ERRORS_PER_BATCH];
   gpr_atm num_errors;
 
   grpc_transport_stream_op_batch op;
@@ -134,16 +136,16 @@ typedef struct batch_control {
 
 typedef struct {
   gpr_mu child_list_mu;
-  grpc_call *first_child;
+  grpc_call* first_child;
 } parent_call;
 
 typedef struct {
-  grpc_call *parent;
+  grpc_call* parent;
   /** siblings: children of the same parent form a list, and this list is
      protected under
       parent->mu */
-  grpc_call *sibling_next;
-  grpc_call *sibling_prev;
+  grpc_call* sibling_next;
+  grpc_call* sibling_prev;
 } child_call;
 
 #define RECV_NONE ((gpr_atm)0)
@@ -151,14 +153,14 @@ typedef struct {
 
 struct grpc_call {
   gpr_refcount ext_ref;
-  gpr_arena *arena;
+  gpr_arena* arena;
   grpc_call_combiner call_combiner;
-  grpc_completion_queue *cq;
+  grpc_completion_queue* cq;
   grpc_polling_entity pollent;
-  grpc_channel *channel;
+  grpc_channel* channel;
   gpr_timespec start_time;
   /* parent_call* */ gpr_atm parent_call_atm;
-  child_call *child;
+  child_call* child;
 
   /* client or server call */
   bool is_client;
@@ -176,7 +178,7 @@ struct grpc_call {
   gpr_atm any_ops_sent_atm;
   gpr_atm received_final_op_atm;
 
-  batch_control *active_batches[MAX_CONCURRENT_BATCHES];
+  batch_control* active_batches[MAX_CONCURRENT_BATCHES];
   grpc_transport_stream_op_batch_payload stream_op_payload;
 
   /* first idx: is_receiving, second idx: is_trailing */
@@ -184,7 +186,7 @@ struct grpc_call {
 
   /* Buffered read metadata waiting to be returned to the application.
      Element 0 is initial metadata, element 1 is trailing metadata. */
-  grpc_metadata_array *buffered_metadata[2];
+  grpc_metadata_array* buffered_metadata[2];
 
   grpc_metadata compression_md;
 
@@ -214,12 +216,12 @@ struct grpc_call {
      server, it's trailing metadata */
   grpc_linked_mdelem send_extra_metadata[MAX_SEND_EXTRA_METADATA_COUNT];
   int send_extra_metadata_count;
-  gpr_timespec send_deadline;
+  grpc_millis send_deadline;
 
   grpc_slice_buffer_stream sending_stream;
 
-  grpc_byte_stream *receiving_stream;
-  grpc_byte_buffer **receiving_buffer;
+  grpc_byte_stream* receiving_stream;
+  grpc_byte_buffer** receiving_buffer;
   grpc_slice receiving_slice;
   grpc_closure receiving_slice_ready;
   grpc_closure receiving_stream_ready;
@@ -230,11 +232,12 @@ struct grpc_call {
 
   union {
     struct {
-      grpc_status_code *status;
-      grpc_slice *status_details;
+      grpc_status_code* status;
+      grpc_slice* status_details;
+      const char** error_string;
     } client;
     struct {
-      int *cancelled;
+      int* cancelled;
     } server;
   } final_op;
 
@@ -257,83 +260,82 @@ struct grpc_call {
   gpr_atm recv_state;
 };
 
-grpc_tracer_flag grpc_call_error_trace =
-    GRPC_TRACER_INITIALIZER(false, "call_error");
-grpc_tracer_flag grpc_compression_trace =
-    GRPC_TRACER_INITIALIZER(false, "compression");
+grpc_core::TraceFlag grpc_call_error_trace(false, "call_error");
+grpc_core::TraceFlag grpc_compression_trace(false, "compression");
 
-#define CALL_STACK_FROM_CALL(call) ((grpc_call_stack *)((call) + 1))
-#define CALL_FROM_CALL_STACK(call_stack) (((grpc_call *)(call_stack)) - 1)
+#define CALL_STACK_FROM_CALL(call) ((grpc_call_stack*)((call) + 1))
+#define CALL_FROM_CALL_STACK(call_stack) (((grpc_call*)(call_stack)) - 1)
 #define CALL_ELEM_FROM_CALL(call, idx) \
   grpc_call_stack_element(CALL_STACK_FROM_CALL(call), idx)
 #define CALL_FROM_TOP_ELEM(top_elem) \
   CALL_FROM_CALL_STACK(grpc_call_stack_from_top_element(top_elem))
 
-static void execute_batch(grpc_exec_ctx *exec_ctx, grpc_call *call,
-                          grpc_transport_stream_op_batch *op,
-                          grpc_closure *start_batch_closure);
-static void cancel_with_status(grpc_exec_ctx *exec_ctx, grpc_call *c,
+static void execute_batch(grpc_exec_ctx* exec_ctx, grpc_call* call,
+                          grpc_transport_stream_op_batch* op,
+                          grpc_closure* start_batch_closure);
+static void cancel_with_status(grpc_exec_ctx* exec_ctx, grpc_call* c,
                                status_source source, grpc_status_code status,
-                               const char *description);
-static void cancel_with_error(grpc_exec_ctx *exec_ctx, grpc_call *c,
-                              status_source source, grpc_error *error);
-static void destroy_call(grpc_exec_ctx *exec_ctx, void *call_stack,
-                         grpc_error *error);
-static void receiving_slice_ready(grpc_exec_ctx *exec_ctx, void *bctlp,
-                                  grpc_error *error);
-static void get_final_status(grpc_call *call,
+                               const char* description);
+static void cancel_with_error(grpc_exec_ctx* exec_ctx, grpc_call* c,
+                              status_source source, grpc_error* error);
+static void destroy_call(grpc_exec_ctx* exec_ctx, void* call_stack,
+                         grpc_error* error);
+static void receiving_slice_ready(grpc_exec_ctx* exec_ctx, void* bctlp,
+                                  grpc_error* error);
+static void get_final_status(grpc_exec_ctx* exec_ctx, grpc_call* call,
                              void (*set_value)(grpc_status_code code,
-                                               void *user_data),
-                             void *set_value_user_data, grpc_slice *details);
-static void set_status_value_directly(grpc_status_code status, void *dest);
-static void set_status_from_error(grpc_exec_ctx *exec_ctx, grpc_call *call,
-                                  status_source source, grpc_error *error);
-static void process_data_after_md(grpc_exec_ctx *exec_ctx, batch_control *bctl);
-static void post_batch_completion(grpc_exec_ctx *exec_ctx, batch_control *bctl);
-static void add_batch_error(grpc_exec_ctx *exec_ctx, batch_control *bctl,
-                            grpc_error *error, bool has_cancelled);
-
-static void add_init_error(grpc_error **composite, grpc_error *new_err) {
+                                               void* user_data),
+                             void* set_value_user_data, grpc_slice* details,
+                             const char** error_string);
+static void set_status_value_directly(grpc_status_code status, void* dest);
+static void set_status_from_error(grpc_exec_ctx* exec_ctx, grpc_call* call,
+                                  status_source source, grpc_error* error);
+static void process_data_after_md(grpc_exec_ctx* exec_ctx, batch_control* bctl);
+static void post_batch_completion(grpc_exec_ctx* exec_ctx, batch_control* bctl);
+static void add_batch_error(grpc_exec_ctx* exec_ctx, batch_control* bctl,
+                            grpc_error* error, bool has_cancelled);
+
+static void add_init_error(grpc_error** composite, grpc_error* new_err) {
   if (new_err == GRPC_ERROR_NONE) return;
   if (*composite == GRPC_ERROR_NONE)
     *composite = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Call creation failed");
   *composite = grpc_error_add_child(*composite, new_err);
 }
 
-void *grpc_call_arena_alloc(grpc_call *call, size_t size) {
+void* grpc_call_arena_alloc(grpc_call* call, size_t size) {
   return gpr_arena_alloc(call->arena, size);
 }
 
-static parent_call *get_or_create_parent_call(grpc_call *call) {
-  parent_call *p = (parent_call *)gpr_atm_acq_load(&call->parent_call_atm);
-  if (p == NULL) {
-    p = (parent_call *)gpr_arena_alloc(call->arena, sizeof(*p));
+static parent_call* get_or_create_parent_call(grpc_call* call) {
+  parent_call* p = (parent_call*)gpr_atm_acq_load(&call->parent_call_atm);
+  if (p == nullptr) {
+    p = (parent_call*)gpr_arena_alloc(call->arena, sizeof(*p));
     gpr_mu_init(&p->child_list_mu);
     if (!gpr_atm_rel_cas(&call->parent_call_atm, (gpr_atm)NULL, (gpr_atm)p)) {
       gpr_mu_destroy(&p->child_list_mu);
-      p = (parent_call *)gpr_atm_acq_load(&call->parent_call_atm);
+      p = (parent_call*)gpr_atm_acq_load(&call->parent_call_atm);
     }
   }
   return p;
 }
 
-static parent_call *get_parent_call(grpc_call *call) {
-  return (parent_call *)gpr_atm_acq_load(&call->parent_call_atm);
+static parent_call* get_parent_call(grpc_call* call) {
+  return (parent_call*)gpr_atm_acq_load(&call->parent_call_atm);
 }
 
-grpc_error *grpc_call_create(grpc_exec_ctx *exec_ctx,
-                             const grpc_call_create_args *args,
-                             grpc_call **out_call) {
+grpc_error* grpc_call_create(grpc_exec_ctx* exec_ctx,
+                             const grpc_call_create_args* args,
+                             grpc_call** out_call) {
   size_t i, j;
-  grpc_error *error = GRPC_ERROR_NONE;
-  grpc_channel_stack *channel_stack =
+  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_channel_stack* channel_stack =
       grpc_channel_get_channel_stack(args->channel);
-  grpc_call *call;
+  grpc_call* call;
   GPR_TIMER_BEGIN("grpc_call_create", 0);
   size_t initial_size = grpc_channel_get_call_size_estimate(args->channel);
   GRPC_STATS_INC_CALL_INITIAL_SIZE(exec_ctx, initial_size);
-  gpr_arena *arena = gpr_arena_create(initial_size);
-  call = (grpc_call *)gpr_arena_alloc(
+  gpr_arena* arena = gpr_arena_create(initial_size);
+  call = (grpc_call*)gpr_arena_alloc(
       arena, sizeof(grpc_call) + channel_stack->call_stack_size);
   gpr_ref_init(&call->ext_ref, 1);
   call->arena = arena;
@@ -344,7 +346,7 @@ grpc_error *grpc_call_create(grpc_exec_ctx *exec_ctx,
   call->start_time = gpr_now(GPR_CLOCK_MONOTONIC);
   /* Always support no compression */
   GPR_BITSET(&call->encodings_accepted_by_peer, GRPC_COMPRESS_NONE);
-  call->is_client = args->server_transport_data == NULL;
+  call->is_client = args->server_transport_data == nullptr;
   if (call->is_client) {
     GRPC_STATS_INC_CLIENT_CALLS_CREATED(exec_ctx);
   } else {
@@ -370,32 +372,28 @@ grpc_error *grpc_call_create(grpc_exec_ctx *exec_ctx,
   }
   for (i = 0; i < 2; i++) {
     for (j = 0; j < 2; j++) {
-      call->metadata_batch[i][j].deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC);
+      call->metadata_batch[i][j].deadline = GRPC_MILLIS_INF_FUTURE;
     }
   }
-  gpr_timespec send_deadline =
-      gpr_convert_clock_type(args->send_deadline, GPR_CLOCK_MONOTONIC);
+  grpc_millis send_deadline = args->send_deadline;
 
   bool immediately_cancel = false;
 
-  if (args->parent != NULL) {
-    child_call *cc = call->child =
-        (child_call *)gpr_arena_alloc(arena, sizeof(child_call));
+  if (args->parent != nullptr) {
+    child_call* cc = call->child =
+        (child_call*)gpr_arena_alloc(arena, sizeof(child_call));
     call->child->parent = args->parent;
 
     GRPC_CALL_INTERNAL_REF(args->parent, "child");
     GPR_ASSERT(call->is_client);
     GPR_ASSERT(!args->parent->is_client);
 
-    parent_call *pc = get_or_create_parent_call(args->parent);
+    parent_call* pc = get_or_create_parent_call(args->parent);
 
     gpr_mu_lock(&pc->child_list_mu);
 
     if (args->propagation_mask & GRPC_PROPAGATE_DEADLINE) {
-      send_deadline = gpr_time_min(
-          gpr_convert_clock_type(send_deadline,
-                                 args->parent->send_deadline.clock_type),
-          args->parent->send_deadline);
+      send_deadline = GPR_MIN(send_deadline, args->parent->send_deadline);
     }
     /* for now GRPC_PROPAGATE_TRACING_CONTEXT *MUST* be passed with
      * GRPC_PROPAGATE_STATS_CONTEXT */
@@ -409,7 +407,7 @@ grpc_error *grpc_call_create(grpc_exec_ctx *exec_ctx,
       }
       grpc_call_context_set(call, GRPC_CONTEXT_TRACING,
                             args->parent->context[GRPC_CONTEXT_TRACING].value,
-                            NULL);
+                            nullptr);
     } else if (args->propagation_mask & GRPC_PROPAGATE_CENSUS_STATS_CONTEXT) {
       add_init_error(&error, GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                                  "Census context propagation requested "
@@ -422,7 +420,7 @@ grpc_error *grpc_call_create(grpc_exec_ctx *exec_ctx,
       }
     }
 
-    if (pc->first_child == NULL) {
+    if (pc->first_child == nullptr) {
       pc->first_child = call;
       cc->sibling_next = cc->sibling_prev = call;
     } else {
@@ -439,15 +437,14 @@ grpc_error *grpc_call_create(grpc_exec_ctx *exec_ctx,
 
   GRPC_CHANNEL_INTERNAL_REF(args->channel, "call");
   /* initial refcount dropped by grpc_call_unref */
-  grpc_call_element_args call_args = {
-      .call_stack = CALL_STACK_FROM_CALL(call),
-      .server_transport_data = args->server_transport_data,
-      .context = call->context,
-      .path = path,
-      .start_time = call->start_time,
-      .deadline = send_deadline,
-      .arena = call->arena,
-      .call_combiner = &call->call_combiner};
+  grpc_call_element_args call_args = {CALL_STACK_FROM_CALL(call),
+                                      args->server_transport_data,
+                                      call->context,
+                                      path,
+                                      call->start_time,
+                                      send_deadline,
+                                      call->arena,
+                                      &call->call_combiner};
   add_init_error(&error, grpc_call_stack_init(exec_ctx, channel_stack, 1,
                                               destroy_call, call, &call_args));
   if (error != GRPC_ERROR_NONE) {
@@ -458,15 +455,15 @@ grpc_error *grpc_call_create(grpc_exec_ctx *exec_ctx,
     cancel_with_error(exec_ctx, call, STATUS_FROM_API_OVERRIDE,
                       GRPC_ERROR_CANCELLED);
   }
-  if (args->cq != NULL) {
+  if (args->cq != nullptr) {
     GPR_ASSERT(
-        args->pollset_set_alternative == NULL &&
+        args->pollset_set_alternative == nullptr &&
         "Only one of 'cq' and 'pollset_set_alternative' should be non-NULL.");
     GRPC_CQ_INTERNAL_REF(args->cq, "bind");
     call->pollent =
         grpc_polling_entity_create_from_pollset(grpc_cq_pollset(args->cq));
   }
-  if (args->pollset_set_alternative != NULL) {
+  if (args->pollset_set_alternative != nullptr) {
     call->pollent = grpc_polling_entity_create_from_pollset_set(
         args->pollset_set_alternative);
   }
@@ -481,11 +478,11 @@ grpc_error *grpc_call_create(grpc_exec_ctx *exec_ctx,
   return error;
 }
 
-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) {
   GPR_ASSERT(cq);
 
-  if (grpc_polling_entity_pollset_set(&call->pollent) != NULL) {
+  if (grpc_polling_entity_pollset_set(&call->pollent) != nullptr) {
     gpr_log(GPR_ERROR, "A pollset_set is already registered for this call.");
     abort();
   }
@@ -498,44 +495,44 @@ void grpc_call_set_completion_queue(grpc_exec_ctx *exec_ctx, grpc_call *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_call_internal_ref(grpc_call *c REF_ARG) {
+void grpc_call_internal_ref(grpc_call* c REF_ARG) {
   GRPC_CALL_STACK_REF(CALL_STACK_FROM_CALL(c), REF_REASON);
 }
-void grpc_call_internal_unref(grpc_exec_ctx *exec_ctx, grpc_call *c REF_ARG) {
+void grpc_call_internal_unref(grpc_exec_ctx* exec_ctx, grpc_call* c REF_ARG) {
   GRPC_CALL_STACK_UNREF(exec_ctx, CALL_STACK_FROM_CALL(c), REF_REASON);
 }
 
-static void release_call(grpc_exec_ctx *exec_ctx, void *call,
-                         grpc_error *error) {
-  grpc_call *c = (grpc_call *)call;
-  grpc_channel *channel = c->channel;
+static void release_call(grpc_exec_ctx* exec_ctx, void* call,
+                         grpc_error* error) {
+  grpc_call* c = (grpc_call*)call;
+  grpc_channel* channel = c->channel;
   grpc_call_combiner_destroy(&c->call_combiner);
-  gpr_free((char *)c->peer_string);
+  gpr_free((char*)c->peer_string);
   grpc_channel_update_call_size_estimate(channel, gpr_arena_destroy(c->arena));
   GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, channel, "call");
 }
 
-static void set_status_value_directly(grpc_status_code status, void *dest);
-static void destroy_call(grpc_exec_ctx *exec_ctx, void *call,
-                         grpc_error *error) {
+static void set_status_value_directly(grpc_status_code status, void* dest);
+static void destroy_call(grpc_exec_ctx* exec_ctx, void* call,
+                         grpc_error* error) {
   size_t i;
   int ii;
-  grpc_call *c = (grpc_call *)call;
+  grpc_call* c = (grpc_call*)call;
   GPR_TIMER_BEGIN("destroy_call", 0);
   for (i = 0; i < 2; i++) {
     grpc_metadata_batch_destroy(
         exec_ctx, &c->metadata_batch[1 /* is_receiving */][i /* is_initial */]);
   }
-  if (c->receiving_stream != NULL) {
+  if (c->receiving_stream != nullptr) {
     grpc_byte_stream_destroy(exec_ctx, c->receiving_stream);
   }
-  parent_call *pc = get_parent_call(c);
-  if (pc != NULL) {
+  parent_call* pc = get_parent_call(c);
+  if (pc != nullptr) {
     gpr_mu_destroy(&pc->child_list_mu);
   }
   for (ii = 0; ii < c->send_extra_metadata_count; ii++) {
@@ -550,8 +547,9 @@ static void destroy_call(grpc_exec_ctx *exec_ctx, void *call,
     GRPC_CQ_INTERNAL_UNREF(exec_ctx, c->cq, "bind");
   }
 
-  get_final_status(c, set_status_value_directly, &c->final_info.final_status,
-                   NULL);
+  get_final_status(exec_ctx, c, set_status_value_directly,
+                   &c->final_info.final_status, nullptr,
+                   c->final_info.error_string);
   c->final_info.stats.latency =
       gpr_time_sub(gpr_now(GPR_CLOCK_MONOTONIC), c->start_time);
 
@@ -566,24 +564,24 @@ static void destroy_call(grpc_exec_ctx *exec_ctx, void *call,
   GPR_TIMER_END("destroy_call", 0);
 }
 
-void grpc_call_ref(grpc_call *c) { gpr_ref(&c->ext_ref); }
+void grpc_call_ref(grpc_call* c) { gpr_ref(&c->ext_ref); }
 
-void grpc_call_unref(grpc_call *c) {
+void grpc_call_unref(grpc_call* c) {
   if (!gpr_unref(&c->ext_ref)) return;
 
-  child_call *cc = c->child;
+  child_call* cc = c->child;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
   GPR_TIMER_BEGIN("grpc_call_unref", 0);
   GRPC_API_TRACE("grpc_call_unref(c=%p)", 1, (c));
 
   if (cc) {
-    parent_call *pc = get_parent_call(cc->parent);
+    parent_call* pc = get_parent_call(cc->parent);
     gpr_mu_lock(&pc->child_list_mu);
     if (c == pc->first_child) {
       pc->first_child = cc->sibling_next;
       if (c == pc->first_child) {
-        pc->first_child = NULL;
+        pc->first_child = nullptr;
       }
     }
     cc->sibling_prev->child->sibling_next = cc->sibling_next;
@@ -604,14 +602,15 @@ void grpc_call_unref(grpc_call *c) {
     // effect of scheduling the previously set cancellation closure, if
     // any, so that it can release any internal references it may be
     // holding to the call stack.
-    grpc_call_combiner_set_notify_on_cancel(&exec_ctx, &c->call_combiner, NULL);
+    grpc_call_combiner_set_notify_on_cancel(&exec_ctx, &c->call_combiner,
+                                            nullptr);
   }
   GRPC_CALL_INTERNAL_UNREF(&exec_ctx, c, "destroy");
   grpc_exec_ctx_finish(&exec_ctx);
   GPR_TIMER_END("grpc_call_unref", 0);
 }
 
-grpc_call_error grpc_call_cancel(grpc_call *call, void *reserved) {
+grpc_call_error grpc_call_cancel(grpc_call* call, void* reserved) {
   GRPC_API_TRACE("grpc_call_cancel(call=%p, reserved=%p)", 2, (call, reserved));
   GPR_ASSERT(!reserved);
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -623,12 +622,12 @@ grpc_call_error grpc_call_cancel(grpc_call *call, void *reserved) {
 
 // This is called via the call combiner to start sending a batch down
 // the filter stack.
-static void execute_batch_in_call_combiner(grpc_exec_ctx *exec_ctx, void *arg,
-                                           grpc_error *ignored) {
-  grpc_transport_stream_op_batch *batch = (grpc_transport_stream_op_batch *)arg;
-  grpc_call *call = (grpc_call *)batch->handler_private.extra_arg;
+static void execute_batch_in_call_combiner(grpc_exec_ctx* exec_ctx, void* arg,
+                                           grpc_error* ignored) {
+  grpc_transport_stream_op_batch* batch = (grpc_transport_stream_op_batch*)arg;
+  grpc_call* call = (grpc_call*)batch->handler_private.extra_arg;
   GPR_TIMER_BEGIN("execute_batch", 0);
-  grpc_call_element *elem = CALL_ELEM_FROM_CALL(call, 0);
+  grpc_call_element* elem = CALL_ELEM_FROM_CALL(call, 0);
   GRPC_CALL_LOG_OP(GPR_INFO, elem, batch);
   elem->filter->start_transport_stream_op_batch(exec_ctx, elem, batch);
   GPR_TIMER_END("execute_batch", 0);
@@ -636,9 +635,9 @@ static void execute_batch_in_call_combiner(grpc_exec_ctx *exec_ctx, void *arg,
 
 // start_batch_closure points to a caller-allocated closure to be used
 // for entering the call combiner.
-static void execute_batch(grpc_exec_ctx *exec_ctx, grpc_call *call,
-                          grpc_transport_stream_op_batch *batch,
-                          grpc_closure *start_batch_closure) {
+static void execute_batch(grpc_exec_ctx* exec_ctx, grpc_call* call,
+                          grpc_transport_stream_op_batch* batch,
+                          grpc_closure* start_batch_closure) {
   batch->handler_private.extra_arg = call;
   GRPC_CLOSURE_INIT(start_batch_closure, execute_batch_in_call_combiner, batch,
                     grpc_schedule_on_exec_ctx);
@@ -646,15 +645,15 @@ static void execute_batch(grpc_exec_ctx *exec_ctx, grpc_call *call,
                            GRPC_ERROR_NONE, "executing batch");
 }
 
-char *grpc_call_get_peer(grpc_call *call) {
-  char *peer_string = (char *)gpr_atm_acq_load(&call->peer_string);
-  if (peer_string != NULL) return gpr_strdup(peer_string);
+char* grpc_call_get_peer(grpc_call* call) {
+  char* peer_string = (char*)gpr_atm_acq_load(&call->peer_string);
+  if (peer_string != nullptr) return gpr_strdup(peer_string);
   peer_string = grpc_channel_get_target(call->channel);
-  if (peer_string != NULL) return peer_string;
+  if (peer_string != nullptr) return peer_string;
   return gpr_strdup("unknown");
 }
 
-grpc_call *grpc_call_from_top_element(grpc_call_element *elem) {
+grpc_call* grpc_call_from_top_element(grpc_call_element* elem) {
   return CALL_FROM_TOP_ELEM(elem);
 }
 
@@ -662,16 +661,16 @@ grpc_call *grpc_call_from_top_element(grpc_call_element *elem) {
  * CANCELLATION
  */
 
-grpc_call_error grpc_call_cancel_with_status(grpc_call *c,
+grpc_call_error grpc_call_cancel_with_status(grpc_call* c,
                                              grpc_status_code status,
-                                             const char *description,
-                                             void *reserved) {
+                                             const char* description,
+                                             void* reserved) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   GRPC_API_TRACE(
       "grpc_call_cancel_with_status("
       "c=%p, status=%d, description=%s, reserved=%p)",
       4, (c, (int)status, description, reserved));
-  GPR_ASSERT(reserved == NULL);
+  GPR_ASSERT(reserved == nullptr);
   cancel_with_status(&exec_ctx, c, STATUS_FROM_API_OVERRIDE, status,
                      description);
   grpc_exec_ctx_finish(&exec_ctx);
@@ -679,24 +678,24 @@ grpc_call_error grpc_call_cancel_with_status(grpc_call *c,
 }
 
 typedef struct {
-  grpc_call *call;
+  grpc_call* call;
   grpc_closure start_batch;
   grpc_closure finish_batch;
 } cancel_state;
 
 // The on_complete callback used when sending a cancel_stream batch down
 // the filter stack.  Yields the call combiner when the batch is done.
-static void done_termination(grpc_exec_ctx *exec_ctx, void *arg,
-                             grpc_error *error) {
-  cancel_state *state = (cancel_state *)arg;
+static void done_termination(grpc_exec_ctx* exec_ctx, void* arg,
+                             grpc_error* error) {
+  cancel_state* state = (cancel_state*)arg;
   GRPC_CALL_COMBINER_STOP(exec_ctx, &state->call->call_combiner,
                           "on_complete for cancel_stream op");
   GRPC_CALL_INTERNAL_UNREF(exec_ctx, state->call, "termination");
   gpr_free(state);
 }
 
-static void cancel_with_error(grpc_exec_ctx *exec_ctx, grpc_call *c,
-                              status_source source, grpc_error *error) {
+static void cancel_with_error(grpc_exec_ctx* exec_ctx, grpc_call* c,
+                              status_source source, grpc_error* error) {
   GRPC_CALL_INTERNAL_REF(c, "termination");
   // Inform the call combiner of the cancellation, so that it can cancel
   // any in-flight asynchronous actions that may be holding the call
@@ -704,19 +703,19 @@ static void cancel_with_error(grpc_exec_ctx *exec_ctx, grpc_call *c,
   // down the filter stack in a timely manner.
   grpc_call_combiner_cancel(exec_ctx, &c->call_combiner, GRPC_ERROR_REF(error));
   set_status_from_error(exec_ctx, c, source, GRPC_ERROR_REF(error));
-  cancel_state *state = (cancel_state *)gpr_malloc(sizeof(*state));
+  cancel_state* state = (cancel_state*)gpr_malloc(sizeof(*state));
   state->call = c;
   GRPC_CLOSURE_INIT(&state->finish_batch, done_termination, state,
                     grpc_schedule_on_exec_ctx);
-  grpc_transport_stream_op_batch *op =
+  grpc_transport_stream_op_batch* op =
       grpc_make_transport_stream_op(&state->finish_batch);
   op->cancel_stream = true;
   op->payload->cancel_stream.cancel_error = error;
   execute_batch(exec_ctx, c, op, &state->start_batch);
 }
 
-static grpc_error *error_from_status(grpc_status_code status,
-                                     const char *description) {
+static grpc_error* error_from_status(grpc_status_code status,
+                                     const char* description) {
   // copying 'description' is needed to ensure the grpc_call_cancel_with_status
   // guarantee that can be short-lived.
   return grpc_error_set_int(
@@ -726,9 +725,9 @@ static grpc_error *error_from_status(grpc_status_code status,
       GRPC_ERROR_INT_GRPC_STATUS, status);
 }
 
-static void cancel_with_status(grpc_exec_ctx *exec_ctx, grpc_call *c,
+static void cancel_with_status(grpc_exec_ctx* exec_ctx, grpc_call* c,
                                status_source source, grpc_status_code status,
-                               const char *description) {
+                               const char* description) {
   cancel_with_error(exec_ctx, c, source,
                     error_from_status(status, description));
 }
@@ -738,33 +737,36 @@ static void cancel_with_status(grpc_exec_ctx *exec_ctx, grpc_call *c,
  */
 
 static bool get_final_status_from(
-    grpc_call *call, grpc_error *error, bool allow_ok_status,
-    void (*set_value)(grpc_status_code code, void *user_data),
-    void *set_value_user_data, grpc_slice *details) {
+    grpc_exec_ctx* exec_ctx, grpc_call* call, grpc_error* error,
+    bool allow_ok_status,
+    void (*set_value)(grpc_status_code code, void* user_data),
+    void* set_value_user_data, grpc_slice* details, const char** error_string) {
   grpc_status_code code;
   grpc_slice slice = grpc_empty_slice();
-  grpc_error_get_status(error, call->send_deadline, &code, &slice, NULL);
+  grpc_error_get_status(exec_ctx, error, call->send_deadline, &code, &slice,
+                        nullptr, error_string);
   if (code == GRPC_STATUS_OK && !allow_ok_status) {
     return false;
   }
 
   set_value(code, set_value_user_data);
-  if (details != NULL) {
+  if (details != nullptr) {
     *details = grpc_slice_ref_internal(slice);
   }
   return true;
 }
 
-static void get_final_status(grpc_call *call,
+static void get_final_status(grpc_exec_ctx* exec_ctx, grpc_call* call,
                              void (*set_value)(grpc_status_code code,
-                                               void *user_data),
-                             void *set_value_user_data, grpc_slice *details) {
+                                               void* user_data),
+                             void* set_value_user_data, grpc_slice* details,
+                             const char** error_string) {
   int i;
   received_status status[STATUS_SOURCE_COUNT];
   for (i = 0; i < STATUS_SOURCE_COUNT; i++) {
     status[i] = unpack_received_status(gpr_atm_acq_load(&call->status[i]));
   }
-  if (GRPC_TRACER_ON(grpc_call_error_trace)) {
+  if (grpc_call_error_trace.enabled()) {
     gpr_log(GPR_DEBUG, "get_final_status %s", call->is_client ? "CLI" : "SVR");
     for (i = 0; i < STATUS_SOURCE_COUNT; i++) {
       if (status[i].is_set) {
@@ -780,8 +782,9 @@ static void get_final_status(grpc_call *call,
     for (i = 0; i < STATUS_SOURCE_COUNT; i++) {
       if (status[i].is_set &&
           grpc_error_has_clear_grpc_status(status[i].error)) {
-        if (get_final_status_from(call, status[i].error, allow_ok_status != 0,
-                                  set_value, set_value_user_data, details)) {
+        if (get_final_status_from(exec_ctx, call, status[i].error,
+                                  allow_ok_status != 0, set_value,
+                                  set_value_user_data, details, error_string)) {
           return;
         }
       }
@@ -789,8 +792,9 @@ static void get_final_status(grpc_call *call,
     /* If no clearly defined status exists, search for 'anything' */
     for (i = 0; i < STATUS_SOURCE_COUNT; i++) {
       if (status[i].is_set) {
-        if (get_final_status_from(call, status[i].error, allow_ok_status != 0,
-                                  set_value, set_value_user_data, details)) {
+        if (get_final_status_from(exec_ctx, call, status[i].error,
+                                  allow_ok_status != 0, set_value,
+                                  set_value_user_data, details, error_string)) {
           return;
         }
       }
@@ -804,13 +808,11 @@ static void get_final_status(grpc_call *call,
   }
 }
 
-static void set_status_from_error(grpc_exec_ctx *exec_ctx, grpc_call *call,
-                                  status_source source, grpc_error *error) {
+static void set_status_from_error(grpc_exec_ctx* exec_ctx, grpc_call* call,
+                                  status_source source, grpc_error* error) {
   if (!gpr_atm_rel_cas(&call->status[source],
-                       pack_received_status((received_status){
-                           .is_set = false, .error = GRPC_ERROR_NONE}),
-                       pack_received_status((received_status){
-                           .is_set = true, .error = error}))) {
+                       pack_received_status({false, GRPC_ERROR_NONE}),
+                       pack_received_status({true, error}))) {
     GRPC_ERROR_UNREF(error);
   }
 }
@@ -820,56 +822,56 @@ static void set_status_from_error(grpc_exec_ctx *exec_ctx, grpc_call *call,
  */
 
 static void set_incoming_compression_algorithm(
-    grpc_call *call, grpc_compression_algorithm algo) {
+    grpc_call* call, grpc_compression_algorithm algo) {
   GPR_ASSERT(algo < GRPC_COMPRESS_ALGORITHMS_COUNT);
   call->incoming_compression_algorithm = algo;
 }
 
 static void set_incoming_stream_compression_algorithm(
-    grpc_call *call, grpc_stream_compression_algorithm algo) {
+    grpc_call* call, grpc_stream_compression_algorithm algo) {
   GPR_ASSERT(algo < GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT);
   call->incoming_stream_compression_algorithm = algo;
 }
 
 grpc_compression_algorithm grpc_call_test_only_get_compression_algorithm(
-    grpc_call *call) {
+    grpc_call* call) {
   grpc_compression_algorithm algorithm;
   algorithm = call->incoming_compression_algorithm;
   return algorithm;
 }
 
 static grpc_compression_algorithm compression_algorithm_for_level_locked(
-    grpc_call *call, grpc_compression_level level) {
+    grpc_call* call, grpc_compression_level level) {
   return grpc_compression_algorithm_for_level(level,
                                               call->encodings_accepted_by_peer);
 }
 
 static grpc_stream_compression_algorithm
 stream_compression_algorithm_for_level_locked(
-    grpc_call *call, grpc_stream_compression_level level) {
+    grpc_call* call, grpc_stream_compression_level level) {
   return grpc_stream_compression_algorithm_for_level(
       level, call->stream_encodings_accepted_by_peer);
 }
 
-uint32_t grpc_call_test_only_get_message_flags(grpc_call *call) {
+uint32_t grpc_call_test_only_get_message_flags(grpc_call* call) {
   uint32_t flags;
   flags = call->test_only_last_message_flags;
   return flags;
 }
 
-static void destroy_encodings_accepted_by_peer(void *p) { return; }
+static void destroy_encodings_accepted_by_peer(void* p) { return; }
 
-static void set_encodings_accepted_by_peer(grpc_exec_ctx *exec_ctx,
-                                           grpc_call *call, grpc_mdelem mdel) {
+static void set_encodings_accepted_by_peer(grpc_exec_ctx* exec_ctx,
+                                           grpc_call* call, grpc_mdelem mdel) {
   size_t i;
   grpc_compression_algorithm algorithm;
   grpc_slice_buffer accept_encoding_parts;
   grpc_slice accept_encoding_slice;
-  void *accepted_user_data;
+  void* accepted_user_data;
 
   accepted_user_data =
       grpc_mdelem_get_user_data(mdel, destroy_encodings_accepted_by_peer);
-  if (accepted_user_data != NULL) {
+  if (accepted_user_data != nullptr) {
     call->encodings_accepted_by_peer =
         (uint32_t)(((uintptr_t)accepted_user_data) - 1);
     return;
@@ -889,7 +891,7 @@ static void set_encodings_accepted_by_peer(grpc_exec_ctx *exec_ctx,
                                          &algorithm)) {
       GPR_BITSET(&call->encodings_accepted_by_peer, algorithm);
     } else {
-      char *accept_encoding_entry_str =
+      char* accept_encoding_entry_str =
           grpc_slice_to_c_string(accept_encoding_entry_slice);
       gpr_log(GPR_ERROR,
               "Invalid entry in accept encoding metadata: '%s'. Ignoring.",
@@ -902,21 +904,21 @@ static void set_encodings_accepted_by_peer(grpc_exec_ctx *exec_ctx,
 
   grpc_mdelem_set_user_data(
       mdel, destroy_encodings_accepted_by_peer,
-      (void *)(((uintptr_t)call->encodings_accepted_by_peer) + 1));
+      (void*)(((uintptr_t)call->encodings_accepted_by_peer) + 1));
 }
 
-static void set_stream_encodings_accepted_by_peer(grpc_exec_ctx *exec_ctx,
-                                                  grpc_call *call,
+static void set_stream_encodings_accepted_by_peer(grpc_exec_ctx* exec_ctx,
+                                                  grpc_call* call,
                                                   grpc_mdelem mdel) {
   size_t i;
   grpc_stream_compression_algorithm algorithm;
   grpc_slice_buffer accept_encoding_parts;
   grpc_slice accept_encoding_slice;
-  void *accepted_user_data;
+  void* accepted_user_data;
 
   accepted_user_data =
       grpc_mdelem_get_user_data(mdel, destroy_encodings_accepted_by_peer);
-  if (accepted_user_data != NULL) {
+  if (accepted_user_data != nullptr) {
     call->stream_encodings_accepted_by_peer =
         (uint32_t)(((uintptr_t)accepted_user_data) - 1);
     return;
@@ -935,7 +937,7 @@ static void set_stream_encodings_accepted_by_peer(grpc_exec_ctx *exec_ctx,
                                                 &algorithm)) {
       GPR_BITSET(&call->stream_encodings_accepted_by_peer, algorithm);
     } else {
-      char *accept_encoding_entry_str =
+      char* accept_encoding_entry_str =
           grpc_slice_to_c_string(accept_encoding_entry_slice);
       gpr_log(GPR_ERROR,
               "Invalid entry in accept encoding metadata: '%s'. Ignoring.",
@@ -948,52 +950,52 @@ static void set_stream_encodings_accepted_by_peer(grpc_exec_ctx *exec_ctx,
 
   grpc_mdelem_set_user_data(
       mdel, destroy_encodings_accepted_by_peer,
-      (void *)(((uintptr_t)call->stream_encodings_accepted_by_peer) + 1));
+      (void*)(((uintptr_t)call->stream_encodings_accepted_by_peer) + 1));
 }
 
-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) {
   uint32_t encodings_accepted_by_peer;
   encodings_accepted_by_peer = call->encodings_accepted_by_peer;
   return encodings_accepted_by_peer;
 }
 
 uint32_t grpc_call_test_only_get_stream_encodings_accepted_by_peer(
-    grpc_call *call) {
+    grpc_call* call) {
   uint32_t stream_encodings_accepted_by_peer;
   stream_encodings_accepted_by_peer = call->stream_encodings_accepted_by_peer;
   return stream_encodings_accepted_by_peer;
 }
 
 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) {
   return call->incoming_stream_compression_algorithm;
 }
 
-static grpc_linked_mdelem *linked_from_md(const grpc_metadata *md) {
-  return (grpc_linked_mdelem *)&md->internal_data;
+static grpc_linked_mdelem* linked_from_md(const grpc_metadata* md) {
+  return (grpc_linked_mdelem*)&md->internal_data;
 }
 
-static grpc_metadata *get_md_elem(grpc_metadata *metadata,
-                                  grpc_metadata *additional_metadata, int i,
+static grpc_metadata* get_md_elem(grpc_metadata* metadata,
+                                  grpc_metadata* additional_metadata, int i,
                                   int count) {
-  grpc_metadata *res =
+  grpc_metadata* res =
       i < count ? &metadata[i] : &additional_metadata[i - count];
   GPR_ASSERT(res);
   return res;
 }
 
 static int prepare_application_metadata(
-    grpc_exec_ctx *exec_ctx, grpc_call *call, int count,
-    grpc_metadata *metadata, int is_trailing, int prepend_extra_metadata,
-    grpc_metadata *additional_metadata, int additional_metadata_count) {
+    grpc_exec_ctx* exec_ctx, grpc_call* call, int count,
+    grpc_metadata* metadata, int is_trailing, int prepend_extra_metadata,
+    grpc_metadata* additional_metadata, int additional_metadata_count) {
   int total_count = count + additional_metadata_count;
   int i;
-  grpc_metadata_batch *batch =
+  grpc_metadata_batch* batch =
       &call->metadata_batch[0 /* is_receiving */][is_trailing];
   for (i = 0; i < total_count; i++) {
-    const grpc_metadata *md =
+    const grpc_metadata* md =
         get_md_elem(metadata, additional_metadata, i, count);
-    grpc_linked_mdelem *l = linked_from_md(md);
+    grpc_linked_mdelem* l = linked_from_md(md);
     GPR_ASSERT(sizeof(grpc_linked_mdelem) == sizeof(md->internal_data));
     if (!GRPC_LOG_IF_ERROR("validate_metadata",
                            grpc_validate_header_key_is_legal(md->key))) {
@@ -1004,13 +1006,13 @@ static int prepare_application_metadata(
                    grpc_validate_header_nonbin_value_is_legal(md->value))) {
       break;
     }
-    l->md = grpc_mdelem_from_grpc_metadata(exec_ctx, (grpc_metadata *)md);
+    l->md = grpc_mdelem_from_grpc_metadata(exec_ctx, (grpc_metadata*)md);
   }
   if (i != total_count) {
     for (int j = 0; j < i; j++) {
-      const grpc_metadata *md =
+      const grpc_metadata* md =
           get_md_elem(metadata, additional_metadata, j, count);
-      grpc_linked_mdelem *l = linked_from_md(md);
+      grpc_linked_mdelem* l = linked_from_md(md);
       GRPC_MDELEM_UNREF(exec_ctx, l->md);
     }
     return 0;
@@ -1027,9 +1029,9 @@ static int prepare_application_metadata(
     }
   }
   for (i = 0; i < total_count; i++) {
-    grpc_metadata *md = get_md_elem(metadata, additional_metadata, i, count);
-    grpc_linked_mdelem *l = linked_from_md(md);
-    grpc_error *error = grpc_metadata_batch_link_tail(exec_ctx, batch, l);
+    grpc_metadata* md = get_md_elem(metadata, additional_metadata, i, count);
+    grpc_linked_mdelem* l = linked_from_md(md);
+    grpc_error* error = grpc_metadata_batch_link_tail(exec_ctx, batch, l);
     if (error != GRPC_ERROR_NONE) {
       GRPC_MDELEM_UNREF(exec_ctx, l->md);
     }
@@ -1044,23 +1046,23 @@ static int prepare_application_metadata(
    as metadata cannot store a 0 value (which is used as OK for grpc_status_codes
    */
 #define STATUS_OFFSET 1
-static void destroy_status(void *ignored) {}
+static void destroy_status(void* ignored) {}
 
 static uint32_t decode_status(grpc_mdelem md) {
   uint32_t status;
-  void *user_data;
+  void* user_data;
   if (grpc_mdelem_eq(md, GRPC_MDELEM_GRPC_STATUS_0)) return 0;
   if (grpc_mdelem_eq(md, GRPC_MDELEM_GRPC_STATUS_1)) return 1;
   if (grpc_mdelem_eq(md, GRPC_MDELEM_GRPC_STATUS_2)) return 2;
   user_data = grpc_mdelem_get_user_data(md, destroy_status);
-  if (user_data != NULL) {
+  if (user_data != nullptr) {
     status = ((uint32_t)(intptr_t)user_data) - STATUS_OFFSET;
   } else {
     if (!grpc_parse_slice_to_uint32(GRPC_MDVALUE(md), &status)) {
       status = GRPC_STATUS_UNKNOWN; /* could not parse status code */
     }
     grpc_mdelem_set_user_data(md, destroy_status,
-                              (void *)(intptr_t)(status + STATUS_OFFSET));
+                              (void*)(intptr_t)(status + STATUS_OFFSET));
   }
   return status;
 }
@@ -1069,7 +1071,7 @@ static grpc_compression_algorithm decode_compression(grpc_mdelem md) {
   grpc_compression_algorithm algorithm =
       grpc_compression_algorithm_from_slice(GRPC_MDVALUE(md));
   if (algorithm == GRPC_COMPRESS_ALGORITHMS_COUNT) {
-    char *md_c_str = grpc_slice_to_c_string(GRPC_MDVALUE(md));
+    char* md_c_str = grpc_slice_to_c_string(GRPC_MDVALUE(md));
     gpr_log(GPR_ERROR,
             "Invalid incoming compression algorithm: '%s'. Interpreting "
             "incoming data as uncompressed.",
@@ -1085,7 +1087,7 @@ static grpc_stream_compression_algorithm decode_stream_compression(
   grpc_stream_compression_algorithm algorithm =
       grpc_stream_compression_algorithm_from_slice(GRPC_MDVALUE(md));
   if (algorithm == GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) {
-    char *md_c_str = grpc_slice_to_c_string(GRPC_MDVALUE(md));
+    char* md_c_str = grpc_slice_to_c_string(GRPC_MDVALUE(md));
     gpr_log(GPR_ERROR,
             "Invalid incoming stream compression algorithm: '%s'. Interpreting "
             "incoming data as uncompressed.",
@@ -1096,20 +1098,20 @@ static grpc_stream_compression_algorithm decode_stream_compression(
   return algorithm;
 }
 
-static void publish_app_metadata(grpc_call *call, grpc_metadata_batch *b,
+static void publish_app_metadata(grpc_call* call, grpc_metadata_batch* b,
                                  int is_trailing) {
   if (b->list.count == 0) return;
   GPR_TIMER_BEGIN("publish_app_metadata", 0);
-  grpc_metadata_array *dest;
-  grpc_metadata *mdusr;
+  grpc_metadata_array* dest;
+  grpc_metadata* mdusr;
   dest = call->buffered_metadata[is_trailing];
   if (dest->count + b->list.count > dest->capacity) {
     dest->capacity =
         GPR_MAX(dest->capacity + b->list.count, dest->capacity * 3 / 2);
-    dest->metadata = (grpc_metadata *)gpr_realloc(
+    dest->metadata = (grpc_metadata*)gpr_realloc(
         dest->metadata, sizeof(grpc_metadata) * dest->capacity);
   }
-  for (grpc_linked_mdelem *l = b->list.head; l != NULL; l = l->next) {
+  for (grpc_linked_mdelem* l = b->list.head; l != nullptr; l = l->next) {
     mdusr = &dest->metadata[dest->count++];
     /* we pass back borrowed slices that are valid whilst the call is valid */
     mdusr->key = GRPC_MDKEY(l->md);
@@ -1118,10 +1120,10 @@ static void publish_app_metadata(grpc_call *call, grpc_metadata_batch *b,
   GPR_TIMER_END("publish_app_metadata", 0);
 }
 
-static void recv_initial_filter(grpc_exec_ctx *exec_ctx, grpc_call *call,
-                                grpc_metadata_batch *b) {
-  if (b->idx.named.content_encoding != NULL) {
-    if (b->idx.named.grpc_encoding != NULL) {
+static void recv_initial_filter(grpc_exec_ctx* exec_ctx, grpc_call* call,
+                                grpc_metadata_batch* b) {
+  if (b->idx.named.content_encoding != nullptr) {
+    if (b->idx.named.grpc_encoding != nullptr) {
       gpr_log(GPR_ERROR,
               "Received both content-encoding and grpc-encoding header. "
               "Ignoring grpc-encoding.");
@@ -1132,21 +1134,21 @@ static void recv_initial_filter(grpc_exec_ctx *exec_ctx, grpc_call *call,
         call, decode_stream_compression(b->idx.named.content_encoding->md));
     GPR_TIMER_END("incoming_stream_compression_algorithm", 0);
     grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.content_encoding);
-  } else if (b->idx.named.grpc_encoding != NULL) {
+  } else if (b->idx.named.grpc_encoding != nullptr) {
     GPR_TIMER_BEGIN("incoming_compression_algorithm", 0);
     set_incoming_compression_algorithm(
         call, decode_compression(b->idx.named.grpc_encoding->md));
     GPR_TIMER_END("incoming_compression_algorithm", 0);
     grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.grpc_encoding);
   }
-  if (b->idx.named.grpc_accept_encoding != NULL) {
+  if (b->idx.named.grpc_accept_encoding != nullptr) {
     GPR_TIMER_BEGIN("encodings_accepted_by_peer", 0);
     set_encodings_accepted_by_peer(exec_ctx, call,
                                    b->idx.named.grpc_accept_encoding->md);
     grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.grpc_accept_encoding);
     GPR_TIMER_END("encodings_accepted_by_peer", 0);
   }
-  if (b->idx.named.accept_encoding != NULL) {
+  if (b->idx.named.accept_encoding != nullptr) {
     GPR_TIMER_BEGIN("stream_encodings_accepted_by_peer", 0);
     set_stream_encodings_accepted_by_peer(exec_ctx, call,
                                           b->idx.named.accept_encoding->md);
@@ -1156,19 +1158,19 @@ static void recv_initial_filter(grpc_exec_ctx *exec_ctx, grpc_call *call,
   publish_app_metadata(call, b, false);
 }
 
-static void recv_trailing_filter(grpc_exec_ctx *exec_ctx, void *args,
-                                 grpc_metadata_batch *b) {
-  grpc_call *call = (grpc_call *)args;
-  if (b->idx.named.grpc_status != NULL) {
+static void recv_trailing_filter(grpc_exec_ctx* exec_ctx, void* args,
+                                 grpc_metadata_batch* b) {
+  grpc_call* call = (grpc_call*)args;
+  if (b->idx.named.grpc_status != nullptr) {
     uint32_t status_code = decode_status(b->idx.named.grpc_status->md);
-    grpc_error *error =
+    grpc_error* error =
         status_code == GRPC_STATUS_OK
             ? GRPC_ERROR_NONE
             : grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                                      "Error received from peer"),
                                  GRPC_ERROR_INT_GRPC_STATUS,
                                  (intptr_t)status_code);
-    if (b->idx.named.grpc_message != NULL) {
+    if (b->idx.named.grpc_message != nullptr) {
       error = grpc_error_set_str(
           error, GRPC_ERROR_STR_GRPC_MESSAGE,
           grpc_slice_ref_internal(GRPC_MDVALUE(b->idx.named.grpc_message->md)));
@@ -1183,7 +1185,7 @@ static void recv_trailing_filter(grpc_exec_ctx *exec_ctx, void *args,
   publish_app_metadata(call, b, true);
 }
 
-grpc_call_stack *grpc_call_get_call_stack(grpc_call *call) {
+grpc_call_stack* grpc_call_get_call_stack(grpc_call* call) {
   return CALL_STACK_FROM_CALL(call);
 }
 
@@ -1191,12 +1193,12 @@ grpc_call_stack *grpc_call_get_call_stack(grpc_call *call) {
  * BATCH API IMPLEMENTATION
  */
 
-static void set_status_value_directly(grpc_status_code status, void *dest) {
-  *(grpc_status_code *)dest = status;
+static void set_status_value_directly(grpc_status_code status, void* dest) {
+  *(grpc_status_code*)dest = status;
 }
 
-static void set_cancelled_value(grpc_status_code status, void *dest) {
-  *(int *)dest = (status != GRPC_STATUS_OK);
+static void set_cancelled_value(grpc_status_code status, void* dest) {
+  *(int*)dest = (status != GRPC_STATUS_OK);
 }
 
 static bool are_write_flags_valid(uint32_t flags) {
@@ -1236,18 +1238,18 @@ static int batch_slot_for_op(grpc_op_type type) {
   GPR_UNREACHABLE_CODE(return 123456789);
 }
 
-static batch_control *allocate_batch_control(grpc_call *call,
-                                             const grpc_op *ops,
+static batch_control* allocate_batch_control(grpc_call* call,
+                                             const grpc_op* ops,
                                              size_t num_ops) {
   int slot = batch_slot_for_op(ops[0].op);
-  batch_control **pslot = &call->active_batches[slot];
-  if (*pslot == NULL) {
+  batch_control** pslot = &call->active_batches[slot];
+  if (*pslot == nullptr) {
     *pslot =
-        (batch_control *)gpr_arena_alloc(call->arena, sizeof(batch_control));
+        (batch_control*)gpr_arena_alloc(call->arena, sizeof(batch_control));
   }
-  batch_control *bctl = *pslot;
-  if (bctl->call != NULL) {
-    return NULL;
+  batch_control* bctl = *pslot;
+  if (bctl->call != nullptr) {
+    return nullptr;
   }
   memset(bctl, 0, sizeof(*bctl));
   bctl->call = call;
@@ -1255,40 +1257,40 @@ static batch_control *allocate_batch_control(grpc_call *call,
   return bctl;
 }
 
-static void finish_batch_completion(grpc_exec_ctx *exec_ctx, void *user_data,
-                                    grpc_cq_completion *storage) {
-  batch_control *bctl = (batch_control *)user_data;
-  grpc_call *call = bctl->call;
-  bctl->call = NULL;
+static void finish_batch_completion(grpc_exec_ctx* exec_ctx, void* user_data,
+                                    grpc_cq_completion* storage) {
+  batch_control* bctl = (batch_control*)user_data;
+  grpc_call* call = bctl->call;
+  bctl->call = nullptr;
   GRPC_CALL_INTERNAL_UNREF(exec_ctx, call, "completion");
 }
 
-static grpc_error *consolidate_batch_errors(batch_control *bctl) {
+static grpc_error* consolidate_batch_errors(batch_control* bctl) {
   size_t n = (size_t)gpr_atm_acq_load(&bctl->num_errors);
   if (n == 0) {
     return GRPC_ERROR_NONE;
   } else if (n == 1) {
     /* Skip creating a composite error in the case that only one error was
        logged */
-    grpc_error *e = bctl->errors[0];
-    bctl->errors[0] = NULL;
+    grpc_error* e = bctl->errors[0];
+    bctl->errors[0] = nullptr;
     return e;
   } else {
-    grpc_error *error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+    grpc_error* error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
         "Call batch failed", bctl->errors, n);
     for (size_t i = 0; i < n; i++) {
       GRPC_ERROR_UNREF(bctl->errors[i]);
-      bctl->errors[i] = NULL;
+      bctl->errors[i] = nullptr;
     }
     return error;
   }
 }
 
-static void post_batch_completion(grpc_exec_ctx *exec_ctx,
-                                  batch_control *bctl) {
-  grpc_call *next_child_call;
-  grpc_call *call = bctl->call;
-  grpc_error *error = consolidate_batch_errors(bctl);
+static void post_batch_completion(grpc_exec_ctx* exec_ctx,
+                                  batch_control* bctl) {
+  grpc_call* next_child_call;
+  grpc_call* call = bctl->call;
+  grpc_error* error = consolidate_batch_errors(bctl);
 
   if (bctl->op.send_initial_metadata) {
     grpc_metadata_batch_destroy(
@@ -1304,18 +1306,18 @@ static void post_batch_completion(grpc_exec_ctx *exec_ctx,
         &call->metadata_batch[0 /* is_receiving */][1 /* is_trailing */]);
   }
   if (bctl->op.recv_trailing_metadata) {
-    grpc_metadata_batch *md =
+    grpc_metadata_batch* md =
         &call->metadata_batch[1 /* is_receiving */][1 /* is_trailing */];
     recv_trailing_filter(exec_ctx, call, md);
 
     /* propagate cancellation to any interested children */
     gpr_atm_rel_store(&call->received_final_op_atm, 1);
-    parent_call *pc = get_parent_call(call);
-    if (pc != NULL) {
-      grpc_call *child;
+    parent_call* pc = get_parent_call(call);
+    if (pc != nullptr) {
+      grpc_call* child;
       gpr_mu_lock(&pc->child_list_mu);
       child = pc->first_child;
-      if (child != NULL) {
+      if (child != nullptr) {
         do {
           next_child_call = child->child->sibling_next;
           if (child->cancellation_is_inherited) {
@@ -1331,23 +1333,29 @@ static void post_batch_completion(grpc_exec_ctx *exec_ctx,
     }
 
     if (call->is_client) {
-      get_final_status(call, set_status_value_directly,
+      get_final_status(exec_ctx, call, set_status_value_directly,
                        call->final_op.client.status,
-                       call->final_op.client.status_details);
+                       call->final_op.client.status_details,
+                       call->final_op.client.error_string);
     } else {
-      get_final_status(call, set_cancelled_value,
-                       call->final_op.server.cancelled, NULL);
+      get_final_status(exec_ctx, call, set_cancelled_value,
+                       call->final_op.server.cancelled, nullptr, nullptr);
     }
 
     GRPC_ERROR_UNREF(error);
     error = GRPC_ERROR_NONE;
   }
+  if (error != GRPC_ERROR_NONE && bctl->op.recv_message &&
+      *call->receiving_buffer != nullptr) {
+    grpc_byte_buffer_destroy(*call->receiving_buffer);
+    *call->receiving_buffer = nullptr;
+  }
 
   if (bctl->completion_data.notify_tag.is_closure) {
     /* unrefs bctl->error */
-    bctl->call = NULL;
+    bctl->call = nullptr;
     GRPC_CLOSURE_RUN(
-        exec_ctx, (grpc_closure *)bctl->completion_data.notify_tag.tag, error);
+        exec_ctx, (grpc_closure*)bctl->completion_data.notify_tag.tag, error);
     GRPC_CALL_INTERNAL_UNREF(exec_ctx, call, "completion");
   } else {
     /* unrefs bctl->error */
@@ -1357,23 +1365,23 @@ static void post_batch_completion(grpc_exec_ctx *exec_ctx,
   }
 }
 
-static void finish_batch_step(grpc_exec_ctx *exec_ctx, batch_control *bctl) {
+static void finish_batch_step(grpc_exec_ctx* exec_ctx, batch_control* bctl) {
   if (gpr_unref(&bctl->steps_to_complete)) {
     post_batch_completion(exec_ctx, bctl);
   }
 }
 
-static void continue_receiving_slices(grpc_exec_ctx *exec_ctx,
-                                      batch_control *bctl) {
-  grpc_error *error;
-  grpc_call *call = bctl->call;
+static void continue_receiving_slices(grpc_exec_ctx* exec_ctx,
+                                      batch_control* bctl) {
+  grpc_error* error;
+  grpc_call* call = bctl->call;
   for (;;) {
     size_t remaining = call->receiving_stream->length -
                        (*call->receiving_buffer)->data.raw.slice_buffer.length;
     if (remaining == 0) {
       call->receiving_message = 0;
       grpc_byte_stream_destroy(exec_ctx, call->receiving_stream);
-      call->receiving_stream = NULL;
+      call->receiving_stream = nullptr;
       finish_batch_step(exec_ctx, bctl);
       return;
     }
@@ -1386,9 +1394,9 @@ static void continue_receiving_slices(grpc_exec_ctx *exec_ctx,
                               call->receiving_slice);
       } else {
         grpc_byte_stream_destroy(exec_ctx, call->receiving_stream);
-        call->receiving_stream = NULL;
+        call->receiving_stream = nullptr;
         grpc_byte_buffer_destroy(*call->receiving_buffer);
-        *call->receiving_buffer = NULL;
+        *call->receiving_buffer = nullptr;
         call->receiving_message = 0;
         finish_batch_step(exec_ctx, bctl);
         return;
@@ -1399,11 +1407,11 @@ static void continue_receiving_slices(grpc_exec_ctx *exec_ctx,
   }
 }
 
-static void receiving_slice_ready(grpc_exec_ctx *exec_ctx, void *bctlp,
-                                  grpc_error *error) {
-  batch_control *bctl = (batch_control *)bctlp;
-  grpc_call *call = bctl->call;
-  grpc_byte_stream *bs = call->receiving_stream;
+static void receiving_slice_ready(grpc_exec_ctx* exec_ctx, void* bctlp,
+                                  grpc_error* error) {
+  batch_control* bctl = (batch_control*)bctlp;
+  grpc_call* call = bctl->call;
+  grpc_byte_stream* bs = call->receiving_stream;
   bool release_error = false;
 
   if (error == GRPC_ERROR_NONE) {
@@ -1421,13 +1429,13 @@ static void receiving_slice_ready(grpc_exec_ctx *exec_ctx, void *bctlp,
   }
 
   if (error != GRPC_ERROR_NONE) {
-    if (GRPC_TRACER_ON(grpc_trace_operation_failures)) {
+    if (grpc_trace_operation_failures.enabled()) {
       GRPC_LOG_IF_ERROR("receiving_slice_ready", GRPC_ERROR_REF(error));
     }
     grpc_byte_stream_destroy(exec_ctx, call->receiving_stream);
-    call->receiving_stream = NULL;
+    call->receiving_stream = nullptr;
     grpc_byte_buffer_destroy(*call->receiving_buffer);
-    *call->receiving_buffer = NULL;
+    *call->receiving_buffer = nullptr;
     call->receiving_message = 0;
     finish_batch_step(exec_ctx, bctl);
     if (release_error) {
@@ -1436,11 +1444,11 @@ static void receiving_slice_ready(grpc_exec_ctx *exec_ctx, void *bctlp,
   }
 }
 
-static void process_data_after_md(grpc_exec_ctx *exec_ctx,
-                                  batch_control *bctl) {
-  grpc_call *call = bctl->call;
-  if (call->receiving_stream == NULL) {
-    *call->receiving_buffer = NULL;
+static void process_data_after_md(grpc_exec_ctx* exec_ctx,
+                                  batch_control* bctl) {
+  grpc_call* call = bctl->call;
+  if (call->receiving_stream == nullptr) {
+    *call->receiving_buffer = nullptr;
     call->receiving_message = 0;
     finish_batch_step(exec_ctx, bctl);
   } else {
@@ -1448,9 +1456,9 @@ static void process_data_after_md(grpc_exec_ctx *exec_ctx,
     if ((call->receiving_stream->flags & GRPC_WRITE_INTERNAL_COMPRESS) &&
         (call->incoming_compression_algorithm > GRPC_COMPRESS_NONE)) {
       *call->receiving_buffer = grpc_raw_compressed_byte_buffer_create(
-          NULL, 0, call->incoming_compression_algorithm);
+          nullptr, 0, call->incoming_compression_algorithm);
     } else {
-      *call->receiving_buffer = grpc_raw_byte_buffer_create(NULL, 0);
+      *call->receiving_buffer = grpc_raw_byte_buffer_create(nullptr, 0);
     }
     GRPC_CLOSURE_INIT(&call->receiving_slice_ready, receiving_slice_ready, bctl,
                       grpc_schedule_on_exec_ctx);
@@ -1458,14 +1466,14 @@ static void process_data_after_md(grpc_exec_ctx *exec_ctx,
   }
 }
 
-static void receiving_stream_ready(grpc_exec_ctx *exec_ctx, void *bctlp,
-                                   grpc_error *error) {
-  batch_control *bctl = (batch_control *)bctlp;
-  grpc_call *call = bctl->call;
+static void receiving_stream_ready(grpc_exec_ctx* exec_ctx, void* bctlp,
+                                   grpc_error* error) {
+  batch_control* bctl = (batch_control*)bctlp;
+  grpc_call* call = bctl->call;
   if (error != GRPC_ERROR_NONE) {
-    if (call->receiving_stream != NULL) {
+    if (call->receiving_stream != nullptr) {
       grpc_byte_stream_destroy(exec_ctx, call->receiving_stream);
-      call->receiving_stream = NULL;
+      call->receiving_stream = nullptr;
     }
     add_batch_error(exec_ctx, bctl, GRPC_ERROR_REF(error), true);
     cancel_with_error(exec_ctx, call, STATUS_FROM_SURFACE,
@@ -1474,7 +1482,7 @@ static void receiving_stream_ready(grpc_exec_ctx *exec_ctx, void *bctlp,
   /* If recv_state is RECV_NONE, we will save the batch_control
    * object with rel_cas, and will not use it after the cas. Its corresponding
    * acq_load is in receiving_initial_metadata_ready() */
-  if (error != GRPC_ERROR_NONE || call->receiving_stream == NULL ||
+  if (error != GRPC_ERROR_NONE || call->receiving_stream == nullptr ||
       !gpr_atm_rel_cas(&call->recv_state, RECV_NONE, (gpr_atm)bctlp)) {
     process_data_after_md(exec_ctx, bctl);
   }
@@ -1483,24 +1491,24 @@ static void receiving_stream_ready(grpc_exec_ctx *exec_ctx, void *bctlp,
 // The recv_message_ready callback used when sending a batch containing
 // a recv_message op down the filter stack.  Yields the call combiner
 // before processing the received message.
-static void receiving_stream_ready_in_call_combiner(grpc_exec_ctx *exec_ctx,
-                                                    void *bctlp,
-                                                    grpc_error *error) {
-  batch_control *bctl = (batch_control *)bctlp;
-  grpc_call *call = bctl->call;
+static void receiving_stream_ready_in_call_combiner(grpc_exec_ctx* exec_ctx,
+                                                    void* bctlp,
+                                                    grpc_error* error) {
+  batch_control* bctl = (batch_control*)bctlp;
+  grpc_call* call = bctl->call;
   GRPC_CALL_COMBINER_STOP(exec_ctx, &call->call_combiner, "recv_message_ready");
   receiving_stream_ready(exec_ctx, bctlp, error);
 }
 
-static void validate_filtered_metadata(grpc_exec_ctx *exec_ctx,
-                                       batch_control *bctl) {
-  grpc_call *call = bctl->call;
+static void validate_filtered_metadata(grpc_exec_ctx* exec_ctx,
+                                       batch_control* bctl) {
+  grpc_call* call = bctl->call;
   /* validate compression algorithms */
   if (call->incoming_stream_compression_algorithm !=
       GRPC_STREAM_COMPRESS_NONE) {
     const grpc_stream_compression_algorithm algo =
         call->incoming_stream_compression_algorithm;
-    char *error_msg = NULL;
+    char* error_msg = nullptr;
     const grpc_compression_options compression_options =
         grpc_channel_compression_options(call->channel);
     if (algo >= GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) {
@@ -1512,7 +1520,7 @@ static void validate_filtered_metadata(grpc_exec_ctx *exec_ctx,
     } else if (grpc_compression_options_is_stream_compression_algorithm_enabled(
                    &compression_options, algo) == 0) {
       /* check if algorithm is supported by current channel config */
-      const char *algo_name = NULL;
+      const char* algo_name = nullptr;
       grpc_stream_compression_algorithm_name(algo, &algo_name);
       gpr_asprintf(&error_msg, "Stream compression algorithm '%s' is disabled.",
                    algo_name);
@@ -1525,8 +1533,8 @@ static void validate_filtered_metadata(grpc_exec_ctx *exec_ctx,
     GPR_ASSERT(call->stream_encodings_accepted_by_peer != 0);
     if (!GPR_BITGET(call->stream_encodings_accepted_by_peer,
                     call->incoming_stream_compression_algorithm)) {
-      if (GRPC_TRACER_ON(grpc_compression_trace)) {
-        const char *algo_name = NULL;
+      if (grpc_compression_trace.enabled()) {
+        const char* algo_name = nullptr;
         grpc_stream_compression_algorithm_name(
             call->incoming_stream_compression_algorithm, &algo_name);
         gpr_log(
@@ -1540,7 +1548,7 @@ static void validate_filtered_metadata(grpc_exec_ctx *exec_ctx,
   } else if (call->incoming_compression_algorithm != GRPC_COMPRESS_NONE) {
     const grpc_compression_algorithm algo =
         call->incoming_compression_algorithm;
-    char *error_msg = NULL;
+    char* error_msg = nullptr;
     const grpc_compression_options compression_options =
         grpc_channel_compression_options(call->channel);
     /* check if algorithm is known */
@@ -1553,7 +1561,7 @@ static void validate_filtered_metadata(grpc_exec_ctx *exec_ctx,
     } else if (grpc_compression_options_is_algorithm_enabled(
                    &compression_options, algo) == 0) {
       /* check if algorithm is supported by current channel config */
-      const char *algo_name = NULL;
+      const char* algo_name = nullptr;
       grpc_compression_algorithm_name(algo, &algo_name);
       gpr_asprintf(&error_msg, "Compression algorithm '%s' is disabled.",
                    algo_name);
@@ -1568,8 +1576,8 @@ static void validate_filtered_metadata(grpc_exec_ctx *exec_ctx,
     GPR_ASSERT(call->encodings_accepted_by_peer != 0);
     if (!GPR_BITGET(call->encodings_accepted_by_peer,
                     call->incoming_compression_algorithm)) {
-      if (GRPC_TRACER_ON(grpc_compression_trace)) {
-        const char *algo_name = NULL;
+      if (grpc_compression_trace.enabled()) {
+        const char* algo_name = nullptr;
         grpc_compression_algorithm_name(call->incoming_compression_algorithm,
                                         &algo_name);
         gpr_log(GPR_ERROR,
@@ -1582,8 +1590,8 @@ static void validate_filtered_metadata(grpc_exec_ctx *exec_ctx,
   }
 }
 
-static void add_batch_error(grpc_exec_ctx *exec_ctx, batch_control *bctl,
-                            grpc_error *error, bool has_cancelled) {
+static void add_batch_error(grpc_exec_ctx* exec_ctx, batch_control* bctl,
+                            grpc_error* error, bool has_cancelled) {
   if (error == GRPC_ERROR_NONE) return;
   int idx = (int)gpr_atm_full_fetch_add(&bctl->num_errors, 1);
   if (idx == 0 && !has_cancelled) {
@@ -1593,17 +1601,17 @@ static void add_batch_error(grpc_exec_ctx *exec_ctx, batch_control *bctl,
   bctl->errors[idx] = error;
 }
 
-static void receiving_initial_metadata_ready(grpc_exec_ctx *exec_ctx,
-                                             void *bctlp, grpc_error *error) {
-  batch_control *bctl = (batch_control *)bctlp;
-  grpc_call *call = bctl->call;
+static void receiving_initial_metadata_ready(grpc_exec_ctx* exec_ctx,
+                                             void* bctlp, grpc_error* error) {
+  batch_control* bctl = (batch_control*)bctlp;
+  grpc_call* call = bctl->call;
 
   GRPC_CALL_COMBINER_STOP(exec_ctx, &call->call_combiner,
                           "recv_initial_metadata_ready");
 
   add_batch_error(exec_ctx, bctl, GRPC_ERROR_REF(error), false);
   if (error == GRPC_ERROR_NONE) {
-    grpc_metadata_batch *md =
+    grpc_metadata_batch* md =
         &call->metadata_batch[1 /* is_receiving */][0 /* is_trailing */];
     recv_initial_filter(exec_ctx, call, md);
 
@@ -1612,15 +1620,12 @@ static void receiving_initial_metadata_ready(grpc_exec_ctx *exec_ctx,
     validate_filtered_metadata(exec_ctx, bctl);
     GPR_TIMER_END("validate_filtered_metadata", 0);
 
-    if (gpr_time_cmp(md->deadline, gpr_inf_future(md->deadline.clock_type)) !=
-            0 &&
-        !call->is_client) {
-      call->send_deadline =
-          gpr_convert_clock_type(md->deadline, GPR_CLOCK_MONOTONIC);
+    if (md->deadline != GRPC_MILLIS_INF_FUTURE && !call->is_client) {
+      call->send_deadline = md->deadline;
     }
   }
 
-  grpc_closure *saved_rsr_closure = NULL;
+  grpc_closure* saved_rsr_closure = nullptr;
   while (true) {
     gpr_atm rsr_bctlp = gpr_atm_acq_load(&call->recv_state);
     /* Should only receive initial metadata once */
@@ -1637,45 +1642,45 @@ static void receiving_initial_metadata_ready(grpc_exec_ctx *exec_ctx,
       }
     } else {
       /* Already received messages */
-      saved_rsr_closure = GRPC_CLOSURE_CREATE(receiving_stream_ready,
-                                              (batch_control *)rsr_bctlp,
-                                              grpc_schedule_on_exec_ctx);
+      saved_rsr_closure =
+          GRPC_CLOSURE_CREATE(receiving_stream_ready, (batch_control*)rsr_bctlp,
+                              grpc_schedule_on_exec_ctx);
       /* No need to modify recv_state */
       break;
     }
   }
-  if (saved_rsr_closure != NULL) {
+  if (saved_rsr_closure != nullptr) {
     GRPC_CLOSURE_RUN(exec_ctx, saved_rsr_closure, GRPC_ERROR_REF(error));
   }
 
   finish_batch_step(exec_ctx, bctl);
 }
 
-static void finish_batch(grpc_exec_ctx *exec_ctx, void *bctlp,
-                         grpc_error *error) {
-  batch_control *bctl = (batch_control *)bctlp;
-  grpc_call *call = bctl->call;
+static void finish_batch(grpc_exec_ctx* exec_ctx, void* bctlp,
+                         grpc_error* error) {
+  batch_control* bctl = (batch_control*)bctlp;
+  grpc_call* call = bctl->call;
   GRPC_CALL_COMBINER_STOP(exec_ctx, &call->call_combiner, "on_complete");
   add_batch_error(exec_ctx, bctl, GRPC_ERROR_REF(error), false);
   finish_batch_step(exec_ctx, bctl);
 }
 
-static void free_no_op_completion(grpc_exec_ctx *exec_ctx, void *p,
-                                  grpc_cq_completion *completion) {
+static void free_no_op_completion(grpc_exec_ctx* exec_ctx, void* p,
+                                  grpc_cq_completion* completion) {
   gpr_free(completion);
 }
 
-static grpc_call_error call_start_batch(grpc_exec_ctx *exec_ctx,
-                                        grpc_call *call, const grpc_op *ops,
-                                        size_t nops, void *notify_tag,
+static grpc_call_error call_start_batch(grpc_exec_ctx* exec_ctx,
+                                        grpc_call* call, const grpc_op* ops,
+                                        size_t nops, void* notify_tag,
                                         int is_notify_tag_closure) {
   size_t i;
-  const grpc_op *op;
-  batch_control *bctl;
+  const grpc_op* op;
+  batch_control* bctl;
   int num_completion_callbacks_needed = 1;
   grpc_call_error error = GRPC_CALL_OK;
-  grpc_transport_stream_op_batch *stream_op;
-  grpc_transport_stream_op_batch_payload *stream_op_payload;
+  grpc_transport_stream_op_batch* stream_op;
+  grpc_transport_stream_op_batch_payload* stream_op_payload;
 
   GPR_TIMER_BEGIN("grpc_call_start_batch", 0);
   GRPC_CALL_LOG_BATCH(GPR_INFO, call, ops, nops, notify_tag);
@@ -1685,17 +1690,17 @@ static grpc_call_error call_start_batch(grpc_exec_ctx *exec_ctx,
       GPR_ASSERT(grpc_cq_begin_op(call->cq, notify_tag));
       grpc_cq_end_op(
           exec_ctx, call->cq, notify_tag, GRPC_ERROR_NONE,
-          free_no_op_completion, NULL,
-          (grpc_cq_completion *)gpr_malloc(sizeof(grpc_cq_completion)));
+          free_no_op_completion, nullptr,
+          (grpc_cq_completion*)gpr_malloc(sizeof(grpc_cq_completion)));
     } else {
-      GRPC_CLOSURE_SCHED(exec_ctx, (grpc_closure *)notify_tag, GRPC_ERROR_NONE);
+      GRPC_CLOSURE_SCHED(exec_ctx, (grpc_closure*)notify_tag, GRPC_ERROR_NONE);
     }
     error = GRPC_CALL_OK;
     goto done;
   }
 
   bctl = allocate_batch_control(call, ops, nops);
-  if (bctl == NULL) {
+  if (bctl == nullptr) {
     return GRPC_CALL_ERROR_TOO_MANY_OPERATIONS;
   }
   bctl->completion_data.notify_tag.tag = notify_tag;
@@ -1708,7 +1713,7 @@ static grpc_call_error call_start_batch(grpc_exec_ctx *exec_ctx,
   /* rewrite batch ops into a transport op */
   for (i = 0; i < nops; i++) {
     op = &ops[i];
-    if (op->reserved != NULL) {
+    if (op->reserved != nullptr) {
       error = GRPC_CALL_ERROR;
       goto done_with_error;
     }
@@ -1813,7 +1818,7 @@ static grpc_call_error call_start_batch(grpc_exec_ctx *exec_ctx,
           error = GRPC_CALL_ERROR_INVALID_FLAGS;
           goto done_with_error;
         }
-        if (op->data.send_message.send_message == NULL) {
+        if (op->data.send_message.send_message == nullptr) {
           error = GRPC_CALL_ERROR_INVALID_MESSAGE;
           goto done_with_error;
         }
@@ -1884,18 +1889,18 @@ static grpc_call_error call_start_batch(grpc_exec_ctx *exec_ctx,
         call->send_extra_metadata[0].md = grpc_channel_get_reffed_status_elem(
             exec_ctx, call->channel, op->data.send_status_from_server.status);
         {
-          grpc_error *override_error = GRPC_ERROR_NONE;
+          grpc_error* override_error = GRPC_ERROR_NONE;
           if (op->data.send_status_from_server.status != GRPC_STATUS_OK) {
             override_error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                 "Error from server send status");
           }
-          if (op->data.send_status_from_server.status_details != NULL) {
+          if (op->data.send_status_from_server.status_details != nullptr) {
             call->send_extra_metadata[1].md = grpc_mdelem_from_slices(
                 exec_ctx, GRPC_MDSTR_GRPC_MESSAGE,
                 grpc_slice_ref_internal(
                     *op->data.send_status_from_server.status_details));
             call->send_extra_metadata_count++;
-            char *msg = grpc_slice_to_c_string(
+            char* msg = grpc_slice_to_c_string(
                 GRPC_MDVALUE(call->send_extra_metadata[1].md));
             override_error =
                 grpc_error_set_str(override_error, GRPC_ERROR_STR_GRPC_MESSAGE,
@@ -1908,8 +1913,8 @@ static grpc_call_error call_start_batch(grpc_exec_ctx *exec_ctx,
         if (!prepare_application_metadata(
                 exec_ctx, call,
                 (int)op->data.send_status_from_server.trailing_metadata_count,
-                op->data.send_status_from_server.trailing_metadata, 1, 1, NULL,
-                0)) {
+                op->data.send_status_from_server.trailing_metadata, 1, 1,
+                nullptr, 0)) {
           for (int n = 0; n < call->send_extra_metadata_count; n++) {
             GRPC_MDELEM_UNREF(exec_ctx, call->send_extra_metadata[n].md);
           }
@@ -1991,6 +1996,8 @@ static grpc_call_error call_start_batch(grpc_exec_ctx *exec_ctx,
         call->final_op.client.status = op->data.recv_status_on_client.status;
         call->final_op.client.status_details =
             op->data.recv_status_on_client.status_details;
+        call->final_op.client.error_string =
+            op->data.recv_status_on_client.error_string;
         stream_op->recv_trailing_metadata = true;
         stream_op->collect_stats = true;
         stream_op_payload->recv_trailing_metadata.recv_trailing_metadata =
@@ -2070,8 +2077,8 @@ done_with_error:
   goto done;
 }
 
-grpc_call_error grpc_call_start_batch(grpc_call *call, const grpc_op *ops,
-                                      size_t nops, void *tag, void *reserved) {
+grpc_call_error grpc_call_start_batch(grpc_call* call, const grpc_op* ops,
+                                      size_t nops, void* tag, void* reserved) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_call_error err;
 
@@ -2080,7 +2087,7 @@ grpc_call_error grpc_call_start_batch(grpc_call *call, const grpc_op *ops,
       "reserved=%p)",
       5, (call, ops, (unsigned long)nops, tag, reserved));
 
-  if (reserved != NULL) {
+  if (reserved != nullptr) {
     err = GRPC_CALL_ERROR;
   } else {
     err = call_start_batch(&exec_ctx, call, ops, nops, tag, 0);
@@ -2090,16 +2097,16 @@ grpc_call_error grpc_call_start_batch(grpc_call *call, const grpc_op *ops,
   return err;
 }
 
-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) {
   return call_start_batch(exec_ctx, call, ops, nops, closure, 1);
 }
 
-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)) {
   if (call->context[elem].destroy) {
     call->context[elem].destroy(call->context[elem].value);
   }
@@ -2107,20 +2114,20 @@ void grpc_call_context_set(grpc_call *call, grpc_context_index elem,
   call->context[elem].destroy = destroy;
 }
 
-void *grpc_call_context_get(grpc_call *call, grpc_context_index elem) {
+void* grpc_call_context_get(grpc_call* call, grpc_context_index elem) {
   return call->context[elem].value;
 }
 
-uint8_t grpc_call_is_client(grpc_call *call) { return call->is_client; }
+uint8_t grpc_call_is_client(grpc_call* call) { return call->is_client; }
 
 grpc_compression_algorithm grpc_call_compression_for_level(
-    grpc_call *call, grpc_compression_level level) {
+    grpc_call* call, grpc_compression_level level) {
   grpc_compression_algorithm algo =
       compression_algorithm_for_level_locked(call, level);
   return algo;
 }
 
-const char *grpc_call_error_to_string(grpc_call_error error) {
+const char* grpc_call_error_to_string(grpc_call_error error) {
   switch (error) {
     case GRPC_CALL_ERROR:
       return "GRPC_CALL_ERROR";