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

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

@@ -21,12 +21,17 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
+#include <algorithm>  // IWYU pragma: keep
 #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 "absl/utility/utility.h"
 
 #include <grpc/impl/codegen/grpc_types.h>
 
@@ -81,6 +86,11 @@ struct ChannelArgTypeTraits<
   };
 };
 
+// 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>> {
@@ -191,6 +201,11 @@ class ChannelArgs {
                 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; }
 
@@ -203,6 +218,7 @@ class ChannelArgs {
   }
   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
@@ -221,12 +237,26 @@ class ChannelArgs {
   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)) {}
 
@@ -333,8 +363,9 @@ 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,8 @@
 
 #include "src/core/lib/channel/channel_args_preconditioning.h"
 
-#include <grpc/support/alloc.h>
+#include <algorithm>
+#include <utility>
 
 namespace grpc_core {
 
@@ -30,13 +31,13 @@ ChannelArgsPreconditioning ChannelArgsPreconditioning::Builder::Build() {
   return preconditioning;
 }
 
-const grpc_channel_args* ChannelArgsPreconditioning::PreconditionChannelArgs(
+ChannelArgs ChannelArgsPreconditioning::PreconditionChannelArgs(
     const grpc_channel_args* args) const {
   ChannelArgs channel_args = ChannelArgsBuiltinPrecondition(args);
   for (auto& stage : stages_) {
     channel_args = stage(std::move(channel_args));
   }
-  return channel_args.ToC();
+  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 {
@@ -49,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_fwd.h

@@ -0,0 +1,26 @@
+// 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_CORE_LIB_CHANNEL_CHANNEL_FWD_H
+#define GRPC_CORE_LIB_CHANNEL_CHANNEL_FWD_H
+
+typedef struct grpc_channel_stack grpc_channel_stack;
+typedef struct grpc_channel_filter grpc_channel_filter;
+
+typedef struct grpc_channel_element grpc_channel_element;
+typedef struct grpc_call_element grpc_call_element;
+
+typedef struct grpc_call_stack grpc_call_stack;
+
+#endif  // GRPC_CORE_LIB_CHANNEL_CHANNEL_FWD_H

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));
@@ -140,8 +143,8 @@ grpc_error_handle grpc_channel_stack_init(
     elems[i].channel_data = user_data;
     grpc_error_handle error =
         elems[i].filter->init_channel_elem(&elems[i], &args);
-    if (error != GRPC_ERROR_NONE) {
-      if (first_error == GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
+      if (GRPC_ERROR_IS_NONE(first_error)) {
         first_error = error;
       } else {
         GRPC_ERROR_UNREF(error);
@@ -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(
@@ -199,8 +205,8 @@ grpc_error_handle grpc_call_stack_init(
   for (size_t i = 0; i < count; i++) {
     grpc_error_handle error =
         call_elems[i].filter->init_call_elem(&call_elems[i], elem_args);
-    if (error != GRPC_ERROR_NONE) {
-      if (first_error == GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
+      if (GRPC_ERROR_IS_NONE(first_error)) {
         first_error = error;
       } else {
         GRPC_ERROR_UNREF(error);
@@ -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,25 +50,27 @@
 
 #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/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;
-
 struct grpc_channel_element_args {
   grpc_channel_stack* channel_stack;
   const grpc_channel_args* channel_args;
@@ -164,6 +166,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);
@@ -195,10 +201,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.
@@ -211,6 +223,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
@@ -222,6 +237,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 */
@@ -304,6 +329,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,
@@ -333,6 +366,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,21 +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::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)});
+void ChannelStackBuilder::AppendFilter(const grpc_channel_filter* filter) {
+  stack_.push_back(filter);
 }
 
 }  // namespace grpc_core

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

@@ -17,22 +17,19 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
-
-#include <functional>
+#include <string>
 #include <vector>
 
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/log.h>
+
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-
-typedef struct grpc_channel_stack grpc_channel_stack;
-typedef struct grpc_channel_element grpc_channel_element;
-typedef struct grpc_channel_filter grpc_channel_filter;
-typedef struct grpc_transport grpc_transport;
+#include "src/core/lib/transport/transport_fwd.h"
 
 namespace grpc_core {
 
@@ -43,17 +40,6 @@ namespace grpc_core {
 // and a transport.
 class ChannelStackBuilder {
  public:
-  // A function that will be called after the channel stack is successfully
-  // built.
-  using PostInitFunc = std::function<void(grpc_channel_stack* channel_stack,
-                                          grpc_channel_element* elem)>;
-
-  // One filter in the currently building stack.
-  struct StackEntry {
-    const grpc_channel_filter* filter;
-    PostInitFunc post_init;
-  };
-
   // Initialize with a name.
   ChannelStackBuilder(const char* name, grpc_channel_stack_type type)
       : name_(name), type_(type) {}
@@ -77,31 +63,29 @@ class ChannelStackBuilder {
   grpc_transport* transport() const { return transport_; }
 
   // Set channel args (takes a copy of them).
-  ChannelStackBuilder& SetChannelArgs(const grpc_channel_args* args);
+  ChannelStackBuilder& SetChannelArgs(ChannelArgs args);
 
   // Query the channel args.
-  const grpc_channel_args* channel_args() const { return args_; }
+  const ChannelArgs& channel_args() const { return args_; }
 
   // Mutable vector of proposed stack entries.
-  std::vector<StackEntry>* mutable_stack() { return &stack_; }
+  std::vector<const grpc_channel_filter*>* mutable_stack() { return &stack_; }
 
   // The type of channel stack being built.
   grpc_channel_stack_type channel_stack_type() const { return type_; }
 
   // Helper to add a filter to the front of the stack.
-  void PrependFilter(const grpc_channel_filter* filter, PostInitFunc post_init);
+  void PrependFilter(const grpc_channel_filter* filter);
 
   // Helper to add a filter to the end of the stack.
-  void AppendFilter(const grpc_channel_filter* filter, PostInitFunc post_init);
+  void AppendFilter(const grpc_channel_filter* filter);
 
   // Build the channel stack.
   // After success, *result holds the new channel stack,
   // prefix_bytes are allocated before the channel stack,
-  // initial_refs, destroy, destroy_arg are as per grpc_channel_stack_init
+  // destroy is as per grpc_channel_stack_init
   // On failure, *result is nullptr.
-  virtual grpc_error_handle Build(size_t prefix_bytes, int initial_refs,
-                                  grpc_iomgr_cb_func destroy, void* destroy_arg,
-                                  void** result) = 0;
+  virtual absl::StatusOr<RefCountedPtr<grpc_channel_stack>> Build() = 0;
 
  protected:
   ~ChannelStackBuilder();
@@ -118,10 +102,11 @@ class ChannelStackBuilder {
   // The transport
   grpc_transport* transport_ = nullptr;
   // Channel args
-  const grpc_channel_args* args_ = nullptr;
+  ChannelArgs args_;
   // The in-progress stack
-  std::vector<StackEntry> stack_;
+  std::vector<const grpc_channel_filter*> stack_;
 };
+
 }  // namespace grpc_core
 
 #endif  // GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_H

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

@@ -22,40 +22,35 @@
 
 #include <string.h>
 
+#include <vector>
+
+#include "absl/status/status.h"
+
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
-grpc_error_handle ChannelStackBuilderImpl::Build(size_t prefix_bytes,
-                                                 int initial_refs,
-                                                 grpc_iomgr_cb_func destroy,
-                                                 void* destroy_arg,
-                                                 void** result) {
+absl::StatusOr<RefCountedPtr<grpc_channel_stack>>
+ChannelStackBuilderImpl::Build() {
   auto* stack = mutable_stack();
 
-  // 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());
+      grpc_channel_stack_size(stack->data(), stack->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);
+  // allocate memory
+  auto* channel_stack =
+      static_cast<grpc_channel_stack*>(gpr_zalloc(channel_stack_size));
 
-  const grpc_channel_args* final_args;
+  ChannelArgs final_args = channel_args();
   if (transport() != nullptr) {
     static const grpc_arg_pointer_vtable vtable = {
         // copy
@@ -65,38 +60,38 @@ grpc_error_handle ChannelStackBuilderImpl::Build(size_t prefix_bytes,
         // 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(channel_args(), &arg, 1);
-  } else {
-    final_args = channel_args();
+    final_args = final_args.Set(GRPC_ARG_TRANSPORT,
+                                ChannelArgs::Pointer(transport(), &vtable));
   }
 
   // and initialize it
+  const grpc_channel_args* c_args = final_args.ToC();
   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 != channel_args()) {
-    grpc_channel_args_destroy(final_args);
-  }
-
-  if (error != GRPC_ERROR_NONE) {
+      1,
+      [](void* p, grpc_error_handle) {
+        auto* stk = static_cast<grpc_channel_stack*>(p);
+        grpc_channel_stack_destroy(stk);
+        gpr_free(stk);
+      },
+      channel_stack, stack->data(), stack->size(), c_args, name(),
+      channel_stack);
+  grpc_channel_args_destroy(c_args);
+
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_channel_stack_destroy(channel_stack);
-    gpr_free(*result);
-    *result = nullptr;
-    return error;
+    gpr_free(channel_stack);
+    auto status = grpc_error_to_absl_status(error);
+    GRPC_ERROR_UNREF(error);
+    return status;
   }
 
   // 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));
-    }
+  for (size_t i = 0; i < stack->size(); i++) {
+    auto* elem = grpc_channel_stack_element(channel_stack, i);
+    elem->filter->post_init_channel_elem(channel_stack, elem);
   }
 
-  return GRPC_ERROR_NONE;
+  return RefCountedPtr<grpc_channel_stack>(channel_stack);
 }
 
 }  // namespace grpc_core

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

@@ -17,11 +17,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
+#include "absl/status/statusor.h"
 
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 
 namespace grpc_core {
 
@@ -39,9 +39,7 @@ class ChannelStackBuilderImpl final : public ChannelStackBuilder {
   // prefix_bytes are allocated before the channel stack,
   // initial_refs, destroy, destroy_arg are as per grpc_channel_stack_init
   // On failure, *result is nullptr.
-  grpc_error_handle Build(size_t prefix_bytes, int initial_refs,
-                          grpc_iomgr_cb_func destroy, void* destroy_arg,
-                          void** result) override;
+  absl::StatusOr<RefCountedPtr<grpc_channel_stack>> Build() override;
 };
 }  // namespace grpc_core