grpc 1.44.0.pre2 → 1.46.3

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

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/slice/slice.h"
+
 #include <string.h>
 
 #include <grpc/slice.h>
@@ -27,6 +29,7 @@
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_refcount_base.h"
 
 char* grpc_slice_to_c_string(grpc_slice slice) {
   char* out = static_cast<char*>(gpr_malloc(GRPC_SLICE_LENGTH(slice) + 1));
@@ -35,7 +38,9 @@ char* grpc_slice_to_c_string(grpc_slice slice) {
   return out;
 }
 
-grpc_slice grpc_empty_slice(void) { return grpc_core::UnmanagedMemorySlice(); }
+grpc_slice grpc_empty_slice(void) {
+  return grpc_core::slice_detail::EmptySlice();
+}
 
 grpc_slice grpc_slice_copy(grpc_slice s) {
   grpc_slice out = GRPC_SLICE_MALLOC(GRPC_SLICE_LENGTH(s));
@@ -46,30 +51,21 @@ grpc_slice grpc_slice_copy(grpc_slice s) {
 
 namespace grpc_core {
 
-/* grpc_slice_from_static_string support structure - a refcount that does
-   nothing */
-grpc_slice_refcount kNoopRefcount(grpc_slice_refcount::Type::NOP);
-static_assert(std::is_trivially_destructible<decltype(kNoopRefcount)>::value,
-              "kNoopRefcount must be trivially destructible.");
-
 /* grpc_slice_new support structures - we create a refcount object extended
    with the user provided data pointer & destroy function */
-class NewSliceRefcount {
+class NewSliceRefcount : public grpc_slice_refcount {
  public:
-  static void Destroy(void* arg) { delete static_cast<NewSliceRefcount*>(arg); }
-
   NewSliceRefcount(void (*destroy)(void*), void* user_data)
-      : base_(grpc_slice_refcount::Type::REGULAR, &refs_, Destroy, this,
-              &base_),
+      : grpc_slice_refcount(Destroy),
         user_destroy_(destroy),
         user_data_(user_data) {}
   ~NewSliceRefcount() { user_destroy_(user_data_); }
 
-  grpc_slice_refcount* base_refcount() { return &base_; }
-
  private:
-  grpc_slice_refcount base_;
-  std::atomic<size_t> refs_{1};
+  static void Destroy(grpc_slice_refcount* arg) {
+    delete static_cast<NewSliceRefcount*>(arg);
+  }
+
   void (*user_destroy_)(void*);
   void* user_data_;
 };
@@ -77,7 +73,8 @@ class NewSliceRefcount {
 }  // namespace grpc_core
 
 size_t grpc_slice_memory_usage(grpc_slice s) {
-  if (s.refcount == nullptr || s.refcount == &grpc_core::kNoopRefcount) {
+  if (s.refcount == nullptr ||
+      s.refcount == grpc_slice_refcount::NoopRefcount()) {
     return 0;
   } else {
     return s.data.refcounted.length;
@@ -85,19 +82,18 @@ size_t grpc_slice_memory_usage(grpc_slice s) {
 }
 
 grpc_slice grpc_slice_from_static_buffer(const void* s, size_t len) {
-  return grpc_core::ExternallyManagedSlice(s, len);
+  return grpc_core::StaticSlice::FromStaticBuffer(s, len).TakeCSlice();
 }
 
 grpc_slice grpc_slice_from_static_string(const char* s) {
-  return grpc_core::ExternallyManagedSlice(s, strlen(s));
+  return grpc_core::StaticSlice::FromStaticString(s).TakeCSlice();
 }
 
 grpc_slice grpc_slice_new_with_user_data(void* p, size_t len,
                                          void (*destroy)(void*),
                                          void* user_data) {
   grpc_slice slice;
-  slice.refcount =
-      (new grpc_core::NewSliceRefcount(destroy, user_data))->base_refcount();
+  slice.refcount = new grpc_core::NewSliceRefcount(destroy, user_data);
   slice.data.refcounted.bytes = static_cast<uint8_t*>(p);
   slice.data.refcounted.length = len;
   return slice;
@@ -111,68 +107,51 @@ grpc_slice grpc_slice_new(void* p, size_t len, void (*destroy)(void*)) {
 namespace grpc_core {
 /* grpc_slice_new_with_len support structures - we create a refcount object
    extended with the user provided data pointer & destroy function */
-class NewWithLenSliceRefcount {
+class NewWithLenSliceRefcount : public grpc_slice_refcount {
  public:
-  static void Destroy(void* arg) {
-    delete static_cast<NewWithLenSliceRefcount*>(arg);
-  }
-
   NewWithLenSliceRefcount(void (*destroy)(void*, size_t), void* user_data,
                           size_t user_length)
-      : base_(grpc_slice_refcount::Type::REGULAR, &refs_, Destroy, this,
-              &base_),
+      : grpc_slice_refcount(Destroy),
         user_data_(user_data),
         user_length_(user_length),
         user_destroy_(destroy) {}
   ~NewWithLenSliceRefcount() { user_destroy_(user_data_, user_length_); }
 
-  grpc_slice_refcount* base_refcount() { return &base_; }
-
  private:
-  grpc_slice_refcount base_;
-  std::atomic<size_t> refs_{1};
+  static void Destroy(grpc_slice_refcount* arg) {
+    delete static_cast<NewWithLenSliceRefcount*>(arg);
+  }
+
   void* user_data_;
   size_t user_length_;
   void (*user_destroy_)(void*, size_t);
 };
 
 /** grpc_slice_from_moved_(string|buffer) ref count .*/
-class MovedStringSliceRefCount {
+class MovedStringSliceRefCount : public grpc_slice_refcount {
  public:
   explicit MovedStringSliceRefCount(UniquePtr<char>&& str)
-      : base_(grpc_slice_refcount::Type::REGULAR, &refs_, Destroy, this,
-              &base_),
-        str_(std::move(str)) {}
-
-  grpc_slice_refcount* base_refcount() { return &base_; }
+      : grpc_slice_refcount(Destroy), str_(std::move(str)) {}
 
  private:
-  static void Destroy(void* arg) {
+  static void Destroy(grpc_slice_refcount* arg) {
     delete static_cast<MovedStringSliceRefCount*>(arg);
   }
 
-  grpc_slice_refcount base_;
-  std::atomic<size_t> refs_{1};
   UniquePtr<char> str_;
 };
 
 // grpc_slice_from_cpp_string() ref count.
-class MovedCppStringSliceRefCount {
+class MovedCppStringSliceRefCount : public grpc_slice_refcount {
  public:
   explicit MovedCppStringSliceRefCount(std::string&& str)
-      : base_(grpc_slice_refcount::Type::REGULAR, &refs_, Destroy, this,
-              &base_),
-        str_(std::move(str)) {}
-
-  grpc_slice_refcount* base_refcount() { return &base_; }
+      : grpc_slice_refcount(Destroy), str_(std::move(str)) {}
 
  private:
-  static void Destroy(void* arg) {
+  static void Destroy(grpc_slice_refcount* arg) {
     delete static_cast<MovedCppStringSliceRefCount*>(arg);
   }
 
-  grpc_slice_refcount base_;
-  std::atomic<size_t> refs_{1};
   std::string str_;
 };
 
@@ -181,44 +160,17 @@ class MovedCppStringSliceRefCount {
 grpc_slice grpc_slice_new_with_len(void* p, size_t len,
                                    void (*destroy)(void*, size_t)) {
   grpc_slice slice;
-  slice.refcount = (new grpc_core::NewWithLenSliceRefcount(destroy, p, len))
-                       ->base_refcount();
+  slice.refcount = new grpc_core::NewWithLenSliceRefcount(destroy, p, len);
   slice.data.refcounted.bytes = static_cast<uint8_t*>(p);
   slice.data.refcounted.length = len;
   return slice;
 }
 
-grpc_core::UnmanagedMemorySlice::UnmanagedMemorySlice(const char* source,
-                                                      size_t length) {
-  if (length <= sizeof(data.inlined.bytes)) {
-    refcount = nullptr;
-    data.inlined.length = static_cast<uint8_t>(length);
-  } else {
-    HeapInit(length);
-  }
-  if (length > 0) {
-    memcpy(GRPC_SLICE_START_PTR(*this), source, length);
-  }
-}
-
-grpc_core::UnmanagedMemorySlice::UnmanagedMemorySlice(const char* source)
-    : grpc_core::UnmanagedMemorySlice::UnmanagedMemorySlice(source,
-                                                            strlen(source)) {}
-
-grpc_slice grpc_slice_from_copied_buffer(const char* source, size_t length) {
-  grpc_slice slice;
-  if (length <= sizeof(slice.data.inlined.bytes)) {
-    slice.refcount = nullptr;
-    slice.data.inlined.length = length;
-  } else {
-    // Create a ref-counted slice.
-    slice = grpc_core::UnmanagedMemorySlice(
-        length, grpc_core::UnmanagedMemorySlice::ForceHeapAllocation());
-  }
-  if (length > 0) {
-    memcpy(GRPC_SLICE_START_PTR(slice), source, length);
-  }
-  return slice;
+grpc_slice grpc_slice_from_copied_buffer(const char* source, size_t len) {
+  if (len == 0) return grpc_empty_slice();
+  grpc_slice out = grpc_slice_malloc(len);
+  memcpy(GRPC_SLICE_START_PTR(out), source, len);
+  return out;
 }
 
 grpc_slice grpc_slice_from_copied_string(const char* source) {
@@ -234,8 +186,7 @@ grpc_slice grpc_slice_from_moved_buffer(grpc_core::UniquePtr<char> p,
     slice.data.inlined.length = len;
     memcpy(GRPC_SLICE_START_PTR(slice), ptr, len);
   } else {
-    slice.refcount = (new grpc_core::MovedStringSliceRefCount(std::move(p)))
-                         ->base_refcount();
+    slice.refcount = new grpc_core::MovedStringSliceRefCount(std::move(p));
     slice.data.refcounted.bytes = ptr;
     slice.data.refcounted.length = len;
   }
@@ -257,94 +208,44 @@ grpc_slice grpc_slice_from_cpp_string(std::string str) {
     slice.data.refcounted.bytes =
         reinterpret_cast<uint8_t*>(const_cast<char*>(str.data()));
     slice.data.refcounted.length = str.size();
-    slice.refcount =
-        (new grpc_core::MovedCppStringSliceRefCount(std::move(str)))
-            ->base_refcount();
+    slice.refcount = new grpc_core::MovedCppStringSliceRefCount(std::move(str));
   }
   return slice;
 }
 
-namespace {
-
-class MallocRefCount {
- public:
-  static void Destroy(void* arg) {
-    MallocRefCount* r = static_cast<MallocRefCount*>(arg);
-    r->~MallocRefCount();
-    gpr_free(r);
-  }
-
-  MallocRefCount()
-      : base_(grpc_slice_refcount::Type::REGULAR, &refs_, Destroy, this,
-              &base_) {}
-  ~MallocRefCount() = default;
-
-  grpc_slice_refcount* base_refcount() { return &base_; }
-
- private:
-  grpc_slice_refcount base_;
-  std::atomic<size_t> refs_{1};
-};
-
-}  // namespace
-
 grpc_slice grpc_slice_malloc_large(size_t length) {
-  return grpc_core::UnmanagedMemorySlice(
-      length, grpc_core::UnmanagedMemorySlice::ForceHeapAllocation());
-}
-
-void grpc_core::UnmanagedMemorySlice::HeapInit(size_t length) {
-  /* Memory layout used by the slice created here:
-
-     +-----------+----------------------------------------------------------+
-     | refcount  | bytes                                                    |
-     +-----------+----------------------------------------------------------+
-
-     refcount is a malloc_refcount
-     bytes is an array of bytes of the requested length
-     Both parts are placed in the same allocation returned from gpr_malloc */
-  auto* rc =
-      static_cast<MallocRefCount*>(gpr_malloc(sizeof(MallocRefCount) + length));
-
-  /* Initial refcount on rc is 1 - and it's up to the caller to release
-     this reference. */
-  new (rc) MallocRefCount();
-
-  /* Build up the slice to be returned. */
-  /* The slices refcount points back to the allocated block. */
-  refcount = rc->base_refcount();
-  /* The data bytes are placed immediately after the refcount struct */
-  data.refcounted.bytes = reinterpret_cast<uint8_t*>(rc + 1);
-  /* And the length of the block is set to the requested length */
-  data.refcounted.length = length;
+  grpc_slice slice;
+  uint8_t* memory = new uint8_t[sizeof(grpc_slice_refcount) + length];
+  slice.refcount = new (memory) grpc_slice_refcount(
+      [](grpc_slice_refcount* p) { delete[] reinterpret_cast<uint8_t*>(p); });
+  slice.data.refcounted.bytes = memory + sizeof(grpc_slice_refcount);
+  slice.data.refcounted.length = length;
+  return slice;
 }
 
 grpc_slice grpc_slice_malloc(size_t length) {
-  return grpc_core::UnmanagedMemorySlice(length);
-}
-
-grpc_core::UnmanagedMemorySlice::UnmanagedMemorySlice(size_t length) {
-  if (length > sizeof(data.inlined.bytes)) {
-    HeapInit(length);
+  if (length <= GRPC_SLICE_INLINED_SIZE) {
+    grpc_slice slice;
+    slice.refcount = nullptr;
+    slice.data.inlined.length = length;
+    return slice;
   } else {
-    /* small slice: just inline the data */
-    refcount = nullptr;
-    data.inlined.length = static_cast<uint8_t>(length);
+    return grpc_slice_malloc_large(length);
   }
 }
 
-template <typename Slice>
-static Slice sub_no_ref(const Slice& source, size_t begin, size_t end) {
-  Slice subset;
+static grpc_slice sub_no_ref(const grpc_slice& source, size_t begin,
+                             size_t end) {
+  grpc_slice subset;
 
   GPR_ASSERT(end >= begin);
 
-  if (source.refcount) {
+  if (source.refcount != nullptr) {
     /* Enforce preconditions */
     GPR_ASSERT(source.data.refcounted.length >= end);
 
     /* Build the result */
-    subset.refcount = source.refcount->sub_refcount();
+    subset.refcount = source.refcount;
     /* Point into the source array */
     subset.data.refcounted.bytes = source.data.refcounted.bytes + begin;
     subset.data.refcounted.length = end - begin;
@@ -363,11 +264,6 @@ grpc_slice grpc_slice_sub_no_ref(grpc_slice source, size_t begin, size_t end) {
   return sub_no_ref(source, begin, end);
 }
 
-grpc_core::UnmanagedMemorySlice grpc_slice_sub_no_ref(
-    const grpc_core::UnmanagedMemorySlice& source, size_t begin, size_t end) {
-  return sub_no_ref(source, begin, end);
-}
-
 grpc_slice grpc_slice_sub(grpc_slice source, size_t begin, size_t end) {
   grpc_slice subset;
 
@@ -379,7 +275,9 @@ grpc_slice grpc_slice_sub(grpc_slice source, size_t begin, size_t end) {
   } else {
     subset = grpc_slice_sub_no_ref(source, begin, end);
     /* Bump the refcount */
-    subset.refcount->Ref();
+    if (subset.refcount != grpc_slice_refcount::NoopRefcount()) {
+      subset.refcount->Ref();
+    }
   }
   return subset;
 }
@@ -397,6 +295,12 @@ grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
     memcpy(tail.data.inlined.bytes, source->data.inlined.bytes + split,
            tail.data.inlined.length);
     source->data.inlined.length = static_cast<uint8_t>(split);
+  } else if (source->refcount == grpc_slice_refcount::NoopRefcount()) {
+    /* refcount == NoopRefcount(), so we can just split in-place */
+    tail.refcount = grpc_slice_refcount::NoopRefcount();
+    tail.data.refcounted.bytes = source->data.refcounted.bytes + split;
+    tail.data.refcounted.length = source->data.refcounted.length - split;
+    source->data.refcounted.length = split;
   } else {
     size_t tail_length = source->data.refcounted.length - split;
     GPR_ASSERT(source->data.refcounted.length >= split);
@@ -407,23 +311,22 @@ grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
       tail.data.inlined.length = static_cast<uint8_t>(tail_length);
       memcpy(tail.data.inlined.bytes, source->data.refcounted.bytes + split,
              tail_length);
-      source->refcount = source->refcount->sub_refcount();
     } else {
       /* Build the result */
       switch (ref_whom) {
         case GRPC_SLICE_REF_TAIL:
-          tail.refcount = source->refcount->sub_refcount();
-          source->refcount = &grpc_core::kNoopRefcount;
+          tail.refcount = source->refcount;
+          source->refcount = grpc_slice_refcount::NoopRefcount();
           break;
         case GRPC_SLICE_REF_HEAD:
-          tail.refcount = &grpc_core::kNoopRefcount;
-          source->refcount = source->refcount->sub_refcount();
+          tail.refcount = grpc_slice_refcount::NoopRefcount();
           break;
         case GRPC_SLICE_REF_BOTH:
-          tail.refcount = source->refcount->sub_refcount();
-          source->refcount = source->refcount->sub_refcount();
+          tail.refcount = source->refcount;
           /* Bump the refcount */
-          tail.refcount->Ref();
+          if (tail.refcount != grpc_slice_refcount::NoopRefcount()) {
+            tail.refcount->Ref();
+          }
           break;
       }
       /* Point into the source array */
@@ -459,20 +362,20 @@ grpc_slice grpc_slice_split_head(grpc_slice* source, size_t split) {
     head.refcount = nullptr;
     head.data.inlined.length = static_cast<uint8_t>(split);
     memcpy(head.data.inlined.bytes, source->data.refcounted.bytes, split);
-    source->refcount = source->refcount->sub_refcount();
     source->data.refcounted.bytes += split;
     source->data.refcounted.length -= split;
   } else {
     GPR_ASSERT(source->data.refcounted.length >= split);
 
     /* Build the result */
-    head.refcount = source->refcount->sub_refcount();
+    head.refcount = source->refcount;
     /* Bump the refcount */
-    head.refcount->Ref();
+    if (head.refcount != grpc_slice_refcount::NoopRefcount()) {
+      head.refcount->Ref();
+    }
     /* Point into the source array */
     head.data.refcounted.bytes = source->data.refcounted.bytes;
     head.data.refcounted.length = split;
-    source->refcount = source->refcount->sub_refcount();
     source->data.refcounted.bytes += split;
     source->data.refcounted.length -= split;
   }
@@ -480,21 +383,13 @@ grpc_slice grpc_slice_split_head(grpc_slice* source, size_t split) {
   return head;
 }
 
-int grpc_slice_default_eq_impl(grpc_slice a, grpc_slice b) {
+int grpc_slice_eq(grpc_slice a, grpc_slice b) {
   if (GRPC_SLICE_LENGTH(a) != GRPC_SLICE_LENGTH(b)) return false;
   if (GRPC_SLICE_LENGTH(a) == 0) return true;
   return 0 == memcmp(GRPC_SLICE_START_PTR(a), GRPC_SLICE_START_PTR(b),
                      GRPC_SLICE_LENGTH(a));
 }
 
-int grpc_slice_eq(grpc_slice a, grpc_slice b) {
-  if (a.refcount && b.refcount &&
-      a.refcount->GetType() == b.refcount->GetType()) {
-    return a.refcount->Eq(a, b);
-  }
-  return grpc_slice_default_eq_impl(a, b);
-}
-
 int grpc_slice_differs_refcounted(const grpc_slice& a,
                                   const grpc_slice& b_not_inline) {
   size_t a_len;

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

@@ -25,6 +25,8 @@
 
 #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
@@ -103,6 +105,8 @@ class BaseSlice {
     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) {}
@@ -162,7 +166,7 @@ inline bool operator!=(const grpc_slice& a, const BaseSlice& b) {
 template <typename Out>
 struct CopyConstructors {
   static Out FromCopiedString(const char* s) {
-    return Out(grpc_slice_from_copied_string(s));
+    return FromCopiedBuffer(s, strlen(s));
   }
   static Out FromCopiedString(absl::string_view s) {
     return FromCopiedBuffer(s.data(), s.size());
@@ -171,7 +175,7 @@ struct CopyConstructors {
     return Out(grpc_slice_from_cpp_string(std::move(s)));
   }
   static Out FromCopiedBuffer(const char* p, size_t len) {
-    return Out(UnmanagedMemorySlice(p, len));
+    return Out(grpc_slice_from_copied_buffer(p, len));
   }
 
   template <typename Buffer>
@@ -190,11 +194,20 @@ struct CopyConstructors {
 template <typename Out>
 struct StaticConstructors {
   static Out FromStaticString(const char* s) {
-    return Out(grpc_slice_from_static_string(s));
+    return FromStaticBuffer(s, strlen(s));
   }
 
   static Out FromStaticString(absl::string_view s) {
-    return Out(ExternallyManagedSlice(s.data(), s.size()));
+    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);
   }
 };
 
@@ -206,11 +219,8 @@ class StaticSlice : public slice_detail::BaseSlice,
   StaticSlice() = default;
   explicit StaticSlice(const grpc_slice& slice)
       : slice_detail::BaseSlice(slice) {
-    GPR_DEBUG_ASSERT(slice.refcount->GetType() ==
-                     grpc_slice_refcount::Type::NOP);
+    GPR_DEBUG_ASSERT(slice.refcount == grpc_slice_refcount::NoopRefcount());
   }
-  explicit StaticSlice(const StaticMetadataSlice& slice)
-      : slice_detail::BaseSlice(slice) {}
 
   StaticSlice(const StaticSlice& other)
       : slice_detail::BaseSlice(other.c_slice()) {}
@@ -232,8 +242,7 @@ class MutableSlice : public slice_detail::BaseSlice,
   MutableSlice() = default;
   explicit MutableSlice(const grpc_slice& slice)
       : slice_detail::BaseSlice(slice) {
-    GPR_DEBUG_ASSERT(slice.refcount == nullptr ||
-                     slice.refcount->IsRegularUnique());
+    GPR_DEBUG_ASSERT(slice.refcount == nullptr || slice.refcount->IsUnique());
   }
   ~MutableSlice() { grpc_slice_unref_internal(c_slice()); }
 
@@ -297,7 +306,7 @@ class Slice : public slice_detail::BaseSlice,
     if (c_slice().refcount == nullptr) {
       return Slice(c_slice());
     }
-    if (c_slice().refcount->GetType() == grpc_slice_refcount::Type::NOP) {
+    if (c_slice().refcount == grpc_slice_refcount::NoopRefcount()) {
       return Slice(grpc_slice_copy(c_slice()));
     }
     return Slice(TakeCSlice());
@@ -309,7 +318,7 @@ class Slice : public slice_detail::BaseSlice,
     if (c_slice().refcount == nullptr) {
       return Slice(c_slice());
     }
-    if (c_slice().refcount->GetType() == grpc_slice_refcount::Type::NOP) {
+    if (c_slice().refcount == grpc_slice_refcount::NoopRefcount()) {
       return Slice(grpc_slice_copy(c_slice()));
     }
     return Slice(grpc_slice_ref_internal(c_slice()));
@@ -327,8 +336,8 @@ class Slice : public slice_detail::BaseSlice,
     if (c_slice().refcount == nullptr) {
       return MutableSlice(c_slice());
     }
-    if (c_slice().refcount->GetType() == grpc_slice_refcount::Type::REGULAR &&
-        c_slice().refcount->IsRegularUnique()) {
+    if (c_slice().refcount != grpc_slice_refcount::NoopRefcount() &&
+        c_slice().refcount->IsUnique()) {
       return MutableSlice(TakeCSlice());
     }
     return MutableSlice(grpc_slice_copy(c_slice()));
@@ -359,11 +368,15 @@ class Slice : public slice_detail::BaseSlice,
                                     const uint8_t* begin, const uint8_t* end) {
     grpc_slice out;
     out.refcount = r;
-    r->Ref();
+    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

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,21 +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));
-}
-
-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)
@@ -77,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);
@@ -102,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 {
@@ -113,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) {