grpc 1.7.3 → 1.8.0

data/src/core/lib/transport/error_utils.h

@@ -20,22 +20,34 @@
 #define GRPC_CORE_LIB_TRANSPORT_ERROR_UTILS_H
 
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/transport/http2_errors.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /// A utility function to get the status code and message to be returned
 /// to the application.  If not set in the top-level message, looks
 /// through child errors until it finds the first one with these attributes.
-/// All attributes are pulled from the same child error. If any of the
-/// attributes (code, msg, http_status) are unneeded, they can be passed as
+/// All attributes are pulled from the same child error. error_string will
+/// be populated with the entire error string. If any of the attributes (code,
+/// msg, http_status, error_string) are unneeded, they can be passed as
 /// NULL.
-void grpc_error_get_status(grpc_error *error, gpr_timespec deadline,
-                           grpc_status_code *code, grpc_slice *slice,
-                           grpc_http2_error_code *http_status);
+void grpc_error_get_status(grpc_exec_ctx* exec_ctx, grpc_error* error,
+                           grpc_millis deadline, grpc_status_code* code,
+                           grpc_slice* slice,
+                           grpc_http2_error_code* http_status,
+                           const char** error_string);
 
 /// A utility function to check whether there is a clear status code that
 /// doesn't need to be guessed in \a error. This means that \a error or some
 /// child has GRPC_ERROR_INT_GRPC_STATUS set, or that it is GRPC_ERROR_NONE or
 /// GRPC_ERROR_CANCELLED
-bool grpc_error_has_clear_grpc_status(grpc_error *error);
+bool grpc_error_has_clear_grpc_status(grpc_error* error);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_TRANSPORT_ERROR_UTILS_H */

data/src/core/lib/transport/{metadata.c → metadata.cc}

@@ -19,6 +19,7 @@
 #include "src/core/lib/transport/metadata.h"
 
 #include <assert.h>
+#include <inttypes.h>
 #include <stddef.h>
 #include <string.h>
 
@@ -47,9 +48,9 @@
  * used to determine which kind of element a pointer refers to.
  */
 
+grpc_core::DebugOnlyTraceFlag grpc_trace_metadata(false, "metadata");
+
 #ifndef NDEBUG
-grpc_tracer_flag grpc_trace_metadata =
-    GRPC_TRACER_INITIALIZER(false, "metadata");
 #define DEBUG_ARGS , const char *file, int line
 #define FWD_DEBUG_ARGS , file, line
 #define REF_MD_LOCKED(shard, s) ref_md_locked((shard), (s), __FILE__, __LINE__)
@@ -66,7 +67,7 @@ grpc_tracer_flag grpc_trace_metadata =
 #define TABLE_IDX(hash, capacity) (((hash) >> (LOG2_SHARD_COUNT)) % (capacity))
 #define SHARD_IDX(hash) ((hash) & ((1 << (LOG2_SHARD_COUNT)) - 1))
 
-typedef void (*destroy_user_data_func)(void *user_data);
+typedef void (*destroy_user_data_func)(void* user_data);
 
 /* Shadow structure for grpc_mdelem_data for interned elements */
 typedef struct interned_metadata {
@@ -81,7 +82,7 @@ typedef struct interned_metadata {
   gpr_atm destroy_user_data;
   gpr_atm user_data;
 
-  struct interned_metadata *bucket_next;
+  struct interned_metadata* bucket_next;
 } interned_metadata;
 
 /* Shadow structure for grpc_mdelem_data for allocated elements */
@@ -96,7 +97,7 @@ typedef struct allocated_metadata {
 
 typedef struct mdtab_shard {
   gpr_mu mu;
-  interned_metadata **elems;
+  interned_metadata** elems;
   size_t count;
   size_t capacity;
   /** Estimate of the number of unreferenced mdelems in the hash table.
@@ -107,24 +108,24 @@ typedef struct mdtab_shard {
 
 static mdtab_shard g_shards[SHARD_COUNT];
 
-static void gc_mdtab(grpc_exec_ctx *exec_ctx, mdtab_shard *shard);
+static void gc_mdtab(grpc_exec_ctx* exec_ctx, mdtab_shard* shard);
 
 void grpc_mdctx_global_init(void) {
   /* initialize shards */
   for (size_t i = 0; i < SHARD_COUNT; i++) {
-    mdtab_shard *shard = &g_shards[i];
+    mdtab_shard* shard = &g_shards[i];
     gpr_mu_init(&shard->mu);
     shard->count = 0;
     gpr_atm_no_barrier_store(&shard->free_estimate, 0);
     shard->capacity = INITIAL_SHARD_CAPACITY;
-    shard->elems = (interned_metadata **)gpr_zalloc(sizeof(*shard->elems) *
-                                                    shard->capacity);
+    shard->elems = (interned_metadata**)gpr_zalloc(sizeof(*shard->elems) *
+                                                   shard->capacity);
   }
 }
 
-void grpc_mdctx_global_shutdown(grpc_exec_ctx *exec_ctx) {
+void grpc_mdctx_global_shutdown(grpc_exec_ctx* exec_ctx) {
   for (size_t i = 0; i < SHARD_COUNT; i++) {
-    mdtab_shard *shard = &g_shards[i];
+    mdtab_shard* shard = &g_shards[i];
     gpr_mu_destroy(&shard->mu);
     gc_mdtab(exec_ctx, shard);
     /* TODO(ctiller): GPR_ASSERT(shard->count == 0); */
@@ -145,14 +146,14 @@ static int is_mdelem_static(grpc_mdelem e) {
              &grpc_static_mdelem_table[GRPC_STATIC_MDELEM_COUNT];
 }
 
-static void ref_md_locked(mdtab_shard *shard,
-                          interned_metadata *md DEBUG_ARGS) {
+static void ref_md_locked(mdtab_shard* shard,
+                          interned_metadata* md DEBUG_ARGS) {
 #ifndef NDEBUG
-  if (GRPC_TRACER_ON(grpc_trace_metadata)) {
-    char *key_str = grpc_slice_to_c_string(md->key);
-    char *value_str = grpc_slice_to_c_string(md->value);
+  if (grpc_trace_metadata.enabled()) {
+    char* key_str = grpc_slice_to_c_string(md->key);
+    char* value_str = grpc_slice_to_c_string(md->value);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
-            "ELM   REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'", (void *)md,
+            "ELM   REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'", (void*)md,
             gpr_atm_no_barrier_load(&md->refcnt),
             gpr_atm_no_barrier_load(&md->refcnt) + 1, key_str, value_str);
     gpr_free(key_str);
@@ -164,9 +165,9 @@ static void ref_md_locked(mdtab_shard *shard,
   }
 }
 
-static void gc_mdtab(grpc_exec_ctx *exec_ctx, mdtab_shard *shard) {
+static void gc_mdtab(grpc_exec_ctx* exec_ctx, mdtab_shard* shard) {
   size_t i;
-  interned_metadata **prev_next;
+  interned_metadata** prev_next;
   interned_metadata *md, *next;
   gpr_atm num_freed = 0;
 
@@ -174,7 +175,7 @@ static void gc_mdtab(grpc_exec_ctx *exec_ctx, mdtab_shard *shard) {
   for (i = 0; i < shard->capacity; i++) {
     prev_next = &shard->elems[i];
     for (md = shard->elems[i]; md; md = next) {
-      void *user_data = (void *)gpr_atm_no_barrier_load(&md->user_data);
+      void* user_data = (void*)gpr_atm_no_barrier_load(&md->user_data);
       next = md->bucket_next;
       if (gpr_atm_acq_load(&md->refcnt) == 0) {
         grpc_slice_unref_internal(exec_ctx, md->key);
@@ -196,17 +197,17 @@ static void gc_mdtab(grpc_exec_ctx *exec_ctx, mdtab_shard *shard) {
   GPR_TIMER_END("gc_mdtab", 0);
 }
 
-static void grow_mdtab(mdtab_shard *shard) {
+static void grow_mdtab(mdtab_shard* shard) {
   size_t capacity = shard->capacity * 2;
   size_t i;
-  interned_metadata **mdtab;
+  interned_metadata** mdtab;
   interned_metadata *md, *next;
   uint32_t hash;
 
   GPR_TIMER_BEGIN("grow_mdtab", 0);
 
   mdtab =
-      (interned_metadata **)gpr_zalloc(sizeof(interned_metadata *) * capacity);
+      (interned_metadata**)gpr_zalloc(sizeof(interned_metadata*) * capacity);
 
   for (i = 0; i < shard->capacity; i++) {
     for (md = shard->elems[i]; md; md = next) {
@@ -227,7 +228,7 @@ static void grow_mdtab(mdtab_shard *shard) {
   GPR_TIMER_END("grow_mdtab", 0);
 }
 
-static void rehash_mdtab(grpc_exec_ctx *exec_ctx, mdtab_shard *shard) {
+static void rehash_mdtab(grpc_exec_ctx* exec_ctx, mdtab_shard* shard) {
   if (gpr_atm_no_barrier_load(&shard->free_estimate) >
       (gpr_atm)(shard->capacity / 4)) {
     gc_mdtab(exec_ctx, shard);
@@ -237,25 +238,25 @@ static void rehash_mdtab(grpc_exec_ctx *exec_ctx, mdtab_shard *shard) {
 }
 
 grpc_mdelem grpc_mdelem_create(
-    grpc_exec_ctx *exec_ctx, grpc_slice key, grpc_slice value,
-    grpc_mdelem_data *compatible_external_backing_store) {
+    grpc_exec_ctx* exec_ctx, grpc_slice key, grpc_slice value,
+    grpc_mdelem_data* compatible_external_backing_store) {
   if (!grpc_slice_is_interned(key) || !grpc_slice_is_interned(value)) {
-    if (compatible_external_backing_store != NULL) {
+    if (compatible_external_backing_store != nullptr) {
       return GRPC_MAKE_MDELEM(compatible_external_backing_store,
                               GRPC_MDELEM_STORAGE_EXTERNAL);
     }
 
-    allocated_metadata *allocated =
-        (allocated_metadata *)gpr_malloc(sizeof(*allocated));
+    allocated_metadata* allocated =
+        (allocated_metadata*)gpr_malloc(sizeof(*allocated));
     allocated->key = grpc_slice_ref_internal(key);
     allocated->value = grpc_slice_ref_internal(value);
     gpr_atm_rel_store(&allocated->refcnt, 1);
 #ifndef NDEBUG
-    if (GRPC_TRACER_ON(grpc_trace_metadata)) {
-      char *key_str = grpc_slice_to_c_string(allocated->key);
-      char *value_str = grpc_slice_to_c_string(allocated->value);
+    if (grpc_trace_metadata.enabled()) {
+      char* key_str = grpc_slice_to_c_string(allocated->key);
+      char* value_str = grpc_slice_to_c_string(allocated->value);
       gpr_log(GPR_DEBUG, "ELM ALLOC:%p:%" PRIdPTR ": '%s' = '%s'",
-              (void *)allocated, gpr_atm_no_barrier_load(&allocated->refcnt),
+              (void*)allocated, gpr_atm_no_barrier_load(&allocated->refcnt),
               key_str, value_str);
       gpr_free(key_str);
       gpr_free(value_str);
@@ -275,8 +276,8 @@ grpc_mdelem grpc_mdelem_create(
 
   uint32_t hash =
       GRPC_MDSTR_KV_HASH(grpc_slice_hash(key), grpc_slice_hash(value));
-  interned_metadata *md;
-  mdtab_shard *shard = &g_shards[SHARD_IDX(hash)];
+  interned_metadata* md;
+  mdtab_shard* shard = &g_shards[SHARD_IDX(hash)];
   size_t idx;
 
   GPR_TIMER_BEGIN("grpc_mdelem_from_metadata_strings", 0);
@@ -295,7 +296,7 @@ grpc_mdelem grpc_mdelem_create(
   }
 
   /* not found: create a new pair */
-  md = (interned_metadata *)gpr_malloc(sizeof(interned_metadata));
+  md = (interned_metadata*)gpr_malloc(sizeof(interned_metadata));
   gpr_atm_rel_store(&md->refcnt, 1);
   md->key = grpc_slice_ref_internal(key);
   md->value = grpc_slice_ref_internal(value);
@@ -305,10 +306,10 @@ grpc_mdelem grpc_mdelem_create(
   shard->elems[idx] = md;
   gpr_mu_init(&md->mu_user_data);
 #ifndef NDEBUG
-  if (GRPC_TRACER_ON(grpc_trace_metadata)) {
-    char *key_str = grpc_slice_to_c_string(md->key);
-    char *value_str = grpc_slice_to_c_string(md->value);
-    gpr_log(GPR_DEBUG, "ELM   NEW:%p:%" PRIdPTR ": '%s' = '%s'", (void *)md,
+  if (grpc_trace_metadata.enabled()) {
+    char* key_str = grpc_slice_to_c_string(md->key);
+    char* value_str = grpc_slice_to_c_string(md->value);
+    gpr_log(GPR_DEBUG, "ELM   NEW:%p:%" PRIdPTR ": '%s' = '%s'", (void*)md,
             gpr_atm_no_barrier_load(&md->refcnt), key_str, value_str);
     gpr_free(key_str);
     gpr_free(value_str);
@@ -327,23 +328,23 @@ grpc_mdelem grpc_mdelem_create(
   return GRPC_MAKE_MDELEM(md, GRPC_MDELEM_STORAGE_INTERNED);
 }
 
-grpc_mdelem grpc_mdelem_from_slices(grpc_exec_ctx *exec_ctx, grpc_slice key,
+grpc_mdelem grpc_mdelem_from_slices(grpc_exec_ctx* exec_ctx, grpc_slice key,
                                     grpc_slice value) {
-  grpc_mdelem out = grpc_mdelem_create(exec_ctx, key, value, NULL);
+  grpc_mdelem out = grpc_mdelem_create(exec_ctx, key, value, nullptr);
   grpc_slice_unref_internal(exec_ctx, key);
   grpc_slice_unref_internal(exec_ctx, value);
   return out;
 }
 
-grpc_mdelem grpc_mdelem_from_grpc_metadata(grpc_exec_ctx *exec_ctx,
-                                           grpc_metadata *metadata) {
+grpc_mdelem grpc_mdelem_from_grpc_metadata(grpc_exec_ctx* exec_ctx,
+                                           grpc_metadata* metadata) {
   bool changed = false;
   grpc_slice key_slice =
       grpc_slice_maybe_static_intern(metadata->key, &changed);
   grpc_slice value_slice =
       grpc_slice_maybe_static_intern(metadata->value, &changed);
   return grpc_mdelem_create(exec_ctx, key_slice, value_slice,
-                            changed ? NULL : (grpc_mdelem_data *)metadata);
+                            changed ? nullptr : (grpc_mdelem_data*)metadata);
 }
 
 static size_t get_base64_encoded_size(size_t raw_length) {
@@ -351,11 +352,14 @@ static size_t get_base64_encoded_size(size_t raw_length) {
   return raw_length / 3 * 4 + tail_xtra[raw_length % 3];
 }
 
-size_t grpc_mdelem_get_size_in_hpack_table(grpc_mdelem elem) {
+size_t grpc_mdelem_get_size_in_hpack_table(grpc_mdelem elem,
+                                           bool use_true_binary_metadata) {
   size_t overhead_and_key = 32 + GRPC_SLICE_LENGTH(GRPC_MDKEY(elem));
   size_t value_len = GRPC_SLICE_LENGTH(GRPC_MDVALUE(elem));
   if (grpc_is_binary_header(GRPC_MDKEY(elem))) {
-    return overhead_and_key + get_base64_encoded_size(value_len);
+    return overhead_and_key + (use_true_binary_metadata
+                                   ? value_len + 1
+                                   : get_base64_encoded_size(value_len));
   } else {
     return overhead_and_key + value_len;
   }
@@ -367,14 +371,14 @@ grpc_mdelem grpc_mdelem_ref(grpc_mdelem gmd DEBUG_ARGS) {
     case GRPC_MDELEM_STORAGE_STATIC:
       break;
     case GRPC_MDELEM_STORAGE_INTERNED: {
-      interned_metadata *md = (interned_metadata *)GRPC_MDELEM_DATA(gmd);
+      interned_metadata* md = (interned_metadata*)GRPC_MDELEM_DATA(gmd);
 #ifndef NDEBUG
-      if (GRPC_TRACER_ON(grpc_trace_metadata)) {
-        char *key_str = grpc_slice_to_c_string(md->key);
-        char *value_str = grpc_slice_to_c_string(md->value);
+      if (grpc_trace_metadata.enabled()) {
+        char* key_str = grpc_slice_to_c_string(md->key);
+        char* value_str = grpc_slice_to_c_string(md->value);
         gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
                 "ELM   REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'",
-                (void *)md, gpr_atm_no_barrier_load(&md->refcnt),
+                (void*)md, gpr_atm_no_barrier_load(&md->refcnt),
                 gpr_atm_no_barrier_load(&md->refcnt) + 1, key_str, value_str);
         gpr_free(key_str);
         gpr_free(value_str);
@@ -389,14 +393,14 @@ grpc_mdelem grpc_mdelem_ref(grpc_mdelem gmd DEBUG_ARGS) {
       break;
     }
     case GRPC_MDELEM_STORAGE_ALLOCATED: {
-      allocated_metadata *md = (allocated_metadata *)GRPC_MDELEM_DATA(gmd);
+      allocated_metadata* md = (allocated_metadata*)GRPC_MDELEM_DATA(gmd);
 #ifndef NDEBUG
-      if (GRPC_TRACER_ON(grpc_trace_metadata)) {
-        char *key_str = grpc_slice_to_c_string(md->key);
-        char *value_str = grpc_slice_to_c_string(md->value);
+      if (grpc_trace_metadata.enabled()) {
+        char* key_str = grpc_slice_to_c_string(md->key);
+        char* value_str = grpc_slice_to_c_string(md->value);
         gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
                 "ELM   REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'",
-                (void *)md, gpr_atm_no_barrier_load(&md->refcnt),
+                (void*)md, gpr_atm_no_barrier_load(&md->refcnt),
                 gpr_atm_no_barrier_load(&md->refcnt) + 1, key_str, value_str);
         gpr_free(key_str);
         gpr_free(value_str);
@@ -413,20 +417,20 @@ grpc_mdelem grpc_mdelem_ref(grpc_mdelem gmd DEBUG_ARGS) {
   return gmd;
 }
 
-void grpc_mdelem_unref(grpc_exec_ctx *exec_ctx, grpc_mdelem gmd DEBUG_ARGS) {
+void grpc_mdelem_unref(grpc_exec_ctx* exec_ctx, grpc_mdelem gmd DEBUG_ARGS) {
   switch (GRPC_MDELEM_STORAGE(gmd)) {
     case GRPC_MDELEM_STORAGE_EXTERNAL:
     case GRPC_MDELEM_STORAGE_STATIC:
       break;
     case GRPC_MDELEM_STORAGE_INTERNED: {
-      interned_metadata *md = (interned_metadata *)GRPC_MDELEM_DATA(gmd);
+      interned_metadata* md = (interned_metadata*)GRPC_MDELEM_DATA(gmd);
 #ifndef NDEBUG
-      if (GRPC_TRACER_ON(grpc_trace_metadata)) {
-        char *key_str = grpc_slice_to_c_string(md->key);
-        char *value_str = grpc_slice_to_c_string(md->value);
+      if (grpc_trace_metadata.enabled()) {
+        char* key_str = grpc_slice_to_c_string(md->key);
+        char* value_str = grpc_slice_to_c_string(md->value);
         gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
                 "ELM UNREF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'",
-                (void *)md, gpr_atm_no_barrier_load(&md->refcnt),
+                (void*)md, gpr_atm_no_barrier_load(&md->refcnt),
                 gpr_atm_no_barrier_load(&md->refcnt) - 1, key_str, value_str);
         gpr_free(key_str);
         gpr_free(value_str);
@@ -439,20 +443,20 @@ void grpc_mdelem_unref(grpc_exec_ctx *exec_ctx, grpc_mdelem gmd DEBUG_ARGS) {
       if (1 == prev_refcount) {
         /* once the refcount hits zero, some other thread can come along and
            free md at any time: it's unsafe from this point on to access it */
-        mdtab_shard *shard = &g_shards[SHARD_IDX(hash)];
+        mdtab_shard* shard = &g_shards[SHARD_IDX(hash)];
         gpr_atm_no_barrier_fetch_add(&shard->free_estimate, 1);
       }
       break;
     }
     case GRPC_MDELEM_STORAGE_ALLOCATED: {
-      allocated_metadata *md = (allocated_metadata *)GRPC_MDELEM_DATA(gmd);
+      allocated_metadata* md = (allocated_metadata*)GRPC_MDELEM_DATA(gmd);
 #ifndef NDEBUG
-      if (GRPC_TRACER_ON(grpc_trace_metadata)) {
-        char *key_str = grpc_slice_to_c_string(md->key);
-        char *value_str = grpc_slice_to_c_string(md->value);
+      if (grpc_trace_metadata.enabled()) {
+        char* key_str = grpc_slice_to_c_string(md->key);
+        char* value_str = grpc_slice_to_c_string(md->value);
         gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
                 "ELM UNREF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'",
-                (void *)md, gpr_atm_no_barrier_load(&md->refcnt),
+                (void*)md, gpr_atm_no_barrier_load(&md->refcnt),
                 gpr_atm_no_barrier_load(&md->refcnt) - 1, key_str, value_str);
         gpr_free(key_str);
         gpr_free(value_str);
@@ -470,51 +474,51 @@ void grpc_mdelem_unref(grpc_exec_ctx *exec_ctx, grpc_mdelem gmd DEBUG_ARGS) {
   }
 }
 
-void *grpc_mdelem_get_user_data(grpc_mdelem md, void (*destroy_func)(void *)) {
+void* grpc_mdelem_get_user_data(grpc_mdelem md, void (*destroy_func)(void*)) {
   switch (GRPC_MDELEM_STORAGE(md)) {
     case GRPC_MDELEM_STORAGE_EXTERNAL:
     case GRPC_MDELEM_STORAGE_ALLOCATED:
-      return NULL;
+      return nullptr;
     case GRPC_MDELEM_STORAGE_STATIC:
-      return (void *)grpc_static_mdelem_user_data[GRPC_MDELEM_DATA(md) -
-                                                  grpc_static_mdelem_table];
+      return (void*)grpc_static_mdelem_user_data[GRPC_MDELEM_DATA(md) -
+                                                 grpc_static_mdelem_table];
     case GRPC_MDELEM_STORAGE_INTERNED: {
-      interned_metadata *im = (interned_metadata *)GRPC_MDELEM_DATA(md);
-      void *result;
+      interned_metadata* im = (interned_metadata*)GRPC_MDELEM_DATA(md);
+      void* result;
       if (gpr_atm_acq_load(&im->destroy_user_data) == (gpr_atm)destroy_func) {
-        return (void *)gpr_atm_no_barrier_load(&im->user_data);
+        return (void*)gpr_atm_no_barrier_load(&im->user_data);
       } else {
-        return NULL;
+        return nullptr;
       }
       return result;
     }
   }
-  GPR_UNREACHABLE_CODE(return NULL);
+  GPR_UNREACHABLE_CODE(return nullptr);
 }
 
-void *grpc_mdelem_set_user_data(grpc_mdelem md, void (*destroy_func)(void *),
-                                void *user_data) {
+void* grpc_mdelem_set_user_data(grpc_mdelem md, void (*destroy_func)(void*),
+                                void* user_data) {
   switch (GRPC_MDELEM_STORAGE(md)) {
     case GRPC_MDELEM_STORAGE_EXTERNAL:
     case GRPC_MDELEM_STORAGE_ALLOCATED:
       destroy_func(user_data);
-      return NULL;
+      return nullptr;
     case GRPC_MDELEM_STORAGE_STATIC:
       destroy_func(user_data);
-      return (void *)grpc_static_mdelem_user_data[GRPC_MDELEM_DATA(md) -
-                                                  grpc_static_mdelem_table];
+      return (void*)grpc_static_mdelem_user_data[GRPC_MDELEM_DATA(md) -
+                                                 grpc_static_mdelem_table];
     case GRPC_MDELEM_STORAGE_INTERNED: {
-      interned_metadata *im = (interned_metadata *)GRPC_MDELEM_DATA(md);
+      interned_metadata* im = (interned_metadata*)GRPC_MDELEM_DATA(md);
       GPR_ASSERT(!is_mdelem_static(md));
-      GPR_ASSERT((user_data == NULL) == (destroy_func == NULL));
+      GPR_ASSERT((user_data == nullptr) == (destroy_func == nullptr));
       gpr_mu_lock(&im->mu_user_data);
       if (gpr_atm_no_barrier_load(&im->destroy_user_data)) {
         /* user data can only be set once */
         gpr_mu_unlock(&im->mu_user_data);
-        if (destroy_func != NULL) {
+        if (destroy_func != nullptr) {
           destroy_func(user_data);
         }
-        return (void *)gpr_atm_no_barrier_load(&im->user_data);
+        return (void*)gpr_atm_no_barrier_load(&im->user_data);
       }
       gpr_atm_no_barrier_store(&im->user_data, (gpr_atm)user_data);
       gpr_atm_rel_store(&im->destroy_user_data, (gpr_atm)destroy_func);
@@ -522,7 +526,7 @@ void *grpc_mdelem_set_user_data(grpc_mdelem md, void (*destroy_func)(void *),
       return user_data;
     }
   }
-  GPR_UNREACHABLE_CODE(return NULL);
+  GPR_UNREACHABLE_CODE(return nullptr);
 }
 
 bool grpc_mdelem_eq(grpc_mdelem a, grpc_mdelem b) {