grpc 1.22.1 → 1.23.0.pre1

data/src/core/lib/security/security_connector/tls/spiffe_security_connector.h

@@ -53,7 +53,8 @@ class SpiffeChannelSecurityConnector final
 
   int cmp(const grpc_security_connector* other_sc) const override;
 
-  bool check_call_host(const char* host, grpc_auth_context* auth_context,
+  bool check_call_host(grpc_core::StringView host,
+                       grpc_auth_context* auth_context,
                        grpc_closure* on_call_host_checked,
                        grpc_error** error) override;
 
@@ -83,8 +84,8 @@ class SpiffeChannelSecurityConnector final
       grpc_tls_server_authorization_check_arg* arg);
 
   grpc_closure* on_peer_checked_;
-  char* target_name_;
-  char* overridden_target_name_;
+  grpc_core::UniquePtr<char> target_name_;
+  grpc_core::UniquePtr<char> overridden_target_name_;
   tsi_ssl_client_handshaker_factory* client_handshaker_factory_ = nullptr;
   grpc_tls_server_authorization_check_arg* check_arg_;
 };

data/src/core/lib/security/transport/client_auth_filter.cc

@@ -346,7 +346,7 @@ static void auth_start_transport_stream_op_batch(
       GRPC_CALL_STACK_REF(calld->owning_call, "check_call_host");
       GRPC_CLOSURE_INIT(&calld->async_result_closure, on_host_checked, batch,
                         grpc_schedule_on_exec_ctx);
-      char* call_host = grpc_slice_to_c_string(calld->host);
+      grpc_core::StringView call_host(calld->host);
       grpc_error* error = GRPC_ERROR_NONE;
       if (chand->security_connector->check_call_host(
               call_host, chand->auth_context.get(),
@@ -360,7 +360,6 @@ static void auth_start_transport_stream_op_batch(
             &calld->check_call_host_cancel_closure, cancel_check_call_host,
             elem, grpc_schedule_on_exec_ctx));
       }
-      gpr_free(call_host);
       return; /* early exit */
     }
   }

data/src/core/lib/security/util/json_util.cc

@@ -18,6 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/security/util/json_util.h"
 
 #include <string.h>
@@ -26,17 +27,27 @@
 #include <grpc/support/string_util.h>
 
 const char* grpc_json_get_string_property(const grpc_json* json,
-                                          const char* prop_name) {
-  grpc_json* child;
+                                          const char* prop_name,
+                                          grpc_error** error) {
+  grpc_json* child = nullptr;
+  if (error != nullptr) *error = GRPC_ERROR_NONE;
   for (child = json->child; child != nullptr; child = child->next) {
     if (child->key == nullptr) {
-      gpr_log(GPR_ERROR, "Invalid (null) JSON key encountered");
+      if (error != nullptr) {
+        *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "Invalid (null) JSON key encountered");
+      }
       return nullptr;
     }
     if (strcmp(child->key, prop_name) == 0) break;
   }
   if (child == nullptr || child->type != GRPC_JSON_STRING) {
-    gpr_log(GPR_ERROR, "Invalid or missing %s property.", prop_name);
+    if (error != nullptr) {
+      char* error_msg;
+      gpr_asprintf(&error_msg, "Invalid or missing %s property.", prop_name);
+      *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg);
+      gpr_free(error_msg);
+    }
     return nullptr;
   }
   return child->value;
@@ -45,7 +56,10 @@ const char* grpc_json_get_string_property(const grpc_json* json,
 bool grpc_copy_json_string_property(const grpc_json* json,
                                     const char* prop_name,
                                     char** copied_value) {
-  const char* prop_value = grpc_json_get_string_property(json, prop_name);
+  grpc_error* error = GRPC_ERROR_NONE;
+  const char* prop_value =
+      grpc_json_get_string_property(json, prop_name, &error);
+  GRPC_LOG_IF_ERROR("Could not copy JSON property", error);
   if (prop_value == nullptr) return false;
   *copied_value = gpr_strdup(prop_value);
   return true;

data/src/core/lib/security/util/json_util.h

@@ -23,6 +23,7 @@
 
 #include <stdbool.h>
 
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
 
 // Constants.
@@ -32,7 +33,8 @@
 
 // Gets a child property from a json node.
 const char* grpc_json_get_string_property(const grpc_json* json,
-                                          const char* prop_name);
+                                          const char* prop_name,
+                                          grpc_error** error);
 
 // Copies the value of the json child property specified by prop_name.
 // Returns false if the property was not found.

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

@@ -37,12 +37,7 @@ char* grpc_slice_to_c_string(grpc_slice slice) {
   return out;
 }
 
-grpc_slice grpc_empty_slice(void) {
-  grpc_slice out;
-  out.refcount = nullptr;
-  out.data.inlined.length = 0;
-  return out;
-}
+grpc_slice grpc_empty_slice(void) { return grpc_core::UnmanagedMemorySlice(); }
 
 grpc_slice grpc_slice_copy(grpc_slice s) {
   grpc_slice out = GRPC_SLICE_MALLOC(GRPC_SLICE_LENGTH(s));
@@ -66,32 +61,13 @@ void grpc_slice_unref(grpc_slice slice) {
   }
 }
 
+namespace grpc_core {
+
 /* grpc_slice_from_static_string support structure - a refcount that does
    nothing */
-static grpc_slice_refcount NoopRefcount =
-    grpc_slice_refcount(grpc_slice_refcount::Type::NOP);
-
-size_t grpc_slice_memory_usage(grpc_slice s) {
-  if (s.refcount == nullptr || s.refcount == &NoopRefcount) {
-    return 0;
-  } else {
-    return s.data.refcounted.length;
-  }
-}
-
-grpc_slice grpc_slice_from_static_buffer(const void* s, size_t len) {
-  grpc_slice slice;
-  slice.refcount = &NoopRefcount;
-  slice.data.refcounted.bytes = (uint8_t*)s;
-  slice.data.refcounted.length = len;
-  return slice;
-}
-
-grpc_slice grpc_slice_from_static_string(const char* s) {
-  return grpc_slice_from_static_buffer(s, strlen(s));
-}
-
-namespace grpc_core {
+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 */
@@ -122,6 +98,22 @@ class NewSliceRefcount {
 
 }  // namespace grpc_core
 
+size_t grpc_slice_memory_usage(grpc_slice s) {
+  if (s.refcount == nullptr || s.refcount == &grpc_core::kNoopRefcount) {
+    return 0;
+  } else {
+    return s.data.refcounted.length;
+  }
+}
+
+grpc_slice grpc_slice_from_static_buffer(const void* s, size_t len) {
+  return grpc_core::ExternallyManagedSlice(s, len);
+}
+
+grpc_slice grpc_slice_from_static_string(const char* s) {
+  return grpc_core::ExternallyManagedSlice(s, strlen(s));
+}
+
 grpc_slice grpc_slice_new_with_user_data(void* p, size_t len,
                                          void (*destroy)(void*),
                                          void* user_data) {
@@ -205,15 +197,29 @@ grpc_slice grpc_slice_new_with_len(void* p, size_t 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) {
-  if (length == 0) return grpc_empty_slice();
-  grpc_slice slice = GRPC_SLICE_MALLOC(length);
-  memcpy(GRPC_SLICE_START_PTR(slice), source, length);
-  return slice;
+  return grpc_core::UnmanagedMemorySlice(source, length);
 }
 
 grpc_slice grpc_slice_from_copied_string(const char* source) {
-  return grpc_slice_from_copied_buffer(source, strlen(source));
+  return grpc_core::UnmanagedMemorySlice(source, strlen(source));
 }
 
 grpc_slice grpc_slice_from_moved_buffer(grpc_core::UniquePtr<char> p,
@@ -264,8 +270,11 @@ class MallocRefCount {
 }  // namespace
 
 grpc_slice grpc_slice_malloc_large(size_t length) {
-  grpc_slice slice;
+  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:
 
      +-----------+----------------------------------------------------------+
@@ -284,29 +293,30 @@ grpc_slice grpc_slice_malloc_large(size_t length) {
 
   /* Build up the slice to be returned. */
   /* The slices refcount points back to the allocated block. */
-  slice.refcount = rc->base_refcount();
+  refcount = rc->base_refcount();
   /* The data bytes are placed immediately after the refcount struct */
-  slice.data.refcounted.bytes = reinterpret_cast<uint8_t*>(rc + 1);
+  data.refcounted.bytes = reinterpret_cast<uint8_t*>(rc + 1);
   /* And the length of the block is set to the requested length */
-  slice.data.refcounted.length = length;
-  return slice;
+  data.refcounted.length = length;
 }
 
 grpc_slice grpc_slice_malloc(size_t length) {
-  grpc_slice slice;
+  return grpc_core::UnmanagedMemorySlice(length);
+}
 
-  if (length > sizeof(slice.data.inlined.bytes)) {
-    return grpc_slice_malloc_large(length);
+grpc_core::UnmanagedMemorySlice::UnmanagedMemorySlice(size_t length) {
+  if (length > sizeof(data.inlined.bytes)) {
+    HeapInit(length);
   } else {
     /* small slice: just inline the data */
-    slice.refcount = nullptr;
-    slice.data.inlined.length = static_cast<uint8_t>(length);
+    refcount = nullptr;
+    data.inlined.length = static_cast<uint8_t>(length);
   }
-  return slice;
 }
 
-grpc_slice grpc_slice_sub_no_ref(grpc_slice source, size_t begin, size_t end) {
-  grpc_slice subset;
+template <typename Slice>
+static Slice sub_no_ref(const Slice& source, size_t begin, size_t end) {
+  Slice subset;
 
   GPR_ASSERT(end >= begin);
 
@@ -330,6 +340,15 @@ grpc_slice grpc_slice_sub_no_ref(grpc_slice source, size_t begin, size_t end) {
   return subset;
 }
 
+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;
 
@@ -375,10 +394,10 @@ grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
       switch (ref_whom) {
         case GRPC_SLICE_REF_TAIL:
           tail.refcount = source->refcount->sub_refcount();
-          source->refcount = &NoopRefcount;
+          source->refcount = &grpc_core::kNoopRefcount;
           break;
         case GRPC_SLICE_REF_HEAD:
-          tail.refcount = &NoopRefcount;
+          tail.refcount = &grpc_core::kNoopRefcount;
           source->refcount = source->refcount->sub_refcount();
           break;
         case GRPC_SLICE_REF_BOTH:

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

@@ -103,7 +103,7 @@ uint8_t* grpc_slice_buffer_tiny_add(grpc_slice_buffer* sb, size_t n) {
 
   sb->length += n;
 
-  if (sb->count == 0) goto add_new;
+  if (sb->count == 0) goto add_first;
   back = &sb->slices[sb->count - 1];
   if (back->refcount) goto add_new;
   if ((back->data.inlined.length + n) > sizeof(back->data.inlined.bytes))
@@ -115,6 +115,7 @@ uint8_t* grpc_slice_buffer_tiny_add(grpc_slice_buffer* sb, size_t n) {
 
 add_new:
   maybe_embiggen(sb);
+add_first:
   back = &sb->slices[sb->count];
   sb->count++;
   back->refcount = nullptr;
@@ -262,9 +263,9 @@ void grpc_slice_buffer_move_into(grpc_slice_buffer* src,
   src->length = 0;
 }
 
+template <bool incref>
 static void slice_buffer_move_first_maybe_ref(grpc_slice_buffer* src, size_t n,
-                                              grpc_slice_buffer* dst,
-                                              bool incref) {
+                                              grpc_slice_buffer* dst) {
   GPR_ASSERT(src->length >= n);
   if (src->length == n) {
     grpc_slice_buffer_move_into(src, dst);
@@ -304,12 +305,12 @@ static void slice_buffer_move_first_maybe_ref(grpc_slice_buffer* src, size_t n,
 
 void grpc_slice_buffer_move_first(grpc_slice_buffer* src, size_t n,
                                   grpc_slice_buffer* dst) {
-  slice_buffer_move_first_maybe_ref(src, n, dst, true);
+  slice_buffer_move_first_maybe_ref<true>(src, n, dst);
 }
 
 void grpc_slice_buffer_move_first_no_ref(grpc_slice_buffer* src, size_t n,
                                          grpc_slice_buffer* dst) {
-  slice_buffer_move_first_maybe_ref(src, n, dst, false);
+  slice_buffer_move_first_maybe_ref<false>(src, n, dst);
 }
 
 void grpc_slice_buffer_move_first_into_buffer(grpc_slice_buffer* src, size_t n,

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

@@ -25,6 +25,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -77,13 +78,8 @@ class SliceHashTable : public RefCounted<SliceHashTable<T>> {
   static int Cmp(const SliceHashTable& a, const SliceHashTable& b);
 
  private:
-  // So New() can call our private ctor.
-  template <typename T2, typename... Args>
-  friend T2* New(Args&&... args);
-
-  // So Delete() can call our private dtor.
-  template <typename T2>
-  friend void Delete(T2*);
+  GRPC_ALLOW_CLASS_TO_USE_NON_PUBLIC_DELETE
+  GRPC_ALLOW_CLASS_TO_USE_NON_PUBLIC_NEW
 
   SliceHashTable(size_t num_entries, Entry* entries, ValueCmp value_cmp);
   virtual ~SliceHashTable();

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

@@ -107,12 +107,10 @@ static void grow_shard(slice_shard* shard) {
   shard->capacity = capacity;
 }
 
-static grpc_slice materialize(InternedSliceRefcount* s) {
-  grpc_slice slice;
-  slice.refcount = &s->base;
-  slice.data.refcounted.bytes = reinterpret_cast<uint8_t*>(s + 1);
-  slice.data.refcounted.length = s->length;
-  return slice;
+grpc_core::InternedSlice::InternedSlice(InternedSliceRefcount* s) {
+  refcount = &s->base;
+  data.refcounted.bytes = reinterpret_cast<uint8_t*>(s + 1);
+  data.refcounted.length = s->length;
 }
 
 uint32_t grpc_slice_default_hash_impl(grpc_slice s) {
@@ -152,57 +150,150 @@ grpc_slice grpc_slice_maybe_static_intern(grpc_slice slice,
 }
 
 grpc_slice grpc_slice_intern(grpc_slice slice) {
-  GPR_TIMER_SCOPE("grpc_slice_intern", 0);
-  if (GRPC_IS_STATIC_METADATA_STRING(slice)) {
-    return slice;
-  }
-
-  uint32_t hash = grpc_slice_hash_internal(slice);
+  /* TODO(arjunroy): At present, this is capable of returning either a static or
+     an interned slice. This yields weirdness like the constructor for
+     ManagedMemorySlice instantiating itself as an instance of a derived type
+     (StaticMetadataSlice or InternedSlice). Should reexamine. */
+  return grpc_core::ManagedMemorySlice(&slice);
+}
 
+// Attempt to see if the provided slice or string matches a static slice.
+// SliceArgs... is either a const grpc_slice& or a string and length. In either
+// case, hash is the pre-computed hash value.
+//
+// Returns: a matching static slice, or null.
+template <class... SliceArgs>
+static const grpc_core::StaticMetadataSlice* MatchStaticSlice(
+    uint32_t hash, SliceArgs&&... args) {
   for (uint32_t i = 0; i <= max_static_metadata_hash_probe; i++) {
     static_metadata_hash_ent ent =
         static_metadata_hash[(hash + i) % GPR_ARRAY_SIZE(static_metadata_hash)];
     if (ent.hash == hash && ent.idx < GRPC_STATIC_MDSTR_COUNT &&
-        grpc_slice_eq_static_interned(slice,
-                                      grpc_static_slice_table[ent.idx])) {
-      return grpc_static_slice_table[ent.idx];
+        grpc_static_slice_table[ent.idx].Equals(
+            std::forward<SliceArgs>(args)...)) {
+      return &grpc_static_slice_table[ent.idx];
     }
   }
+  return nullptr;
+}
 
-  InternedSliceRefcount* s;
-  slice_shard* shard = &g_shards[SHARD_IDX(hash)];
+// Helper methods to enable us to select appropriately overloaded slice methods
+// whether we're dealing with a slice, or a buffer with length, when interning
+// strings. Helpers for FindOrCreateInternedSlice().
+static const void* GetBuffer(const void* buf, size_t len) { return buf; }
+static size_t GetLength(const void* buf, size_t len) { return len; }
+static const void* GetBuffer(const grpc_slice& slice) {
+  return GRPC_SLICE_START_PTR(slice);
+}
+static size_t GetLength(const grpc_slice& slice) {
+  return GRPC_SLICE_LENGTH(slice);
+}
 
-  gpr_mu_lock(&shard->mu);
+// Creates an interned slice for a string that does not currently exist in the
+// intern table. SliceArgs... is either a const grpc_slice& or a string and
+// length. In either case, hash is the pre-computed hash value. We must already
+// hold the shard lock. Helper for FindOrCreateInternedSlice().
+//
+// Returns: a newly interned slice.
+template <class... SliceArgs>
+static InternedSliceRefcount* InternNewStringLocked(slice_shard* shard,
+                                                    size_t shard_idx,
+                                                    uint32_t hash,
+                                                    SliceArgs&&... args) {
+  /* string data goes after the internal_string header */
+  size_t len = GetLength(std::forward<SliceArgs>(args)...);
+  const void* buffer = GetBuffer(std::forward<SliceArgs>(args)...);
+  InternedSliceRefcount* s =
+      static_cast<InternedSliceRefcount*>(gpr_malloc(sizeof(*s) + len));
+  new (s) grpc_core::InternedSliceRefcount(len, hash, shard->strs[shard_idx]);
+  memcpy(reinterpret_cast<char*>(s + 1), buffer, len);
+  shard->strs[shard_idx] = s;
+  shard->count++;
+  if (shard->count > shard->capacity * 2) {
+    grow_shard(shard);
+  }
+  return s;
+}
 
+// Attempt to see if the provided slice or string matches an existing interned
+// slice. SliceArgs... is either a const grpc_slice& or a string and length. In
+// either case, hash is the pre-computed hash value.  We must already hold the
+// shard lock. Helper for FindOrCreateInternedSlice().
+//
+// Returns: a pre-existing matching static slice, or null.
+template <class... SliceArgs>
+static InternedSliceRefcount* MatchInternedSliceLocked(uint32_t hash,
+                                                       size_t idx,
+                                                       SliceArgs&&... args) {
+  InternedSliceRefcount* s;
+  slice_shard* shard = &g_shards[SHARD_IDX(hash)];
   /* search for an existing string */
-  size_t idx = TABLE_IDX(hash, shard->capacity);
   for (s = shard->strs[idx]; s; s = s->bucket_next) {
     if (s->hash == hash &&
-        grpc_slice_eq_static_interned(slice, materialize(s))) {
+        grpc_core::InternedSlice(s).Equals(std::forward<SliceArgs>(args)...)) {
       if (s->refcnt.RefIfNonZero()) {
-        gpr_mu_unlock(&shard->mu);
-        return materialize(s);
+        return s;
       }
     }
   }
+  return nullptr;
+}
 
-  /* not found: create a new string */
-  /* string data goes after the internal_string header */
-  s = static_cast<InternedSliceRefcount*>(
-      gpr_malloc(sizeof(*s) + GRPC_SLICE_LENGTH(slice)));
-
-  new (s) grpc_core::InternedSliceRefcount(GRPC_SLICE_LENGTH(slice), hash,
-                                           shard->strs[idx]);
-  memcpy(reinterpret_cast<char*>(s + 1), GRPC_SLICE_START_PTR(slice),
-         GRPC_SLICE_LENGTH(slice));
-  shard->strs[idx] = s;
-  shard->count++;
-  if (shard->count > shard->capacity * 2) {
-    grow_shard(shard);
+// Attempt to see if the provided slice or string matches an existing interned
+// slice, and failing that, create an interned slice with its contents. Returns
+// either the existing matching interned slice or the newly created one.
+// SliceArgs... is either a const grpc_slice& or a string and length. In either
+// case, hash is the pre-computed hash value. We do not hold the shard lock
+// here, but do take it.
+//
+// Returns: an interned slice, either pre-existing/matched or newly created.
+template <class... SliceArgs>
+static InternedSliceRefcount* FindOrCreateInternedSlice(uint32_t hash,
+                                                        SliceArgs&&... args) {
+  slice_shard* shard = &g_shards[SHARD_IDX(hash)];
+  gpr_mu_lock(&shard->mu);
+  const size_t idx = TABLE_IDX(hash, shard->capacity);
+  InternedSliceRefcount* s =
+      MatchInternedSliceLocked(hash, idx, std::forward<SliceArgs>(args)...);
+  if (s == nullptr) {
+    s = InternNewStringLocked(shard, idx, hash,
+                              std::forward<SliceArgs>(args)...);
   }
-
   gpr_mu_unlock(&shard->mu);
-  return materialize(s);
+  return s;
+}
+
+grpc_core::ManagedMemorySlice::ManagedMemorySlice(const char* string)
+    : grpc_core::ManagedMemorySlice::ManagedMemorySlice(string,
+                                                        strlen(string)) {}
+
+grpc_core::ManagedMemorySlice::ManagedMemorySlice(const char* string,
+                                                  size_t len) {
+  GPR_TIMER_SCOPE("grpc_slice_intern", 0);
+  const uint32_t hash = gpr_murmur_hash3(string, len, g_hash_seed);
+  const StaticMetadataSlice* static_slice = MatchStaticSlice(hash, string, len);
+  if (static_slice) {
+    *this = *static_slice;
+  } else {
+    *this =
+        grpc_core::InternedSlice(FindOrCreateInternedSlice(hash, string, len));
+  }
+}
+
+grpc_core::ManagedMemorySlice::ManagedMemorySlice(const grpc_slice* slice_ptr) {
+  GPR_TIMER_SCOPE("grpc_slice_intern", 0);
+  const grpc_slice& slice = *slice_ptr;
+  if (GRPC_IS_STATIC_METADATA_STRING(slice)) {
+    *this = static_cast<const grpc_core::StaticMetadataSlice&>(slice);
+    return;
+  }
+  const uint32_t hash = grpc_slice_hash_internal(slice);
+  const StaticMetadataSlice* static_slice = MatchStaticSlice(hash, slice);
+  if (static_slice) {
+    *this = *static_slice;
+  } else {
+    *this = grpc_core::InternedSlice(FindOrCreateInternedSlice(hash, slice));
+  }
 }
 
 void grpc_test_only_set_slice_hash_seed(uint32_t seed) {
@@ -259,8 +350,8 @@ void grpc_slice_intern_shutdown(void) {
               shard->count);
       for (size_t j = 0; j < shard->capacity; j++) {
         for (InternedSliceRefcount* s = shard->strs[j]; s; s = s->bucket_next) {
-          char* text =
-              grpc_dump_slice(materialize(s), GPR_DUMP_HEX | GPR_DUMP_ASCII);
+          char* text = grpc_dump_slice(grpc_core::InternedSlice(s),
+                                       GPR_DUMP_HEX | GPR_DUMP_ASCII);
           gpr_log(GPR_DEBUG, "LEAKED: %s", text);
           gpr_free(text);
         }