grpc 1.46.3 → 1.53.1

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

@@ -1,49 +1,93 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
+//
+//
+// Copyright 2015 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.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/slice/slice_buffer.h"
+
 #include <string.h>
 
+#include <utility>
+
+#include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice_internal.h"
 
-/* grow a buffer; requires GRPC_SLICE_BUFFER_INLINE_ELEMENTS > 1 */
+namespace grpc_core {
+
+void SliceBuffer::Append(Slice slice) {
+  grpc_slice_buffer_add(&slice_buffer_, slice.TakeCSlice());
+}
+
+void SliceBuffer::Append(const SliceBuffer& other) {
+  for (size_t i = 0; i < other.Count(); i++) {
+    Append(other.RefSlice(i));
+  }
+}
+
+size_t SliceBuffer::AppendIndexed(Slice slice) {
+  return grpc_slice_buffer_add_indexed(&slice_buffer_, slice.TakeCSlice());
+}
+
+Slice SliceBuffer::TakeFirst() {
+  return Slice(grpc_slice_buffer_take_first(&slice_buffer_));
+}
+
+void SliceBuffer::Prepend(Slice slice) {
+  grpc_slice_buffer_undo_take_first(&slice_buffer_, slice.TakeCSlice());
+}
+
+Slice SliceBuffer::RefSlice(size_t index) const {
+  return Slice(CSliceRef(slice_buffer_.slices[index]));
+}
+
+std::string SliceBuffer::JoinIntoString() const {
+  std::string result;
+  result.reserve(slice_buffer_.length);
+  for (size_t i = 0; i < slice_buffer_.count; i++) {
+    result.append(reinterpret_cast<const char*>(
+                      GRPC_SLICE_START_PTR(slice_buffer_.slices[i])),
+                  GRPC_SLICE_LENGTH(slice_buffer_.slices[i]));
+  }
+  return result;
+}
+
+}  // namespace grpc_core
+
+// grow a buffer; requires GRPC_SLICE_BUFFER_INLINE_ELEMENTS > 1
 #define GROW(x) (3 * (x) / 2)
 
-/* Typically, we do not actually need to embiggen (by calling
- * memmove/malloc/realloc) - only if we were up against the full capacity of the
- * slice buffer. If do_embiggen is inlined, the compiler clobbers multiple
- * registers pointlessly in the common case. */
+// Typically, we do not actually need to embiggen (by calling
+// memmove/malloc/realloc) - only if we were up against the full capacity of the
+// slice buffer. If do_embiggen is inlined, the compiler clobbers multiple
+// registers pointlessly in the common case.
 static void GPR_ATTRIBUTE_NOINLINE do_embiggen(grpc_slice_buffer* sb,
                                                const size_t slice_count,
                                                const size_t slice_offset) {
   if (slice_offset != 0) {
-    /* Make room by moving elements if there's still space unused */
+    // Make room by moving elements if there's still space unused
     memmove(sb->base_slices, sb->slices, sb->count * sizeof(grpc_slice));
     sb->slices = sb->base_slices;
   } else {
-    /* Allocate more memory if no more space is available */
+    // Allocate more memory if no more space is available
     const size_t new_capacity = GROW(sb->capacity);
     sb->capacity = new_capacity;
     if (sb->base_slices == sb->inlined) {
@@ -65,7 +109,7 @@ static void maybe_embiggen(grpc_slice_buffer* sb) {
     return;
   }
 
-  /* How far away from sb->base_slices is sb->slices pointer */
+  // How far away from sb->base_slices is sb->slices pointer
   size_t slice_offset = static_cast<size_t>(sb->slices - sb->base_slices);
   size_t slice_count = sb->count + slice_offset;
   if (GPR_UNLIKELY(slice_count == sb->capacity)) {
@@ -80,26 +124,17 @@ void grpc_slice_buffer_init(grpc_slice_buffer* sb) {
   sb->base_slices = sb->slices = sb->inlined;
 }
 
-void grpc_slice_buffer_destroy_internal(grpc_slice_buffer* sb) {
-  grpc_slice_buffer_reset_and_unref_internal(sb);
+void grpc_slice_buffer_destroy(grpc_slice_buffer* sb) {
+  grpc_slice_buffer_reset_and_unref(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
+    // to prevent a double free attempt if grpc_slice_buffer_destroy
     // is invoked two times on the same slice buffer.
     sb->base_slices = sb->slices = sb->inlined;
   }
 }
 
-void grpc_slice_buffer_destroy(grpc_slice_buffer* sb) {
-  if (grpc_core::ExecCtx::Get() == nullptr) {
-    grpc_core::ExecCtx exec_ctx;
-    grpc_slice_buffer_destroy_internal(sb);
-  } else {
-    grpc_slice_buffer_destroy_internal(sb);
-  }
-}
-
 uint8_t* grpc_slice_buffer_tiny_add(grpc_slice_buffer* sb, size_t n) {
   grpc_slice* back;
   uint8_t* out;
@@ -138,13 +173,29 @@ size_t grpc_slice_buffer_add_indexed(grpc_slice_buffer* sb, grpc_slice s) {
 
 void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice s) {
   size_t n = sb->count;
-  /* if both the last slice in the slice buffer and the slice being added
-     are inlined (that is, that they carry their data inside the slice data
-     structure), and the back slice is not full, then concatenate directly
-     into the back slice, preventing many small slices being passed into
-     writes */
+  grpc_slice* back = nullptr;
+  if (n != 0) {
+    back = &sb->slices[n - 1];
+  }
+  if (s.refcount != nullptr && back != nullptr &&
+      s.refcount == back->refcount &&
+      GRPC_SLICE_START_PTR(s) == GRPC_SLICE_END_PTR(*back)) {
+    // Merge the two slices into one because they are contiguous and share the
+    // same refcount object.
+    back->data.refcounted.length += GRPC_SLICE_LENGTH(s);
+    sb->length += GRPC_SLICE_LENGTH(s);
+    // Unref the merged slice.
+    grpc_core::CSliceUnref(s);
+    // early out
+    return;
+  }
+
   if (!s.refcount && n) {
-    grpc_slice* back = &sb->slices[n - 1];
+    // if both the last slice in the slice buffer and the slice being added
+    // are inlined (that is, that they carry their data inside the slice data
+    // structure), and the back slice is not full, then concatenate directly
+    // into the back slice, preventing many small slices being passed into
+    // writes
     if (!back->refcount &&
         back->data.inlined.length < GRPC_SLICE_INLINED_SIZE) {
       if (s.data.inlined.length + back->data.inlined.length <=
@@ -168,7 +219,7 @@ void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice s) {
                s.data.inlined.length - cp1);
       }
       sb->length += s.data.inlined.length;
-      return; /* early out */
+      return;  // early out
     }
   }
   grpc_slice_buffer_add_indexed(sb, s);
@@ -188,10 +239,10 @@ void grpc_slice_buffer_pop(grpc_slice_buffer* sb) {
   }
 }
 
-void grpc_slice_buffer_reset_and_unref_internal(grpc_slice_buffer* sb) {
+void grpc_slice_buffer_reset_and_unref(grpc_slice_buffer* sb) {
   size_t i;
   for (i = 0; i < sb->count; i++) {
-    grpc_slice_unref_internal(sb->slices[i]);
+    grpc_core::CSliceUnref(sb->slices[i]);
   }
 
   sb->count = 0;
@@ -199,15 +250,6 @@ void grpc_slice_buffer_reset_and_unref_internal(grpc_slice_buffer* sb) {
   sb->slices = sb->base_slices;
 }
 
-void grpc_slice_buffer_reset_and_unref(grpc_slice_buffer* sb) {
-  if (grpc_core::ExecCtx::Get() == nullptr) {
-    grpc_core::ExecCtx exec_ctx;
-    grpc_slice_buffer_reset_and_unref_internal(sb);
-  } else {
-    grpc_slice_buffer_reset_and_unref_internal(sb);
-  }
-}
-
 void grpc_slice_buffer_swap(grpc_slice_buffer* a, grpc_slice_buffer* b) {
   size_t a_offset = static_cast<size_t>(a->slices - a->base_slices);
   size_t b_offset = static_cast<size_t>(b->slices - b->base_slices);
@@ -217,34 +259,34 @@ void grpc_slice_buffer_swap(grpc_slice_buffer* a, grpc_slice_buffer* b) {
 
   if (a->base_slices == a->inlined) {
     if (b->base_slices == b->inlined) {
-      /* swap contents of inlined buffer */
+      // swap contents of inlined buffer
       grpc_slice temp[GRPC_SLICE_BUFFER_INLINE_ELEMENTS];
       memcpy(temp, a->base_slices, a_count * sizeof(grpc_slice));
       memcpy(a->base_slices, b->base_slices, b_count * sizeof(grpc_slice));
       memcpy(b->base_slices, temp, a_count * sizeof(grpc_slice));
     } else {
-      /* a is inlined, b is not - copy a inlined into b, fix pointers */
+      // a is inlined, b is not - copy a inlined into b, fix pointers
       a->base_slices = b->base_slices;
       b->base_slices = b->inlined;
       memcpy(b->base_slices, a->inlined, a_count * sizeof(grpc_slice));
     }
   } else if (b->base_slices == b->inlined) {
-    /* b is inlined, a is not - copy b inlined int a, fix pointers */
+    // b is inlined, a is not - copy b inlined int a, fix pointers
     b->base_slices = a->base_slices;
     a->base_slices = a->inlined;
     memcpy(a->base_slices, b->inlined, b_count * sizeof(grpc_slice));
   } else {
-    /* no inlining: easy swap */
+    // no inlining: easy swap
     std::swap(a->base_slices, b->base_slices);
   }
 
-  /* Update the slices pointers (cannot do a std::swap on slices fields here).
-   * Also note that since the base_slices pointers are already swapped we need
-   * use 'b_offset' for 'a->base_slices' and vice versa */
+  // Update the slices pointers (cannot do a std::swap on slices fields here).
+  // Also note that since the base_slices pointers are already swapped we need
+  // use 'b_offset' for 'a->base_slices' and vice versa
   a->slices = a->base_slices + b_offset;
   b->slices = b->base_slices + a_offset;
 
-  /* base_slices and slices fields are correctly set. Swap all other fields */
+  // base_slices and slices fields are correctly set. Swap all other fields
   std::swap(a->count, b->count);
   std::swap(a->capacity, b->capacity);
   std::swap(a->length, b->length);
@@ -252,16 +294,16 @@ void grpc_slice_buffer_swap(grpc_slice_buffer* a, grpc_slice_buffer* b) {
 
 void grpc_slice_buffer_move_into(grpc_slice_buffer* src,
                                  grpc_slice_buffer* dst) {
-  /* anything to move? */
+  // anything to move?
   if (src->count == 0) {
     return;
   }
-  /* anything in dst? */
+  // anything in dst?
   if (dst->count == 0) {
     grpc_slice_buffer_swap(src, dst);
     return;
   }
-  /* both buffers have data - copy, and reset src */
+  // both buffers have data - copy, and reset src
   grpc_slice_buffer_addn(dst, src->slices, src->count);
   src->count = 0;
   src->length = 0;
@@ -288,13 +330,13 @@ static void slice_buffer_move_first_maybe_ref(grpc_slice_buffer* src, size_t n,
     } else if (n == slice_len) {
       grpc_slice_buffer_add(dst, slice);
       break;
-    } else if (incref) { /* n < slice_len */
+    } else if (incref) {  // n < slice_len
       grpc_slice_buffer_undo_take_first(
           src, grpc_slice_split_tail_maybe_ref(&slice, n, GRPC_SLICE_REF_BOTH));
       GPR_ASSERT(GRPC_SLICE_LENGTH(slice) == n);
       grpc_slice_buffer_add(dst, slice);
       break;
-    } else { /* n < slice_len */
+    } else {  // n < slice_len
       grpc_slice_buffer_undo_take_first(
           src, grpc_slice_split_tail_maybe_ref(&slice, n, GRPC_SLICE_REF_TAIL));
       GPR_ASSERT(GRPC_SLICE_LENGTH(slice) == n);
@@ -332,14 +374,32 @@ void grpc_slice_buffer_move_first_into_buffer(grpc_slice_buffer* src, size_t n,
       n = 0;
     } else if (slice_len == n) {
       memcpy(dstp, GRPC_SLICE_START_PTR(slice), n);
-      grpc_slice_unref_internal(slice);
+      grpc_core::CSliceUnref(slice);
       n = 0;
     } else {
       memcpy(dstp, GRPC_SLICE_START_PTR(slice), slice_len);
       dstp += slice_len;
       n -= slice_len;
-      grpc_slice_unref_internal(slice);
+      grpc_core::CSliceUnref(slice);
+    }
+  }
+}
+
+void grpc_slice_buffer_copy_first_into_buffer(grpc_slice_buffer* src, size_t n,
+                                              void* dst) {
+  uint8_t* dstp = static_cast<uint8_t*>(dst);
+  GPR_ASSERT(src->length >= n);
+
+  for (size_t i = 0; i < src->count; i++) {
+    grpc_slice slice = src->slices[i];
+    size_t slice_len = GRPC_SLICE_LENGTH(slice);
+    if (slice_len >= n) {
+      memcpy(dstp, GRPC_SLICE_START_PTR(slice), n);
+      return;
     }
+    memcpy(dstp, GRPC_SLICE_START_PTR(slice), slice_len);
+    dstp += slice_len;
+    n -= slice_len;
   }
 }
 
@@ -356,14 +416,14 @@ void grpc_slice_buffer_trim_end(grpc_slice_buffer* sb, size_t n,
       if (garbage) {
         grpc_slice_buffer_add_indexed(garbage, slice);
       } else {
-        grpc_slice_unref_internal(slice);
+        grpc_core::CSliceUnref(slice);
       }
       return;
     } else if (slice_len == n) {
       if (garbage) {
         grpc_slice_buffer_add_indexed(garbage, slice);
       } else {
-        grpc_slice_unref_internal(slice);
+        grpc_core::CSliceUnref(slice);
       }
       sb->count = idx;
       return;
@@ -371,7 +431,7 @@ void grpc_slice_buffer_trim_end(grpc_slice_buffer* sb, size_t n,
       if (garbage) {
         grpc_slice_buffer_add_indexed(garbage, slice);
       } else {
-        grpc_slice_unref_internal(slice);
+        grpc_core::CSliceUnref(slice);
       }
       n -= slice_len;
       sb->count = idx;
@@ -393,7 +453,7 @@ grpc_slice grpc_slice_buffer_take_first(grpc_slice_buffer* sb) {
 void grpc_slice_buffer_remove_first(grpc_slice_buffer* sb) {
   GPR_DEBUG_ASSERT(sb->count > 0);
   sb->length -= GRPC_SLICE_LENGTH(sb->slices[0]);
-  grpc_slice_unref_internal(sb->slices[0]);
+  grpc_core::CSliceUnref(sb->slices[0]);
   sb->slices++;
   if (--sb->count == 0) {
     sb->slices = sb->base_slices;

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

@@ -0,0 +1,168 @@
+// Copyright 2022 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_SRC_CORE_LIB_SLICE_SLICE_BUFFER_H
+#define GRPC_SRC_CORE_LIB_SLICE_SLICE_BUFFER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stdint.h>
+#include <string.h>
+
+#include <memory>
+#include <string>
+
+#include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
+
+#include "src/core/lib/slice/slice.h"
+
+namespace grpc_core {
+
+/// A slice buffer holds the memory for a collection of slices.
+/// The SliceBuffer object itself is meant to only hide the C-style API,
+/// and won't hold the data itself. In terms of lifespan, the
+/// grpc_slice_buffer ought to be kept somewhere inside the caller's objects,
+/// like a transport or an endpoint.
+///
+/// This lifespan rule is likely to change in the future, as we may
+/// collapse the grpc_slice_buffer structure straight into this class.
+///
+/// The SliceBuffer API is basically a replica of the grpc_slice_buffer's,
+/// and its documentation will move here once we remove the C structure,
+/// which should happen before the EventEngine's API is no longer
+/// an experimental API.
+class SliceBuffer {
+ public:
+  explicit SliceBuffer() { grpc_slice_buffer_init(&slice_buffer_); }
+  SliceBuffer(const SliceBuffer& other) = delete;
+  SliceBuffer(SliceBuffer&& other) noexcept {
+    grpc_slice_buffer_init(&slice_buffer_);
+    grpc_slice_buffer_swap(&slice_buffer_, &other.slice_buffer_);
+  }
+  /// Upon destruction, the underlying raw slice buffer is cleaned out and all
+  /// slices are unreffed.
+  ~SliceBuffer() { grpc_slice_buffer_destroy(&slice_buffer_); }
+
+  SliceBuffer& operator=(const SliceBuffer&) = delete;
+  SliceBuffer& operator=(SliceBuffer&& other) noexcept {
+    grpc_slice_buffer_swap(&slice_buffer_, &other.slice_buffer_);
+    return *this;
+  }
+
+  /// Appends a new slice into the SliceBuffer and makes an attempt to merge
+  /// this slice with the last slice in the SliceBuffer.
+  void Append(Slice slice);
+  /// Appends a SliceBuffer into the SliceBuffer and makes an attempt to merge
+  /// this slice with the last slice in the SliceBuffer.
+  void Append(const SliceBuffer& other);
+
+  /// Adds a new slice into the SliceBuffer at the next available index.
+  /// Returns the index at which the new slice is added.
+  size_t AppendIndexed(Slice slice);
+
+  /// Returns the number of slices held by the SliceBuffer.
+  size_t Count() const { return slice_buffer_.count; }
+
+  /// Removes/deletes the last n bytes in the SliceBuffer.
+  void RemoveLastNBytes(size_t n) {
+    grpc_slice_buffer_trim_end(&slice_buffer_, n, nullptr);
+  }
+
+  /// Move the first n bytes of the SliceBuffer into a memory pointed to by dst.
+  void MoveFirstNBytesIntoBuffer(size_t n, void* dst) {
+    grpc_slice_buffer_move_first_into_buffer(&slice_buffer_, n, dst);
+  }
+
+  /// Removes/deletes the last n bytes in the SliceBuffer and add it to the
+  /// other SliceBuffer
+  void MoveLastNBytesIntoSliceBuffer(size_t n, SliceBuffer& other) {
+    grpc_slice_buffer_trim_end(&slice_buffer_, n, &other.slice_buffer_);
+  }
+
+  /// Move the first n bytes of the SliceBuffer into the other SliceBuffer
+  void MoveFirstNBytesIntoSliceBuffer(size_t n, SliceBuffer& other) {
+    grpc_slice_buffer_move_first(&slice_buffer_, n, &other.slice_buffer_);
+  }
+
+  /// Removes and unrefs all slices in the SliceBuffer.
+  void Clear() { grpc_slice_buffer_reset_and_unref(&slice_buffer_); }
+
+  /// Removes the first slice in the SliceBuffer and returns it.
+  Slice TakeFirst();
+
+  /// Prepends the slice to the the front of the SliceBuffer.
+  void Prepend(Slice slice);
+
+  /// Increased the ref-count of slice at the specified index and returns the
+  /// associated slice.
+  Slice RefSlice(size_t index) const;
+
+  const Slice& operator[](size_t index) const {
+    return grpc_event_engine::experimental::internal::SliceCast<Slice>(
+        slice_buffer_.slices[index]);
+  }
+
+  /// The total number of bytes held by the SliceBuffer
+  size_t Length() const { return slice_buffer_.length; }
+
+  /// Swap with another slice buffer
+  void Swap(SliceBuffer* other) {
+    grpc_slice_buffer_swap(c_slice_buffer(), other->c_slice_buffer());
+  }
+
+  /// Concatenate all slices and return the resulting string.
+  std::string JoinIntoString() const;
+
+  // Return a copy of the slice buffer
+  SliceBuffer Copy() const {
+    SliceBuffer copy;
+    for (size_t i = 0; i < Count(); i++) {
+      copy.Append(RefSlice(i));
+    }
+    return copy;
+  }
+
+  /// Add a small amount to the end of the slice buffer.
+  uint8_t* AddTiny(size_t n) {
+    return grpc_slice_buffer_tiny_add(&slice_buffer_, n);
+  }
+
+  /// Return a pointer to the back raw grpc_slice_buffer
+  grpc_slice_buffer* c_slice_buffer() { return &slice_buffer_; }
+
+  /// Return a pointer to the back raw grpc_slice_buffer
+  const grpc_slice_buffer* c_slice_buffer() const { return &slice_buffer_; }
+
+  const grpc_slice& c_slice_at(size_t index) {
+    return slice_buffer_.slices[index];
+  }
+
+ private:
+  /// The backing raw slice buffer.
+  grpc_slice_buffer slice_buffer_;
+
+// Make failure to destruct show up in ASAN builds.
+#ifndef NDEBUG
+  std::unique_ptr<int> asan_canary_ = std::make_unique<int>(0);
+#endif
+};
+
+}  // namespace grpc_core
+
+// Copy the first n bytes of src into memory pointed to by dst.
+void grpc_slice_buffer_copy_first_into_buffer(grpc_slice_buffer* src, size_t n,
+                                              void* dst);
+
+#endif  // GRPC_SRC_CORE_LIB_SLICE_SLICE_BUFFER_H

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

@@ -1,43 +1,38 @@
-/*
- *
- * Copyright 2016 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_INTERNAL_H
-#define GRPC_CORE_LIB_SLICE_SLICE_INTERNAL_H
+//
+//
+// Copyright 2016 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_SRC_CORE_LIB_SLICE_SLICE_INTERNAL_H
+#define GRPC_SRC_CORE_LIB_SLICE_SLICE_INTERNAL_H
 
 #include <grpc/support/port_platform.h>
 
-#include <string.h>
+#include <stdint.h>
 
+#include <cstddef>
+#include <string>
+
+#include "absl/hash/hash.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
-#include <grpc/slice_buffer.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gpr/murmur_hash.h"
 #include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/gprpp/ref_counted.h"
-#include "src/core/lib/slice/slice_refcount.h"
-
-void grpc_slice_buffer_reset_and_unref_internal(grpc_slice_buffer* sb);
-void grpc_slice_buffer_partial_unref_internal(grpc_slice_buffer* sb,
-                                              size_t idx);
-void grpc_slice_buffer_destroy_internal(grpc_slice_buffer* sb);
 
 // Returns a pointer to the first slice in the slice buffer without giving
 // ownership to or a reference count on that slice.
@@ -53,7 +48,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);
 
-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)
 // used for surface boundaries where we might receive an un-interned static
@@ -63,11 +57,6 @@ 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_internal(const grpc_slice& s) {
-  return gpr_murmur_hash3(GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s),
-                          grpc_core::g_hash_seed);
-}
-
 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);
@@ -80,14 +69,6 @@ size_t grpc_slice_memory_usage(grpc_slice s);
 
 namespace grpc_core {
 
-struct SliceHash {
-  std::size_t operator()(const grpc_slice& slice) const {
-    return grpc_slice_hash_internal(slice);
-  }
-};
-
-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(
@@ -97,8 +78,20 @@ inline absl::string_view StringViewFromSlice(const grpc_slice& slice) {
 
 }  // namespace grpc_core
 
+inline uint32_t grpc_slice_hash(const grpc_slice& s) {
+  return absl::HashOf(grpc_core::StringViewFromSlice(s));
+}
+
+namespace grpc_core {
+struct SliceHash {
+  std::size_t operator()(const grpc_slice& slice) const {
+    return grpc_slice_hash(slice);
+  }
+};
+}  // namespace grpc_core
+
 inline bool operator==(const grpc_slice& s1, const grpc_slice& s2) {
   return grpc_slice_eq(s1, s2);
 }
 
-#endif /* GRPC_CORE_LIB_SLICE_SLICE_INTERNAL_H */
+#endif  // GRPC_SRC_CORE_LIB_SLICE_SLICE_INTERNAL_H