grpc 1.7.3 → 1.8.0

data/src/core/lib/slice/slice_internal.h

@@ -24,12 +24,19 @@
 
 #include "src/core/lib/iomgr/exec_ctx.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 grpc_slice grpc_slice_ref_internal(grpc_slice slice);
-void grpc_slice_unref_internal(grpc_exec_ctx *exec_ctx, grpc_slice slice);
-void grpc_slice_buffer_reset_and_unref_internal(grpc_exec_ctx *exec_ctx,
-                                                grpc_slice_buffer *sb);
-void grpc_slice_buffer_destroy_internal(grpc_exec_ctx *exec_ctx,
-                                        grpc_slice_buffer *sb);
+void grpc_slice_unref_internal(grpc_exec_ctx* exec_ctx, grpc_slice slice);
+void grpc_slice_buffer_reset_and_unref_internal(grpc_exec_ctx* exec_ctx,
+                                                grpc_slice_buffer* sb);
+void grpc_slice_buffer_partial_unref_internal(grpc_exec_ctx* exec_ctx,
+                                              grpc_slice_buffer* sb,
+                                              size_t idx);
+void grpc_slice_buffer_destroy_internal(grpc_exec_ctx* exec_ctx,
+                                        grpc_slice_buffer* sb);
 
 /* Check if a slice is interned */
 bool grpc_slice_is_interned(grpc_slice slice);
@@ -42,8 +49,12 @@ void grpc_test_only_set_slice_hash_seed(uint32_t key);
 // used for surface boundaries where we might receive an un-interned static
 // string
 grpc_slice grpc_slice_maybe_static_intern(grpc_slice slice,
-                                          bool *returned_slice_is_different);
+                                          bool* returned_slice_is_different);
 uint32_t grpc_static_slice_hash(grpc_slice s);
 int grpc_static_slice_eq(grpc_slice a, grpc_slice b);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_SLICE_SLICE_INTERNAL_H */

data/src/core/lib/slice/{slice_string_helpers.c → slice_string_helpers.cc}

@@ -25,8 +25,8 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/support/string.h"
 
-char *grpc_dump_slice(grpc_slice s, uint32_t flags) {
-  return gpr_dump((const char *)GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s),
+char* grpc_dump_slice(grpc_slice s, uint32_t flags) {
+  return gpr_dump((const char*)GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s),
                   flags);
 }
 
@@ -35,11 +35,11 @@ char *grpc_dump_slice(grpc_slice s, uint32_t flags) {
  * str.
  *
  * Returns 1 and updates \a begin and \a end. Returns 0 otherwise. */
-static int slice_find_separator_offset(const grpc_slice str, const char *sep,
-                                       const size_t read_offset, size_t *begin,
-                                       size_t *end) {
+static int slice_find_separator_offset(const grpc_slice str, const char* sep,
+                                       const size_t read_offset, size_t* begin,
+                                       size_t* end) {
   size_t i;
-  const uint8_t *str_ptr = GRPC_SLICE_START_PTR(str) + read_offset;
+  const uint8_t* str_ptr = GRPC_SLICE_START_PTR(str) + read_offset;
   const size_t str_len = GRPC_SLICE_LENGTH(str) - read_offset;
   const size_t sep_len = strlen(sep);
   if (str_len < sep_len) {
@@ -56,7 +56,7 @@ static int slice_find_separator_offset(const grpc_slice str, const char *sep,
   return 0;
 }
 
-void grpc_slice_split(grpc_slice str, const char *sep, grpc_slice_buffer *dst) {
+void grpc_slice_split(grpc_slice str, const char* sep, grpc_slice_buffer* dst) {
   const size_t sep_len = strlen(sep);
   size_t begin, end;
 
@@ -74,7 +74,7 @@ void grpc_slice_split(grpc_slice str, const char *sep, grpc_slice_buffer *dst) {
   }
 }
 
-bool grpc_parse_slice_to_uint32(grpc_slice str, uint32_t *result) {
-  return gpr_parse_bytes_to_uint32((const char *)GRPC_SLICE_START_PTR(str),
+bool grpc_parse_slice_to_uint32(grpc_slice str, uint32_t* result) {
+  return gpr_parse_bytes_to_uint32((const char*)GRPC_SLICE_START_PTR(str),
                                    GRPC_SLICE_LENGTH(str), result) != 0;
 }

data/src/core/lib/slice/slice_string_helpers.h

@@ -33,13 +33,13 @@ extern "C" {
 #endif
 
 /* Calls gpr_dump on a slice. */
-char *grpc_dump_slice(grpc_slice slice, uint32_t flags);
+char* grpc_dump_slice(grpc_slice slice, uint32_t flags);
 
 /** Split \a str by the separator \a sep. Results are stored in \a dst, which
  * should be a properly initialized instance. */
-void grpc_slice_split(grpc_slice str, const char *sep, grpc_slice_buffer *dst);
+void grpc_slice_split(grpc_slice str, const char* sep, grpc_slice_buffer* dst);
 
-bool grpc_parse_slice_to_uint32(grpc_slice str, uint32_t *result);
+bool grpc_parse_slice_to_uint32(grpc_slice str, uint32_t* result);
 
 #ifdef __cplusplus
 }

data/src/core/lib/support/abstract.h

@@ -0,0 +1,29 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef GRPC_CORE_LIB_SUPPORT_ABSTRACT_H
+#define GRPC_CORE_LIB_SUPPORT_ABSTRACT_H
+
+// This is needed to support abstract base classes in the c core. Since gRPC
+// doesn't have a c++ runtime, it will hit a linker error on delete unless
+// we define a virtual operator delete. See this blog for more info:
+// https://eli.thegreenplace.net/2015/c-deleting-destructors-and-virtual-operator-delete/
+#define GRPC_ABSTRACT_BASE_CLASS \
+  static void operator delete(void* p) { abort(); }
+
+#endif /* GRPC_CORE_LIB_SUPPORT_ABSTRACT_H */

data/src/core/lib/support/{alloc.c → alloc.cc}

@@ -24,10 +24,10 @@
 #include <string.h>
 #include "src/core/lib/profiling/timers.h"
 
-static void *zalloc_with_calloc(size_t sz) { return calloc(sz, 1); }
+static void* zalloc_with_calloc(size_t sz) { return calloc(sz, 1); }
 
-static void *zalloc_with_gpr_malloc(size_t sz) {
-  void *p = gpr_malloc(sz);
+static void* zalloc_with_gpr_malloc(size_t sz) {
+  void* p = gpr_malloc(sz);
   memset(p, 0, sz);
   return p;
 }
@@ -40,18 +40,18 @@ gpr_allocation_functions gpr_get_allocation_functions() {
 }
 
 void gpr_set_allocation_functions(gpr_allocation_functions functions) {
-  GPR_ASSERT(functions.malloc_fn != NULL);
-  GPR_ASSERT(functions.realloc_fn != NULL);
-  GPR_ASSERT(functions.free_fn != NULL);
-  if (functions.zalloc_fn == NULL) {
+  GPR_ASSERT(functions.malloc_fn != nullptr);
+  GPR_ASSERT(functions.realloc_fn != nullptr);
+  GPR_ASSERT(functions.free_fn != nullptr);
+  if (functions.zalloc_fn == nullptr) {
     functions.zalloc_fn = zalloc_with_gpr_malloc;
   }
   g_alloc_functions = functions;
 }
 
-void *gpr_malloc(size_t size) {
-  void *p;
-  if (size == 0) return NULL;
+void* gpr_malloc(size_t size) {
+  void* p;
+  if (size == 0) return nullptr;
   GPR_TIMER_BEGIN("gpr_malloc", 0);
   p = g_alloc_functions.malloc_fn(size);
   if (!p) {
@@ -61,9 +61,9 @@ void *gpr_malloc(size_t size) {
   return p;
 }
 
-void *gpr_zalloc(size_t size) {
-  void *p;
-  if (size == 0) return NULL;
+void* gpr_zalloc(size_t size) {
+  void* p;
+  if (size == 0) return nullptr;
   GPR_TIMER_BEGIN("gpr_zalloc", 0);
   p = g_alloc_functions.zalloc_fn(size);
   if (!p) {
@@ -73,14 +73,14 @@ void *gpr_zalloc(size_t size) {
   return p;
 }
 
-void gpr_free(void *p) {
+void gpr_free(void* p) {
   GPR_TIMER_BEGIN("gpr_free", 0);
   g_alloc_functions.free_fn(p);
   GPR_TIMER_END("gpr_free", 0);
 }
 
-void *gpr_realloc(void *p, size_t size) {
-  if ((size == 0) && (p == NULL)) return NULL;
+void* gpr_realloc(void* p, size_t size) {
+  if ((size == 0) && (p == nullptr)) return nullptr;
   GPR_TIMER_BEGIN("gpr_realloc", 0);
   p = g_alloc_functions.realloc_fn(p, size);
   if (!p) {
@@ -90,13 +90,13 @@ void *gpr_realloc(void *p, size_t size) {
   return p;
 }
 
-void *gpr_malloc_aligned(size_t size, size_t alignment_log) {
+void* gpr_malloc_aligned(size_t size, size_t alignment_log) {
   size_t alignment = ((size_t)1) << alignment_log;
-  size_t extra = alignment - 1 + sizeof(void *);
-  void *p = gpr_malloc(size + extra);
-  void **ret = (void **)(((uintptr_t)p + extra) & ~(alignment - 1));
+  size_t extra = alignment - 1 + sizeof(void*);
+  void* p = gpr_malloc(size + extra);
+  void** ret = (void**)(((uintptr_t)p + extra) & ~(alignment - 1));
   ret[-1] = p;
-  return (void *)ret;
+  return (void*)ret;
 }
 
-void gpr_free_aligned(void *ptr) { gpr_free(((void **)ptr)[-1]); }
+void gpr_free_aligned(void* ptr) { gpr_free(((void**)ptr)[-1]); }

data/src/core/lib/support/{arena.c → arena.cc}

@@ -36,40 +36,40 @@ struct gpr_arena {
   zone initial_zone;
 };
 
-gpr_arena *gpr_arena_create(size_t initial_size) {
+gpr_arena* gpr_arena_create(size_t initial_size) {
   initial_size = ROUND_UP_TO_ALIGNMENT_SIZE(initial_size);
-  gpr_arena *a = (gpr_arena *)gpr_zalloc(sizeof(gpr_arena) + initial_size);
+  gpr_arena* a = (gpr_arena*)gpr_zalloc(sizeof(gpr_arena) + initial_size);
   a->initial_zone.size_end = initial_size;
   return a;
 }
 
-size_t gpr_arena_destroy(gpr_arena *arena) {
+size_t gpr_arena_destroy(gpr_arena* arena) {
   gpr_atm size = gpr_atm_no_barrier_load(&arena->size_so_far);
-  zone *z = (zone *)gpr_atm_no_barrier_load(&arena->initial_zone.next_atm);
+  zone* z = (zone*)gpr_atm_no_barrier_load(&arena->initial_zone.next_atm);
   gpr_free(arena);
   while (z) {
-    zone *next_z = (zone *)gpr_atm_no_barrier_load(&z->next_atm);
+    zone* next_z = (zone*)gpr_atm_no_barrier_load(&z->next_atm);
     gpr_free(z);
     z = next_z;
   }
   return (size_t)size;
 }
 
-void *gpr_arena_alloc(gpr_arena *arena, size_t size) {
+void* gpr_arena_alloc(gpr_arena* arena, size_t size) {
   size = ROUND_UP_TO_ALIGNMENT_SIZE(size);
   size_t start =
       (size_t)gpr_atm_no_barrier_fetch_add(&arena->size_so_far, size);
-  zone *z = &arena->initial_zone;
+  zone* z = &arena->initial_zone;
   while (start > z->size_end) {
-    zone *next_z = (zone *)gpr_atm_acq_load(&z->next_atm);
-    if (next_z == NULL) {
+    zone* next_z = (zone*)gpr_atm_acq_load(&z->next_atm);
+    if (next_z == nullptr) {
       size_t next_z_size = (size_t)gpr_atm_no_barrier_load(&arena->size_so_far);
-      next_z = (zone *)gpr_zalloc(sizeof(zone) + next_z_size);
+      next_z = (zone*)gpr_zalloc(sizeof(zone) + next_z_size);
       next_z->size_begin = z->size_end;
       next_z->size_end = z->size_end + next_z_size;
       if (!gpr_atm_rel_cas(&z->next_atm, (gpr_atm)NULL, (gpr_atm)next_z)) {
         gpr_free(next_z);
-        next_z = (zone *)gpr_atm_acq_load(&z->next_atm);
+        next_z = (zone*)gpr_atm_acq_load(&z->next_atm);
       }
     }
     z = next_z;
@@ -79,5 +79,5 @@ void *gpr_arena_alloc(gpr_arena *arena, size_t size) {
   }
   GPR_ASSERT(start >= z->size_begin);
   GPR_ASSERT(start + size <= z->size_end);
-  return ((char *)(z + 1)) + start - z->size_begin;
+  return ((char*)(z + 1)) + start - z->size_begin;
 }

data/src/core/lib/support/arena.h

@@ -27,13 +27,21 @@
 
 #include <stddef.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct gpr_arena gpr_arena;
 
 // Create an arena, with \a initial_size bytes in the first allocated buffer
-gpr_arena *gpr_arena_create(size_t initial_size);
+gpr_arena* gpr_arena_create(size_t initial_size);
 // Allocate \a size bytes from the arena
-void *gpr_arena_alloc(gpr_arena *arena, size_t size);
+void* gpr_arena_alloc(gpr_arena* arena, size_t size);
 // Destroy an arena, returning the total number of bytes allocated
-size_t gpr_arena_destroy(gpr_arena *arena);
+size_t gpr_arena_destroy(gpr_arena* arena);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_SUPPORT_ARENA_H */

data/src/core/lib/support/{atm.c → atm.cc}

@@ -19,7 +19,7 @@
 #include <grpc/support/atm.h>
 #include <grpc/support/useful.h>
 
-gpr_atm gpr_atm_no_barrier_clamped_add(gpr_atm *value, gpr_atm delta,
+gpr_atm gpr_atm_no_barrier_clamped_add(gpr_atm* value, gpr_atm delta,
                                        gpr_atm min, gpr_atm max) {
   gpr_atm current_value;
   gpr_atm new_value;

data/src/core/lib/support/{avl.c → avl.cc}

@@ -25,23 +25,23 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/useful.h>
 
-gpr_avl gpr_avl_create(const gpr_avl_vtable *vtable) {
+gpr_avl gpr_avl_create(const gpr_avl_vtable* vtable) {
   gpr_avl out;
   out.vtable = vtable;
-  out.root = NULL;
+  out.root = nullptr;
   return out;
 }
 
-static gpr_avl_node *ref_node(gpr_avl_node *node) {
+static gpr_avl_node* ref_node(gpr_avl_node* node) {
   if (node) {
     gpr_ref(&node->refs);
   }
   return node;
 }
 
-static void unref_node(const gpr_avl_vtable *vtable, gpr_avl_node *node,
-                       void *user_data) {
-  if (node == NULL) {
+static void unref_node(const gpr_avl_vtable* vtable, gpr_avl_node* node,
+                       void* user_data) {
+  if (node == nullptr) {
     return;
   }
   if (gpr_unref(&node->refs)) {
@@ -53,18 +53,19 @@ static void unref_node(const gpr_avl_vtable *vtable, gpr_avl_node *node,
   }
 }
 
-static long node_height(gpr_avl_node *node) {
-  return node == NULL ? 0 : node->height;
+static long node_height(gpr_avl_node* node) {
+  return node == nullptr ? 0 : node->height;
 }
 
 #ifndef NDEBUG
-static long calculate_height(gpr_avl_node *node) {
-  return node == NULL ? 0 : 1 + GPR_MAX(calculate_height(node->left),
-                                        calculate_height(node->right));
+static long calculate_height(gpr_avl_node* node) {
+  return node == nullptr ? 0
+                         : 1 + GPR_MAX(calculate_height(node->left),
+                                       calculate_height(node->right));
 }
 
-static gpr_avl_node *assert_invariants(gpr_avl_node *n) {
-  if (n == NULL) return NULL;
+static gpr_avl_node* assert_invariants(gpr_avl_node* n) {
+  if (n == nullptr) return nullptr;
   assert_invariants(n->left);
   assert_invariants(n->right);
   assert(calculate_height(n) == n->height);
@@ -72,12 +73,12 @@ static gpr_avl_node *assert_invariants(gpr_avl_node *n) {
   return n;
 }
 #else
-static gpr_avl_node *assert_invariants(gpr_avl_node *n) { return n; }
+static gpr_avl_node* assert_invariants(gpr_avl_node* n) { return n; }
 #endif
 
-gpr_avl_node *new_node(void *key, void *value, gpr_avl_node *left,
-                       gpr_avl_node *right) {
-  gpr_avl_node *node = (gpr_avl_node *)gpr_malloc(sizeof(*node));
+gpr_avl_node* new_node(void* key, void* value, gpr_avl_node* left,
+                       gpr_avl_node* right) {
+  gpr_avl_node* node = (gpr_avl_node*)gpr_malloc(sizeof(*node));
   gpr_ref_init(&node->refs, 1);
   node->key = key;
   node->value = value;
@@ -87,12 +88,12 @@ gpr_avl_node *new_node(void *key, void *value, gpr_avl_node *left,
   return node;
 }
 
-static gpr_avl_node *get(const gpr_avl_vtable *vtable, gpr_avl_node *node,
-                         void *key, void *user_data) {
+static gpr_avl_node* get(const gpr_avl_vtable* vtable, gpr_avl_node* node,
+                         void* key, void* user_data) {
   long cmp;
 
-  if (node == NULL) {
-    return NULL;
+  if (node == nullptr) {
+    return nullptr;
   }
 
   cmp = vtable->compare_keys(node->key, key, user_data);
@@ -105,24 +106,24 @@ static gpr_avl_node *get(const gpr_avl_vtable *vtable, gpr_avl_node *node,
   }
 }
 
-void *gpr_avl_get(gpr_avl avl, void *key, void *user_data) {
-  gpr_avl_node *node = get(avl.vtable, avl.root, key, user_data);
-  return node ? node->value : NULL;
+void* gpr_avl_get(gpr_avl avl, void* key, void* user_data) {
+  gpr_avl_node* node = get(avl.vtable, avl.root, key, user_data);
+  return node ? node->value : nullptr;
 }
 
-int gpr_avl_maybe_get(gpr_avl avl, void *key, void **value, void *user_data) {
-  gpr_avl_node *node = get(avl.vtable, avl.root, key, user_data);
-  if (node != NULL) {
+int gpr_avl_maybe_get(gpr_avl avl, void* key, void** value, void* user_data) {
+  gpr_avl_node* node = get(avl.vtable, avl.root, key, user_data);
+  if (node != nullptr) {
     *value = node->value;
     return 1;
   }
   return 0;
 }
 
-static gpr_avl_node *rotate_left(const gpr_avl_vtable *vtable, void *key,
-                                 void *value, gpr_avl_node *left,
-                                 gpr_avl_node *right, void *user_data) {
-  gpr_avl_node *n = new_node(vtable->copy_key(right->key, user_data),
+static gpr_avl_node* rotate_left(const gpr_avl_vtable* vtable, void* key,
+                                 void* value, gpr_avl_node* left,
+                                 gpr_avl_node* right, void* user_data) {
+  gpr_avl_node* n = new_node(vtable->copy_key(right->key, user_data),
                              vtable->copy_value(right->value, user_data),
                              new_node(key, value, left, ref_node(right->left)),
                              ref_node(right->right));
@@ -130,10 +131,10 @@ static gpr_avl_node *rotate_left(const gpr_avl_vtable *vtable, void *key,
   return n;
 }
 
-static gpr_avl_node *rotate_right(const gpr_avl_vtable *vtable, void *key,
-                                  void *value, gpr_avl_node *left,
-                                  gpr_avl_node *right, void *user_data) {
-  gpr_avl_node *n =
+static gpr_avl_node* rotate_right(const gpr_avl_vtable* vtable, void* key,
+                                  void* value, gpr_avl_node* left,
+                                  gpr_avl_node* right, void* user_data) {
+  gpr_avl_node* n =
       new_node(vtable->copy_key(left->key, user_data),
                vtable->copy_value(left->value, user_data), ref_node(left->left),
                new_node(key, value, ref_node(left->right), right));
@@ -141,11 +142,11 @@ static gpr_avl_node *rotate_right(const gpr_avl_vtable *vtable, void *key,
   return n;
 }
 
-static gpr_avl_node *rotate_left_right(const gpr_avl_vtable *vtable, void *key,
-                                       void *value, gpr_avl_node *left,
-                                       gpr_avl_node *right, void *user_data) {
+static gpr_avl_node* rotate_left_right(const gpr_avl_vtable* vtable, void* key,
+                                       void* value, gpr_avl_node* left,
+                                       gpr_avl_node* right, void* user_data) {
   /* rotate_right(..., rotate_left(left), right) */
-  gpr_avl_node *n =
+  gpr_avl_node* n =
       new_node(vtable->copy_key(left->right->key, user_data),
                vtable->copy_value(left->right->value, user_data),
                new_node(vtable->copy_key(left->key, user_data),
@@ -156,11 +157,11 @@ static gpr_avl_node *rotate_left_right(const gpr_avl_vtable *vtable, void *key,
   return n;
 }
 
-static gpr_avl_node *rotate_right_left(const gpr_avl_vtable *vtable, void *key,
-                                       void *value, gpr_avl_node *left,
-                                       gpr_avl_node *right, void *user_data) {
+static gpr_avl_node* rotate_right_left(const gpr_avl_vtable* vtable, void* key,
+                                       void* value, gpr_avl_node* left,
+                                       gpr_avl_node* right, void* user_data) {
   /* rotate_left(..., left, rotate_right(right)) */
-  gpr_avl_node *n =
+  gpr_avl_node* n =
       new_node(vtable->copy_key(right->left->key, user_data),
                vtable->copy_value(right->left->value, user_data),
                new_node(key, value, left, ref_node(right->left->left)),
@@ -171,9 +172,9 @@ static gpr_avl_node *rotate_right_left(const gpr_avl_vtable *vtable, void *key,
   return n;
 }
 
-static gpr_avl_node *rebalance(const gpr_avl_vtable *vtable, void *key,
-                               void *value, gpr_avl_node *left,
-                               gpr_avl_node *right, void *user_data) {
+static gpr_avl_node* rebalance(const gpr_avl_vtable* vtable, void* key,
+                               void* value, gpr_avl_node* left,
+                               gpr_avl_node* right, void* user_data) {
   switch (node_height(left) - node_height(right)) {
     case 2:
       if (node_height(left->left) - node_height(left->right) == -1) {
@@ -196,11 +197,11 @@ static gpr_avl_node *rebalance(const gpr_avl_vtable *vtable, void *key,
   }
 }
 
-static gpr_avl_node *add_key(const gpr_avl_vtable *vtable, gpr_avl_node *node,
-                             void *key, void *value, void *user_data) {
+static gpr_avl_node* add_key(const gpr_avl_vtable* vtable, gpr_avl_node* node,
+                             void* key, void* value, void* user_data) {
   long cmp;
-  if (node == NULL) {
-    return new_node(key, value, NULL, NULL);
+  if (node == nullptr) {
+    return new_node(key, value, nullptr, nullptr);
   }
   cmp = vtable->compare_keys(node->key, key, user_data);
   if (cmp == 0) {
@@ -218,49 +219,49 @@ static gpr_avl_node *add_key(const gpr_avl_vtable *vtable, gpr_avl_node *node,
   }
 }
 
-gpr_avl gpr_avl_add(gpr_avl avl, void *key, void *value, void *user_data) {
-  gpr_avl_node *old_root = avl.root;
+gpr_avl gpr_avl_add(gpr_avl avl, void* key, void* value, void* user_data) {
+  gpr_avl_node* old_root = avl.root;
   avl.root = add_key(avl.vtable, avl.root, key, value, user_data);
   assert_invariants(avl.root);
   unref_node(avl.vtable, old_root, user_data);
   return avl;
 }
 
-static gpr_avl_node *in_order_head(gpr_avl_node *node) {
-  while (node->left != NULL) {
+static gpr_avl_node* in_order_head(gpr_avl_node* node) {
+  while (node->left != nullptr) {
     node = node->left;
   }
   return node;
 }
 
-static gpr_avl_node *in_order_tail(gpr_avl_node *node) {
-  while (node->right != NULL) {
+static gpr_avl_node* in_order_tail(gpr_avl_node* node) {
+  while (node->right != nullptr) {
     node = node->right;
   }
   return node;
 }
 
-static gpr_avl_node *remove_key(const gpr_avl_vtable *vtable,
-                                gpr_avl_node *node, void *key,
-                                void *user_data) {
+static gpr_avl_node* remove_key(const gpr_avl_vtable* vtable,
+                                gpr_avl_node* node, void* key,
+                                void* user_data) {
   long cmp;
-  if (node == NULL) {
-    return NULL;
+  if (node == nullptr) {
+    return nullptr;
   }
   cmp = vtable->compare_keys(node->key, key, user_data);
   if (cmp == 0) {
-    if (node->left == NULL) {
+    if (node->left == nullptr) {
       return ref_node(node->right);
-    } else if (node->right == NULL) {
+    } else if (node->right == nullptr) {
       return ref_node(node->left);
     } else if (node->left->height < node->right->height) {
-      gpr_avl_node *h = in_order_head(node->right);
+      gpr_avl_node* h = in_order_head(node->right);
       return rebalance(
           vtable, vtable->copy_key(h->key, user_data),
           vtable->copy_value(h->value, user_data), ref_node(node->left),
           remove_key(vtable, node->right, h->key, user_data), user_data);
     } else {
-      gpr_avl_node *h = in_order_tail(node->left);
+      gpr_avl_node* h = in_order_tail(node->left);
       return rebalance(vtable, vtable->copy_key(h->key, user_data),
                        vtable->copy_value(h->value, user_data),
                        remove_key(vtable, node->left, h->key, user_data),
@@ -279,21 +280,21 @@ static gpr_avl_node *remove_key(const gpr_avl_vtable *vtable,
   }
 }
 
-gpr_avl gpr_avl_remove(gpr_avl avl, void *key, void *user_data) {
-  gpr_avl_node *old_root = avl.root;
+gpr_avl gpr_avl_remove(gpr_avl avl, void* key, void* user_data) {
+  gpr_avl_node* old_root = avl.root;
   avl.root = remove_key(avl.vtable, avl.root, key, user_data);
   assert_invariants(avl.root);
   unref_node(avl.vtable, old_root, user_data);
   return avl;
 }
 
-gpr_avl gpr_avl_ref(gpr_avl avl, void *user_data) {
+gpr_avl gpr_avl_ref(gpr_avl avl, void* user_data) {
   ref_node(avl.root);
   return avl;
 }
 
-void gpr_avl_unref(gpr_avl avl, void *user_data) {
+void gpr_avl_unref(gpr_avl avl, void* user_data) {
   unref_node(avl.vtable, avl.root, user_data);
 }
 
-int gpr_avl_is_empty(gpr_avl avl) { return avl.root == NULL; }
+int gpr_avl_is_empty(gpr_avl avl) { return avl.root == nullptr; }