grpc 1.45.0 → 1.46.2

data/src/core/lib/avl/avl.h

@@ -22,6 +22,8 @@
 #include <algorithm>
 #include <memory>
 
+#include "absl/container/inlined_vector.h"
+
 namespace grpc_core {
 
 template <class K, class V = void>
@@ -32,8 +34,12 @@ class AVL {
   AVL Add(K key, V value) const {
     return AVL(AddKey(root_, std::move(key), std::move(value)));
   }
-  AVL Remove(const K& key) const { return AVL(RemoveKey(root_, key)); }
-  const V* Lookup(const K& key) const {
+  template <typename SomethingLikeK>
+  AVL Remove(const SomethingLikeK& key) const {
+    return AVL(RemoveKey(root_, key));
+  }
+  template <typename SomethingLikeK>
+  const V* Lookup(const SomethingLikeK& key) const {
     NodePtr n = Get(root_, key);
     return n ? &n->kv.second : nullptr;
   }
@@ -50,7 +56,36 @@ class AVL {
     ForEachImpl(root_.get(), std::forward<F>(f));
   }
 
-  bool SameIdentity(AVL avl) const { return root_ == avl.root_; }
+  bool SameIdentity(const AVL& avl) const { return root_ == avl.root_; }
+
+  bool operator==(const AVL& other) const {
+    Iterator a(root_);
+    Iterator b(other.root_);
+    for (;;) {
+      Node* p = a.current();
+      Node* q = b.current();
+      if (p == nullptr) return q == nullptr;
+      if (q == nullptr) return false;
+      if (p->kv != q->kv) return false;
+      a.MoveNext();
+      b.MoveNext();
+    }
+  }
+
+  bool operator<(const AVL& other) const {
+    Iterator a(root_);
+    Iterator b(other.root_);
+    for (;;) {
+      Node* p = a.current();
+      Node* q = b.current();
+      if (p == nullptr) return q != nullptr;
+      if (q == nullptr) return false;
+      if (p->kv < q->kv) return true;
+      if (p->kv != q->kv) return false;
+      a.MoveNext();
+      b.MoveNext();
+    }
+  }
 
  private:
   struct Node;
@@ -68,6 +103,32 @@ class AVL {
   };
   NodePtr root_;
 
+  class Iterator {
+   public:
+    explicit Iterator(const NodePtr& root) {
+      auto* n = root.get();
+      while (n != nullptr) {
+        stack_.push_back(n);
+        n = n->left.get();
+      }
+    }
+    Node* current() const { return stack_.empty() ? nullptr : stack_.back(); }
+    void MoveNext() {
+      auto* n = stack_.back();
+      stack_.pop_back();
+      if (n->right != nullptr) {
+        n = n->right.get();
+        while (n != nullptr) {
+          stack_.push_back(n);
+          n = n->left.get();
+        }
+      }
+    }
+
+   private:
+    absl::InlinedVector<Node*, 8> stack_;
+  };
+
   explicit AVL(NodePtr root) : root_(std::move(root)) {}
 
   template <class F>
@@ -86,7 +147,8 @@ class AVL {
                                   1 + std::max(Height(left), Height(right)));
   }
 
-  static NodePtr Get(const NodePtr& node, const K& key) {
+  template <typename SomethingLikeK>
+  static NodePtr Get(const NodePtr& node, const SomethingLikeK& key) {
     if (node == nullptr) {
       return nullptr;
     }
@@ -198,7 +260,8 @@ class AVL {
     return node;
   }
 
-  static NodePtr RemoveKey(const NodePtr& node, const K& key) {
+  template <typename SomethingLikeK>
+  static NodePtr RemoveKey(const NodePtr& node, const SomethingLikeK& key) {
     if (node == nullptr) {
       return nullptr;
     }

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

@@ -59,9 +59,12 @@ class CallTracer {
     virtual void RecordReceivedInitialMetadata(
         grpc_metadata_batch* recv_initial_metadata, uint32_t flags) = 0;
     virtual void RecordReceivedMessage(const ByteStream& recv_message) = 0;
+    // If the call was cancelled before the recv_trailing_metadata op
+    // was started, recv_trailing_metadata and transport_stream_stats
+    // will be null.
     virtual void RecordReceivedTrailingMetadata(
         absl::Status status, grpc_metadata_batch* recv_trailing_metadata,
-        const grpc_transport_stream_stats& transport_stream_stats) = 0;
+        const grpc_transport_stream_stats* transport_stream_stats) = 0;
     virtual void RecordCancel(grpc_error_handle cancel_error) = 0;
     // Should be the last API call to the object. Once invoked, the tracer
     // library is free to destroy the object.

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

@@ -37,6 +37,130 @@
 
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/match.h"
+
+namespace {
+
+int PointerCompare(void* a_ptr, const grpc_arg_pointer_vtable* a_vtable,
+                   void* b_ptr, const grpc_arg_pointer_vtable* b_vtable) {
+  int c = grpc_core::QsortCompare(a_ptr, b_ptr);
+  if (c == 0) return 0;
+  c = grpc_core::QsortCompare(a_vtable, b_vtable);
+  if (c != 0) return c;
+  return a_vtable->cmp(a_ptr, b_ptr);
+}
+
+}  // namespace
+
+namespace grpc_core {
+
+bool ChannelArgs::Pointer::operator==(const Pointer& rhs) const {
+  return PointerCompare(p_, vtable_, rhs.p_, rhs.vtable_) == 0;
+}
+
+bool ChannelArgs::Pointer::operator<(const Pointer& rhs) const {
+  return PointerCompare(p_, vtable_, rhs.p_, rhs.vtable_) < 0;
+}
+
+ChannelArgs::ChannelArgs() = default;
+
+ChannelArgs ChannelArgs::Set(grpc_arg arg) const {
+  switch (arg.type) {
+    case GRPC_ARG_INTEGER:
+      return Set(arg.key, arg.value.integer);
+    case GRPC_ARG_STRING:
+      if (arg.value.string != nullptr) return Set(arg.key, arg.value.string);
+      return Set(arg.key, "");
+    case GRPC_ARG_POINTER:
+      return Set(arg.key,
+                 Pointer(arg.value.pointer.vtable->copy(arg.value.pointer.p),
+                         arg.value.pointer.vtable));
+  }
+  GPR_UNREACHABLE_CODE(return ChannelArgs());
+}
+
+ChannelArgs ChannelArgs::FromC(const grpc_channel_args* args) {
+  ChannelArgs result;
+  if (args != nullptr) {
+    for (size_t i = 0; i < args->num_args; i++) {
+      result = result.Set(args->args[i]);
+    }
+  }
+  return result;
+}
+
+const grpc_channel_args* ChannelArgs::ToC() const {
+  std::vector<grpc_arg> c_args;
+  args_.ForEach([&c_args](const std::string& key, const Value& value) {
+    char* name = const_cast<char*>(key.c_str());
+    c_args.push_back(Match(
+        value,
+        [name](int i) { return grpc_channel_arg_integer_create(name, i); },
+        [name](const std::string& s) {
+          return grpc_channel_arg_string_create(name,
+                                                const_cast<char*>(s.c_str()));
+        },
+        [name](const Pointer& p) {
+          return grpc_channel_arg_pointer_create(name, p.c_pointer(),
+                                                 p.c_vtable());
+        }));
+  });
+  return grpc_channel_args_copy_and_add(nullptr, c_args.data(), c_args.size());
+}
+
+ChannelArgs ChannelArgs::Set(absl::string_view key, Value value) const {
+  return ChannelArgs(args_.Add(std::string(key), std::move(value)));
+}
+
+ChannelArgs ChannelArgs::Set(absl::string_view key,
+                             absl::string_view value) const {
+  return Set(key, std::string(value));
+}
+
+ChannelArgs ChannelArgs::Set(absl::string_view key, const char* value) const {
+  return Set(key, std::string(value));
+}
+
+ChannelArgs ChannelArgs::Set(absl::string_view key, std::string value) const {
+  return Set(key, Value(std::move(value)));
+}
+
+ChannelArgs ChannelArgs::Remove(absl::string_view key) const {
+  return ChannelArgs(args_.Remove(key));
+}
+
+absl::optional<int> ChannelArgs::GetInt(absl::string_view name) const {
+  auto* v = Get(name);
+  if (v == nullptr) return absl::nullopt;
+  if (!absl::holds_alternative<int>(*v)) return absl::nullopt;
+  return absl::get<int>(*v);
+}
+
+absl::optional<Duration> ChannelArgs::GetDurationFromIntMillis(
+    absl::string_view name) const {
+  auto ms = GetInt(name);
+  if (!ms.has_value()) return absl::nullopt;
+  if (*ms == INT_MAX) return Duration::Infinity();
+  if (*ms == INT_MIN) return Duration::NegativeInfinity();
+  return Duration::Milliseconds(*ms);
+}
+
+absl::optional<absl::string_view> ChannelArgs::GetString(
+    absl::string_view name) const {
+  auto* v = Get(name);
+  if (v == nullptr) return absl::nullopt;
+  if (!absl::holds_alternative<std::string>(*v)) return absl::nullopt;
+  return absl::get<std::string>(*v);
+}
+
+void* ChannelArgs::GetVoidPointer(absl::string_view name) const {
+  auto* v = Get(name);
+  if (v == nullptr) return nullptr;
+  if (!absl::holds_alternative<Pointer>(*v)) return nullptr;
+  return absl::get<Pointer>(*v).c_pointer();
+}
+
+}  // namespace grpc_core
 
 static grpc_arg copy_arg(const grpc_arg* src) {
   grpc_arg dst;
@@ -156,16 +280,8 @@ static int cmp_arg(const grpc_arg* a, const grpc_arg* b) {
     case GRPC_ARG_INTEGER:
       return grpc_core::QsortCompare(a->value.integer, b->value.integer);
     case GRPC_ARG_POINTER:
-      c = grpc_core::QsortCompare(a->value.pointer.p, b->value.pointer.p);
-      if (c != 0) {
-        c = grpc_core::QsortCompare(a->value.pointer.vtable,
-                                    b->value.pointer.vtable);
-        if (c == 0) {
-          c = a->value.pointer.vtable->cmp(a->value.pointer.p,
-                                           b->value.pointer.p);
-        }
-      }
-      return c;
+      return PointerCompare(a->value.pointer.p, a->value.pointer.vtable,
+                            b->value.pointer.p, b->value.pointer.vtable);
   }
   GPR_UNREACHABLE_CODE(return 0);
 }
@@ -369,25 +485,11 @@ std::string grpc_channel_args_string(const grpc_channel_args* args) {
 }
 
 namespace grpc_core {
-const grpc_channel_args* RemoveGrpcInternalArgs(const grpc_channel_args* src) {
-  if (src == nullptr) return nullptr;
-  // Create result.
-  grpc_channel_args* dst =
-      static_cast<grpc_channel_args*>(gpr_malloc(sizeof(grpc_channel_args)));
-  dst->args =
-      static_cast<grpc_arg*>(gpr_malloc(sizeof(grpc_arg) * src->num_args));
-  dst->num_args = 0;
-  for (size_t i = 0; i < src->num_args; ++i) {
-    if (absl::StartsWith(src->args[i].key, "grpc.internal.")) continue;
-    dst->args[dst->num_args++] = copy_arg(&src->args[i]);
-  }
-  return dst;
-}
-
-const grpc_channel_args* UniquifyChannelArgKeys(const grpc_channel_args* src) {
-  if (src == nullptr) return nullptr;
-  std::map<absl::string_view, const grpc_arg*> values;
-  std::map<absl::string_view, std::vector<std::string>> concatenated_values;
+ChannelArgs ChannelArgsBuiltinPrecondition(const grpc_channel_args* src) {
+  if (src == nullptr) return ChannelArgs();
+  ChannelArgs output;
+  std::map<absl::string_view, std::vector<absl::string_view>>
+      concatenated_values;
   for (size_t i = 0; i < src->num_args; i++) {
     absl::string_view key = src->args[i].key;
     // User-agent strings were traditionally multi-valued and concatenated.
@@ -401,46 +503,23 @@ const grpc_channel_args* UniquifyChannelArgKeys(const grpc_channel_args* src) {
         concatenated_values[key].push_back(src->args[i].value.string);
       }
       continue;
+    } else if (absl::StartsWith(key, "grpc.internal.")) {
+      continue;
     }
-    auto it = values.find(key);
-    if (it == values.end()) {
-      values[key] = &src->args[i];
+    if (!output.Contains(key)) {
+      output = output.Set(src->args[i]);
     } else {
       // Traditional grpc_channel_args_find behavior was to pick the first
       // value.
       // For compatibility with existing users, we will do the same here.
     }
   }
-  if (values.size() + concatenated_values.size() == src->num_args) {
-    return grpc_channel_args_copy(src);
-  }
   // Concatenate the concatenated values.
-  std::map<absl::string_view, std::string> concatenated_values_str;
   for (const auto& concatenated_value : concatenated_values) {
-    concatenated_values_str[concatenated_value.first] =
-        absl::StrJoin(concatenated_value.second, " ");
-  }
-  // Create the result
-  std::vector<grpc_arg> argv;
-  argv.reserve(values.size());
-  for (const auto& a : values) {
-    argv.push_back(*a.second);
-  }
-  for (const auto& a : concatenated_values_str) {
-    argv.push_back(
-        grpc_channel_arg_string_create(const_cast<char*>(a.first.data()),
-                                       const_cast<char*>(a.second.c_str())));
+    output = output.Set(concatenated_value.first,
+                        absl::StrJoin(concatenated_value.second, " "));
   }
-  grpc_channel_args args = {argv.size(), argv.data()};
-  // Log that we're mutating things
-  gpr_log(GPR_INFO,
-          "Uniquification pass on channel args is mutating them: {%s} is being "
-          "changed to {%s}",
-          grpc_channel_args_string(src).c_str(),
-          grpc_channel_args_string(&args).c_str());
-  // Return the result (note we need to copy because we're borrowing the args
-  // from src still!)
-  return grpc_channel_args_copy(&args);
+  return output;
 }
 }  // namespace grpc_core
 

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

@@ -23,12 +23,218 @@
 
 #include <string>
 
+#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>
 
+#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;
+  };
+};
+
+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()));
+  }
+  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;
+
+  // 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());
+  }
+
+  bool operator<(const ChannelArgs& other) const { return args_ < other.args_; }
+  bool operator==(const ChannelArgs& other) const {
+    return args_ == other.args_;
+  }
+
+ 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,15 +326,10 @@ 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

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

@@ -25,10 +25,6 @@ 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;
@@ -36,13 +32,11 @@ ChannelArgsPreconditioning ChannelArgsPreconditioning::Builder::Build() {
 
 const grpc_channel_args* 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.ToC();
 }
 
 }  // namespace grpc_core

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

@@ -33,8 +33,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:

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

@@ -69,8 +69,6 @@ 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 +120,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.