grpc 1.40.0 → 1.46.3

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

@@ -0,0 +1,86 @@
+// 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_CALL_FINALIZATION_H
+#define GRPC_CORE_LIB_CHANNEL_CALL_FINALIZATION_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/resource_quota/arena.h"
+
+namespace grpc_core {
+
+// Call finalization context.
+// Sometimes a filter needs to perform some operation after the last byte of
+// data is flushed to the wire. This context is used to perform that
+// finalization.
+// Filters can register a finalizer by calling Add().
+// The finalizer will be called before the call is destroyed but after
+// the top level promise is completed.
+class CallFinalization {
+ public:
+  // Add a step to the finalization context.
+  // Takes a callable with a signature compatible with:
+  // (const grpc_call_final_info&) -> void.
+  // Finalizers are run in the reverse order they are added.
+  template <typename F>
+  void Add(F&& t) {
+    first_ =
+        GetContext<Arena>()->New<FuncFinalizer<F>>(std::forward<F>(t), first_);
+  }
+
+  void Run(const grpc_call_final_info* final_info) {
+    if (Finalizer* f = absl::exchange(first_, nullptr)) f->Run(final_info);
+  }
+
+ private:
+  // Base class for finalizer implementations.
+  class Finalizer {
+   public:
+    // Run the finalizer and call the destructor of this Finalizer.
+    virtual void Run(const grpc_call_final_info* final_info) = 0;
+
+   protected:
+    ~Finalizer() {}
+  };
+  // Specialization for callable objects.
+  template <typename F>
+  class FuncFinalizer final : public Finalizer {
+   public:
+    FuncFinalizer(F&& f, Finalizer* next)
+        : next_(next), f_(std::forward<F>(f)) {}
+
+    void Run(const grpc_call_final_info* final_info) override {
+      f_(final_info);
+      Finalizer* next = next_;
+      this->~FuncFinalizer();
+      if (next != nullptr) next->Run(final_info);
+    }
+
+   private:
+    Finalizer* next_;
+    F f_;
+  };
+  // The first finalizer in the chain.
+  Finalizer* first_ = nullptr;
+};
+
+template <>
+struct ContextType<CallFinalization> {};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_CHANNEL_CALL_FINALIZATION_H

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

@@ -18,24 +18,149 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/channel/channel_args.h"
+
 #include <limits.h>
 #include <string.h>
 
+#include <map>
 #include <vector>
 
+#include "absl/strings/match.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
-#include <grpc/grpc.h>
 #include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/impl/codegen/log.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/channel/channel_args.h"
 #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;
@@ -145,7 +270,7 @@ grpc_channel_args* grpc_channel_args_union(const grpc_channel_args* a,
 }
 
 static int cmp_arg(const grpc_arg* a, const grpc_arg* b) {
-  int c = GPR_ICMP(a->type, b->type);
+  int c = grpc_core::QsortCompare(a->type, b->type);
   if (c != 0) return c;
   c = strcmp(a->key, b->key);
   if (c != 0) return c;
@@ -153,17 +278,10 @@ static int cmp_arg(const grpc_arg* a, const grpc_arg* b) {
     case GRPC_ARG_STRING:
       return strcmp(a->value.string, b->value.string);
     case GRPC_ARG_INTEGER:
-      return GPR_ICMP(a->value.integer, b->value.integer);
+      return grpc_core::QsortCompare(a->value.integer, b->value.integer);
     case GRPC_ARG_POINTER:
-      c = GPR_ICMP(a->value.pointer.p, b->value.pointer.p);
-      if (c != 0) {
-        c = GPR_ICMP(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);
 }
@@ -174,7 +292,7 @@ static int cmp_key_stable(const void* ap, const void* bp) {
   const grpc_arg* const* a = static_cast<const grpc_arg* const*>(ap);
   const grpc_arg* const* b = static_cast<const grpc_arg* const*>(bp);
   int c = strcmp((*a)->key, (*b)->key);
-  if (c == 0) c = GPR_ICMP(*a, *b);
+  if (c == 0) c = grpc_core::QsortCompare(*a, *b);
   return c;
 }
 
@@ -224,7 +342,7 @@ int grpc_channel_args_compare(const grpc_channel_args* a,
                               const grpc_channel_args* b) {
   if (a == nullptr && b == nullptr) return 0;
   if (a == nullptr || b == nullptr) return a == nullptr ? -1 : 1;
-  int c = GPR_ICMP(a->num_args, b->num_args);
+  int c = grpc_core::QsortCompare(a->num_args, b->num_args);
   if (c != 0) return c;
   for (size_t i = 0; i < a->num_args; i++) {
     c = cmp_arg(&a->args[i], &b->args[i]);
@@ -366,6 +484,45 @@ std::string grpc_channel_args_string(const grpc_channel_args* args) {
   return absl::StrJoin(arg_strings, ", ");
 }
 
+namespace grpc_core {
+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.
+    // We preserve this behavior for backwards compatibility.
+    if (key == GRPC_ARG_PRIMARY_USER_AGENT_STRING ||
+        key == GRPC_ARG_SECONDARY_USER_AGENT_STRING) {
+      if (src->args[i].type != GRPC_ARG_STRING) {
+        gpr_log(GPR_ERROR, "Channel argument '%s' should be a string",
+                std::string(key).c_str());
+      } else {
+        concatenated_values[key].push_back(src->args[i].value.string);
+      }
+      continue;
+    } else if (absl::StartsWith(key, "grpc.internal.")) {
+      continue;
+    }
+    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.
+    }
+  }
+  // Concatenate the concatenated values.
+  for (const auto& concatenated_value : concatenated_values) {
+    output = output.Set(concatenated_value.first,
+                        absl::StrJoin(concatenated_value.second, " "));
+  }
+  return output;
+}
+}  // namespace grpc_core
+
 namespace {
 grpc_channel_args_client_channel_creation_mutator g_mutator = nullptr;
 }  // namespace

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

@@ -23,12 +23,218 @@
 
 #include <string>
 
-#include <grpc/grpc.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>
+
+#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);
 
@@ -119,6 +325,13 @@ grpc_arg grpc_channel_arg_pointer_create(char* name, void* value,
 // Returns a string representing channel args in human-readable form.
 std::string grpc_channel_args_string(const grpc_channel_args* args);
 
+namespace grpc_core {
+// Ensure no duplicate channel args (with some backwards compatibility hacks).
+// Eliminate any grpc.internal.* args.
+// Return a C++ object.
+ChannelArgs ChannelArgsBuiltinPrecondition(const grpc_channel_args* src);
+}  // namespace grpc_core
+
 // Takes ownership of the old_args
 typedef grpc_channel_args* (*grpc_channel_args_client_channel_creation_mutator)(
     const char* target, grpc_channel_args* old_args,

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

@@ -0,0 +1,42 @@
+// Copyright 2021 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_args_preconditioning.h"
+
+#include <grpc/support/alloc.h>
+
+namespace grpc_core {
+
+void ChannelArgsPreconditioning::Builder::RegisterStage(Stage stage) {
+  stages_.emplace_back(std::move(stage));
+}
+
+ChannelArgsPreconditioning ChannelArgsPreconditioning::Builder::Build() {
+  ChannelArgsPreconditioning preconditioning;
+  preconditioning.stages_ = std::move(stages_);
+  return preconditioning;
+}
+
+const grpc_channel_args* 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();
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,61 @@
+// Copyright 2021 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_ARGS_PRECONDITIONING_H
+#define GRPC_CORE_LIB_CHANNEL_CHANNEL_ARGS_PRECONDITIONING_H
+
+#include <grpc/support/port_platform.h>
+
+#include <functional>
+#include <vector>
+
+#include "src/core/lib/channel/channel_args.h"
+
+namespace grpc_core {
+
+// Registry of mutators for channel args.
+// Surface APIs should call into this with channel args received from outside
+// of gRPC, in order to prepare those channel args for the expections of the
+// gRPC internals.
+class ChannelArgsPreconditioning {
+ public:
+  // 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<ChannelArgs(ChannelArgs)>;
+
+  class Builder {
+   public:
+    // Register a new channel args preconditioner.
+    void RegisterStage(Stage stage);
+    // Build out the preconditioners.
+    ChannelArgsPreconditioning Build();
+
+   private:
+    std::vector<Stage> stages_;
+  };
+
+  // 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;
+
+ private:
+  std::vector<Stage> stages_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_CHANNEL_CHANNEL_ARGS_PRECONDITIONING_H