s/NULL/nullptr

4 files changed, 22 insertions, 22 deletions

diff --git a/src/core/lib/slice/slice.cc b/src/core/lib/slice/slice.cc
index d8e3200136..bbaf87ba23 100644
--- a/src/core/lib/slice/slice.cc
+++ b/src/core/lib/slice/slice.cc
@@ -35,7 +35,7 @@ char* grpc_slice_to_c_string(grpc_slice slice) {
 
 grpc_slice grpc_empty_slice(void) {
   grpc_slice out;
-  out.refcount = NULL;
+  out.refcount = nullptr;
   out.data.inlined.length = 0;
   return out;
 }
@@ -260,7 +260,7 @@ grpc_slice grpc_slice_malloc(size_t length) {
     return grpc_slice_malloc_large(length);
   } else {
     /* small slice: just inline the data */
-    slice.refcount = NULL;
+    slice.refcount = nullptr;
     slice.data.inlined.length = (uint8_t)length;
   }
   return slice;
@@ -283,7 +283,7 @@ grpc_slice grpc_slice_sub_no_ref(grpc_slice source, size_t begin, size_t end) {
   } else {
     /* Enforce preconditions */
     GPR_ASSERT(source.data.inlined.length >= end);
-    subset.refcount = NULL;
+    subset.refcount = nullptr;
     subset.data.inlined.length = (uint8_t)(end - begin);
     memcpy(subset.data.inlined.bytes, source.data.inlined.bytes + begin,
            end - begin);
@@ -295,7 +295,7 @@ grpc_slice grpc_slice_sub(grpc_slice source, size_t begin, size_t end) {
   grpc_slice subset;
 
   if (end - begin <= sizeof(subset.data.inlined.bytes)) {
-    subset.refcount = NULL;
+    subset.refcount = nullptr;
     subset.data.inlined.length = (uint8_t)(end - begin);
     memcpy(subset.data.inlined.bytes, GRPC_SLICE_START_PTR(source) + begin,
            end - begin);
@@ -311,10 +311,10 @@ grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
                                            grpc_slice_ref_whom ref_whom) {
   grpc_slice tail;
 
-  if (source->refcount == NULL) {
+  if (source->refcount == nullptr) {
     /* inlined data, copy it out */
     GPR_ASSERT(source->data.inlined.length >= split);
-    tail.refcount = NULL;
+    tail.refcount = nullptr;
     tail.data.inlined.length = (uint8_t)(source->data.inlined.length - split);
     memcpy(tail.data.inlined.bytes, source->data.inlined.bytes + split,
            tail.data.inlined.length);
@@ -325,7 +325,7 @@ grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
     if (tail_length < sizeof(tail.data.inlined.bytes) &&
         ref_whom != GRPC_SLICE_REF_TAIL) {
       /* Copy out the bytes - it'll be cheaper than refcounting */
-      tail.refcount = NULL;
+      tail.refcount = nullptr;
       tail.data.inlined.length = (uint8_t)tail_length;
       memcpy(tail.data.inlined.bytes, source->data.refcounted.bytes + split,
              tail_length);
@@ -365,10 +365,10 @@ grpc_slice grpc_slice_split_tail(grpc_slice* source, size_t split) {
 grpc_slice grpc_slice_split_head(grpc_slice* source, size_t split) {
   grpc_slice head;
 
-  if (source->refcount == NULL) {
+  if (source->refcount == nullptr) {
     GPR_ASSERT(source->data.inlined.length >= split);
 
-    head.refcount = NULL;
+    head.refcount = nullptr;
     head.data.inlined.length = (uint8_t)split;
     memcpy(head.data.inlined.bytes, source->data.inlined.bytes, split);
     source->data.inlined.length =
@@ -378,7 +378,7 @@ grpc_slice grpc_slice_split_head(grpc_slice* source, size_t split) {
   } else if (split < sizeof(head.data.inlined.bytes)) {
     GPR_ASSERT(source->data.refcounted.length >= split);
 
-    head.refcount = NULL;
+    head.refcount = nullptr;
     head.data.inlined.length = (uint8_t)split;
     memcpy(head.data.inlined.bytes, source->data.refcounted.bytes, split);
     source->refcount = source->refcount->sub_refcount;
@@ -431,7 +431,7 @@ int grpc_slice_str_cmp(grpc_slice a, const char* b) {
 }
 
 int grpc_slice_is_equivalent(grpc_slice a, grpc_slice b) {
-  if (a.refcount == NULL || b.refcount == NULL) {
+  if (a.refcount == nullptr || b.refcount == nullptr) {
     return grpc_slice_eq(a, b);
   }
   return a.data.refcounted.length == b.data.refcounted.length &&
@@ -454,7 +454,7 @@ int grpc_slice_rchr(grpc_slice s, char c) {
 int grpc_slice_chr(grpc_slice s, char c) {
   const char* b = (const char*)GRPC_SLICE_START_PTR(s);
   const char* p = (const char*)memchr(b, c, GRPC_SLICE_LENGTH(s));
-  return p == NULL ? -1 : (int)(p - b);
+  return p == nullptr ? -1 : (int)(p - b);
 }
 
 int grpc_slice_slice(grpc_slice haystack, grpc_slice needle) {
diff --git a/src/core/lib/slice/slice_buffer.cc b/src/core/lib/slice/slice_buffer.cc
index 3b71fdd4ea..5db54dad91 100644
--- a/src/core/lib/slice/slice_buffer.cc
+++ b/src/core/lib/slice/slice_buffer.cc
@@ -98,7 +98,7 @@ add_new:
   maybe_embiggen(sb);
   back = &sb->slices[sb->count];
   sb->count++;
-  back->refcount = NULL;
+  back->refcount = nullptr;
   back->data.inlined.length = (uint8_t)n;
   return back->data.inlined.bytes;
 }
@@ -137,7 +137,7 @@ void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice s) {
         maybe_embiggen(sb);
         back = &sb->slices[n];
         sb->count = n + 1;
-        back->refcount = NULL;
+        back->refcount = nullptr;
         back->data.inlined.length = (uint8_t)(s.data.inlined.length - cp1);
         memcpy(back->data.inlined.bytes, s.data.inlined.bytes + cp1,
                s.data.inlined.length - cp1);
diff --git a/src/core/lib/slice/slice_hash_table.cc b/src/core/lib/slice/slice_hash_table.cc
index 6c2c9c201c..8f8e5a6b34 100644
--- a/src/core/lib/slice/slice_hash_table.cc
+++ b/src/core/lib/slice/slice_hash_table.cc
@@ -35,12 +35,12 @@ struct grpc_slice_hash_table {
 };
 
 static bool is_empty(grpc_slice_hash_table_entry* entry) {
-  return entry->value == NULL;
+  return entry->value == nullptr;
 }
 
 static void grpc_slice_hash_table_add(grpc_slice_hash_table* table,
                                       grpc_slice key, void* value) {
-  GPR_ASSERT(value != NULL);
+  GPR_ASSERT(value != nullptr);
   const size_t hash = grpc_slice_hash(key);
   for (size_t offset = 0; offset < table->size; ++offset) {
     const size_t idx = (hash + offset) % table->size;
@@ -77,13 +77,13 @@ grpc_slice_hash_table* grpc_slice_hash_table_create(
 }
 
 grpc_slice_hash_table* grpc_slice_hash_table_ref(grpc_slice_hash_table* table) {
-  if (table != NULL) gpr_ref(&table->refs);
+  if (table != nullptr) gpr_ref(&table->refs);
   return table;
 }
 
 void grpc_slice_hash_table_unref(grpc_exec_ctx* exec_ctx,
                                  grpc_slice_hash_table* table) {
-  if (table != NULL && gpr_unref(&table->refs)) {
+  if (table != nullptr && gpr_unref(&table->refs)) {
     for (size_t i = 0; i < table->size; ++i) {
       grpc_slice_hash_table_entry* entry = &table->entries[i];
       if (!is_empty(entry)) {
@@ -108,16 +108,16 @@ void* grpc_slice_hash_table_get(const grpc_slice_hash_table* table,
       return table->entries[idx].value;
     }
   }
-  return NULL;  // Not found.
+  return nullptr;  // Not found.
 }
 
 static int pointer_cmp(void* a, void* b) { return GPR_ICMP(a, b); }
 int grpc_slice_hash_table_cmp(const grpc_slice_hash_table* a,
                               const grpc_slice_hash_table* b) {
   int (*const value_cmp_fn_a)(void* a, void* b) =
-      a->value_cmp != NULL ? a->value_cmp : pointer_cmp;
+      a->value_cmp != nullptr ? a->value_cmp : pointer_cmp;
   int (*const value_cmp_fn_b)(void* a, void* b) =
-      b->value_cmp != NULL ? b->value_cmp : pointer_cmp;
+      b->value_cmp != nullptr ? b->value_cmp : pointer_cmp;
   // Compare value_fns
   const int value_fns_cmp =
       GPR_ICMP((void*)value_cmp_fn_a, (void*)value_cmp_fn_b);
diff --git a/src/core/lib/slice/slice_intern.cc b/src/core/lib/slice/slice_intern.cc
index 50a0eba49c..4ceb712904 100644
--- a/src/core/lib/slice/slice_intern.cc
+++ b/src/core/lib/slice/slice_intern.cc
@@ -171,7 +171,7 @@ int grpc_static_slice_eq(grpc_slice a, grpc_slice b) {
 }
 
 uint32_t grpc_slice_hash(grpc_slice s) {
-  return s.refcount == NULL ? grpc_slice_default_hash_impl(s)
+  return s.refcount == nullptr ? grpc_slice_default_hash_impl(s)
                             : s.refcount->vtable->hash(s);
 }