grpc 1.42.0 → 1.46.3

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

@@ -0,0 +1,384 @@
+// Copyright 2021 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_SLICE_SLICE_H
+#define GRPC_CORE_LIB_SLICE_SLICE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <cstdint>
+
+#include "absl/strings/string_view.h"
+
+#include <grpc/slice.h>
+
+#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_refcount.h"
+#include "src/core/lib/slice/slice_refcount_base.h"
+
+// Herein lies grpc_core::Slice and its team of thin wrappers around grpc_slice.
+// They aim to keep you safe by providing strong guarantees around lifetime and
+// mutability.
+//
+// The team:
+//   Slice        - provides a wrapper around an unknown type of slice.
+//                  Immutable (since we don't know who else might be referencing
+//                  it), and potentially ref counted.
+//   StaticSlice  - provides a wrapper around a static slice. Not refcounted,
+//                  fast to copy.
+//   MutableSlice - provides a guarantee of unique ownership, meaning the
+//                  underlying data can be mutated safely.
+
+namespace grpc_core {
+
+// Forward declarations
+class Slice;
+class StaticSlice;
+class MutableSlice;
+
+namespace slice_detail {
+
+// Returns an empty slice.
+static constexpr grpc_slice EmptySlice() { return {nullptr, {}}; }
+
+// BaseSlice holds the grpc_slice object, but does not apply refcounting policy.
+// It does export immutable access into the slice, such that this can be shared
+// by all storage policies.
+class BaseSlice {
+ public:
+  BaseSlice(const BaseSlice&) = delete;
+  BaseSlice& operator=(const BaseSlice&) = delete;
+  BaseSlice(BaseSlice&& other) = delete;
+  BaseSlice& operator=(BaseSlice&& other) = delete;
+
+  // Iterator access to the underlying bytes
+  const uint8_t* begin() const { return GRPC_SLICE_START_PTR(c_slice()); }
+  const uint8_t* end() const { return GRPC_SLICE_END_PTR(c_slice()); }
+  const uint8_t* cbegin() const { return GRPC_SLICE_START_PTR(c_slice()); }
+  const uint8_t* cend() const { return GRPC_SLICE_END_PTR(c_slice()); }
+
+  // Retrieve a borrowed reference to the underlying grpc_slice.
+  const grpc_slice& c_slice() const { return slice_; }
+
+  // Retrieve the underlying grpc_slice, and replace the one in this object with
+  // EmptySlice().
+  grpc_slice TakeCSlice() {
+    grpc_slice out = slice_;
+    slice_ = EmptySlice();
+    return out;
+  }
+
+  // As other things... borrowed references.
+  absl::string_view as_string_view() const {
+    return absl::string_view(reinterpret_cast<const char*>(data()), size());
+  }
+
+  // Array access
+  uint8_t operator[](size_t i) const {
+    return GRPC_SLICE_START_PTR(c_slice())[i];
+  }
+
+  // Access underlying data
+  const uint8_t* data() const { return GRPC_SLICE_START_PTR(c_slice()); }
+
+  // Size of the slice
+  size_t size() const { return GRPC_SLICE_LENGTH(c_slice()); }
+  size_t length() const { return size(); }
+  bool empty() const { return size() == 0; }
+
+  // For inlined slices - are these two slices equal?
+  // For non-inlined slices - do these two slices refer to the same block of
+  // memory?
+  bool is_equivalent(const BaseSlice& other) const {
+    return grpc_slice_is_equivalent(slice_, other.slice_);
+  }
+
+  uint32_t Hash() const { return grpc_slice_hash_internal(slice_); }
+
+ protected:
+  BaseSlice() : slice_(EmptySlice()) {}
+  explicit BaseSlice(const grpc_slice& slice) : slice_(slice) {}
+  ~BaseSlice() = default;
+
+  void Swap(BaseSlice* other) { std::swap(slice_, other->slice_); }
+  void SetCSlice(const grpc_slice& slice) { slice_ = slice; }
+
+  uint8_t* mutable_data() { return GRPC_SLICE_START_PTR(slice_); }
+
+  grpc_slice* c_slice_ptr() { return &slice_; }
+
+ private:
+  grpc_slice slice_;
+};
+
+inline bool operator==(const BaseSlice& a, const BaseSlice& b) {
+  return grpc_slice_eq(a.c_slice(), b.c_slice()) != 0;
+}
+
+inline bool operator!=(const BaseSlice& a, const BaseSlice& b) {
+  return grpc_slice_eq(a.c_slice(), b.c_slice()) == 0;
+}
+
+inline bool operator==(const BaseSlice& a, absl::string_view b) {
+  return a.as_string_view() == b;
+}
+
+inline bool operator!=(const BaseSlice& a, absl::string_view b) {
+  return a.as_string_view() != b;
+}
+
+inline bool operator==(absl::string_view a, const BaseSlice& b) {
+  return a == b.as_string_view();
+}
+
+inline bool operator!=(absl::string_view a, const BaseSlice& b) {
+  return a != b.as_string_view();
+}
+
+inline bool operator==(const BaseSlice& a, const grpc_slice& b) {
+  return grpc_slice_eq(a.c_slice(), b) != 0;
+}
+
+inline bool operator!=(const BaseSlice& a, const grpc_slice& b) {
+  return grpc_slice_eq(a.c_slice(), b) == 0;
+}
+
+inline bool operator==(const grpc_slice& a, const BaseSlice& b) {
+  return grpc_slice_eq(a, b.c_slice()) != 0;
+}
+
+inline bool operator!=(const grpc_slice& a, const BaseSlice& b) {
+  return grpc_slice_eq(a, b.c_slice()) == 0;
+}
+
+template <typename Out>
+struct CopyConstructors {
+  static Out FromCopiedString(const char* s) {
+    return FromCopiedBuffer(s, strlen(s));
+  }
+  static Out FromCopiedString(absl::string_view s) {
+    return FromCopiedBuffer(s.data(), s.size());
+  }
+  static Out FromCopiedString(std::string s) {
+    return Out(grpc_slice_from_cpp_string(std::move(s)));
+  }
+  static Out FromCopiedBuffer(const char* p, size_t len) {
+    return Out(grpc_slice_from_copied_buffer(p, len));
+  }
+
+  template <typename Buffer>
+  static Out FromCopiedBuffer(const Buffer& buffer) {
+    return FromCopiedBuffer(reinterpret_cast<const char*>(buffer.data()),
+                            buffer.size());
+  }
+
+  static Out FromInt64(int64_t i) {
+    char buffer[GPR_LTOA_MIN_BUFSIZE];
+    gpr_ltoa(i, buffer);
+    return FromCopiedString(buffer);
+  }
+};
+
+template <typename Out>
+struct StaticConstructors {
+  static Out FromStaticString(const char* s) {
+    return FromStaticBuffer(s, strlen(s));
+  }
+
+  static Out FromStaticString(absl::string_view s) {
+    return FromStaticBuffer(s.data(), s.size());
+  }
+
+  static Out FromStaticBuffer(const void* s, size_t len) {
+    grpc_slice slice;
+    slice.refcount = grpc_slice_refcount::NoopRefcount();
+    slice.data.refcounted.bytes =
+        const_cast<uint8_t*>(static_cast<const uint8_t*>(s));
+    slice.data.refcounted.length = len;
+    return Out(slice);
+  }
+};
+
+}  // namespace slice_detail
+
+class StaticSlice : public slice_detail::BaseSlice,
+                    public slice_detail::StaticConstructors<StaticSlice> {
+ public:
+  StaticSlice() = default;
+  explicit StaticSlice(const grpc_slice& slice)
+      : slice_detail::BaseSlice(slice) {
+    GPR_DEBUG_ASSERT(slice.refcount == grpc_slice_refcount::NoopRefcount());
+  }
+
+  StaticSlice(const StaticSlice& other)
+      : slice_detail::BaseSlice(other.c_slice()) {}
+  StaticSlice& operator=(const StaticSlice& other) {
+    SetCSlice(other.c_slice());
+    return *this;
+  }
+  StaticSlice(StaticSlice&& other) noexcept
+      : slice_detail::BaseSlice(other.TakeCSlice()) {}
+  StaticSlice& operator=(StaticSlice&& other) noexcept {
+    Swap(&other);
+    return *this;
+  }
+};
+
+class MutableSlice : public slice_detail::BaseSlice,
+                     public slice_detail::CopyConstructors<MutableSlice> {
+ public:
+  MutableSlice() = default;
+  explicit MutableSlice(const grpc_slice& slice)
+      : slice_detail::BaseSlice(slice) {
+    GPR_DEBUG_ASSERT(slice.refcount == nullptr || slice.refcount->IsUnique());
+  }
+  ~MutableSlice() { grpc_slice_unref_internal(c_slice()); }
+
+  MutableSlice(const MutableSlice&) = delete;
+  MutableSlice& operator=(const MutableSlice&) = delete;
+  MutableSlice(MutableSlice&& other) noexcept
+      : slice_detail::BaseSlice(other.TakeCSlice()) {}
+  MutableSlice& operator=(MutableSlice&& other) noexcept {
+    Swap(&other);
+    return *this;
+  }
+
+  static MutableSlice CreateUninitialized(size_t length) {
+    return MutableSlice(grpc_slice_malloc(length));
+  }
+
+  // Return a sub slice of this one. Leaves this slice in an indeterminate but
+  // valid state.
+  MutableSlice TakeSubSlice(size_t pos, size_t n) {
+    return MutableSlice(grpc_slice_sub_no_ref(TakeCSlice(), pos, pos + n));
+  }
+
+  // Iterator access to the underlying bytes
+  uint8_t* begin() { return mutable_data(); }
+  uint8_t* end() { return mutable_data() + size(); }
+  uint8_t* data() { return mutable_data(); }
+
+  // Array access
+  uint8_t& operator[](size_t i) { return mutable_data()[i]; }
+};
+
+class Slice : public slice_detail::BaseSlice,
+              public slice_detail::CopyConstructors<Slice>,
+              public slice_detail::StaticConstructors<Slice> {
+ public:
+  Slice() = default;
+  ~Slice() { grpc_slice_unref_internal(c_slice()); }
+  explicit Slice(const grpc_slice& slice) : slice_detail::BaseSlice(slice) {}
+  explicit Slice(slice_detail::BaseSlice&& other)
+      : slice_detail::BaseSlice(other.TakeCSlice()) {}
+
+  Slice(const Slice&) = delete;
+  Slice& operator=(const Slice&) = delete;
+  Slice(Slice&& other) noexcept : slice_detail::BaseSlice(other.TakeCSlice()) {}
+  Slice& operator=(Slice&& other) noexcept {
+    Swap(&other);
+    return *this;
+  }
+
+  // A slice might refer to some memory that we keep a refcount to (this is
+  // owned), or some memory that's inlined into the slice (also owned), or some
+  // other block of memory that we know will be available for the lifetime of
+  // some operation in the common case (not owned). In the *less common* case
+  // that we need to keep that slice text for longer than our API's guarantee us
+  // access, we need to take a copy and turn this into something that we do own.
+
+  // TakeOwned returns an owned slice regardless of current ownership, and
+  // leaves the current slice in a valid but externally unpredictable state - in
+  // doing so it can avoid adding a ref to the underlying slice.
+  Slice TakeOwned() {
+    if (c_slice().refcount == nullptr) {
+      return Slice(c_slice());
+    }
+    if (c_slice().refcount == grpc_slice_refcount::NoopRefcount()) {
+      return Slice(grpc_slice_copy(c_slice()));
+    }
+    return Slice(TakeCSlice());
+  }
+
+  // AsOwned returns an owned slice but does not mutate the current slice,
+  // meaning that it may add a reference to the underlying slice.
+  Slice AsOwned() const {
+    if (c_slice().refcount == nullptr) {
+      return Slice(c_slice());
+    }
+    if (c_slice().refcount == grpc_slice_refcount::NoopRefcount()) {
+      return Slice(grpc_slice_copy(c_slice()));
+    }
+    return Slice(grpc_slice_ref_internal(c_slice()));
+  }
+
+  // TakeMutable returns a MutableSlice, and leaves the current slice in an
+  // indeterminate but valid state.
+  // A mutable slice requires only one reference to the bytes of the slice -
+  // this can be achieved either with inlined storage or with a single
+  // reference.
+  // If the current slice is refcounted and there are more than one references
+  // to that slice, then the slice is copied in order to achieve a mutable
+  // version.
+  MutableSlice TakeMutable() {
+    if (c_slice().refcount == nullptr) {
+      return MutableSlice(c_slice());
+    }
+    if (c_slice().refcount != grpc_slice_refcount::NoopRefcount() &&
+        c_slice().refcount->IsUnique()) {
+      return MutableSlice(TakeCSlice());
+    }
+    return MutableSlice(grpc_slice_copy(c_slice()));
+  }
+
+  // Return a sub slice of this one. Leaves this slice in an indeterminate but
+  // valid state.
+  Slice TakeSubSlice(size_t pos, size_t n) {
+    return Slice(grpc_slice_sub_no_ref(TakeCSlice(), pos, pos + n));
+  }
+
+  // Return a sub slice of this one. Adds a reference to the underlying slice.
+  Slice RefSubSlice(size_t pos, size_t n) const {
+    return Slice(grpc_slice_sub(c_slice(), pos, pos + n));
+  }
+
+  // Split this slice, returning a new slice containing (split:end] and
+  // leaving this slice with [begin:split).
+  Slice Split(size_t split) {
+    return Slice(grpc_slice_split_tail(c_slice_ptr(), split));
+  }
+
+  Slice Ref() const { return Slice(grpc_slice_ref_internal(c_slice())); }
+
+  Slice Copy() const { return Slice(grpc_slice_copy(c_slice())); }
+
+  static Slice FromRefcountAndBytes(grpc_slice_refcount* r,
+                                    const uint8_t* begin, const uint8_t* end) {
+    grpc_slice out;
+    out.refcount = r;
+    if (r != grpc_slice_refcount::NoopRefcount()) r->Ref();
+    out.data.refcounted.bytes = const_cast<uint8_t*>(begin);
+    out.data.refcounted.length = end - begin;
+    return Slice(out);
+  }
+
+  static Slice FromExternalString(absl::string_view str) {
+    return FromStaticString(str);
+  }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_SLICE_SLICE_H

data/src/core/lib/slice/slice_buffer.cc

@@ -84,6 +84,10 @@ void grpc_slice_buffer_destroy_internal(grpc_slice_buffer* sb) {
   grpc_slice_buffer_reset_and_unref_internal(sb);
   if (sb->base_slices != sb->inlined) {
     gpr_free(sb->base_slices);
+    // As a precaution, set sb->base_slices to equal sb->inlined
+    // to prevent a double free attempt if grpc_slice_buffer_destroy_internal
+    // is invoked two times on the same slice buffer.
+    sb->base_slices = sb->slices = sb->inlined;
   }
 }
 

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

@@ -23,6 +23,8 @@
 
 #include <string.h>
 
+#include "absl/strings/string_view.h"
+
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/log.h>
@@ -31,7 +33,6 @@
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/slice/slice_refcount.h"
-#include "src/core/lib/slice/slice_utils.h"
 
 void grpc_slice_buffer_reset_and_unref_internal(grpc_slice_buffer* sb);
 void grpc_slice_buffer_partial_unref_internal(grpc_slice_buffer* sb,
@@ -52,22 +53,6 @@ void grpc_slice_buffer_remove_first(grpc_slice_buffer* sb);
 void grpc_slice_buffer_sub_first(grpc_slice_buffer* sb, size_t begin,
                                  size_t end);
 
-/* Check if a slice is interned */
-bool grpc_slice_is_interned(const grpc_slice& slice);
-inline bool grpc_slice_is_interned(const grpc_slice& slice) {
-  return (slice.refcount &&
-          (slice.refcount->GetType() == grpc_slice_refcount::Type::INTERNED ||
-           slice.refcount->GetType() == grpc_slice_refcount::Type::STATIC));
-}
-
-inline bool grpc_slice_static_interned_equal(const grpc_slice& a,
-                                             const grpc_slice& b) {
-  GPR_DEBUG_ASSERT(grpc_slice_is_interned(a) && grpc_slice_is_interned(b));
-  return a.refcount == b.refcount;
-}
-
-void grpc_slice_intern_init(void);
-void grpc_slice_intern_shutdown(void);
 void grpc_test_only_set_slice_hash_seed(uint32_t seed);
 // if slice matches a static slice, returns the static slice
 // otherwise returns the passed in slice (without reffing it)
@@ -78,21 +63,11 @@ grpc_slice grpc_slice_maybe_static_intern(grpc_slice slice,
 uint32_t grpc_static_slice_hash(grpc_slice s);
 int grpc_static_slice_eq(grpc_slice a, grpc_slice b);
 
-inline uint32_t grpc_slice_hash_refcounted(const grpc_slice& s) {
-  GPR_DEBUG_ASSERT(s.refcount != nullptr);
-  return s.refcount->Hash(s);
-}
-
-inline uint32_t grpc_slice_default_hash_internal(const grpc_slice& s) {
+inline uint32_t grpc_slice_hash_internal(const grpc_slice& s) {
   return gpr_murmur_hash3(GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s),
                           grpc_core::g_hash_seed);
 }
 
-inline uint32_t grpc_slice_hash_internal(const grpc_slice& s) {
-  return s.refcount == nullptr ? grpc_slice_default_hash_internal(s)
-                               : grpc_slice_hash_refcounted(s);
-}
-
 grpc_slice grpc_slice_from_moved_buffer(grpc_core::UniquePtr<char> p,
                                         size_t len);
 grpc_slice grpc_slice_from_moved_string(grpc_core::UniquePtr<char> p);
@@ -103,9 +78,6 @@ grpc_slice grpc_slice_from_cpp_string(std::string str);
 // 0. All other slices will return the size of the allocated chars.
 size_t grpc_slice_memory_usage(grpc_slice s);
 
-grpc_core::UnmanagedMemorySlice grpc_slice_sub_no_ref(
-    const grpc_core::UnmanagedMemorySlice& source, size_t begin, size_t end);
-
 namespace grpc_core {
 
 struct SliceHash {
@@ -114,6 +86,15 @@ struct SliceHash {
   }
 };
 
+extern uint32_t g_hash_seed;
+
+// Converts grpc_slice to absl::string_view.
+inline absl::string_view StringViewFromSlice(const grpc_slice& slice) {
+  return absl::string_view(
+      reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(slice)),
+      GRPC_SLICE_LENGTH(slice));
+}
+
 }  // namespace grpc_core
 
 inline bool operator==(const grpc_slice& s1, const grpc_slice& s2) {

data/src/core/lib/slice/slice_refcount.cc

@@ -15,3 +15,21 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/slice/slice_refcount.h"
+
+#include <chrono>
+
+namespace grpc_core {
+
+uint32_t g_hash_seed = []() {
+  auto now = std::chrono::system_clock::now();
+  auto now_since_epoch = now.time_since_epoch();
+  auto now_ns =
+      std::chrono::duration_cast<std::chrono::nanoseconds>(now_since_epoch);
+  return static_cast<uint32_t>(now_ns.count());
+}();
+
+}  // namespace grpc_core
+
+void grpc_test_only_set_slice_hash_seed(uint32_t seed) {
+  grpc_core::g_hash_seed = seed;
+}

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

@@ -17,103 +17,28 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/slice/slice_refcount_base.h"
-#include "src/core/lib/slice/static_slice.h"
-
-// Interned slices have specific fast-path operations for hashing. To inline
-// these operations, we need to forward declare them here.
-extern uint32_t grpc_static_metadata_hash_values[GRPC_STATIC_MDSTR_COUNT];
+#include <string.h>
 
-namespace grpc_core {
+#include <grpc/support/alloc.h>
 
-extern grpc_slice_refcount kNoopRefcount;
-
-struct InternedSliceRefcount {
-  static void Destroy(void* arg) {
-    auto* rc = static_cast<InternedSliceRefcount*>(arg);
-    rc->~InternedSliceRefcount();
-    gpr_free(rc);
-  }
-
-  InternedSliceRefcount(size_t length, uint32_t hash,
-                        InternedSliceRefcount* bucket_next)
-      : base(grpc_slice_refcount::Type::INTERNED, &refcnt, Destroy, this, &sub),
-        sub(grpc_slice_refcount::Type::REGULAR, &refcnt, Destroy, this, &sub),
-        length(length),
-        hash(hash),
-        bucket_next(bucket_next) {}
+#include "src/core/lib/gpr/murmur_hash.h"
+#include "src/core/lib/slice/slice_refcount_base.h"
 
-  ~InternedSliceRefcount();
+namespace grpc_core {
 
-  grpc_slice_refcount base;
-  grpc_slice_refcount sub;
-  const size_t length;
-  RefCount refcnt;
-  const uint32_t hash;
-  InternedSliceRefcount* bucket_next;
-};
+extern uint32_t g_hash_seed;
 
 }  // namespace grpc_core
 
-inline size_t grpc_refcounted_slice_length(const grpc_slice& slice) {
-  GPR_DEBUG_ASSERT(slice.refcount != nullptr);
-  return slice.data.refcounted.length;
-}
-
-inline const uint8_t* grpc_refcounted_slice_data(const grpc_slice& slice) {
-  GPR_DEBUG_ASSERT(slice.refcount != nullptr);
-  return slice.data.refcounted.bytes;
-}
-
-inline int grpc_slice_refcount::Eq(const grpc_slice& a, const grpc_slice& b) {
-  GPR_DEBUG_ASSERT(a.refcount != nullptr);
-  GPR_DEBUG_ASSERT(a.refcount == this);
-  switch (ref_type_) {
-    case Type::STATIC:
-      GPR_DEBUG_ASSERT(
-          (GRPC_STATIC_METADATA_INDEX(a) == GRPC_STATIC_METADATA_INDEX(b)) ==
-          (a.refcount == b.refcount));
-      ABSL_FALLTHROUGH_INTENDED;
-    case Type::INTERNED:
-      return a.refcount == b.refcount;
-    case Type::NOP:
-    case Type::REGULAR:
-      break;
-  }
-  if (grpc_refcounted_slice_length(a) != GRPC_SLICE_LENGTH(b)) return false;
-  if (grpc_refcounted_slice_length(a) == 0) return true;
-  return 0 == memcmp(grpc_refcounted_slice_data(a), GRPC_SLICE_START_PTR(b),
-                     grpc_refcounted_slice_length(a));
-}
-
-inline uint32_t grpc_slice_refcount::Hash(const grpc_slice& slice) {
-  GPR_DEBUG_ASSERT(slice.refcount != nullptr);
-  GPR_DEBUG_ASSERT(slice.refcount == this);
-  switch (ref_type_) {
-    case Type::STATIC:
-      return ::grpc_static_metadata_hash_values[GRPC_STATIC_METADATA_INDEX(
-          slice)];
-    case Type::INTERNED:
-      return reinterpret_cast<grpc_core::InternedSliceRefcount*>(slice.refcount)
-          ->hash;
-    case Type::NOP:
-    case Type::REGULAR:
-      break;
-  }
-  return gpr_murmur_hash3(grpc_refcounted_slice_data(slice),
-                          grpc_refcounted_slice_length(slice),
-                          grpc_core::g_hash_seed);
-}
-
 inline const grpc_slice& grpc_slice_ref_internal(const grpc_slice& slice) {
-  if (slice.refcount) {
+  if (reinterpret_cast<uintptr_t>(slice.refcount) > 1) {
     slice.refcount->Ref();
   }
   return slice;
 }
 
 inline void grpc_slice_unref_internal(const grpc_slice& slice) {
-  if (slice.refcount) {
+  if (reinterpret_cast<uintptr_t>(slice.refcount) > 1) {
     slice.refcount->Unref();
   }
 }