grpc 1.7.3 → 1.8.0

data/src/core/lib/security/context/security_context.h

@@ -22,9 +22,7 @@
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/security/credentials/credentials.h"
 
-#ifndef NDEBUG
-extern grpc_tracer_flag grpc_trace_auth_context_refcount;
-#endif
+extern grpc_core::DebugOnlyTraceFlag grpc_trace_auth_context_refcount;
 
 #ifdef __cplusplus
 extern "C" {
@@ -37,21 +35,21 @@ extern "C" {
 /* Property names are always NULL terminated. */
 
 typedef struct {
-  grpc_auth_property *array;
+  grpc_auth_property* array;
   size_t count;
   size_t capacity;
 } grpc_auth_property_array;
 
 struct grpc_auth_context {
-  struct grpc_auth_context *chained;
+  struct grpc_auth_context* chained;
   grpc_auth_property_array properties;
   gpr_refcount refcount;
-  const char *peer_identity_property_name;
-  grpc_pollset *pollset;
+  const char* peer_identity_property_name;
+  grpc_pollset* pollset;
 };
 
 /* Creation. */
-grpc_auth_context *grpc_auth_context_create(grpc_auth_context *chained);
+grpc_auth_context* grpc_auth_context_create(grpc_auth_context* chained);
 
 /* Refcounting. */
 #ifndef NDEBUG
@@ -59,19 +57,19 @@ grpc_auth_context *grpc_auth_context_create(grpc_auth_context *chained);
   grpc_auth_context_ref((p), __FILE__, __LINE__, (r))
 #define GRPC_AUTH_CONTEXT_UNREF(p, r) \
   grpc_auth_context_unref((p), __FILE__, __LINE__, (r))
-grpc_auth_context *grpc_auth_context_ref(grpc_auth_context *policy,
-                                         const char *file, int line,
-                                         const char *reason);
-void grpc_auth_context_unref(grpc_auth_context *policy, const char *file,
-                             int line, const char *reason);
+grpc_auth_context* grpc_auth_context_ref(grpc_auth_context* policy,
+                                         const char* file, int line,
+                                         const char* reason);
+void grpc_auth_context_unref(grpc_auth_context* policy, const char* file,
+                             int line, const char* reason);
 #else
 #define GRPC_AUTH_CONTEXT_REF(p, r) grpc_auth_context_ref((p))
 #define GRPC_AUTH_CONTEXT_UNREF(p, r) grpc_auth_context_unref((p))
-grpc_auth_context *grpc_auth_context_ref(grpc_auth_context *policy);
-void grpc_auth_context_unref(grpc_auth_context *policy);
+grpc_auth_context* grpc_auth_context_ref(grpc_auth_context* policy);
+void grpc_auth_context_unref(grpc_auth_context* policy);
 #endif
 
-void grpc_auth_property_reset(grpc_auth_property *property);
+void grpc_auth_property_reset(grpc_auth_property* property);
 
 /* --- grpc_security_context_extension ---
 
@@ -79,8 +77,8 @@ void grpc_auth_property_reset(grpc_auth_property *property);
    later by a higher level method on a grpc_call object. */
 
 typedef struct {
-  void *instance;
-  void (*destroy)(void *);
+  void* instance;
+  void (*destroy)(void*);
 } grpc_security_context_extension;
 
 /* --- grpc_client_security_context ---
@@ -88,33 +86,33 @@ typedef struct {
    Internal client-side security context. */
 
 typedef struct {
-  grpc_call_credentials *creds;
-  grpc_auth_context *auth_context;
+  grpc_call_credentials* creds;
+  grpc_auth_context* auth_context;
   grpc_security_context_extension extension;
 } grpc_client_security_context;
 
-grpc_client_security_context *grpc_client_security_context_create(void);
-void grpc_client_security_context_destroy(void *ctx);
+grpc_client_security_context* grpc_client_security_context_create(void);
+void grpc_client_security_context_destroy(void* ctx);
 
 /* --- grpc_server_security_context ---
 
    Internal server-side security context. */
 
 typedef struct {
-  grpc_auth_context *auth_context;
+  grpc_auth_context* auth_context;
   grpc_security_context_extension extension;
 } grpc_server_security_context;
 
-grpc_server_security_context *grpc_server_security_context_create(void);
-void grpc_server_security_context_destroy(void *ctx);
+grpc_server_security_context* grpc_server_security_context_create(void);
+void grpc_server_security_context_destroy(void* ctx);
 
 /* --- Channel args for auth context --- */
 #define GRPC_AUTH_CONTEXT_ARG "grpc.auth_context"
 
-grpc_arg grpc_auth_context_to_arg(grpc_auth_context *c);
-grpc_auth_context *grpc_auth_context_from_arg(const grpc_arg *arg);
-grpc_auth_context *grpc_find_auth_context_in_args(
-    const grpc_channel_args *args);
+grpc_arg grpc_auth_context_to_arg(grpc_auth_context* c);
+grpc_auth_context* grpc_auth_context_from_arg(const grpc_arg* arg);
+grpc_auth_context* grpc_find_auth_context_in_args(
+    const grpc_channel_args* args);
 
 #ifdef __cplusplus
 }

data/src/core/lib/security/credentials/composite/{composite_credentials.c → composite_credentials.cc}

@@ -30,32 +30,32 @@
 /* -- Composite call credentials. -- */
 
 typedef struct {
-  grpc_composite_call_credentials *composite_creds;
+  grpc_composite_call_credentials* composite_creds;
   size_t creds_index;
-  grpc_polling_entity *pollent;
+  grpc_polling_entity* pollent;
   grpc_auth_metadata_context auth_md_context;
-  grpc_credentials_mdelem_array *md_array;
-  grpc_closure *on_request_metadata;
+  grpc_credentials_mdelem_array* md_array;
+  grpc_closure* on_request_metadata;
   grpc_closure internal_on_request_metadata;
 } grpc_composite_call_credentials_metadata_context;
 
-static void composite_call_destruct(grpc_exec_ctx *exec_ctx,
-                                    grpc_call_credentials *creds) {
-  grpc_composite_call_credentials *c = (grpc_composite_call_credentials *)creds;
+static void composite_call_destruct(grpc_exec_ctx* exec_ctx,
+                                    grpc_call_credentials* creds) {
+  grpc_composite_call_credentials* c = (grpc_composite_call_credentials*)creds;
   for (size_t i = 0; i < c->inner.num_creds; i++) {
     grpc_call_credentials_unref(exec_ctx, c->inner.creds_array[i]);
   }
   gpr_free(c->inner.creds_array);
 }
 
-static void composite_call_metadata_cb(grpc_exec_ctx *exec_ctx, void *arg,
-                                       grpc_error *error) {
-  grpc_composite_call_credentials_metadata_context *ctx =
-      (grpc_composite_call_credentials_metadata_context *)arg;
+static void composite_call_metadata_cb(grpc_exec_ctx* exec_ctx, void* arg,
+                                       grpc_error* error) {
+  grpc_composite_call_credentials_metadata_context* ctx =
+      (grpc_composite_call_credentials_metadata_context*)arg;
   if (error == GRPC_ERROR_NONE) {
     /* See if we need to get some more metadata. */
     if (ctx->creds_index < ctx->composite_creds->inner.num_creds) {
-      grpc_call_credentials *inner_creds =
+      grpc_call_credentials* inner_creds =
           ctx->composite_creds->inner.creds_array[ctx->creds_index++];
       if (grpc_call_credentials_get_request_metadata(
               exec_ctx, inner_creds, ctx->pollent, ctx->auth_md_context,
@@ -73,13 +73,14 @@ static void composite_call_metadata_cb(grpc_exec_ctx *exec_ctx, void *arg,
 }
 
 static bool composite_call_get_request_metadata(
-    grpc_exec_ctx *exec_ctx, grpc_call_credentials *creds,
-    grpc_polling_entity *pollent, grpc_auth_metadata_context auth_md_context,
-    grpc_credentials_mdelem_array *md_array, grpc_closure *on_request_metadata,
-    grpc_error **error) {
-  grpc_composite_call_credentials *c = (grpc_composite_call_credentials *)creds;
-  grpc_composite_call_credentials_metadata_context *ctx;
-  ctx = gpr_zalloc(sizeof(grpc_composite_call_credentials_metadata_context));
+    grpc_exec_ctx* exec_ctx, grpc_call_credentials* creds,
+    grpc_polling_entity* pollent, grpc_auth_metadata_context auth_md_context,
+    grpc_credentials_mdelem_array* md_array, grpc_closure* on_request_metadata,
+    grpc_error** error) {
+  grpc_composite_call_credentials* c = (grpc_composite_call_credentials*)creds;
+  grpc_composite_call_credentials_metadata_context* ctx;
+  ctx = (grpc_composite_call_credentials_metadata_context*)gpr_zalloc(
+      sizeof(grpc_composite_call_credentials_metadata_context));
   ctx->composite_creds = c;
   ctx->pollent = pollent;
   ctx->auth_md_context = auth_md_context;
@@ -89,7 +90,7 @@ static bool composite_call_get_request_metadata(
                     composite_call_metadata_cb, ctx, grpc_schedule_on_exec_ctx);
   bool synchronous = true;
   while (ctx->creds_index < ctx->composite_creds->inner.num_creds) {
-    grpc_call_credentials *inner_creds =
+    grpc_call_credentials* inner_creds =
         ctx->composite_creds->inner.creds_array[ctx->creds_index++];
     if (grpc_call_credentials_get_request_metadata(
             exec_ctx, inner_creds, ctx->pollent, ctx->auth_md_context,
@@ -105,9 +106,9 @@ static bool composite_call_get_request_metadata(
 }
 
 static void composite_call_cancel_get_request_metadata(
-    grpc_exec_ctx *exec_ctx, grpc_call_credentials *creds,
-    grpc_credentials_mdelem_array *md_array, grpc_error *error) {
-  grpc_composite_call_credentials *c = (grpc_composite_call_credentials *)creds;
+    grpc_exec_ctx* exec_ctx, grpc_call_credentials* creds,
+    grpc_credentials_mdelem_array* md_array, grpc_error* error) {
+  grpc_composite_call_credentials* c = (grpc_composite_call_credentials*)creds;
   for (size_t i = 0; i < c->inner.num_creds; ++i) {
     grpc_call_credentials_cancel_get_request_metadata(
         exec_ctx, c->inner.creds_array[i], md_array, GRPC_ERROR_REF(error));
@@ -120,9 +121,9 @@ static grpc_call_credentials_vtable composite_call_credentials_vtable = {
     composite_call_cancel_get_request_metadata};
 
 static grpc_call_credentials_array get_creds_array(
-    grpc_call_credentials **creds_addr) {
+    grpc_call_credentials** creds_addr) {
   grpc_call_credentials_array result;
-  grpc_call_credentials *creds = *creds_addr;
+  grpc_call_credentials* creds = *creds_addr;
   result.creds_array = creds_addr;
   result.num_creds = 1;
   if (strcmp(creds->type, GRPC_CALL_CREDENTIALS_TYPE_COMPOSITE) == 0) {
@@ -131,97 +132,100 @@ static grpc_call_credentials_array get_creds_array(
   return result;
 }
 
-grpc_call_credentials *grpc_composite_call_credentials_create(
-    grpc_call_credentials *creds1, grpc_call_credentials *creds2,
-    void *reserved) {
+grpc_call_credentials* grpc_composite_call_credentials_create(
+    grpc_call_credentials* creds1, grpc_call_credentials* creds2,
+    void* reserved) {
   size_t i;
   size_t creds_array_byte_size;
   grpc_call_credentials_array creds1_array;
   grpc_call_credentials_array creds2_array;
-  grpc_composite_call_credentials *c;
+  grpc_composite_call_credentials* c;
   GRPC_API_TRACE(
       "grpc_composite_call_credentials_create(creds1=%p, creds2=%p, "
       "reserved=%p)",
       3, (creds1, creds2, reserved));
-  GPR_ASSERT(reserved == NULL);
-  GPR_ASSERT(creds1 != NULL);
-  GPR_ASSERT(creds2 != NULL);
-  c = gpr_zalloc(sizeof(grpc_composite_call_credentials));
+  GPR_ASSERT(reserved == nullptr);
+  GPR_ASSERT(creds1 != nullptr);
+  GPR_ASSERT(creds2 != nullptr);
+  c = (grpc_composite_call_credentials*)gpr_zalloc(
+      sizeof(grpc_composite_call_credentials));
   c->base.type = GRPC_CALL_CREDENTIALS_TYPE_COMPOSITE;
   c->base.vtable = &composite_call_credentials_vtable;
   gpr_ref_init(&c->base.refcount, 1);
   creds1_array = get_creds_array(&creds1);
   creds2_array = get_creds_array(&creds2);
   c->inner.num_creds = creds1_array.num_creds + creds2_array.num_creds;
-  creds_array_byte_size = c->inner.num_creds * sizeof(grpc_call_credentials *);
-  c->inner.creds_array = gpr_zalloc(creds_array_byte_size);
+  creds_array_byte_size = c->inner.num_creds * sizeof(grpc_call_credentials*);
+  c->inner.creds_array =
+      (grpc_call_credentials**)gpr_zalloc(creds_array_byte_size);
   for (i = 0; i < creds1_array.num_creds; i++) {
-    grpc_call_credentials *cur_creds = creds1_array.creds_array[i];
+    grpc_call_credentials* cur_creds = creds1_array.creds_array[i];
     c->inner.creds_array[i] = grpc_call_credentials_ref(cur_creds);
   }
   for (i = 0; i < creds2_array.num_creds; i++) {
-    grpc_call_credentials *cur_creds = creds2_array.creds_array[i];
+    grpc_call_credentials* cur_creds = creds2_array.creds_array[i];
     c->inner.creds_array[i + creds1_array.num_creds] =
         grpc_call_credentials_ref(cur_creds);
   }
   return &c->base;
 }
 
-const grpc_call_credentials_array *
-grpc_composite_call_credentials_get_credentials(grpc_call_credentials *creds) {
-  const grpc_composite_call_credentials *c =
-      (const grpc_composite_call_credentials *)creds;
+const grpc_call_credentials_array*
+grpc_composite_call_credentials_get_credentials(grpc_call_credentials* creds) {
+  const grpc_composite_call_credentials* c =
+      (const grpc_composite_call_credentials*)creds;
   GPR_ASSERT(strcmp(creds->type, GRPC_CALL_CREDENTIALS_TYPE_COMPOSITE) == 0);
   return &c->inner;
 }
 
-grpc_call_credentials *grpc_credentials_contains_type(
-    grpc_call_credentials *creds, const char *type,
-    grpc_call_credentials **composite_creds) {
+grpc_call_credentials* grpc_credentials_contains_type(
+    grpc_call_credentials* creds, const char* type,
+    grpc_call_credentials** composite_creds) {
   size_t i;
   if (strcmp(creds->type, type) == 0) {
-    if (composite_creds != NULL) *composite_creds = NULL;
+    if (composite_creds != nullptr) *composite_creds = nullptr;
     return creds;
   } else if (strcmp(creds->type, GRPC_CALL_CREDENTIALS_TYPE_COMPOSITE) == 0) {
-    const grpc_call_credentials_array *inner_creds_array =
+    const grpc_call_credentials_array* inner_creds_array =
         grpc_composite_call_credentials_get_credentials(creds);
     for (i = 0; i < inner_creds_array->num_creds; i++) {
       if (strcmp(type, inner_creds_array->creds_array[i]->type) == 0) {
-        if (composite_creds != NULL) *composite_creds = creds;
+        if (composite_creds != nullptr) *composite_creds = creds;
         return inner_creds_array->creds_array[i];
       }
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 /* -- Composite channel credentials. -- */
 
-static void composite_channel_destruct(grpc_exec_ctx *exec_ctx,
-                                       grpc_channel_credentials *creds) {
-  grpc_composite_channel_credentials *c =
-      (grpc_composite_channel_credentials *)creds;
+static void composite_channel_destruct(grpc_exec_ctx* exec_ctx,
+                                       grpc_channel_credentials* creds) {
+  grpc_composite_channel_credentials* c =
+      (grpc_composite_channel_credentials*)creds;
   grpc_channel_credentials_unref(exec_ctx, c->inner_creds);
   grpc_call_credentials_unref(exec_ctx, c->call_creds);
 }
 
 static grpc_security_status composite_channel_create_security_connector(
-    grpc_exec_ctx *exec_ctx, grpc_channel_credentials *creds,
-    grpc_call_credentials *call_creds, const char *target,
-    const grpc_channel_args *args, grpc_channel_security_connector **sc,
-    grpc_channel_args **new_args) {
-  grpc_composite_channel_credentials *c =
-      (grpc_composite_channel_credentials *)creds;
+    grpc_exec_ctx* exec_ctx, grpc_channel_credentials* creds,
+    grpc_call_credentials* call_creds, const char* target,
+    const grpc_channel_args* args, grpc_channel_security_connector** sc,
+    grpc_channel_args** new_args) {
+  grpc_composite_channel_credentials* c =
+      (grpc_composite_channel_credentials*)creds;
   grpc_security_status status = GRPC_SECURITY_ERROR;
 
-  GPR_ASSERT(c->inner_creds != NULL && c->call_creds != NULL &&
-             c->inner_creds->vtable != NULL &&
-             c->inner_creds->vtable->create_security_connector != NULL);
+  GPR_ASSERT(c->inner_creds != nullptr && c->call_creds != nullptr &&
+             c->inner_creds->vtable != nullptr &&
+             c->inner_creds->vtable->create_security_connector != nullptr);
   /* If we are passed a call_creds, create a call composite to pass it
      downstream. */
-  if (call_creds != NULL) {
-    grpc_call_credentials *composite_call_creds =
-        grpc_composite_call_credentials_create(c->call_creds, call_creds, NULL);
+  if (call_creds != nullptr) {
+    grpc_call_credentials* composite_call_creds =
+        grpc_composite_call_credentials_create(c->call_creds, call_creds,
+                                               nullptr);
     status = c->inner_creds->vtable->create_security_connector(
         exec_ctx, c->inner_creds, composite_call_creds, target, args, sc,
         new_args);
@@ -233,11 +237,11 @@ static grpc_security_status composite_channel_create_security_connector(
   return status;
 }
 
-static grpc_channel_credentials *
+static grpc_channel_credentials*
 composite_channel_duplicate_without_call_credentials(
-    grpc_channel_credentials *creds) {
-  grpc_composite_channel_credentials *c =
-      (grpc_composite_channel_credentials *)creds;
+    grpc_channel_credentials* creds) {
+  grpc_composite_channel_credentials* c =
+      (grpc_composite_channel_credentials*)creds;
   return grpc_channel_credentials_ref(c->inner_creds);
 }
 
@@ -245,11 +249,13 @@ static grpc_channel_credentials_vtable composite_channel_credentials_vtable = {
     composite_channel_destruct, composite_channel_create_security_connector,
     composite_channel_duplicate_without_call_credentials};
 
-grpc_channel_credentials *grpc_composite_channel_credentials_create(
-    grpc_channel_credentials *channel_creds, grpc_call_credentials *call_creds,
-    void *reserved) {
-  grpc_composite_channel_credentials *c = gpr_zalloc(sizeof(*c));
-  GPR_ASSERT(channel_creds != NULL && call_creds != NULL && reserved == NULL);
+grpc_channel_credentials* grpc_composite_channel_credentials_create(
+    grpc_channel_credentials* channel_creds, grpc_call_credentials* call_creds,
+    void* reserved) {
+  grpc_composite_channel_credentials* c =
+      (grpc_composite_channel_credentials*)gpr_zalloc(sizeof(*c));
+  GPR_ASSERT(channel_creds != nullptr && call_creds != nullptr &&
+             reserved == nullptr);
   GRPC_API_TRACE(
       "grpc_composite_channel_credentials_create(channel_creds=%p, "
       "call_creds=%p, reserved=%p)",

data/src/core/lib/security/credentials/composite/composite_credentials.h

@@ -21,29 +21,33 @@
 
 #include "src/core/lib/security/credentials/credentials.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct {
-  grpc_call_credentials **creds_array;
+  grpc_call_credentials** creds_array;
   size_t num_creds;
 } grpc_call_credentials_array;
 
-const grpc_call_credentials_array *
+const grpc_call_credentials_array*
 grpc_composite_call_credentials_get_credentials(
-    grpc_call_credentials *composite_creds);
+    grpc_call_credentials* composite_creds);
 
 /* Returns creds if creds is of the specified type or the inner creds of the
    specified type (if found), if the creds is of type COMPOSITE.
    If composite_creds is not NULL, *composite_creds will point to creds if of
    type COMPOSITE in case of success. */
-grpc_call_credentials *grpc_credentials_contains_type(
-    grpc_call_credentials *creds, const char *type,
-    grpc_call_credentials **composite_creds);
+grpc_call_credentials* grpc_credentials_contains_type(
+    grpc_call_credentials* creds, const char* type,
+    grpc_call_credentials** composite_creds);
 
 /* -- Composite channel credentials. -- */
 
 typedef struct {
   grpc_channel_credentials base;
-  grpc_channel_credentials *inner_creds;
-  grpc_call_credentials *call_creds;
+  grpc_channel_credentials* inner_creds;
+  grpc_call_credentials* call_creds;
 } grpc_composite_channel_credentials;
 
 /* -- Composite call credentials. -- */
@@ -53,5 +57,9 @@ typedef struct {
   grpc_call_credentials_array inner;
 } grpc_composite_call_credentials;
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_SECURITY_CREDENTIALS_COMPOSITE_COMPOSITE_CREDENTIALS_H \
-          */
+        */

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

@@ -37,64 +37,65 @@
 
 /* -- Common. -- */
 
-grpc_credentials_metadata_request *grpc_credentials_metadata_request_create(
-    grpc_call_credentials *creds) {
-  grpc_credentials_metadata_request *r =
-      gpr_zalloc(sizeof(grpc_credentials_metadata_request));
+grpc_credentials_metadata_request* grpc_credentials_metadata_request_create(
+    grpc_call_credentials* creds) {
+  grpc_credentials_metadata_request* r =
+      (grpc_credentials_metadata_request*)gpr_zalloc(
+          sizeof(grpc_credentials_metadata_request));
   r->creds = grpc_call_credentials_ref(creds);
   return r;
 }
 
 void grpc_credentials_metadata_request_destroy(
-    grpc_exec_ctx *exec_ctx, grpc_credentials_metadata_request *r) {
+    grpc_exec_ctx* exec_ctx, grpc_credentials_metadata_request* r) {
   grpc_call_credentials_unref(exec_ctx, r->creds);
   grpc_http_response_destroy(&r->response);
   gpr_free(r);
 }
 
-grpc_channel_credentials *grpc_channel_credentials_ref(
-    grpc_channel_credentials *creds) {
-  if (creds == NULL) return NULL;
+grpc_channel_credentials* grpc_channel_credentials_ref(
+    grpc_channel_credentials* creds) {
+  if (creds == nullptr) return nullptr;
   gpr_ref(&creds->refcount);
   return creds;
 }
 
-void grpc_channel_credentials_unref(grpc_exec_ctx *exec_ctx,
-                                    grpc_channel_credentials *creds) {
-  if (creds == NULL) return;
+void grpc_channel_credentials_unref(grpc_exec_ctx* exec_ctx,
+                                    grpc_channel_credentials* creds) {
+  if (creds == nullptr) return;
   if (gpr_unref(&creds->refcount)) {
-    if (creds->vtable->destruct != NULL) {
+    if (creds->vtable->destruct != nullptr) {
       creds->vtable->destruct(exec_ctx, creds);
     }
     gpr_free(creds);
   }
 }
 
-void grpc_channel_credentials_release(grpc_channel_credentials *creds) {
+void grpc_channel_credentials_release(grpc_channel_credentials* creds) {
   GRPC_API_TRACE("grpc_channel_credentials_release(creds=%p)", 1, (creds));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_channel_credentials_unref(&exec_ctx, creds);
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-grpc_call_credentials *grpc_call_credentials_ref(grpc_call_credentials *creds) {
-  if (creds == NULL) return NULL;
+grpc_call_credentials* grpc_call_credentials_ref(grpc_call_credentials* creds) {
+  if (creds == nullptr) return nullptr;
   gpr_ref(&creds->refcount);
   return creds;
 }
 
-void grpc_call_credentials_unref(grpc_exec_ctx *exec_ctx,
-                                 grpc_call_credentials *creds) {
-  if (creds == NULL) return;
+void grpc_call_credentials_unref(grpc_exec_ctx* exec_ctx,
+                                 grpc_call_credentials* creds) {
+  if (creds == nullptr) return;
   if (gpr_unref(&creds->refcount)) {
-    if (creds->vtable->destruct != NULL) {
+    if (creds->vtable->destruct != nullptr) {
       creds->vtable->destruct(exec_ctx, creds);
     }
     gpr_free(creds);
   }
 }
 
-void grpc_call_credentials_release(grpc_call_credentials *creds) {
+void grpc_call_credentials_release(grpc_call_credentials* creds) {
   GRPC_API_TRACE("grpc_call_credentials_release(creds=%p)", 1, (creds));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_call_credentials_unref(&exec_ctx, creds);
@@ -102,11 +103,11 @@ void grpc_call_credentials_release(grpc_call_credentials *creds) {
 }
 
 bool grpc_call_credentials_get_request_metadata(
-    grpc_exec_ctx *exec_ctx, grpc_call_credentials *creds,
-    grpc_polling_entity *pollent, grpc_auth_metadata_context context,
-    grpc_credentials_mdelem_array *md_array, grpc_closure *on_request_metadata,
-    grpc_error **error) {
-  if (creds == NULL || creds->vtable->get_request_metadata == NULL) {
+    grpc_exec_ctx* exec_ctx, grpc_call_credentials* creds,
+    grpc_polling_entity* pollent, grpc_auth_metadata_context context,
+    grpc_credentials_mdelem_array* md_array, grpc_closure* on_request_metadata,
+    grpc_error** error) {
+  if (creds == nullptr || creds->vtable->get_request_metadata == nullptr) {
     return true;
   }
   return creds->vtable->get_request_metadata(
@@ -114,32 +115,33 @@ bool grpc_call_credentials_get_request_metadata(
 }
 
 void grpc_call_credentials_cancel_get_request_metadata(
-    grpc_exec_ctx *exec_ctx, grpc_call_credentials *creds,
-    grpc_credentials_mdelem_array *md_array, grpc_error *error) {
-  if (creds == NULL || creds->vtable->cancel_get_request_metadata == NULL) {
+    grpc_exec_ctx* exec_ctx, grpc_call_credentials* creds,
+    grpc_credentials_mdelem_array* md_array, grpc_error* error) {
+  if (creds == nullptr ||
+      creds->vtable->cancel_get_request_metadata == nullptr) {
     return;
   }
   creds->vtable->cancel_get_request_metadata(exec_ctx, creds, md_array, error);
 }
 
 grpc_security_status grpc_channel_credentials_create_security_connector(
-    grpc_exec_ctx *exec_ctx, grpc_channel_credentials *channel_creds,
-    const char *target, const grpc_channel_args *args,
-    grpc_channel_security_connector **sc, grpc_channel_args **new_args) {
-  *new_args = NULL;
-  if (channel_creds == NULL) {
+    grpc_exec_ctx* exec_ctx, grpc_channel_credentials* channel_creds,
+    const char* target, const grpc_channel_args* args,
+    grpc_channel_security_connector** sc, grpc_channel_args** new_args) {
+  *new_args = nullptr;
+  if (channel_creds == nullptr) {
     return GRPC_SECURITY_ERROR;
   }
-  GPR_ASSERT(channel_creds->vtable->create_security_connector != NULL);
+  GPR_ASSERT(channel_creds->vtable->create_security_connector != nullptr);
   return channel_creds->vtable->create_security_connector(
-      exec_ctx, channel_creds, NULL, target, args, sc, new_args);
+      exec_ctx, channel_creds, nullptr, target, args, sc, new_args);
 }
 
-grpc_channel_credentials *
+grpc_channel_credentials*
 grpc_channel_credentials_duplicate_without_call_credentials(
-    grpc_channel_credentials *channel_creds) {
-  if (channel_creds != NULL && channel_creds->vtable != NULL &&
-      channel_creds->vtable->duplicate_without_call_credentials != NULL) {
+    grpc_channel_credentials* channel_creds) {
+  if (channel_creds != nullptr && channel_creds->vtable != nullptr &&
+      channel_creds->vtable->duplicate_without_call_credentials != nullptr) {
     return channel_creds->vtable->duplicate_without_call_credentials(
         channel_creds);
   } else {
@@ -147,71 +149,73 @@ grpc_channel_credentials_duplicate_without_call_credentials(
   }
 }
 
-static void credentials_pointer_arg_destroy(grpc_exec_ctx *exec_ctx, void *p) {
-  grpc_channel_credentials_unref(exec_ctx, p);
+static void credentials_pointer_arg_destroy(grpc_exec_ctx* exec_ctx, void* p) {
+  grpc_channel_credentials_unref(exec_ctx, (grpc_channel_credentials*)p);
 }
 
-static void *credentials_pointer_arg_copy(void *p) {
-  return grpc_channel_credentials_ref(p);
+static void* credentials_pointer_arg_copy(void* p) {
+  return grpc_channel_credentials_ref((grpc_channel_credentials*)p);
 }
 
-static int credentials_pointer_cmp(void *a, void *b) { return GPR_ICMP(a, b); }
+static int credentials_pointer_cmp(void* a, void* b) { return GPR_ICMP(a, b); }
 
 static const grpc_arg_pointer_vtable credentials_pointer_vtable = {
     credentials_pointer_arg_copy, credentials_pointer_arg_destroy,
     credentials_pointer_cmp};
 
 grpc_arg grpc_channel_credentials_to_arg(
-    grpc_channel_credentials *credentials) {
-  return grpc_channel_arg_pointer_create(
-      GRPC_ARG_CHANNEL_CREDENTIALS, credentials, &credentials_pointer_vtable);
+    grpc_channel_credentials* credentials) {
+  return grpc_channel_arg_pointer_create((char*)GRPC_ARG_CHANNEL_CREDENTIALS,
+                                         credentials,
+                                         &credentials_pointer_vtable);
 }
 
-grpc_channel_credentials *grpc_channel_credentials_from_arg(
-    const grpc_arg *arg) {
-  if (strcmp(arg->key, GRPC_ARG_CHANNEL_CREDENTIALS)) return NULL;
+grpc_channel_credentials* grpc_channel_credentials_from_arg(
+    const grpc_arg* arg) {
+  if (strcmp(arg->key, GRPC_ARG_CHANNEL_CREDENTIALS)) return nullptr;
   if (arg->type != GRPC_ARG_POINTER) {
     gpr_log(GPR_ERROR, "Invalid type %d for arg %s", arg->type,
             GRPC_ARG_CHANNEL_CREDENTIALS);
-    return NULL;
+    return nullptr;
   }
-  return arg->value.pointer.p;
+  return (grpc_channel_credentials*)arg->value.pointer.p;
 }
 
-grpc_channel_credentials *grpc_channel_credentials_find_in_args(
-    const grpc_channel_args *args) {
+grpc_channel_credentials* grpc_channel_credentials_find_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_channel_credentials *credentials =
+    grpc_channel_credentials* credentials =
         grpc_channel_credentials_from_arg(&args->args[i]);
-    if (credentials != NULL) return credentials;
+    if (credentials != nullptr) return credentials;
   }
-  return NULL;
+  return nullptr;
 }
 
-grpc_server_credentials *grpc_server_credentials_ref(
-    grpc_server_credentials *creds) {
-  if (creds == NULL) return NULL;
+grpc_server_credentials* grpc_server_credentials_ref(
+    grpc_server_credentials* creds) {
+  if (creds == nullptr) return nullptr;
   gpr_ref(&creds->refcount);
   return creds;
 }
 
-void grpc_server_credentials_unref(grpc_exec_ctx *exec_ctx,
-                                   grpc_server_credentials *creds) {
-  if (creds == NULL) return;
+void grpc_server_credentials_unref(grpc_exec_ctx* exec_ctx,
+                                   grpc_server_credentials* creds) {
+  if (creds == nullptr) return;
   if (gpr_unref(&creds->refcount)) {
-    if (creds->vtable->destruct != NULL) {
+    if (creds->vtable->destruct != nullptr) {
       creds->vtable->destruct(exec_ctx, creds);
     }
-    if (creds->processor.destroy != NULL && creds->processor.state != NULL) {
+    if (creds->processor.destroy != nullptr &&
+        creds->processor.state != nullptr) {
       creds->processor.destroy(creds->processor.state);
     }
     gpr_free(creds);
   }
 }
 
-void grpc_server_credentials_release(grpc_server_credentials *creds) {
+void grpc_server_credentials_release(grpc_server_credentials* creds) {
   GRPC_API_TRACE("grpc_server_credentials_release(creds=%p)", 1, (creds));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   grpc_server_credentials_unref(&exec_ctx, creds);
@@ -219,9 +223,9 @@ void grpc_server_credentials_release(grpc_server_credentials *creds) {
 }
 
 grpc_security_status grpc_server_credentials_create_security_connector(
-    grpc_exec_ctx *exec_ctx, grpc_server_credentials *creds,
-    grpc_server_security_connector **sc) {
-  if (creds == NULL || creds->vtable->create_security_connector == NULL) {
+    grpc_exec_ctx* exec_ctx, grpc_server_credentials* creds,
+    grpc_server_security_connector** sc) {
+  if (creds == nullptr || creds->vtable->create_security_connector == nullptr) {
     gpr_log(GPR_ERROR, "Server credentials cannot create security context.");
     return GRPC_SECURITY_ERROR;
   }
@@ -229,29 +233,30 @@ grpc_security_status grpc_server_credentials_create_security_connector(
 }
 
 void grpc_server_credentials_set_auth_metadata_processor(
-    grpc_server_credentials *creds, grpc_auth_metadata_processor processor) {
+    grpc_server_credentials* creds, grpc_auth_metadata_processor processor) {
   GRPC_API_TRACE(
       "grpc_server_credentials_set_auth_metadata_processor("
       "creds=%p, "
       "processor=grpc_auth_metadata_processor { process: %p, state: %p })",
-      3, (creds, (void *)(intptr_t)processor.process, processor.state));
-  if (creds == NULL) return;
-  if (creds->processor.destroy != NULL && creds->processor.state != NULL) {
+      3, (creds, (void*)(intptr_t)processor.process, processor.state));
+  if (creds == nullptr) return;
+  if (creds->processor.destroy != nullptr &&
+      creds->processor.state != nullptr) {
     creds->processor.destroy(creds->processor.state);
   }
   creds->processor = processor;
 }
 
-static void server_credentials_pointer_arg_destroy(grpc_exec_ctx *exec_ctx,
-                                                   void *p) {
-  grpc_server_credentials_unref(exec_ctx, p);
+static void server_credentials_pointer_arg_destroy(grpc_exec_ctx* exec_ctx,
+                                                   void* p) {
+  grpc_server_credentials_unref(exec_ctx, (grpc_server_credentials*)p);
 }
 
-static void *server_credentials_pointer_arg_copy(void *p) {
-  return grpc_server_credentials_ref(p);
+static void* server_credentials_pointer_arg_copy(void* p) {
+  return grpc_server_credentials_ref((grpc_server_credentials*)p);
 }
 
-static int server_credentials_pointer_cmp(void *a, void *b) {
+static int server_credentials_pointer_cmp(void* a, void* b) {
   return GPR_ICMP(a, b);
 }
 
@@ -259,29 +264,29 @@ static const grpc_arg_pointer_vtable cred_ptr_vtable = {
     server_credentials_pointer_arg_copy, server_credentials_pointer_arg_destroy,
     server_credentials_pointer_cmp};
 
-grpc_arg grpc_server_credentials_to_arg(grpc_server_credentials *p) {
-  return grpc_channel_arg_pointer_create(GRPC_SERVER_CREDENTIALS_ARG, p,
+grpc_arg grpc_server_credentials_to_arg(grpc_server_credentials* p) {
+  return grpc_channel_arg_pointer_create((char*)GRPC_SERVER_CREDENTIALS_ARG, p,
                                          &cred_ptr_vtable);
 }
 
-grpc_server_credentials *grpc_server_credentials_from_arg(const grpc_arg *arg) {
-  if (strcmp(arg->key, GRPC_SERVER_CREDENTIALS_ARG) != 0) return NULL;
+grpc_server_credentials* grpc_server_credentials_from_arg(const grpc_arg* arg) {
+  if (strcmp(arg->key, GRPC_SERVER_CREDENTIALS_ARG) != 0) return nullptr;
   if (arg->type != GRPC_ARG_POINTER) {
     gpr_log(GPR_ERROR, "Invalid type %d for arg %s", arg->type,
             GRPC_SERVER_CREDENTIALS_ARG);
-    return NULL;
+    return nullptr;
   }
-  return arg->value.pointer.p;
+  return (grpc_server_credentials*)arg->value.pointer.p;
 }
 
-grpc_server_credentials *grpc_find_server_credentials_in_args(
-    const grpc_channel_args *args) {
+grpc_server_credentials* grpc_find_server_credentials_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_server_credentials *p =
+    grpc_server_credentials* p =
         grpc_server_credentials_from_arg(&args->args[i]);
-    if (p != NULL) return p;
+    if (p != nullptr) return p;
   }
-  return NULL;
+  return nullptr;
 }