grpc 1.7.3 → 1.8.0

data/src/core/lib/json/json_writer.h

@@ -35,19 +35,23 @@
 
 #include "src/core/lib/json/json_common.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct grpc_json_writer_vtable {
   /* Adds a character to the output stream. */
-  void (*output_char)(void *userdata, char);
+  void (*output_char)(void* userdata, char);
   /* Adds a zero-terminated string to the output stream. */
-  void (*output_string)(void *userdata, const char *str);
+  void (*output_string)(void* userdata, const char* str);
   /* Adds a fixed-length string to the output stream. */
-  void (*output_string_with_len)(void *userdata, const char *str, size_t len);
+  void (*output_string_with_len)(void* userdata, const char* str, size_t len);
 
 } grpc_json_writer_vtable;
 
 typedef struct grpc_json_writer {
-  void *userdata;
-  grpc_json_writer_vtable *vtable;
+  void* userdata;
+  grpc_json_writer_vtable* vtable;
   int indent;
   int depth;
   int container_empty;
@@ -59,24 +63,28 @@ typedef struct grpc_json_writer {
  * use indent=0, then the output will not have any newlines either, thus
  * emitting a condensed json output.
  */
-void grpc_json_writer_init(grpc_json_writer *writer, int indent,
-                           grpc_json_writer_vtable *vtable, void *userdata);
+void grpc_json_writer_init(grpc_json_writer* writer, int indent,
+                           grpc_json_writer_vtable* vtable, void* userdata);
 
 /* Signals the beginning of a container. */
-void grpc_json_writer_container_begins(grpc_json_writer *writer,
+void grpc_json_writer_container_begins(grpc_json_writer* writer,
                                        grpc_json_type type);
 /* Signals the end of a container. */
-void grpc_json_writer_container_ends(grpc_json_writer *writer,
+void grpc_json_writer_container_ends(grpc_json_writer* writer,
                                      grpc_json_type type);
 /* Writes down an object key for the next value. */
-void grpc_json_writer_object_key(grpc_json_writer *writer, const char *string);
+void grpc_json_writer_object_key(grpc_json_writer* writer, const char* string);
 /* Sets a raw value. Useful for numbers. */
-void grpc_json_writer_value_raw(grpc_json_writer *writer, const char *string);
+void grpc_json_writer_value_raw(grpc_json_writer* writer, const char* string);
 /* Sets a raw value with its length. Useful for values like true or false. */
-void grpc_json_writer_value_raw_with_len(grpc_json_writer *writer,
-                                         const char *string, size_t len);
+void grpc_json_writer_value_raw_with_len(grpc_json_writer* writer,
+                                         const char* string, size_t len);
 /* Sets a string value. It'll be escaped, and utf-8 validated. */
-void grpc_json_writer_value_string(grpc_json_writer *writer,
-                                   const char *string);
+void grpc_json_writer_value_string(grpc_json_writer* writer,
+                                   const char* string);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_JSON_JSON_WRITER_H */

data/src/core/lib/profiling/{basic_timers.c → basic_timers.cc}

@@ -18,10 +18,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#ifdef GRPC_BASIC_PROFILER
-
 #include "src/core/lib/profiling/timers.h"
 
+#ifdef GRPC_BASIC_PROFILER
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
@@ -36,8 +36,8 @@ typedef enum { BEGIN = '{', END = '}', MARK = '.' } marker_type;
 
 typedef struct gpr_timer_entry {
   gpr_timespec tm;
-  const char *tagstr;
-  const char *file;
+  const char* tagstr;
+  const char* file;
   short line;
   char type;
   uint8_t important;
@@ -48,21 +48,21 @@ typedef struct gpr_timer_entry {
 
 typedef struct gpr_timer_log {
   size_t num_entries;
-  struct gpr_timer_log *next;
-  struct gpr_timer_log *prev;
+  struct gpr_timer_log* next;
+  struct gpr_timer_log* prev;
   gpr_timer_entry log[MAX_COUNT];
 } gpr_timer_log;
 
 typedef struct gpr_timer_log_list {
-  gpr_timer_log *head;
+  gpr_timer_log* head;
   /* valid iff head!=NULL */
-  gpr_timer_log *tail;
+  gpr_timer_log* tail;
 } gpr_timer_log_list;
 
-static __thread gpr_timer_log *g_thread_log;
+static __thread gpr_timer_log* g_thread_log;
 static gpr_once g_once_init = GPR_ONCE_INIT;
-static FILE *output_file;
-static const char *output_filename_or_null = NULL;
+static FILE* output_file;
+static const char* output_filename_or_null = NULL;
 static pthread_mutex_t g_mu;
 static pthread_cond_t g_cv;
 static gpr_timer_log_list g_in_progress_logs;
@@ -73,7 +73,7 @@ static __thread int g_thread_id;
 static int g_next_thread_id;
 static int g_writing_enabled = 1;
 
-static const char *output_filename() {
+static const char* output_filename() {
   if (output_filename_or_null == NULL) {
     output_filename_or_null = gpr_getenv("LATENCY_TRACE");
     if (output_filename_or_null == NULL ||
@@ -84,7 +84,7 @@ static const char *output_filename() {
   return output_filename_or_null;
 }
 
-static int timer_log_push_back(gpr_timer_log_list *list, gpr_timer_log *log) {
+static int timer_log_push_back(gpr_timer_log_list* list, gpr_timer_log* log) {
   if (list->head == NULL) {
     list->head = list->tail = log;
     log->next = log->prev = NULL;
@@ -98,8 +98,8 @@ static int timer_log_push_back(gpr_timer_log_list *list, gpr_timer_log *log) {
   }
 }
 
-static gpr_timer_log *timer_log_pop_front(gpr_timer_log_list *list) {
-  gpr_timer_log *out = list->head;
+static gpr_timer_log* timer_log_pop_front(gpr_timer_log_list* list) {
+  gpr_timer_log* out = list->head;
   if (out != NULL) {
     list->head = out->next;
     if (list->head != NULL) {
@@ -111,7 +111,7 @@ static gpr_timer_log *timer_log_pop_front(gpr_timer_log_list *list) {
   return out;
 }
 
-static void timer_log_remove(gpr_timer_log_list *list, gpr_timer_log *log) {
+static void timer_log_remove(gpr_timer_log_list* list, gpr_timer_log* log) {
   if (log->prev == NULL) {
     list->head = log->next;
     if (list->head != NULL) {
@@ -130,13 +130,13 @@ static void timer_log_remove(gpr_timer_log_list *list, gpr_timer_log *log) {
   }
 }
 
-static void write_log(gpr_timer_log *log) {
+static void write_log(gpr_timer_log* log) {
   size_t i;
   if (output_file == NULL) {
     output_file = fopen(output_filename(), "w");
   }
   for (i = 0; i < log->num_entries; i++) {
-    gpr_timer_entry *entry = &(log->log[i]);
+    gpr_timer_entry* entry = &(log->log[i]);
     if (gpr_time_cmp(entry->tm, gpr_time_0(entry->tm.clock_type)) < 0) {
       entry->tm = gpr_time_0(entry->tm.clock_type);
     }
@@ -149,8 +149,8 @@ static void write_log(gpr_timer_log *log) {
   }
 }
 
-static void writing_thread(void *unused) {
-  gpr_timer_log *log;
+static void writing_thread(void* unused) {
+  gpr_timer_log* log;
   pthread_mutex_lock(&g_mu);
   for (;;) {
     while ((log = timer_log_pop_front(&g_done_logs)) == NULL && !g_shutdown) {
@@ -169,8 +169,8 @@ static void writing_thread(void *unused) {
   }
 }
 
-static void flush_logs(gpr_timer_log_list *list) {
-  gpr_timer_log *log;
+static void flush_logs(gpr_timer_log_list* list) {
+  gpr_timer_log* log;
   while ((log = timer_log_pop_front(list)) != NULL) {
     write_log(log);
     free(log);
@@ -196,7 +196,7 @@ static void finish_writing(void) {
   }
 }
 
-void gpr_timers_set_log_filename(const char *filename) {
+void gpr_timers_set_log_filename(const char* filename) {
   output_filename_or_null = filename;
 }
 
@@ -209,9 +209,9 @@ static void init_output() {
 
 static void rotate_log() {
   /* Using malloc here, as this code could end up being called by gpr_malloc */
-  gpr_timer_log *new = malloc(sizeof(*new));
+  gpr_timer_log* log = static_cast<gpr_timer_log*>(malloc(sizeof(*log)));
   gpr_once_init(&g_once_init, init_output);
-  new->num_entries = 0;
+  log->num_entries = 0;
   pthread_mutex_lock(&g_mu);
   if (g_thread_log != NULL) {
     timer_log_remove(&g_in_progress_logs, g_thread_log);
@@ -221,14 +221,14 @@ static void rotate_log() {
   } else {
     g_thread_id = g_next_thread_id++;
   }
-  timer_log_push_back(&g_in_progress_logs, new);
+  timer_log_push_back(&g_in_progress_logs, log);
   pthread_mutex_unlock(&g_mu);
-  g_thread_log = new;
+  g_thread_log = log;
 }
 
-static void gpr_timers_log_add(const char *tagstr, marker_type type,
-                               int important, const char *file, int line) {
-  gpr_timer_entry *entry;
+static void gpr_timers_log_add(const char* tagstr, marker_type type,
+                               int important, const char* file, int line) {
+  gpr_timer_entry* entry;
 
   if (!g_writing_enabled) {
     return;
@@ -250,17 +250,17 @@ static void gpr_timers_log_add(const char *tagstr, marker_type type,
 }
 
 /* Latency profiler API implementation. */
-void gpr_timer_add_mark(const char *tagstr, int important, const char *file,
+void gpr_timer_add_mark(const char* tagstr, int important, const char* file,
                         int line) {
   gpr_timers_log_add(tagstr, MARK, important, file, line);
 }
 
-void gpr_timer_begin(const char *tagstr, int important, const char *file,
+void gpr_timer_begin(const char* tagstr, int important, const char* file,
                      int line) {
   gpr_timers_log_add(tagstr, BEGIN, important, file, line);
 }
 
-void gpr_timer_end(const char *tagstr, int important, const char *file,
+void gpr_timer_end(const char* tagstr, int important, const char* file,
                    int line) {
   gpr_timers_log_add(tagstr, END, important, file, line);
 }
@@ -277,7 +277,7 @@ void gpr_timers_global_init(void) {}
 
 void gpr_timers_global_destroy(void) {}
 
-void gpr_timers_set_log_filename(const char *filename) {}
+void gpr_timers_set_log_filename(const char* filename) {}
 
 void gpr_timer_set_enabled(int enabled) {}
 #endif /* GRPC_BASIC_PROFILER */

data/src/core/lib/profiling/{stap_timers.c → stap_timers.cc}

@@ -27,22 +27,22 @@
 #include "src/core/lib/profiling/stap_probes.h"
 
 /* Latency profiler API implementation. */
-void gpr_timer_add_mark(int tag, const char *tagstr, void *id, const char *file,
+void gpr_timer_add_mark(int tag, const char* tagstr, void* id, const char* file,
                         int line) {
   _STAP_ADD_MARK(tag);
 }
 
-void gpr_timer_add_important_mark(int tag, const char *tagstr, void *id,
-                                  const char *file, int line) {
+void gpr_timer_add_important_mark(int tag, const char* tagstr, void* id,
+                                  const char* file, int line) {
   _STAP_ADD_IMPORTANT_MARK(tag);
 }
 
-void gpr_timer_begin(int tag, const char *tagstr, void *id, const char *file,
+void gpr_timer_begin(int tag, const char* tagstr, void* id, const char* file,
                      int line) {
   _STAP_TIMING_NS_BEGIN(tag);
 }
 
-void gpr_timer_end(int tag, const char *tagstr, void *id, const char *file,
+void gpr_timer_end(int tag, const char* tagstr, void* id, const char* file,
                    int line) {
   _STAP_TIMING_NS_END(tag);
 }

data/src/core/lib/profiling/timers.h

@@ -26,14 +26,14 @@ extern "C" {
 void gpr_timers_global_init(void);
 void gpr_timers_global_destroy(void);
 
-void gpr_timer_add_mark(const char *tagstr, int important, const char *file,
+void gpr_timer_add_mark(const char* tagstr, int important, const char* file,
                         int line);
-void gpr_timer_begin(const char *tagstr, int important, const char *file,
+void gpr_timer_begin(const char* tagstr, int important, const char* file,
                      int line);
-void gpr_timer_end(const char *tagstr, int important, const char *file,
+void gpr_timer_end(const char* tagstr, int important, const char* file,
                    int line);
 
-void gpr_timers_set_log_filename(const char *filename);
+void gpr_timers_set_log_filename(const char* filename);
 
 void gpr_timer_set_enabled(int enabled);
 
@@ -92,14 +92,14 @@ void gpr_timer_set_enabled(int enabled);
 namespace grpc {
 class ProfileScope {
  public:
-  ProfileScope(const char *desc, bool important, const char *file, int line)
+  ProfileScope(const char* desc, bool important, const char* file, int line)
       : desc_(desc) {
     gpr_timer_begin(desc_, important ? 1 : 0, file, line);
   }
   ~ProfileScope() { gpr_timer_end(desc_, 0, "n/a", 0); }
 
  private:
-  const char *const desc_;
+  const char* const desc_;
 };
 }  // namespace grpc
 

data/src/core/lib/security/context/{security_context.c → security_context.cc}

@@ -29,26 +29,24 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#ifndef NDEBUG
-grpc_tracer_flag grpc_trace_auth_context_refcount =
-    GRPC_TRACER_INITIALIZER(false, "auth_context_refcount");
-#endif
+grpc_core::DebugOnlyTraceFlag grpc_trace_auth_context_refcount(
+    false, "auth_context_refcount");
 
 /* --- grpc_call --- */
 
-grpc_call_error grpc_call_set_credentials(grpc_call *call,
-                                          grpc_call_credentials *creds) {
+grpc_call_error grpc_call_set_credentials(grpc_call* call,
+                                          grpc_call_credentials* creds) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_client_security_context *ctx = NULL;
+  grpc_client_security_context* ctx = nullptr;
   GRPC_API_TRACE("grpc_call_set_credentials(call=%p, creds=%p)", 2,
                  (call, creds));
   if (!grpc_call_is_client(call)) {
     gpr_log(GPR_ERROR, "Method is client-side only.");
     return GRPC_CALL_ERROR_NOT_ON_SERVER;
   }
-  ctx = (grpc_client_security_context *)grpc_call_context_get(
+  ctx = (grpc_client_security_context*)grpc_call_context_get(
       call, GRPC_CONTEXT_SECURITY);
-  if (ctx == NULL) {
+  if (ctx == nullptr) {
     ctx = grpc_client_security_context_create();
     ctx->creds = grpc_call_credentials_ref(creds);
     grpc_call_context_set(call, GRPC_CONTEXT_SECURITY, ctx,
@@ -61,36 +59,37 @@ grpc_call_error grpc_call_set_credentials(grpc_call *call,
   return GRPC_CALL_OK;
 }
 
-grpc_auth_context *grpc_call_auth_context(grpc_call *call) {
-  void *sec_ctx = grpc_call_context_get(call, GRPC_CONTEXT_SECURITY);
+grpc_auth_context* grpc_call_auth_context(grpc_call* call) {
+  void* sec_ctx = grpc_call_context_get(call, GRPC_CONTEXT_SECURITY);
   GRPC_API_TRACE("grpc_call_auth_context(call=%p)", 1, (call));
-  if (sec_ctx == NULL) return NULL;
+  if (sec_ctx == nullptr) return nullptr;
   return grpc_call_is_client(call)
              ? GRPC_AUTH_CONTEXT_REF(
-                   ((grpc_client_security_context *)sec_ctx)->auth_context,
+                   ((grpc_client_security_context*)sec_ctx)->auth_context,
                    "grpc_call_auth_context client")
              : GRPC_AUTH_CONTEXT_REF(
-                   ((grpc_server_security_context *)sec_ctx)->auth_context,
+                   ((grpc_server_security_context*)sec_ctx)->auth_context,
                    "grpc_call_auth_context server");
 }
 
-void grpc_auth_context_release(grpc_auth_context *context) {
+void grpc_auth_context_release(grpc_auth_context* context) {
   GRPC_API_TRACE("grpc_auth_context_release(context=%p)", 1, (context));
   GRPC_AUTH_CONTEXT_UNREF(context, "grpc_auth_context_unref");
 }
 
 /* --- grpc_client_security_context --- */
 
-grpc_client_security_context *grpc_client_security_context_create(void) {
-  return gpr_zalloc(sizeof(grpc_client_security_context));
+grpc_client_security_context* grpc_client_security_context_create(void) {
+  return (grpc_client_security_context*)gpr_zalloc(
+      sizeof(grpc_client_security_context));
 }
 
-void grpc_client_security_context_destroy(void *ctx) {
+void grpc_client_security_context_destroy(void* ctx) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_client_security_context *c = (grpc_client_security_context *)ctx;
+  grpc_client_security_context* c = (grpc_client_security_context*)ctx;
   grpc_call_credentials_unref(&exec_ctx, c->creds);
   GRPC_AUTH_CONTEXT_UNREF(c->auth_context, "client_security_context");
-  if (c->extension.instance != NULL && c->extension.destroy != NULL) {
+  if (c->extension.instance != nullptr && c->extension.destroy != nullptr) {
     c->extension.destroy(c->extension.instance);
   }
   gpr_free(ctx);
@@ -99,14 +98,15 @@ void grpc_client_security_context_destroy(void *ctx) {
 
 /* --- grpc_server_security_context --- */
 
-grpc_server_security_context *grpc_server_security_context_create(void) {
-  return gpr_zalloc(sizeof(grpc_server_security_context));
+grpc_server_security_context* grpc_server_security_context_create(void) {
+  return (grpc_server_security_context*)gpr_zalloc(
+      sizeof(grpc_server_security_context));
 }
 
-void grpc_server_security_context_destroy(void *ctx) {
-  grpc_server_security_context *c = (grpc_server_security_context *)ctx;
+void grpc_server_security_context_destroy(void* ctx) {
+  grpc_server_security_context* c = (grpc_server_security_context*)ctx;
   GRPC_AUTH_CONTEXT_UNREF(c->auth_context, "server_security_context");
-  if (c->extension.instance != NULL && c->extension.destroy != NULL) {
+  if (c->extension.instance != nullptr && c->extension.destroy != nullptr) {
     c->extension.destroy(c->extension.instance);
   }
   gpr_free(ctx);
@@ -114,12 +114,13 @@ void grpc_server_security_context_destroy(void *ctx) {
 
 /* --- grpc_auth_context --- */
 
-static grpc_auth_property_iterator empty_iterator = {NULL, 0, NULL};
+static grpc_auth_property_iterator empty_iterator = {nullptr, 0, nullptr};
 
-grpc_auth_context *grpc_auth_context_create(grpc_auth_context *chained) {
-  grpc_auth_context *ctx = gpr_zalloc(sizeof(grpc_auth_context));
+grpc_auth_context* grpc_auth_context_create(grpc_auth_context* chained) {
+  grpc_auth_context* ctx =
+      (grpc_auth_context*)gpr_zalloc(sizeof(grpc_auth_context));
   gpr_ref_init(&ctx->refcount, 1);
-  if (chained != NULL) {
+  if (chained != nullptr) {
     ctx->chained = GRPC_AUTH_CONTEXT_REF(chained, "chained");
     ctx->peer_identity_property_name =
         ctx->chained->peer_identity_property_name;
@@ -128,18 +129,18 @@ grpc_auth_context *grpc_auth_context_create(grpc_auth_context *chained) {
 }
 
 #ifndef NDEBUG
-grpc_auth_context *grpc_auth_context_ref(grpc_auth_context *ctx,
-                                         const char *file, int line,
-                                         const char *reason) {
-  if (ctx == NULL) return NULL;
-  if (GRPC_TRACER_ON(grpc_trace_auth_context_refcount)) {
+grpc_auth_context* grpc_auth_context_ref(grpc_auth_context* ctx,
+                                         const char* file, int line,
+                                         const char* reason) {
+  if (ctx == nullptr) return nullptr;
+  if (grpc_trace_auth_context_refcount.enabled()) {
     gpr_atm val = gpr_atm_no_barrier_load(&ctx->refcount.count);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
             "AUTH_CONTEXT:%p   ref %" PRIdPTR " -> %" PRIdPTR " %s", ctx, val,
             val + 1, reason);
   }
 #else
-grpc_auth_context *grpc_auth_context_ref(grpc_auth_context *ctx) {
+grpc_auth_context* grpc_auth_context_ref(grpc_auth_context* ctx) {
   if (ctx == NULL) return NULL;
 #endif
   gpr_ref(&ctx->refcount);
@@ -147,23 +148,23 @@ grpc_auth_context *grpc_auth_context_ref(grpc_auth_context *ctx) {
 }
 
 #ifndef NDEBUG
-void grpc_auth_context_unref(grpc_auth_context *ctx, const char *file, int line,
-                             const char *reason) {
-  if (ctx == NULL) return;
-  if (GRPC_TRACER_ON(grpc_trace_auth_context_refcount)) {
+void grpc_auth_context_unref(grpc_auth_context* ctx, const char* file, int line,
+                             const char* reason) {
+  if (ctx == nullptr) return;
+  if (grpc_trace_auth_context_refcount.enabled()) {
     gpr_atm val = gpr_atm_no_barrier_load(&ctx->refcount.count);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
             "AUTH_CONTEXT:%p unref %" PRIdPTR " -> %" PRIdPTR " %s", ctx, val,
             val - 1, reason);
   }
 #else
-void grpc_auth_context_unref(grpc_auth_context *ctx) {
+void grpc_auth_context_unref(grpc_auth_context* ctx) {
   if (ctx == NULL) return;
 #endif
   if (gpr_unref(&ctx->refcount)) {
     size_t i;
     GRPC_AUTH_CONTEXT_UNREF(ctx->chained, "chained");
-    if (ctx->properties.array != NULL) {
+    if (ctx->properties.array != nullptr) {
       for (i = 0; i < ctx->properties.count; i++) {
         grpc_auth_property_reset(&ctx->properties.array[i]);
       }
@@ -173,59 +174,59 @@ void grpc_auth_context_unref(grpc_auth_context *ctx) {
   }
 }
 
-const char *grpc_auth_context_peer_identity_property_name(
-    const grpc_auth_context *ctx) {
+const char* grpc_auth_context_peer_identity_property_name(
+    const grpc_auth_context* ctx) {
   GRPC_API_TRACE("grpc_auth_context_peer_identity_property_name(ctx=%p)", 1,
                  (ctx));
   return ctx->peer_identity_property_name;
 }
 
-int grpc_auth_context_set_peer_identity_property_name(grpc_auth_context *ctx,
-                                                      const char *name) {
+int grpc_auth_context_set_peer_identity_property_name(grpc_auth_context* ctx,
+                                                      const char* name) {
   grpc_auth_property_iterator it =
       grpc_auth_context_find_properties_by_name(ctx, name);
-  const grpc_auth_property *prop = grpc_auth_property_iterator_next(&it);
+  const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it);
   GRPC_API_TRACE(
       "grpc_auth_context_set_peer_identity_property_name(ctx=%p, name=%s)", 2,
       (ctx, name));
-  if (prop == NULL) {
+  if (prop == nullptr) {
     gpr_log(GPR_ERROR, "Property name %s not found in auth context.",
-            name != NULL ? name : "NULL");
+            name != nullptr ? name : "NULL");
     return 0;
   }
   ctx->peer_identity_property_name = prop->name;
   return 1;
 }
 
-int grpc_auth_context_peer_is_authenticated(const grpc_auth_context *ctx) {
+int grpc_auth_context_peer_is_authenticated(const grpc_auth_context* ctx) {
   GRPC_API_TRACE("grpc_auth_context_peer_is_authenticated(ctx=%p)", 1, (ctx));
-  return ctx->peer_identity_property_name == NULL ? 0 : 1;
+  return ctx->peer_identity_property_name == nullptr ? 0 : 1;
 }
 
 grpc_auth_property_iterator grpc_auth_context_property_iterator(
-    const grpc_auth_context *ctx) {
+    const grpc_auth_context* ctx) {
   grpc_auth_property_iterator it = empty_iterator;
   GRPC_API_TRACE("grpc_auth_context_property_iterator(ctx=%p)", 1, (ctx));
-  if (ctx == NULL) return it;
+  if (ctx == nullptr) return it;
   it.ctx = ctx;
   return it;
 }
 
-const grpc_auth_property *grpc_auth_property_iterator_next(
-    grpc_auth_property_iterator *it) {
+const grpc_auth_property* grpc_auth_property_iterator_next(
+    grpc_auth_property_iterator* it) {
   GRPC_API_TRACE("grpc_auth_property_iterator_next(it=%p)", 1, (it));
-  if (it == NULL || it->ctx == NULL) return NULL;
+  if (it == nullptr || it->ctx == nullptr) return nullptr;
   while (it->index == it->ctx->properties.count) {
-    if (it->ctx->chained == NULL) return NULL;
+    if (it->ctx->chained == nullptr) return nullptr;
     it->ctx = it->ctx->chained;
     it->index = 0;
   }
-  if (it->name == NULL) {
+  if (it->name == nullptr) {
     return &it->ctx->properties.array[it->index++];
   } else {
     while (it->index < it->ctx->properties.count) {
-      const grpc_auth_property *prop = &it->ctx->properties.array[it->index++];
-      GPR_ASSERT(prop->name != NULL);
+      const grpc_auth_property* prop = &it->ctx->properties.array[it->index++];
+      GPR_ASSERT(prop->name != nullptr);
       if (strcmp(it->name, prop->name) == 0) {
         return prop;
       }
@@ -236,55 +237,56 @@ const grpc_auth_property *grpc_auth_property_iterator_next(
 }
 
 grpc_auth_property_iterator grpc_auth_context_find_properties_by_name(
-    const grpc_auth_context *ctx, const char *name) {
+    const grpc_auth_context* ctx, const char* name) {
   grpc_auth_property_iterator it = empty_iterator;
   GRPC_API_TRACE("grpc_auth_context_find_properties_by_name(ctx=%p, name=%s)",
                  2, (ctx, name));
-  if (ctx == NULL || name == NULL) return empty_iterator;
+  if (ctx == nullptr || name == nullptr) return empty_iterator;
   it.ctx = ctx;
   it.name = name;
   return it;
 }
 
 grpc_auth_property_iterator grpc_auth_context_peer_identity(
-    const grpc_auth_context *ctx) {
+    const grpc_auth_context* ctx) {
   GRPC_API_TRACE("grpc_auth_context_peer_identity(ctx=%p)", 1, (ctx));
-  if (ctx == NULL) return empty_iterator;
+  if (ctx == nullptr) return empty_iterator;
   return grpc_auth_context_find_properties_by_name(
       ctx, ctx->peer_identity_property_name);
 }
 
-static void ensure_auth_context_capacity(grpc_auth_context *ctx) {
+static void ensure_auth_context_capacity(grpc_auth_context* ctx) {
   if (ctx->properties.count == ctx->properties.capacity) {
     ctx->properties.capacity =
         GPR_MAX(ctx->properties.capacity + 8, ctx->properties.capacity * 2);
-    ctx->properties.array =
-        gpr_realloc(ctx->properties.array,
-                    ctx->properties.capacity * sizeof(grpc_auth_property));
+    ctx->properties.array = (grpc_auth_property*)gpr_realloc(
+        ctx->properties.array,
+        ctx->properties.capacity * sizeof(grpc_auth_property));
   }
 }
 
-void grpc_auth_context_add_property(grpc_auth_context *ctx, const char *name,
-                                    const char *value, size_t value_length) {
-  grpc_auth_property *prop;
+void grpc_auth_context_add_property(grpc_auth_context* ctx, const char* name,
+                                    const char* value, size_t value_length) {
+  grpc_auth_property* prop;
   GRPC_API_TRACE(
       "grpc_auth_context_add_property(ctx=%p, name=%s, value=%*.*s, "
       "value_length=%lu)",
-      6, (ctx, name, (int)value_length, (int)value_length, value,
-          (unsigned long)value_length));
+      6,
+      (ctx, name, (int)value_length, (int)value_length, value,
+       (unsigned long)value_length));
   ensure_auth_context_capacity(ctx);
   prop = &ctx->properties.array[ctx->properties.count++];
   prop->name = gpr_strdup(name);
-  prop->value = gpr_malloc(value_length + 1);
+  prop->value = (char*)gpr_malloc(value_length + 1);
   memcpy(prop->value, value, value_length);
   prop->value[value_length] = '\0';
   prop->value_length = value_length;
 }
 
-void grpc_auth_context_add_cstring_property(grpc_auth_context *ctx,
-                                            const char *name,
-                                            const char *value) {
-  grpc_auth_property *prop;
+void grpc_auth_context_add_cstring_property(grpc_auth_context* ctx,
+                                            const char* name,
+                                            const char* value) {
+  grpc_auth_property* prop;
   GRPC_API_TRACE(
       "grpc_auth_context_add_cstring_property(ctx=%p, name=%s, value=%s)", 3,
       (ctx, name, value));
@@ -295,48 +297,49 @@ void grpc_auth_context_add_cstring_property(grpc_auth_context *ctx,
   prop->value_length = strlen(value);
 }
 
-void grpc_auth_property_reset(grpc_auth_property *property) {
+void grpc_auth_property_reset(grpc_auth_property* property) {
   gpr_free(property->name);
   gpr_free(property->value);
   memset(property, 0, sizeof(grpc_auth_property));
 }
 
-static void auth_context_pointer_arg_destroy(grpc_exec_ctx *exec_ctx, void *p) {
-  GRPC_AUTH_CONTEXT_UNREF(p, "auth_context_pointer_arg");
+static void auth_context_pointer_arg_destroy(grpc_exec_ctx* exec_ctx, void* p) {
+  GRPC_AUTH_CONTEXT_UNREF((grpc_auth_context*)p, "auth_context_pointer_arg");
 }
 
-static void *auth_context_pointer_arg_copy(void *p) {
-  return GRPC_AUTH_CONTEXT_REF(p, "auth_context_pointer_arg");
+static void* auth_context_pointer_arg_copy(void* p) {
+  return GRPC_AUTH_CONTEXT_REF((grpc_auth_context*)p,
+                               "auth_context_pointer_arg");
 }
 
-static int auth_context_pointer_cmp(void *a, void *b) { return GPR_ICMP(a, b); }
+static int auth_context_pointer_cmp(void* a, void* b) { return GPR_ICMP(a, b); }
 
 static const grpc_arg_pointer_vtable auth_context_pointer_vtable = {
     auth_context_pointer_arg_copy, auth_context_pointer_arg_destroy,
     auth_context_pointer_cmp};
 
-grpc_arg grpc_auth_context_to_arg(grpc_auth_context *p) {
-  return grpc_channel_arg_pointer_create(GRPC_AUTH_CONTEXT_ARG, p,
+grpc_arg grpc_auth_context_to_arg(grpc_auth_context* p) {
+  return grpc_channel_arg_pointer_create((char*)GRPC_AUTH_CONTEXT_ARG, p,
                                          &auth_context_pointer_vtable);
 }
 
-grpc_auth_context *grpc_auth_context_from_arg(const grpc_arg *arg) {
-  if (strcmp(arg->key, GRPC_AUTH_CONTEXT_ARG) != 0) return NULL;
+grpc_auth_context* grpc_auth_context_from_arg(const grpc_arg* arg) {
+  if (strcmp(arg->key, GRPC_AUTH_CONTEXT_ARG) != 0) return nullptr;
   if (arg->type != GRPC_ARG_POINTER) {
     gpr_log(GPR_ERROR, "Invalid type %d for arg %s", arg->type,
             GRPC_AUTH_CONTEXT_ARG);
-    return NULL;
+    return nullptr;
   }
-  return arg->value.pointer.p;
+  return (grpc_auth_context*)arg->value.pointer.p;
 }
 
-grpc_auth_context *grpc_find_auth_context_in_args(
-    const grpc_channel_args *args) {
+grpc_auth_context* grpc_find_auth_context_in_args(
+    const grpc_channel_args* args) {
   size_t i;
-  if (args == NULL) return NULL;
+  if (args == nullptr) return nullptr;
   for (i = 0; i < args->num_args; i++) {
-    grpc_auth_context *p = grpc_auth_context_from_arg(&args->args[i]);
-    if (p != NULL) return p;
+    grpc_auth_context* p = grpc_auth_context_from_arg(&args->args[i]);
+    if (p != nullptr) return p;
   }
-  return NULL;
+  return nullptr;
 }