grpc 1.45.0 → 1.53.0

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

@@ -1,23 +1,23 @@
-/*
- *
- * 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.
- *
- */
-
-#ifndef GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_H
-#define GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_H
+//
+//
+// 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.
+//
+//
+
+#ifndef GRPC_SRC_CORE_LIB_CHANNEL_CHANNEL_STACK_H
+#define GRPC_SRC_CORE_LIB_CHANNEL_CHANNEL_STACK_H
 
 //////////////////////////////////////////////////////////////////////////////
 // IMPORTANT NOTE:
@@ -26,54 +26,57 @@
 // the C++ API in src/cpp/common/channel_filter.{h,cc}
 //////////////////////////////////////////////////////////////////////////////
 
-/* A channel filter defines how operations on a channel are implemented.
-   Channel filters are chained together to create full channels, and if those
-   chains are linear, then channel stacks provide a mechanism to minimize
-   allocations for that chain.
-   Call stacks are created by channel stacks and represent the per-call data
-   for that stack.
-
-   Implementations should take care of the following details for a batch -
-   1. Synchronization is achieved with a CallCombiner. View
-   src/core/lib/iomgr/call_combiner.h for more details.
-   2. If the filter wants to inject an error on the way down, it needs to call
-   grpc_transport_stream_op_batch_finish_with_failure from within the call
-   combiner. This will cause any batch callbacks to be called with that error.
-   3. If the filter wants to inject an error on the way up (from a callback), it
-   should also inject that error in the recv_trailing_metadata callback so that
-   it can have an effect on the call status.
-*/
+// A channel filter defines how operations on a channel are implemented.
+// Channel filters are chained together to create full channels, and if those
+// chains are linear, then channel stacks provide a mechanism to minimize
+// allocations for that chain.
+// Call stacks are created by channel stacks and represent the per-call data
+// for that stack.
+
+// Implementations should take care of the following details for a batch -
+// 1. Synchronization is achieved with a CallCombiner. View
+// src/core/lib/iomgr/call_combiner.h for more details.
+// 2. If the filter wants to inject an error on the way down, it needs to call
+// grpc_transport_stream_op_batch_finish_with_failure from within the call
+// combiner. This will cause any batch callbacks to be called with that error.
+// 3. If the filter wants to inject an error on the way up (from a callback), it
+// should also inject that error in the recv_trailing_metadata callback so that
+// it can have an effect on the call status.
+//
 
 #include <grpc/support/port_platform.h>
 
 #include <stddef.h>
 
 #include <functional>
+#include <memory>
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
+#include <grpc/slice.h>
+#include <grpc/status.h>
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.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"
 
-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;
+  grpc_core::ChannelArgs channel_args;
   int is_first;
   int is_last;
 };
@@ -89,119 +92,135 @@ struct grpc_call_element_args {
 };
 struct grpc_call_stats {
   grpc_transport_stream_stats transport_stream_stats;
-  gpr_timespec latency; /* From call creating to enqueing of received status */
+  gpr_timespec latency;  // From call creating to enqueing of received status
 };
-/** Information about the call upon completion. */
+/// Information about the call upon completion.
 struct grpc_call_final_info {
   grpc_call_stats stats;
   grpc_status_code final_status = GRPC_STATUS_OK;
   const char* error_string = nullptr;
 };
 
-/* Channel filters specify:
-   1. the amount of memory needed in the channel & call (via the sizeof_XXX
-      members)
-   2. functions to initialize and destroy channel & call data
-      (init_XXX, destroy_XXX)
-   3. functions to implement call operations and channel operations (call_op,
-      channel_op)
-   4. a name, which is useful when debugging
+// Channel filters specify:
+// 1. the amount of memory needed in the channel & call (via the sizeof_XXX
+//    members)
+// 2. functions to initialize and destroy channel & call data
+//    (init_XXX, destroy_XXX)
+// 3. functions to implement call operations and channel operations (call_op,
+//    channel_op)
+// 4. a name, which is useful when debugging
 
-   Members are laid out in approximate frequency of use order. */
+// Members are laid out in approximate frequency of use order.
 struct grpc_channel_filter {
-  /* Called to eg. send/receive data on a call.
-     See grpc_call_next_op on how to call the next element in the stack */
+  // Called to eg. send/receive data on a call.
+  // See grpc_call_next_op on how to call the next element in the stack
   void (*start_transport_stream_op_batch)(grpc_call_element* elem,
                                           grpc_transport_stream_op_batch* op);
-  /* Create a promise to execute one call.
-     If this is non-null, it may be used in preference to
-     start_transport_stream_op_batch.
-     If this is used in preference to start_transport_stream_op_batch, the
-     following can be omitted also:
-       - calling init_call_elem, destroy_call_elem, set_pollset_or_pollset_set
-       - 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,
+  // Create a promise to execute one call.
+  // If this is non-null, it may be used in preference to
+  // start_transport_stream_op_batch.
+  // If this is used in preference to start_transport_stream_op_batch, the
+  // following can be omitted also:
+  //   - calling init_call_elem, destroy_call_elem, set_pollset_or_pollset_set
+  //   - 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::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.
-     See grpc_channel_next_op on how to call the next element in the stack */
+  // Called to handle channel level operations - e.g. new calls, or transport
+  // closure.
+  // See grpc_channel_next_op on how to call the next element in the stack
   void (*start_transport_op)(grpc_channel_element* elem, grpc_transport_op* op);
 
-  /* sizeof(per call data) */
+  // sizeof(per call data)
   size_t sizeof_call_data;
-  /* Initialize per call data.
-     elem is initialized at the start of the call, and elem->call_data is what
-     needs initializing.
-     The filter does not need to do any chaining.
-     server_transport_data is an opaque pointer. If it is NULL, this call is
-     on a client; if it is non-NULL, then it points to memory owned by the
-     transport and is on the server. Most filters want to ignore this
-     argument.
-     Implementations may assume that elem->call_data is all zeros. */
+  // Initialize per call data.
+  // elem is initialized at the start of the call, and elem->call_data is what
+  // needs initializing.
+  // The filter does not need to do any chaining.
+  // server_transport_data is an opaque pointer. If it is NULL, this call is
+  // on a client; if it is non-NULL, then it points to memory owned by the
+  // transport and is on the server. Most filters want to ignore this
+  // argument.
+  // Implementations may assume that elem->call_data is all zeros.
   grpc_error_handle (*init_call_elem)(grpc_call_element* elem,
                                       const grpc_call_element_args* args);
   void (*set_pollset_or_pollset_set)(grpc_call_element* elem,
                                      grpc_polling_entity* pollent);
-  /* Destroy per call data.
-     The filter does not need to do any chaining.
-     The bottom filter of a stack will be passed a non-NULL pointer to
-     \a then_schedule_closure that should be passed to GRPC_CLOSURE_SCHED when
-     destruction is complete. \a final_info contains data about the completed
-     call, mainly for reporting purposes. */
+  // Destroy per call data.
+  // The filter does not need to do any chaining.
+  // The bottom filter of a stack will be passed a non-NULL pointer to
+  // \a then_schedule_closure that should be passed to GRPC_CLOSURE_SCHED when
+  // destruction is complete. \a final_info contains data about the completed
+  // call, mainly for reporting purposes.
   void (*destroy_call_elem)(grpc_call_element* elem,
                             const grpc_call_final_info* final_info,
                             grpc_closure* then_schedule_closure);
 
-  /* sizeof(per channel data) */
+  // sizeof(per channel data)
   size_t sizeof_channel_data;
-  /* Initialize per-channel data.
-     elem is initialized at the creating of the channel, and elem->channel_data
-     is what needs initializing.
-     is_first, is_last designate this elements position in the stack, and are
-     useful for asserting correct configuration by upper layer code.
-     The filter does not need to do any chaining.
-     Implementations may assume that elem->channel_data is all zeros. */
+  // Initialize per-channel data.
+  // elem is initialized at the creating of the channel, and elem->channel_data
+  // is what needs initializing.
+  // is_first, is_last designate this elements position in the stack, and are
+  // useful for asserting correct configuration by upper layer code.
+  // The filter does not need to do any chaining.
+  // 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);
-  /* Destroy per channel data.
-     The filter does not need to do any chaining */
+  // 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);
 
-  /* Implement grpc_channel_get_info() */
+  // Implement grpc_channel_get_info()
   void (*get_channel_info)(grpc_channel_element* elem,
                            const grpc_channel_info* channel_info);
 
-  /* The name of this filter */
+  // The name of this filter
   const char* name;
 };
-/* A channel_element tracks its filter and the filter requested memory within
-   a channel allocation */
+// A channel_element tracks its filter and the filter requested memory within
+// a channel allocation
 struct grpc_channel_element {
   const grpc_channel_filter* filter;
   void* channel_data;
 };
 
-/* A call_element tracks its filter, the filter requested memory within
-   a channel allocation, and the filter requested memory within a call
-   allocation */
+// A call_element tracks its filter, the filter requested memory within
+// a channel allocation, and the filter requested memory within a call
+// allocation
 struct grpc_call_element {
   const grpc_channel_filter* filter;
   void* channel_data;
   void* call_data;
 };
 
-/* A channel stack tracks a set of related filters for one channel, and
-   guarantees they live within a single malloc() allocation */
+// A channel stack tracks a set of related filters for one channel, and
+// guarantees they live within a single malloc() allocation
 struct grpc_channel_stack {
   grpc_stream_refcount refcount;
   size_t count;
-  /* Memory required for a call stack (computed at channel stack
-     initialization) */
+  // 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;
+
+  grpc_core::ManualConstructor<
+      std::shared_ptr<grpc_event_engine::experimental::EventEngine>>
+      event_engine;
+
+  grpc_event_engine::experimental::EventEngine* EventEngine() const {
+    return event_engine->get();
+  }
 
   // Minimal infrastructure to act like a RefCounted thing without converting
   // everything.
@@ -214,23 +233,38 @@ struct grpc_channel_stack {
     IncrementRefCount();
     return grpc_core::RefCountedPtr<grpc_channel_stack>(this);
   }
+
+  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle>
+  MakeClientCallPromise(grpc_core::CallArgs call_args);
+  grpc_core::ArenaPromise<grpc_core::ServerMetadataHandle>
+  MakeServerCallPromise(grpc_core::CallArgs call_args);
 };
 
-/* A call stack tracks a set of related filters for one call, and guarantees
-   they live within a single malloc() allocation */
+// A call stack tracks a set of related filters for one call, and guarantees
+// they live within a single malloc() allocation
 struct grpc_call_stack {
-  /* shared refcount for this channel stack.
-     MUST be the first element: the underlying code calls destroy
-     with the address of the refcount, but higher layers prefer to think
-     about the address of the call stack itself. */
+  // shared refcount for this channel stack.
+  // MUST be the first element: the underlying code calls destroy
+  // with the address of the refcount, but higher layers prefer to think
+  // 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 */
+// Get a channel element given a channel stack and its index
 grpc_channel_element* grpc_channel_stack_element(grpc_channel_stack* stack,
                                                  size_t i);
-/* Get the last channel element in a channel stack */
+// Get the last channel element in a channel stack
 grpc_channel_element* grpc_channel_stack_last_element(
     grpc_channel_stack* stack);
 
@@ -240,30 +274,31 @@ grpc_channel_element* grpc_channel_stack_last_element(
 size_t grpc_channel_stack_filter_instance_number(
     grpc_channel_stack* channel_stack, grpc_channel_element* elem);
 
-/* Get a call stack element given a call stack and an index */
+// Get a call stack element given a call stack and an index
 grpc_call_element* grpc_call_stack_element(grpc_call_stack* stack, size_t i);
 
-/* Determine memory required for a channel stack containing a set of filters */
+// Determine memory required for a channel stack containing a set of filters
 size_t grpc_channel_stack_size(const grpc_channel_filter** filters,
                                size_t filter_count);
-/* Initialize a channel stack given some filters */
+// Initialize a channel stack given some filters
 grpc_error_handle grpc_channel_stack_init(
     int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
     const grpc_channel_filter** filters, size_t filter_count,
-    const grpc_channel_args* args, const char* name, grpc_channel_stack* stack);
-/* Destroy a channel stack */
+    const grpc_core::ChannelArgs& args, const char* name,
+    grpc_channel_stack* stack);
+// Destroy a channel stack
 void grpc_channel_stack_destroy(grpc_channel_stack* stack);
 
-/* Initialize a call stack given a channel stack. transport_server_data is
-   expected to be NULL on a client, or an opaque transport owned pointer on the
-   server. */
+// Initialize a call stack given a channel stack. transport_server_data is
+// expected to be NULL on a client, or an opaque transport owned pointer on the
+// server.
 grpc_error_handle grpc_call_stack_init(grpc_channel_stack* channel_stack,
                                        int initial_refs,
                                        grpc_iomgr_cb_func destroy,
                                        void* destroy_arg,
                                        const grpc_call_element_args* elem_args);
-/* Set a pollset or a pollset_set for a call stack: must occur before the first
- * op is started */
+// Set a pollset or a pollset_set for a call stack: must occur before the first
+// op is started
 void grpc_call_stack_set_pollset_or_pollset_set(grpc_call_stack* call_stack,
                                                 grpc_polling_entity* pollent);
 
@@ -307,35 +342,46 @@ inline void grpc_channel_stack::Unref() {
   GRPC_CHANNEL_STACK_UNREF(this, "smart_pointer");
 }
 
-/* Destroy a call stack */
+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,
                              grpc_closure* then_schedule_closure);
 
-/* Ignore set pollset{_set} - used by filters if they don't care about pollsets
- * at all. Does nothing. */
+// Ignore set pollset{_set} - used by filters if they don't care about pollsets
+// at all. Does nothing.
 void grpc_call_stack_ignore_set_pollset_or_pollset_set(
     grpc_call_element* elem, grpc_polling_entity* pollent);
-/* Call the next operation in a call stack */
+// Call the next operation in a call stack
 void grpc_call_next_op(grpc_call_element* elem,
                        grpc_transport_stream_op_batch* op);
-/* Call the next operation (depending on call directionality) in a channel
-   stack */
+// Call the next operation (depending on call directionality) in a channel
+// stack
 void grpc_channel_next_op(grpc_channel_element* elem, grpc_transport_op* op);
-/* Pass through a request to get_channel_info() to the next child element */
+// Pass through a request to get_channel_info() to the next child element
 void grpc_channel_next_get_info(grpc_channel_element* elem,
                                 const grpc_channel_info* channel_info);
 
-/* Given the top element of a channel stack, get the channel stack itself */
+// Given the top element of a channel stack, get the channel stack itself
 grpc_channel_stack* grpc_channel_stack_from_top_element(
     grpc_channel_element* elem);
-/* Given the top element of a call stack, get the call stack itself */
+// Given the top element of a call stack, get the call stack itself
 grpc_call_stack* grpc_call_stack_from_top_element(grpc_call_element* elem);
 
 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)                \
@@ -345,4 +391,4 @@ extern grpc_core::TraceFlag grpc_trace_channel;
     }                                                  \
   } while (0)
 
-#endif /* GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_H */
+#endif  // GRPC_SRC_CORE_LIB_CHANNEL_CHANNEL_STACK_H

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

@@ -1,39 +1,35 @@
-/*
- *
- * 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.
- *
- */
+//
+//
+// 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.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
 #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 "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(const char* name,
+                                         grpc_channel_stack_type type,
+                                         const ChannelArgs& channel_args)
+    : name_(name), type_(type), args_(channel_args) {}
 
 ChannelStackBuilder& ChannelStackBuilder::SetTarget(const char* target) {
   if (target == nullptr) {
@@ -44,86 +40,12 @@ 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);
-  return *this;
-}
-
-void ChannelStackBuilder::PrependFilter(const grpc_channel_filter* filter,
-                                        PostInitFunc post_init) {
-  stack_.insert(stack_.begin(), {filter, std::move(post_init)});
+void ChannelStackBuilder::PrependFilter(const grpc_channel_filter* filter) {
+  stack_.insert(stack_.begin(), filter);
 }
 
-void ChannelStackBuilder::AppendFilter(const grpc_channel_filter* filter,
-                                       PostInitFunc post_init) {
-  stack_.push_back({filter, std::move(post_init)});
-}
-
-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