grpc 1.45.0 → 1.47.0

data/src/core/lib/channel/channel_args.h

@@ -21,14 +21,249 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
 #include <string>
+#include <type_traits>
+#include <utility>
+
+#include "absl/meta/type_traits.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "absl/types/variant.h"
 
 #include <grpc/impl/codegen/grpc_types.h>
 
+#include "src/core/lib/avl/avl.h"
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/dual_ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 
 // Channel args are intentionally immutable, to avoid the need for locking.
 
+namespace grpc_core {
+
+// Define a traits object for vtable lookup - allows us to integrate with
+// existing code easily (just define the trait!) and allows some magic in
+// ChannelArgs to automatically derive a vtable from a T*.
+// To participate as a pointer, instances should expose the function:
+//   // Gets the vtable for this type
+//   static const grpc_channel_arg_vtable* VTable();
+//   // Performs any mutations required for channel args to own a pointer
+//   // Only needed if ChannelArgs::Set is to be called with a raw pointer.
+//   static void* TakeUnownedPointer(T* p);
+template <typename T, typename Ignored = void /* for SFINAE */>
+struct ChannelArgTypeTraits;
+
+// Specialization for ref-counted pointers.
+// Types should expose:
+// static int ChannelArgsCompare(const T* a, const T* b);
+template <typename T>
+struct ChannelArgTypeTraits<
+    T,
+    absl::enable_if_t<
+        std::is_base_of<RefCounted<T>, T>::value ||
+            std::is_base_of<RefCounted<T, NonPolymorphicRefCount>, T>::value ||
+            std::is_base_of<DualRefCounted<T>, T>::value,
+        void>> {
+  static const grpc_arg_pointer_vtable* VTable() {
+    static const grpc_arg_pointer_vtable tbl = {
+        // copy
+        [](void* p) -> void* { return static_cast<T*>(p)->Ref().release(); },
+        // destroy
+        [](void* p) { static_cast<T*>(p)->Unref(); },
+        // compare
+        [](void* p1, void* p2) {
+          return T::ChannelArgsCompare(static_cast<const T*>(p1),
+                                       static_cast<const T*>(p2));
+        },
+    };
+    return &tbl;
+  };
+};
+
+// If a type declares some member 'struct RawPointerChannelArgTag {}' then
+// we automatically generate a vtable for it that does not do any ownership
+// management and compares the type by pointer identity.
+// This is intended to be relatively ugly because *most types should worry about
+// ownership*.
+template <typename T>
+struct ChannelArgTypeTraits<T,
+                            absl::void_t<typename T::RawPointerChannelArgTag>> {
+  static void* TakeUnownedPointer(T* p) { return p; }
+  static const grpc_arg_pointer_vtable* VTable() {
+    static const grpc_arg_pointer_vtable tbl = {
+        // copy
+        [](void* p) -> void* { return p; },
+        // destroy
+        [](void*) {},
+        // compare
+        [](void* p1, void* p2) { return QsortCompare(p1, p2); },
+    };
+    return &tbl;
+  };
+};
+
+class ChannelArgs {
+ public:
+  class Pointer {
+   public:
+    Pointer(void* p, const grpc_arg_pointer_vtable* vtable)
+        : p_(p), vtable_(vtable == nullptr ? EmptyVTable() : vtable) {}
+    ~Pointer() { vtable_->destroy(p_); }
+
+    Pointer(const Pointer& other)
+        : p_(other.vtable_->copy(other.p_)), vtable_(other.vtable_) {}
+    Pointer& operator=(Pointer other) {
+      std::swap(p_, other.p_);
+      std::swap(vtable_, other.vtable_);
+      return *this;
+    }
+    Pointer(Pointer&& other) noexcept : p_(other.p_), vtable_(other.vtable_) {
+      other.p_ = nullptr;
+      other.vtable_ = EmptyVTable();
+    }
+    Pointer& operator=(Pointer&& other) noexcept {
+      std::swap(p_, other.p_);
+      std::swap(vtable_, other.vtable_);
+      return *this;
+    }
+
+    bool operator==(const Pointer& rhs) const;
+    bool operator<(const Pointer& rhs) const;
+    bool operator!=(const Pointer& rhs) const { return !(*this == rhs); }
+
+    void* c_pointer() const { return p_; }
+
+    const grpc_arg_pointer_vtable* c_vtable() const { return vtable_; }
+
+   private:
+    static const grpc_arg_pointer_vtable* EmptyVTable() {
+      static const grpc_arg_pointer_vtable vtable = {
+          // copy
+          [](void* p) { return p; },
+          // destroy
+          [](void*) {},
+          // cmp
+          [](void* p1, void* p2) -> int { return QsortCompare(p1, p2); },
+      };
+      return &vtable;
+    }
+
+    void* p_;
+    const grpc_arg_pointer_vtable* vtable_;
+  };
+  using Value = absl::variant<int, std::string, Pointer>;
+
+  ChannelArgs();
+
+  static ChannelArgs FromC(const grpc_channel_args* args);
+  // Construct a new grpc_channel_args struct which the caller will own.
+  // It should be destroyed with grpc_channel_args_destroy.
+  const grpc_channel_args* ToC() const;
+
+  const Value* Get(absl::string_view name) const { return args_.Lookup(name); }
+  GRPC_MUST_USE_RESULT ChannelArgs Set(absl::string_view name,
+                                       Value value) const;
+  GRPC_MUST_USE_RESULT ChannelArgs Set(absl::string_view name,
+                                       absl::string_view value) const;
+  GRPC_MUST_USE_RESULT ChannelArgs Set(absl::string_view name,
+                                       std::string value) const;
+  GRPC_MUST_USE_RESULT ChannelArgs Set(absl::string_view name,
+                                       const char* value) const;
+  GRPC_MUST_USE_RESULT ChannelArgs Set(grpc_arg arg) const;
+  template <typename T>
+  GRPC_MUST_USE_RESULT absl::enable_if_t<
+      std::is_same<const grpc_arg_pointer_vtable*,
+                   decltype(ChannelArgTypeTraits<T>::VTable())>::value,
+      ChannelArgs>
+  Set(absl::string_view name, T* value) const {
+    return Set(name, Pointer(ChannelArgTypeTraits<T>::TakeUnownedPointer(value),
+                             ChannelArgTypeTraits<T>::VTable()));
+  }
+  template <typename T>
+  GRPC_MUST_USE_RESULT auto Set(absl::string_view name,
+                                const RefCountedPtr<T>& value) const
+      -> absl::enable_if_t<
+          std::is_same<
+              const grpc_arg_pointer_vtable*,
+              decltype(ChannelArgTypeTraits<absl::remove_cvref_t<
+                           decltype(*value->Ref())>>::VTable())>::value,
+          ChannelArgs> {
+    auto store_value = value->Ref();
+    return Set(
+        name,
+        Pointer(store_value.release(),
+                ChannelArgTypeTraits<
+                    absl::remove_cvref_t<decltype(*store_value)>>::VTable()));
+  }
+  template <typename T>
+  GRPC_MUST_USE_RESULT ChannelArgs SetIfUnset(absl::string_view name, T value) {
+    if (Contains(name)) return *this;
+    return Set(name, std::move(value));
+  }
+  GRPC_MUST_USE_RESULT ChannelArgs Remove(absl::string_view name) const;
+  bool Contains(absl::string_view name) const { return Get(name) != nullptr; }
+
+  absl::optional<int> GetInt(absl::string_view name) const;
+  absl::optional<absl::string_view> GetString(absl::string_view name) const;
+  void* GetVoidPointer(absl::string_view name) const;
+  template <typename T>
+  T* GetPointer(absl::string_view name) const {
+    return static_cast<T*>(GetVoidPointer(name));
+  }
+  absl::optional<Duration> GetDurationFromIntMillis(
+      absl::string_view name) const;
+  absl::optional<bool> GetBool(absl::string_view name) const;
+
+  // Object based get/set.
+  // Deal with the common case that we set a pointer to an object under
+  // the same name in every usage.
+  // Expects ChannelArgTypeTraits to exist for T, and T to expose:
+  //   static string_view ChannelArgName();
+  template <typename T>
+  GRPC_MUST_USE_RESULT ChannelArgs SetObject(T* p) const {
+    return Set(T::ChannelArgName(), p);
+  }
+  template <typename T>
+  GRPC_MUST_USE_RESULT ChannelArgs SetObject(RefCountedPtr<T> p) const {
+    return Set(T::ChannelArgName(), std::move(p));
+  }
+  template <typename T>
+  T* GetObject() {
+    return GetPointer<T>(T::ChannelArgName());
+  }
+  template <typename T>
+  RefCountedPtr<T> GetObjectRef() {
+    auto* p = GetObject<T>();
+    if (p == nullptr) return nullptr;
+    return p->Ref();
+  }
+
+  bool operator<(const ChannelArgs& other) const { return args_ < other.args_; }
+  bool operator==(const ChannelArgs& other) const {
+    return args_ == other.args_;
+  }
+
+  // Helpers for commonly accessed things
+
+  bool WantMinimalStack() const {
+    return GetBool(GRPC_ARG_MINIMAL_STACK).value_or(false);
+  }
+
+  std::string ToString() const;
+
+ private:
+  explicit ChannelArgs(AVL<std::string, Value> args) : args_(std::move(args)) {}
+
+  AVL<std::string, Value> args_;
+};
+
+}  // namespace grpc_core
+
 /** Copy the arguments in \a src into a new instance */
 grpc_channel_args* grpc_channel_args_copy(const grpc_channel_args* src);
 
@@ -120,20 +355,16 @@ grpc_arg grpc_channel_arg_pointer_create(char* name, void* value,
 std::string grpc_channel_args_string(const grpc_channel_args* args);
 
 namespace grpc_core {
-/** Remove any channel args prefixed with 'grpc.internal.'
- *  These are used for internal implementation details and are not intended to
- *  be exposed to users.
- *  Returns a new channel args instance.
- *  Does not take ownership of \a src.
- *  Should be called by any public API that receives channel args. */
-const grpc_channel_args* RemoveGrpcInternalArgs(const grpc_channel_args* src);
-/** Ensure no duplicate channel args, in preparation for moving to a map<> */
-const grpc_channel_args* UniquifyChannelArgKeys(const grpc_channel_args* src);
+// Ensure no duplicate channel args (with some backwards compatibility hacks).
+// Eliminate any grpc.internal.* args.
+// Return a C++ object.
+ChannelArgs ChannelArgsBuiltinPrecondition(const grpc_channel_args* src);
 }  // namespace grpc_core
 
 // Takes ownership of the old_args
-typedef grpc_channel_args* (*grpc_channel_args_client_channel_creation_mutator)(
-    const char* target, grpc_channel_args* old_args,
+typedef grpc_core::ChannelArgs (
+    *grpc_channel_args_client_channel_creation_mutator)(
+    const char* target, grpc_core::ChannelArgs old_args,
     grpc_channel_stack_type type);
 
 // Should be called only once globaly before grpc is init'ed.

data/src/core/lib/channel/channel_args_preconditioning.cc

@@ -16,7 +16,7 @@
 
 #include "src/core/lib/channel/channel_args_preconditioning.h"
 
-#include <grpc/support/alloc.h>
+#include <utility>
 
 namespace grpc_core {
 
@@ -25,24 +25,18 @@ void ChannelArgsPreconditioning::Builder::RegisterStage(Stage stage) {
 }
 
 ChannelArgsPreconditioning ChannelArgsPreconditioning::Builder::Build() {
-  // TODO(ctiller): should probably make this registered too.
-  stages_.emplace_back(RemoveGrpcInternalArgs);
-  stages_.emplace_back(UniquifyChannelArgKeys);
-
   ChannelArgsPreconditioning preconditioning;
   preconditioning.stages_ = std::move(stages_);
   return preconditioning;
 }
 
-const grpc_channel_args* ChannelArgsPreconditioning::PreconditionChannelArgs(
+ChannelArgs ChannelArgsPreconditioning::PreconditionChannelArgs(
     const grpc_channel_args* args) const {
-  const grpc_channel_args* owned_args = nullptr;
+  ChannelArgs channel_args = ChannelArgsBuiltinPrecondition(args);
   for (auto& stage : stages_) {
-    args = stage(args);
-    grpc_channel_args_destroy(owned_args);
-    owned_args = args;
+    channel_args = stage(std::move(channel_args));
   }
-  return args;
+  return channel_args;
 }
 
 }  // namespace grpc_core

data/src/core/lib/channel/channel_args_preconditioning.h

@@ -20,6 +20,8 @@
 #include <functional>
 #include <vector>
 
+#include <grpc/impl/codegen/grpc_types.h>
+
 #include "src/core/lib/channel/channel_args.h"
 
 namespace grpc_core {
@@ -33,8 +35,7 @@ class ChannelArgsPreconditioning {
   // Take channel args and mutate them.
   // Does not take ownership of the channel args passed in.
   // Returns a new channel args object that is owned by the caller.
-  using Stage =
-      std::function<const grpc_channel_args*(const grpc_channel_args*)>;
+  using Stage = std::function<ChannelArgs(ChannelArgs)>;
 
   class Builder {
    public:
@@ -50,8 +51,7 @@ class ChannelArgsPreconditioning {
   // Take channel args and precondition them.
   // Does not take ownership of the channel args passed in.
   // Returns a new channel args object that is owned by the caller.
-  const grpc_channel_args* PreconditionChannelArgs(
-      const grpc_channel_args* args) const;
+  ChannelArgs PreconditionChannelArgs(const grpc_channel_args* args) const;
 
  private:
   std::vector<Stage> stages_;

data/src/core/lib/channel/channel_stack.cc

@@ -20,13 +20,14 @@
 
 #include "src/core/lib/channel/channel_stack.h"
 
-#include <stdlib.h>
-#include <string.h>
+#include <stdint.h>
+
+#include <utility>
 
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/alloc.h"
+#include "src/core/lib/promise/poll.h"
 
 grpc_core::TraceFlag grpc_trace_channel(false, "channel");
 grpc_core::TraceFlag grpc_trace_channel_stack(false, "channel_stack");
@@ -113,6 +114,8 @@ grpc_error_handle grpc_channel_stack_init(
     }
   }
 
+  stack->on_destroy.Init([]() {});
+
   size_t call_size =
       GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack)) +
       GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filter_count * sizeof(grpc_call_element));
@@ -169,6 +172,9 @@ void grpc_channel_stack_destroy(grpc_channel_stack* stack) {
   for (i = 0; i < count; i++) {
     channel_elems[i].filter->destroy_channel_elem(&channel_elems[i]);
   }
+
+  (*stack->on_destroy)();
+  stack->on_destroy.Destroy();
 }
 
 grpc_error_handle grpc_call_stack_init(
@@ -272,3 +278,35 @@ grpc_call_stack* grpc_call_stack_from_top_element(grpc_call_element* elem) {
       reinterpret_cast<char*>(elem) -
       GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack)));
 }
+
+void grpc_channel_stack_no_post_init(grpc_channel_stack*,
+                                     grpc_channel_element*) {}
+
+namespace {
+
+grpc_core::NextPromiseFactory ClientNext(grpc_channel_element* elem) {
+  return [elem](grpc_core::CallArgs args) {
+    return elem->filter->make_call_promise(elem, std::move(args),
+                                           ClientNext(elem + 1));
+  };
+}
+
+grpc_core::NextPromiseFactory ServerNext(grpc_channel_element* elem) {
+  return [elem](grpc_core::CallArgs args) {
+    return elem->filter->make_call_promise(elem, std::move(args),
+                                           ServerNext(elem - 1));
+  };
+}
+
+}  // namespace
+
+grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle>
+grpc_channel_stack::MakeCallPromise(grpc_core::CallArgs call_args) {
+  if (is_client) {
+    return ClientNext(grpc_channel_stack_element(this, 0))(
+        std::move(call_args));
+  } else {
+    return ServerNext(grpc_channel_stack_element(this, this->count - 1))(
+        std::move(call_args));
+  }
+}

data/src/core/lib/channel/channel_stack.h

@@ -50,27 +50,37 @@
 
 #include <functional>
 
-#include <grpc/grpc.h>
+#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/slice.h>
+#include <grpc/status.h>
 #include <grpc/support/log.h>
-#include <grpc/support/time.h>
 
+#include "src/core/lib/channel/context.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/time_precise.h"
+#include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/call_combiner.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/resource_quota/arena.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 
+struct grpc_call_element;
+struct grpc_call_stack;
+struct grpc_channel_element;
+struct grpc_channel_stack;
+
 typedef struct grpc_channel_element grpc_channel_element;
 typedef struct grpc_call_element grpc_call_element;
 
 typedef struct grpc_channel_stack grpc_channel_stack;
 typedef struct grpc_call_stack grpc_call_stack;
 
-#define GRPC_ARG_TRANSPORT "grpc.internal.transport"
-
 struct grpc_channel_element_args {
   grpc_channel_stack* channel_stack;
   const grpc_channel_args* channel_args;
@@ -122,9 +132,8 @@ struct grpc_channel_filter {
        - allocation of memory for call data
      There is an on-going migration to move all filters to providing this, and
      then to drop start_transport_stream_op_batch. */
-  grpc_core::ArenaPromise<grpc_core::TrailingMetadata> (*make_call_promise)(
-      grpc_channel_element* elem,
-      grpc_core::ClientInitialMetadata initial_metadata,
+  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle> (*make_call_promise)(
+      grpc_channel_element* elem, grpc_core::CallArgs call_args,
       grpc_core::NextPromiseFactory next_promise_factory);
   /* Called to handle channel level operations - e.g. new calls, or transport
      closure.
@@ -167,6 +176,10 @@ struct grpc_channel_filter {
      Implementations may assume that elem->channel_data is all zeros. */
   grpc_error_handle (*init_channel_elem)(grpc_channel_element* elem,
                                          grpc_channel_element_args* args);
+  /* Post init per-channel data.
+     Called after all channel elements have been successfully created. */
+  void (*post_init_channel_elem)(grpc_channel_stack* stk,
+                                 grpc_channel_element* elem);
   /* Destroy per channel data.
      The filter does not need to do any chaining */
   void (*destroy_channel_elem)(grpc_channel_element* elem);
@@ -198,10 +211,16 @@ struct grpc_call_element {
    guarantees they live within a single malloc() allocation */
 struct grpc_channel_stack {
   grpc_stream_refcount refcount;
+  bool is_client;
   size_t count;
   /* Memory required for a call stack (computed at channel stack
      initialization) */
   size_t call_stack_size;
+  // TODO(ctiller): remove this mechanism... it's a hack to allow
+  // Channel to be separated from grpc_channel_stack's allocation. As the
+  // promise conversion continues, we'll reconsider what grpc_channel_stack
+  // should look like and this can go.
+  grpc_core::ManualConstructor<std::function<void()>> on_destroy;
 
   // Minimal infrastructure to act like a RefCounted thing without converting
   // everything.
@@ -214,6 +233,9 @@ struct grpc_channel_stack {
     IncrementRefCount();
     return grpc_core::RefCountedPtr<grpc_channel_stack>(this);
   }
+
+  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle> MakeCallPromise(
+      grpc_core::CallArgs call_args);
 };
 
 /* A call stack tracks a set of related filters for one call, and guarantees
@@ -225,6 +247,16 @@ struct grpc_call_stack {
      about the address of the call stack itself. */
   grpc_stream_refcount refcount;
   size_t count;
+
+  // Minimal infrastructure to act like a RefCounted thing without converting
+  // everything.
+  // grpc_call_stack will be eliminated once the promise conversion completes.
+  void IncrementRefCount();
+  void Unref();
+  grpc_core::RefCountedPtr<grpc_call_stack> Ref() {
+    IncrementRefCount();
+    return grpc_core::RefCountedPtr<grpc_call_stack>(this);
+  }
 };
 
 /* Get a channel element given a channel stack and its index */
@@ -307,6 +339,14 @@ inline void grpc_channel_stack::Unref() {
   GRPC_CHANNEL_STACK_UNREF(this, "smart_pointer");
 }
 
+inline void grpc_call_stack::IncrementRefCount() {
+  GRPC_CALL_STACK_REF(this, "smart_pointer");
+}
+
+inline void grpc_call_stack::Unref() {
+  GRPC_CALL_STACK_UNREF(this, "smart_pointer");
+}
+
 /* Destroy a call stack */
 void grpc_call_stack_destroy(grpc_call_stack* stack,
                              const grpc_call_final_info* final_info,
@@ -336,6 +376,9 @@ void grpc_call_log_op(const char* file, int line, gpr_log_severity severity,
                       grpc_call_element* elem,
                       grpc_transport_stream_op_batch* op);
 
+void grpc_channel_stack_no_post_init(grpc_channel_stack* stk,
+                                     grpc_channel_element* elem);
+
 extern grpc_core::TraceFlag grpc_trace_channel;
 
 #define GRPC_CALL_LOG_OP(sev, elem, op)                \

data/src/core/lib/channel/channel_stack_builder.cc

@@ -20,20 +20,14 @@
 
 #include "src/core/lib/channel/channel_stack_builder.h"
 
-#include <string.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
+#include <algorithm>
+#include <utility>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/channel_stack_builder.h"
-#include "src/core/lib/gprpp/memory.h"
 
 namespace grpc_core {
 
-ChannelStackBuilder::~ChannelStackBuilder() {
-  grpc_channel_args_destroy(args_);
-}
+ChannelStackBuilder::~ChannelStackBuilder() = default;
 
 ChannelStackBuilder& ChannelStackBuilder::SetTarget(const char* target) {
   if (target == nullptr) {
@@ -44,86 +38,17 @@ ChannelStackBuilder& ChannelStackBuilder::SetTarget(const char* target) {
   return *this;
 }
 
-ChannelStackBuilder& ChannelStackBuilder::SetChannelArgs(
-    const grpc_channel_args* args) {
-  grpc_channel_args_destroy(args_);
-  args_ = grpc_channel_args_copy(args);
+ChannelStackBuilder& ChannelStackBuilder::SetChannelArgs(ChannelArgs args) {
+  args_ = std::move(args);
   return *this;
 }
 
-void ChannelStackBuilder::PrependFilter(const grpc_channel_filter* filter,
-                                        PostInitFunc post_init) {
-  stack_.insert(stack_.begin(), {filter, std::move(post_init)});
-}
-
-void ChannelStackBuilder::AppendFilter(const grpc_channel_filter* filter,
-                                       PostInitFunc post_init) {
-  stack_.push_back({filter, std::move(post_init)});
+void ChannelStackBuilder::PrependFilter(const grpc_channel_filter* filter) {
+  stack_.insert(stack_.begin(), filter);
 }
 
-grpc_error_handle ChannelStackBuilder::Build(size_t prefix_bytes,
-                                             int initial_refs,
-                                             grpc_iomgr_cb_func destroy,
-                                             void* destroy_arg, void** result) {
-  // create an array of filters
-  std::vector<const grpc_channel_filter*> filters;
-  filters.reserve(stack_.size());
-  for (const auto& elem : stack_) {
-    filters.push_back(elem.filter);
-  }
-
-  // calculate the size of the channel stack
-  size_t channel_stack_size =
-      grpc_channel_stack_size(filters.data(), filters.size());
-
-  // allocate memory, with prefix_bytes followed by channel_stack_size
-  *result = gpr_zalloc(prefix_bytes + channel_stack_size);
-  // fetch a pointer to the channel stack
-  grpc_channel_stack* channel_stack = reinterpret_cast<grpc_channel_stack*>(
-      static_cast<char*>(*result) + prefix_bytes);
-
-  const grpc_channel_args* final_args;
-  if (transport_ != nullptr) {
-    static const grpc_arg_pointer_vtable vtable = {
-        // copy
-        [](void* p) { return p; },
-        // destroy
-        [](void*) {},
-        // cmp
-        [](void* a, void* b) { return QsortCompare(a, b); },
-    };
-    grpc_arg arg = grpc_channel_arg_pointer_create(
-        const_cast<char*>(GRPC_ARG_TRANSPORT), transport_, &vtable);
-    final_args = grpc_channel_args_copy_and_add(args_, &arg, 1);
-  } else {
-    final_args = args_;
-  }
-
-  // and initialize it
-  grpc_error_handle error = grpc_channel_stack_init(
-      initial_refs, destroy, destroy_arg == nullptr ? *result : destroy_arg,
-      filters.data(), filters.size(), final_args, name_, channel_stack);
-
-  if (final_args != args_) {
-    grpc_channel_args_destroy(final_args);
-  }
-
-  if (error != GRPC_ERROR_NONE) {
-    grpc_channel_stack_destroy(channel_stack);
-    gpr_free(*result);
-    *result = nullptr;
-    return error;
-  }
-
-  // run post-initialization functions
-  for (size_t i = 0; i < filters.size(); i++) {
-    if (stack_[i].post_init != nullptr) {
-      stack_[i].post_init(channel_stack,
-                          grpc_channel_stack_element(channel_stack, i));
-    }
-  }
-
-  return GRPC_ERROR_NONE;
+void ChannelStackBuilder::AppendFilter(const grpc_channel_filter* filter) {
+  stack_.push_back(filter);
 }
 
 }  // namespace grpc_core