grpc 1.48.0-x86_64-linux → 1.49.1-x86_64-linux

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

@@ -22,7 +22,8 @@
 #include <algorithm>  // IWYU pragma: keep
 #include <memory>
 #include <utility>
-#include <vector>
+
+#include "src/core/lib/gpr/useful.h"
 
 namespace grpc_core {
 
@@ -58,33 +59,32 @@ class AVL {
 
   bool SameIdentity(const AVL& avl) const { return root_ == avl.root_; }
 
-  bool operator==(const AVL& other) const {
-    Iterator a(root_);
-    Iterator b(other.root_);
+  friend int QsortCompare(const AVL& left, const AVL& right) {
+    if (left.root_.get() == right.root_.get()) return 0;
+    Iterator a(left.root_);
+    Iterator b(right.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;
+      if (p != q) {
+        if (p == nullptr) return -1;
+        if (q == nullptr) return 1;
+        const int kv = QsortCompare(p->kv, q->kv);
+        if (kv != 0) return kv;
+      } else if (p == nullptr) {
+        return 0;
+      }
       a.MoveNext();
       b.MoveNext();
     }
   }
 
+  bool operator==(const AVL& other) const {
+    return QsortCompare(*this, other) == 0;
+  }
+
   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();
-    }
+    return QsortCompare(*this, other) < 0;
   }
 
  private:
@@ -104,30 +104,52 @@ class AVL {
   };
   NodePtr root_;
 
+  class IteratorStack {
+   public:
+    void Push(Node* n) {
+      nodes_[depth_] = n;
+      ++depth_;
+    }
+
+    Node* Pop() {
+      --depth_;
+      return nodes_[depth_];
+    }
+
+    Node* Back() const { return nodes_[depth_ - 1]; }
+
+    bool Empty() const { return depth_ == 0; }
+
+   private:
+    size_t depth_{0};
+    // 32 is the maximum depth we can accept, and corresponds to ~4billion nodes
+    // - which ought to suffice our use cases.
+    Node* nodes_[32];
+  };
+
   class Iterator {
    public:
     explicit Iterator(const NodePtr& root) {
       auto* n = root.get();
       while (n != nullptr) {
-        stack_.push_back(n);
+        stack_.Push(n);
         n = n->left.get();
       }
     }
-    Node* current() const { return stack_.empty() ? nullptr : stack_.back(); }
+    Node* current() const { return stack_.Empty() ? nullptr : stack_.Back(); }
     void MoveNext() {
-      auto* n = stack_.back();
-      stack_.pop_back();
+      auto* n = stack_.Pop();
       if (n->right != nullptr) {
         n = n->right.get();
         while (n != nullptr) {
-          stack_.push_back(n);
+          stack_.Push(n);
           n = n->left.get();
         }
       }
     }
 
    private:
-    std::vector<Node*> stack_;
+    IteratorStack stack_;
   };
 
   explicit AVL(NodePtr root) : root_(std::move(root)) {}

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

@@ -50,7 +50,7 @@ class CallTracer {
     // Please refer to `grpc_transport_stream_op_batch_payload` for details on
     // arguments.
     virtual void RecordSendInitialMetadata(
-        grpc_metadata_batch* send_initial_metadata, uint32_t flags) = 0;
+        grpc_metadata_batch* send_initial_metadata) = 0;
     // TODO(yashkt): We are using gpr_atm here instead of absl::string_view
     // since that's what the transport API uses, and performing an atomic load
     // is unnecessary if the census tracer does not need it at present. Fix this

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

@@ -41,30 +41,65 @@
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/match.h"
 
-namespace {
+namespace grpc_core {
 
-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);
+ChannelArgs::Pointer::Pointer(void* p, const grpc_arg_pointer_vtable* vtable)
+    : p_(p), vtable_(vtable == nullptr ? EmptyVTable() : vtable) {}
+
+ChannelArgs::Pointer::Pointer(const Pointer& other)
+    : p_(other.vtable_->copy(other.p_)), vtable_(other.vtable_) {}
+
+ChannelArgs::Pointer::Pointer(Pointer&& other) noexcept
+    : p_(other.p_), vtable_(other.vtable_) {
+  other.p_ = nullptr;
+  other.vtable_ = EmptyVTable();
 }
 
-}  // namespace
+const grpc_arg_pointer_vtable* ChannelArgs::Pointer::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;
+}
 
-namespace grpc_core {
+ChannelArgs::ChannelArgs() = default;
+ChannelArgs::~ChannelArgs() = default;
+ChannelArgs::ChannelArgs(const ChannelArgs& other) = default;
+ChannelArgs& ChannelArgs::operator=(const ChannelArgs& other) = default;
+ChannelArgs::ChannelArgs(ChannelArgs&& other) noexcept = default;
+ChannelArgs& ChannelArgs::operator=(ChannelArgs&& other) noexcept = default;
 
-bool ChannelArgs::Pointer::operator==(const Pointer& rhs) const {
-  return PointerCompare(p_, vtable_, rhs.p_, rhs.vtable_) == 0;
+const ChannelArgs::Value* ChannelArgs::Get(absl::string_view name) const {
+  return args_.Lookup(name);
 }
 
-bool ChannelArgs::Pointer::operator<(const Pointer& rhs) const {
-  return PointerCompare(p_, vtable_, rhs.p_, rhs.vtable_) < 0;
+bool ChannelArgs::Contains(absl::string_view name) const {
+  return Get(name) != nullptr;
 }
 
-ChannelArgs::ChannelArgs() = default;
+bool ChannelArgs::operator<(const ChannelArgs& other) const {
+  return args_ < other.args_;
+}
+
+bool ChannelArgs::operator==(const ChannelArgs& other) const {
+  return args_ == other.args_;
+}
+
+bool ChannelArgs::operator!=(const ChannelArgs& other) const {
+  return !(*this == other);
+}
+
+bool ChannelArgs::WantMinimalStack() const {
+  return GetBool(GRPC_ARG_MINIMAL_STACK).value_or(false);
+}
+
+ChannelArgs::ChannelArgs(AVL<std::string, Value> args)
+    : args_(std::move(args)) {}
 
 ChannelArgs ChannelArgs::Set(grpc_arg arg) const {
   switch (arg.type) {
@@ -91,7 +126,7 @@ ChannelArgs ChannelArgs::FromC(const grpc_channel_args* args) {
   return result;
 }
 
-const grpc_channel_args* ChannelArgs::ToC() const {
+ChannelArgs::CPtr 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());
@@ -107,7 +142,16 @@ const grpc_channel_args* ChannelArgs::ToC() const {
                                                  p.c_vtable());
         }));
   });
-  return grpc_channel_args_copy_and_add(nullptr, c_args.data(), c_args.size());
+  return CPtr(static_cast<const grpc_channel_args*>(
+      grpc_channel_args_copy_and_add(nullptr, c_args.data(), c_args.size())));
+}
+
+ChannelArgs ChannelArgs::Set(absl::string_view name, Pointer value) const {
+  return Set(name, Value(std::move(value)));
+}
+
+ChannelArgs ChannelArgs::Set(absl::string_view name, int value) const {
+  return Set(name, Value(value));
 }
 
 ChannelArgs ChannelArgs::Set(absl::string_view key, Value value) const {
@@ -155,6 +199,13 @@ absl::optional<absl::string_view> ChannelArgs::GetString(
   return absl::get<std::string>(*v);
 }
 
+absl::optional<std::string> ChannelArgs::GetOwnedString(
+    absl::string_view name) const {
+  absl::optional<absl::string_view> v = GetString(name);
+  if (!v.has_value()) return absl::nullopt;
+  return std::string(*v);
+}
+
 void* ChannelArgs::GetVoidPointer(absl::string_view name) const {
   auto* v = Get(name);
   if (v == nullptr) return nullptr;
@@ -199,6 +250,22 @@ std::string ChannelArgs::ToString() const {
   return absl::StrCat("{", absl::StrJoin(arg_strings, ", "), "}");
 }
 
+ChannelArgs ChannelArgs::UnionWith(ChannelArgs other) const {
+  args_.ForEach([&other](const std::string& key, const Value& value) {
+    other.args_ = other.args_.Add(key, value);
+  });
+  return other;
+}
+
+void ChannelArgs::ChannelArgsDeleter::operator()(
+    const grpc_channel_args* p) const {
+  grpc_channel_args_destroy(p);
+}
+
+std::ostream& operator<<(std::ostream& out, const ChannelArgs& args) {
+  return out << args.ToString();
+}
+
 }  // namespace grpc_core
 
 static grpc_arg copy_arg(const grpc_arg* src) {
@@ -319,8 +386,9 @@ 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:
-      return PointerCompare(a->value.pointer.p, a->value.pointer.vtable,
-                            b->value.pointer.p, b->value.pointer.vtable);
+      return grpc_core::channel_args_detail::PointerCompare(
+          a->value.pointer.p, a->value.pointer.vtable, b->value.pointer.p,
+          b->value.pointer.vtable);
   }
   GPR_UNREACHABLE_CODE(return 0);
 }
@@ -540,6 +608,7 @@ ChannelArgs ChannelArgsBuiltinPrecondition(const grpc_channel_args* src) {
   }
   return output;
 }
+
 }  // namespace grpc_core
 
 namespace {

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

@@ -24,8 +24,9 @@
 #include <stddef.h>
 
 #include <algorithm>  // IWYU pragma: keep
+#include <iosfwd>
+#include <memory>
 #include <string>
-#include <type_traits>
 #include <utility>
 
 #include "absl/meta/type_traits.h"
@@ -37,6 +38,7 @@
 
 #include "src/core/lib/avl/avl.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/debug_location.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"
@@ -59,23 +61,52 @@ namespace grpc_core {
 template <typename T, typename Ignored = void /* for SFINAE */>
 struct ChannelArgTypeTraits;
 
+namespace channel_args_detail {
+inline int PointerCompare(void* a_ptr, const grpc_arg_pointer_vtable* a_vtable,
+                          void* b_ptr,
+                          const grpc_arg_pointer_vtable* b_vtable) {
+  int c = QsortCompare(a_ptr, b_ptr);
+  if (c == 0) return 0;
+  c = QsortCompare(a_vtable, b_vtable);
+  if (c != 0) return c;
+  return a_vtable->cmp(a_ptr, b_ptr);
+}
+
+// The type returned by calling Ref() on a T - used to determine the basest-type
+// before the crt refcount base class.
+template <typename T>
+using RefType = absl::remove_cvref_t<decltype(*std::declval<T>().Ref())>;
+}  // namespace channel_args_detail
+
 // 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>> {
+    T, absl::enable_if_t<
+           std::is_base_of<RefCounted<channel_args_detail::RefType<T>>,
+                           channel_args_detail::RefType<T>>::value ||
+               std::is_base_of<RefCounted<channel_args_detail::RefType<T>,
+                                          NonPolymorphicRefCount>,
+                               channel_args_detail::RefType<T>>::value ||
+               std::is_base_of<DualRefCounted<channel_args_detail::RefType<T>>,
+                               channel_args_detail::RefType<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(); },
+        [](void* p) -> void* {
+          return p == nullptr ? nullptr
+                              : static_cast<T*>(p)
+                                    ->Ref(DEBUG_LOCATION, "ChannelArgs copy")
+                                    .release();
+        },
         // destroy
-        [](void* p) { static_cast<T*>(p)->Unref(); },
+        [](void* p) {
+          if (p != nullptr) {
+            static_cast<T*>(p)->Unref(DEBUG_LOCATION, "ChannelArgs destroy");
+          }
+        },
         // compare
         [](void* p1, void* p2) {
           return T::ChannelArgsCompare(static_cast<const T*>(p1),
@@ -112,63 +143,77 @@ class ChannelArgs {
  public:
   class Pointer {
    public:
-    Pointer(void* p, const grpc_arg_pointer_vtable* vtable)
-        : p_(p), vtable_(vtable == nullptr ? EmptyVTable() : vtable) {}
+    Pointer(void* p, const grpc_arg_pointer_vtable* vtable);
     ~Pointer() { vtable_->destroy(p_); }
 
-    Pointer(const Pointer& other)
-        : p_(other.vtable_->copy(other.p_)), vtable_(other.vtable_) {}
+    Pointer(const Pointer& other);
     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(Pointer&& other) noexcept;
     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); }
+    friend int QsortCompare(const Pointer& a, const Pointer& b) {
+      return channel_args_detail::PointerCompare(a.p_, a.vtable_, b.p_,
+                                                 b.vtable_);
+    }
+
+    bool operator==(const Pointer& rhs) const {
+      return QsortCompare(*this, rhs) == 0;
+    }
+    bool operator<(const Pointer& rhs) const {
+      return QsortCompare(*this, rhs) < 0;
+    }
+    bool operator!=(const Pointer& rhs) const {
+      return QsortCompare(*this, rhs) != 0;
+    }
 
     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;
-    }
+    static const grpc_arg_pointer_vtable* EmptyVTable();
 
     void* p_;
     const grpc_arg_pointer_vtable* vtable_;
   };
+
   using Value = absl::variant<int, std::string, Pointer>;
 
+  struct ChannelArgsDeleter {
+    void operator()(const grpc_channel_args* p) const;
+  };
+  using CPtr =
+      std::unique_ptr<const grpc_channel_args, ChannelArgs::ChannelArgsDeleter>;
+
   ChannelArgs();
+  ~ChannelArgs();
+  ChannelArgs(const ChannelArgs&);
+  ChannelArgs& operator=(const ChannelArgs&);
+  ChannelArgs(ChannelArgs&&) noexcept;
+  ChannelArgs& operator=(ChannelArgs&&) noexcept;
 
   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;
+  static ChannelArgs FromC(const grpc_channel_args& args) {
+    return FromC(&args);
+  }
+  // Construct a new grpc_channel_args struct.
+  CPtr ToC() const;
 
-  const Value* Get(absl::string_view name) const { return args_.Lookup(name); }
+  // Returns the union of this channel args with other.
+  // If a key is present in both, the value from this is used.
+  GRPC_MUST_USE_RESULT ChannelArgs UnionWith(ChannelArgs other) const;
+
+  const Value* Get(absl::string_view name) const;
   GRPC_MUST_USE_RESULT ChannelArgs Set(absl::string_view name,
-                                       Value value) const;
+                                       Pointer value) const;
+  GRPC_MUST_USE_RESULT ChannelArgs Set(absl::string_view name, int 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,
@@ -187,30 +232,28 @@ class ChannelArgs {
   }
   template <typename T>
   GRPC_MUST_USE_RESULT auto Set(absl::string_view name,
-                                const RefCountedPtr<T>& value) 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,
+          std::is_same<const grpc_arg_pointer_vtable*,
+                       decltype(ChannelArgTypeTraits<
+                                absl::remove_cvref_t<T>>::VTable())>::value,
           ChannelArgs> {
-    auto store_value = value->Ref();
     return Set(
-        name,
-        Pointer(store_value.release(),
-                ChannelArgTypeTraits<
-                    absl::remove_cvref_t<decltype(*store_value)>>::VTable()));
+        name, Pointer(value.release(),
+                      ChannelArgTypeTraits<absl::remove_cvref_t<T>>::VTable()));
   }
   template <typename T>
-  GRPC_MUST_USE_RESULT ChannelArgs SetIfUnset(absl::string_view name, T value) {
+  GRPC_MUST_USE_RESULT ChannelArgs SetIfUnset(absl::string_view name,
+                                              T value) const {
     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; }
+  bool Contains(absl::string_view name) const;
 
   absl::optional<int> GetInt(absl::string_view name) const;
   absl::optional<absl::string_view> GetString(absl::string_view name) const;
+  absl::optional<std::string> GetOwnedString(absl::string_view name) const;
   void* GetVoidPointer(absl::string_view name) const;
   template <typename T>
   T* GetPointer(absl::string_view name) const {
@@ -234,35 +277,43 @@ class ChannelArgs {
     return Set(T::ChannelArgName(), std::move(p));
   }
   template <typename T>
-  T* GetObject() {
+  T* GetObject() const {
     return GetPointer<T>(T::ChannelArgName());
   }
   template <typename T>
-  RefCountedPtr<T> GetObjectRef() {
+  RefCountedPtr<T> GetObjectRef() const {
     auto* p = GetObject<T>();
     if (p == nullptr) return nullptr;
-    return p->Ref();
+    return p->Ref(DEBUG_LOCATION, "ChannelArgs GetObjectRef()");
   }
-
-  bool operator<(const ChannelArgs& other) const { return args_ < other.args_; }
-  bool operator==(const ChannelArgs& other) const {
-    return args_ == other.args_;
+  template <typename T>
+  RefCountedPtr<T> GetObjectRef(const DebugLocation& location,
+                                const char* reason) const {
+    auto* p = GetObject<T>();
+    if (p == nullptr) return nullptr;
+    return p->Ref(location, reason);
   }
 
-  // Helpers for commonly accessed things
+  bool operator!=(const ChannelArgs& other) const;
+  bool operator<(const ChannelArgs& other) const;
+  bool operator==(const ChannelArgs& other) const;
 
-  bool WantMinimalStack() const {
-    return GetBool(GRPC_ARG_MINIMAL_STACK).value_or(false);
-  }
+  // Helpers for commonly accessed things
 
+  bool WantMinimalStack() const;
   std::string ToString() const;
 
  private:
-  explicit ChannelArgs(AVL<std::string, Value> args) : args_(std::move(args)) {}
+  explicit ChannelArgs(AVL<std::string, Value> args);
+
+  GRPC_MUST_USE_RESULT ChannelArgs Set(absl::string_view name,
+                                       Value value) const;
 
   AVL<std::string, Value> args_;
 };
 
+std::ostream& operator<<(std::ostream& out, const ChannelArgs& args);
+
 }  // namespace grpc_core
 
 /** Copy the arguments in \a src into a new instance */
@@ -365,7 +416,7 @@ ChannelArgs ChannelArgsBuiltinPrecondition(const grpc_channel_args* src);
 // Takes ownership of the old_args
 typedef grpc_core::ChannelArgs (
     *grpc_channel_args_client_channel_creation_mutator)(
-    const char* target, grpc_core::ChannelArgs old_args,
+    const char* target, const 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_stack.cc

@@ -27,7 +27,6 @@
 #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");

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

@@ -21,7 +21,6 @@
 #include "src/core/lib/channel/channel_stack_builder.h"
 
 #include <algorithm>
-#include <utility>
 
 #include "src/core/lib/channel/channel_args.h"
 
@@ -38,8 +37,9 @@ ChannelStackBuilder& ChannelStackBuilder::SetTarget(const char* target) {
   return *this;
 }
 
-ChannelStackBuilder& ChannelStackBuilder::SetChannelArgs(ChannelArgs args) {
-  args_ = std::move(args);
+ChannelStackBuilder& ChannelStackBuilder::SetChannelArgs(
+    const ChannelArgs& args) {
+  args_ = args;
   return *this;
 }
 

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

@@ -62,8 +62,8 @@ class ChannelStackBuilder {
   // Query the transport.
   grpc_transport* transport() const { return transport_; }
 
-  // Set channel args (takes a copy of them).
-  ChannelStackBuilder& SetChannelArgs(ChannelArgs args);
+  // Set channel args.
+  ChannelStackBuilder& SetChannelArgs(const ChannelArgs& args);
 
   // Query the channel args.
   const ChannelArgs& channel_args() const { return args_; }

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

@@ -65,7 +65,6 @@ ChannelStackBuilderImpl::Build() {
   }
 
   // and initialize it
-  const grpc_channel_args* c_args = final_args.ToC();
   grpc_error_handle error = grpc_channel_stack_init(
       1,
       [](void* p, grpc_error_handle) {
@@ -73,9 +72,8 @@ ChannelStackBuilderImpl::Build() {
         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);
+      channel_stack, stack->data(), stack->size(), final_args.ToC().get(),
+      name(), channel_stack);
 
   if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_channel_stack_destroy(channel_stack);