grpc 1.46.2-x86_64-linux → 1.48.0.pre1-x86_64-linux

data/include/grpc/compression.h

@@ -23,7 +23,7 @@
 
 #include <stdlib.h>
 
-#include <grpc/impl/codegen/compression_types.h>
+#include <grpc/impl/codegen/compression_types.h>  // IWYU pragma: export
 #include <grpc/slice.h>
 
 #ifdef __cplusplus

data/include/grpc/event_engine/event_engine.h

@@ -21,13 +21,13 @@
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
-#include "absl/time/time.h"
 
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/event_engine/port.h>
+#include <grpc/event_engine/slice_buffer.h>
 
-// TODO(hork): Define the Endpoint::Write metrics collection system
+// TODO(vigneshbabu): Define the Endpoint::Write metrics collection system
 namespace grpc_event_engine {
 namespace experimental {
 
@@ -73,6 +73,11 @@ namespace experimental {
 ////////////////////////////////////////////////////////////////////////////////
 class EventEngine {
  public:
+  /// A duration between two events.
+  ///
+  /// Throughout the EventEngine API durations are used to express how long
+  /// until an action should be performed.
+  using Duration = std::chrono::duration<int64_t, std::nano>;
   /// A custom closure type for EventEngine task execution.
   ///
   /// Throughout the EventEngine API, \a Closure ownership is retained by the
@@ -138,6 +143,18 @@ class EventEngine {
     /// Shuts down all connections and invokes all pending read or write
     /// callbacks with an error status.
     virtual ~Endpoint() = default;
+    /// A struct representing optional arguments that may be provided to an
+    /// EventEngine Endpoint Read API  call.
+    ///
+    /// Passed as argument to an Endpoint \a Read
+    struct ReadArgs {
+      // A suggestion to the endpoint implementation to read at-least the
+      // specified number of bytes over the network connection before marking
+      // the endpoint read operation as complete. gRPC may use this argument
+      // to minimize the number of endpoint read API calls over the lifetime
+      // of a connection.
+      int64_t read_hint_bytes;
+    };
     /// Reads data from the Endpoint.
     ///
     /// When data is available on the connection, that data is moved into the
@@ -156,7 +173,21 @@ class EventEngine {
     /// statuses to \a on_read. For example, callbacks might expect to receive
     /// CANCELLED on endpoint shutdown.
     virtual void Read(std::function<void(absl::Status)> on_read,
-                      SliceBuffer* buffer) = 0;
+                      SliceBuffer* buffer, const ReadArgs* args) = 0;
+    /// A struct representing optional arguments that may be provided to an
+    /// EventEngine Endpoint Write API call.
+    ///
+    /// Passed as argument to an Endpoint \a Write
+    struct WriteArgs {
+      // Represents private information that may be passed by gRPC for
+      // select endpoints expected to be used only within google.
+      void* google_specific = nullptr;
+      // A suggestion to the endpoint implementation to group data to be written
+      // into frames of the specified max_frame_size. gRPC may use this
+      // argument to dynamically control the max sizes of frames sent to a
+      // receiver in response to high receiver memory pressure.
+      int64_t max_frame_size;
+    };
     /// Writes data out on the connection.
     ///
     /// \a on_writable is called when the connection is ready for more data. The
@@ -176,7 +207,7 @@ class EventEngine {
     /// statuses to \a on_writable. For example, callbacks might expect to
     /// receive CANCELLED on endpoint shutdown.
     virtual void Write(std::function<void(absl::Status)> on_writable,
-                       SliceBuffer* data) = 0;
+                       SliceBuffer* data, const WriteArgs* args) = 0;
     /// Returns an address in the format described in DNSResolver. The returned
     /// values are expected to remain valid for the life of the Endpoint.
     virtual const ResolvedAddress& GetPeerAddress() const = 0;
@@ -243,7 +274,7 @@ class EventEngine {
                                    const ResolvedAddress& addr,
                                    const EndpointConfig& args,
                                    MemoryAllocator memory_allocator,
-                                   absl::Time deadline) = 0;
+                                   Duration timeout) = 0;
 
   /// Request cancellation of a connection attempt.
   ///
@@ -259,7 +290,13 @@ class EventEngine {
    public:
     /// Task handle for DNS Resolution requests.
     struct LookupTaskHandle {
-      intptr_t key[2];
+      intptr_t keys[2];
+    };
+    /// Optional configuration for DNSResolvers.
+    struct ResolverOptions {
+      /// If empty, default DNS servers will be used.
+      /// Must be in the "IP:port" format as described in naming.md.
+      std::string dns_server;
     };
     /// DNS SRV record type.
     struct SRVRecord {
@@ -293,23 +330,23 @@ class EventEngine {
     ///
     /// If cancelled, \a on_resolve will not be executed.
     virtual LookupTaskHandle LookupHostname(LookupHostnameCallback on_resolve,
-                                            absl::string_view address,
+                                            absl::string_view name,
                                             absl::string_view default_port,
-                                            absl::Time deadline) = 0;
+                                            Duration timeout) = 0;
     /// Asynchronously perform an SRV record lookup.
     ///
     /// \a on_resolve has the same meaning and expectations as \a
     /// LookupHostname's \a on_resolve callback.
     virtual LookupTaskHandle LookupSRV(LookupSRVCallback on_resolve,
                                        absl::string_view name,
-                                       absl::Time deadline) = 0;
+                                       Duration timeout) = 0;
     /// Asynchronously perform a TXT record lookup.
     ///
     /// \a on_resolve has the same meaning and expectations as \a
     /// LookupHostname's \a on_resolve callback.
     virtual LookupTaskHandle LookupTXT(LookupTXTCallback on_resolve,
                                        absl::string_view name,
-                                       absl::Time deadline) = 0;
+                                       Duration timeout) = 0;
     /// Cancel an asynchronous lookup operation.
     ///
     /// This shares the same semantics with \a EventEngine::Cancel: successfully
@@ -331,8 +368,10 @@ class EventEngine {
   // de-experimentalize this API.
   virtual bool IsWorkerThread() = 0;
 
-  /// Creates and returns an instance of a DNSResolver.
-  virtual std::unique_ptr<DNSResolver> GetDNSResolver() = 0;
+  /// Creates and returns an instance of a DNSResolver, optionally configured by
+  /// the \a options struct.
+  virtual std::unique_ptr<DNSResolver> GetDNSResolver(
+      const DNSResolver::ResolverOptions& options) = 0;
 
   /// Asynchronously executes a task as soon as possible.
   ///
@@ -349,13 +388,13 @@ class EventEngine {
   /// in some scenarios. This overload is useful in situations where performance
   /// is not a critical concern.
   virtual void Run(std::function<void()> closure) = 0;
-  /// Synonymous with scheduling an alarm to run at time \a when.
+  /// Synonymous with scheduling an alarm to run after duration \a when.
   ///
   /// The \a closure will execute when time \a when arrives unless it has been
   /// cancelled via the \a Cancel method. If cancelled, the closure will not be
   /// run, nor will it be deleted. Ownership remains with the caller.
-  virtual TaskHandle RunAt(absl::Time when, Closure* closure) = 0;
-  /// Synonymous with scheduling an alarm to run at time \a when.
+  virtual TaskHandle RunAfter(Duration when, Closure* closure) = 0;
+  /// Synonymous with scheduling an alarm to run after duration \a when.
   ///
   /// The \a closure will execute when time \a when arrives unless it has been
   /// cancelled via the \a Cancel method. If cancelled, the closure will not be
@@ -363,10 +402,10 @@ class EventEngine {
   /// version's \a closure will be deleted by the EventEngine after the closure
   /// has been run, or upon cancellation.
   ///
-  /// This version of \a RunAt may be less performant than the \a Closure
+  /// This version of \a RunAfter may be less performant than the \a Closure
   /// version in some scenarios. This overload is useful in situations where
   /// performance is not a critical concern.
-  virtual TaskHandle RunAt(absl::Time when, std::function<void()> closure) = 0;
+  virtual TaskHandle RunAfter(Duration when, std::function<void()> closure) = 0;
   /// Request cancellation of a task.
   ///
   /// If the associated closure has already been scheduled to run, it will not
@@ -375,6 +414,11 @@ class EventEngine {
   /// If the associated callback has not been scheduled to run, it will be
   /// cancelled, and the associated std::function or \a Closure* will not be
   /// executed. In this case, Cancel will return true.
+  ///
+  /// Implementation note: closures should be destroyed in a timely manner after
+  /// execution or cancelliation (milliseconds), since any state bound to the
+  /// closure may need to be destroyed for things to progress (e.g., if a
+  /// closure holds a ref to some ref-counted object).
   virtual bool Cancel(TaskHandle handle) = 0;
 };
 
@@ -388,7 +432,7 @@ class EventEngine {
 /// created, applications must set a custom EventEngine factory method *before*
 /// grpc is initialized.
 void SetDefaultEventEngineFactory(
-    const std::function<std::unique_ptr<EventEngine>()>* factory);
+    std::function<std::unique_ptr<EventEngine>()> factory);
 
 /// Create an EventEngine using the default factory.
 std::unique_ptr<EventEngine> CreateEventEngine();

data/include/grpc/event_engine/memory_allocator.h

@@ -26,24 +26,9 @@
 #include <grpc/event_engine/internal/memory_allocator_impl.h>
 #include <grpc/slice.h>
 
-// forward-declaring an internal struct, not used publicly.
-struct grpc_slice_buffer;
-
 namespace grpc_event_engine {
 namespace experimental {
 
-// TODO(nnoble): needs implementation
-class SliceBuffer {
- public:
-  SliceBuffer() { abort(); }
-  explicit SliceBuffer(grpc_slice_buffer*) { abort(); }
-
-  grpc_slice_buffer* RawSliceBuffer() { return slice_buffer_; }
-
- private:
-  grpc_slice_buffer* slice_buffer_;
-};
-
 // Tracks memory allocated by one system.
 // Is effectively a thin wrapper/smart pointer for a MemoryAllocatorImpl,
 // providing a convenient and stable API.

data/include/grpc/event_engine/port.h

@@ -20,7 +20,7 @@
 #if defined(GPR_ANDROID) || defined(GPR_LINUX) || defined(GPR_APPLE) ||     \
     defined(GPR_FREEBSD) || defined(GPR_OPENBSD) || defined(GPR_SOLARIS) || \
     defined(GPR_AIX) || defined(GPR_NACL) || defined(GPR_FUCHSIA) ||        \
-    defined(GRPC_POSIX_SOCKET)
+    defined(GRPC_POSIX_SOCKET) || defined(GPR_NETBSD)
 #define GRPC_EVENT_ENGINE_POSIX
 #include <arpa/inet.h>
 #include <netdb.h>

data/include/grpc/event_engine/slice.h

@@ -0,0 +1,286 @@
+// 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_EVENT_ENGINE_SLICE_H
+#define GRPC_EVENT_ENGINE_SLICE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string.h>
+
+#include <cstdint>
+#include <string>
+#include <utility>
+
+#include "absl/strings/string_view.h"
+
+#include <grpc/slice.h>
+#include <grpc/support/log.h>
+
+// This public slice definition largely based of the internal grpc_core::Slice
+// implementation. Changes to this implementation might warrant changes to the
+// internal grpc_core::Slice type as well.
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// Forward declarations
+class Slice;
+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;
+
+ 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);
+
+  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());
+  }
+};
+
+}  // namespace slice_detail
+
+class MutableSlice : public slice_detail::BaseSlice,
+                     public slice_detail::CopyConstructors<MutableSlice> {
+ public:
+  MutableSlice() = default;
+  explicit MutableSlice(const grpc_slice& slice);
+  ~MutableSlice();
+
+  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() = default;
+  ~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();
+
+  // 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;
+
+  // 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();
+
+  // 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;
+
+  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);
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_EVENT_ENGINE_SLICE_H

data/include/grpc/event_engine/slice_buffer.h

@@ -0,0 +1,118 @@
+// 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_EVENT_ENGINE_SLICE_BUFFER_H
+#define GRPC_EVENT_ENGINE_SLICE_BUFFER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string.h>
+
+#include <cstdint>
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "absl/utility/utility.h"
+
+#include <grpc/event_engine/slice.h>
+#include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
+#include <grpc/support/log.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+/// A Wrapper around \a grpc_slice_buffer pointer.
+///
+/// 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 Event Engine'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
+      : slice_buffer_(other.slice_buffer_) {
+    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);
+
+  /// 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() { 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 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);
+
+  /// The total number of bytes held by the SliceBuffer
+  size_t Length() { return slice_buffer_.length; }
+
+  /// Return a pointer to the back raw grpc_slice_buffer
+  grpc_slice_buffer* c_slice_buffer() { return &slice_buffer_; }
+
+ private:
+  /// The backing raw slice buffer.
+  grpc_slice_buffer slice_buffer_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_EVENT_ENGINE_SLICE_BUFFER_H

data/include/grpc/grpc.h

@@ -24,8 +24,8 @@
 #include <stddef.h>
 
 #include <grpc/byte_buffer.h>
-#include <grpc/impl/codegen/connectivity_state.h>
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/impl/codegen/connectivity_state.h>  // IWYU pragma: export
+#include <grpc/impl/codegen/grpc_types.h>          // IWYU pragma: export
 #include <grpc/impl/codegen/propagation_bits.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
@@ -542,7 +542,7 @@ GRPCAPI void grpc_resource_quota_set_max_threads(
 
 /** EXPERIMENTAL.  Dumps xDS configs as a serialized ClientConfig proto.
     The full name of the proto is envoy.service.status.v3.ClientConfig. */
-GRPCAPI grpc_slice grpc_dump_xds_configs();
+GRPCAPI grpc_slice grpc_dump_xds_configs(void);
 
 /** Fetch a vtable for a grpc_channel_arg that points to a grpc_resource_quota
  */

data/include/grpc/grpc_security.h

@@ -1047,6 +1047,17 @@ typedef struct grpc_tls_certificate_verifier_external {
 grpc_tls_certificate_verifier* grpc_tls_certificate_verifier_external_create(
     grpc_tls_certificate_verifier_external* external_verifier);
 
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * Factory function for an internal verifier that won't perform any
+ * post-handshake verification. Note: using this solely without any other
+ * authentication mechanisms on the peer identity will leave your applications
+ * to the MITM(Man-In-The-Middle) attacks. Users should avoid doing so in
+ * production environments.
+ */
+grpc_tls_certificate_verifier* grpc_tls_certificate_verifier_no_op_create();
+
 /**
  * EXPERIMENTAL API - Subject to change
  *