grpc 1.40.0 → 1.43.1

data/src/core/lib/address_utils/parse_address.cc

@@ -83,14 +83,13 @@ namespace grpc_core {
 
 grpc_error_handle UnixSockaddrPopulate(absl::string_view path,
                                        grpc_resolved_address* resolved_addr) {
+  memset(resolved_addr, 0, sizeof(*resolved_addr));
   struct sockaddr_un* un =
       reinterpret_cast<struct sockaddr_un*>(resolved_addr->addr);
   const size_t maxlen = sizeof(un->sun_path) - 1;
   if (path.size() > maxlen) {
-    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        absl::StrCat("Path name should not have more than ", maxlen,
-                     " characters")
-            .c_str());
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+        "Path name should not have more than ", maxlen, " characters"));
   }
   un->sun_family = AF_UNIX;
   path.copy(un->sun_path, path.size());
@@ -101,14 +100,13 @@ grpc_error_handle UnixSockaddrPopulate(absl::string_view path,
 
 grpc_error_handle UnixAbstractSockaddrPopulate(
     absl::string_view path, grpc_resolved_address* resolved_addr) {
+  memset(resolved_addr, 0, sizeof(*resolved_addr));
   struct sockaddr_un* un =
       reinterpret_cast<struct sockaddr_un*>(resolved_addr->addr);
   const size_t maxlen = sizeof(un->sun_path) - 1;
   if (path.size() > maxlen) {
-    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        absl::StrCat("Path name should not have more than ", maxlen,
-                     " characters")
-            .c_str());
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+        "Path name should not have more than ", maxlen, " characters"));
   }
   un->sun_family = AF_UNIX;
   un->sun_path[0] = '\0';

data/src/core/lib/address_utils/sockaddr_utils.cc

@@ -212,8 +212,8 @@ grpc_error_handle grpc_string_to_sockaddr(grpc_resolved_address* out,
     addr4->sin_family = GRPC_AF_INET;
     out->len = sizeof(grpc_sockaddr_in);
   } else {
-    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-        absl::StrCat("Failed to parse address:", addr).c_str());
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+        absl::StrCat("Failed to parse address:", addr));
   }
   grpc_sockaddr_set_port(out, port);
   return GRPC_ERROR_NONE;

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

@@ -1,94 +1,395 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+// 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_AVL_AVL_H
 #define GRPC_CORE_LIB_AVL_AVL_H
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/sync.h>
-
-/** internal node of an AVL tree */
-typedef struct grpc_avl_node {
-  gpr_refcount refs;
-  void* key;
-  void* value;
-  struct grpc_avl_node* left;
-  struct grpc_avl_node* right;
-  long height;
-} grpc_avl_node;
-
-/** vtable for the AVL tree
- * The optional user_data is propagated from the top level grpc_avl_XXX API.
- * From the same API call, multiple vtable functions may be called multiple
- * times.
- */
-typedef struct grpc_avl_vtable {
-  /** destroy a key */
-  void (*destroy_key)(void* key, void* user_data);
-  /** copy a key, returning new value */
-  void* (*copy_key)(void* key, void* user_data);
-  /** compare key1, key2; return <0 if key1 < key2,
-      >0 if key1 > key2, 0 if key1 == key2 */
-  long (*compare_keys)(void* key1, void* key2, void* user_data);
-  /** destroy a value */
-  void (*destroy_value)(void* value, void* user_data);
-  /** copy a value */
-  void* (*copy_value)(void* value, void* user_data);
-} grpc_avl_vtable;
-
-/** "pointer" to an AVL tree - this is a reference
-    counted object - use grpc_avl_ref to add a reference,
-    grpc_avl_unref when done with a reference */
-typedef struct grpc_avl {
-  const grpc_avl_vtable* vtable;
-  grpc_avl_node* root;
-} grpc_avl;
-
-/** Create an immutable AVL tree. */
-grpc_avl grpc_avl_create(const grpc_avl_vtable* vtable);
-/** Add a reference to an existing tree - returns
-    the tree as a convenience. The optional user_data will be passed to vtable
-    functions. */
-grpc_avl grpc_avl_ref(grpc_avl avl, void* user_data);
-/** Remove a reference to a tree - destroying it if there
-    are no references left. The optional user_data will be passed to vtable
-    functions. */
-void grpc_avl_unref(grpc_avl avl, void* user_data);
-/** Return a new tree with (key, value) added to avl.
-    implicitly unrefs avl to allow easy chaining.
-    if key exists in avl, the new tree's key entry updated
-    (i.e. a duplicate is not created). The optional user_data will be passed to
-    vtable functions. */
-grpc_avl grpc_avl_add(grpc_avl avl, void* key, void* value, void* user_data);
-/** Return a new tree with key deleted
-    implicitly unrefs avl to allow easy chaining. The optional user_data will be
-    passed to vtable functions. */
-grpc_avl grpc_avl_remove(grpc_avl avl, void* key, void* user_data);
-/** Lookup key, and return the associated value.
-    Does not mutate avl.
-    Returns NULL if key is not found. The optional user_data will be passed to
-    vtable functions.*/
-void* grpc_avl_get(grpc_avl avl, void* key, void* user_data);
-/** Return 1 if avl contains key, 0 otherwise; if it has the key, sets *value to
-    its value. The optional user_data will be passed to vtable functions. */
-int grpc_avl_maybe_get(grpc_avl avl, void* key, void** value, void* user_data);
-/** Return 1 if avl is empty, 0 otherwise */
-int grpc_avl_is_empty(grpc_avl avl);
-
-#endif /* GRPC_CORE_LIB_AVL_AVL_H */
+#include <stdlib.h>
+
+#include <algorithm>
+#include <memory>
+
+namespace grpc_core {
+
+template <class K, class V = void>
+class AVL {
+ public:
+  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 {
+    NodePtr n = Get(root_, key);
+    return n ? &n->kv.second : nullptr;
+  }
+
+  const std::pair<K, V>* LookupBelow(const K& key) const {
+    NodePtr n = GetBelow(root_, *key);
+    return n ? &n->kv : nullptr;
+  }
+
+  bool Empty() const { return root_ == nullptr; }
+
+  template <class F>
+  void ForEach(F&& f) const {
+    ForEachImpl(root_.get(), std::forward<F>(f));
+  }
+
+  bool SameIdentity(AVL avl) const { return root_ == avl.root_; }
+
+ private:
+  struct Node;
+  typedef std::shared_ptr<Node> NodePtr;
+  struct Node : public std::enable_shared_from_this<Node> {
+    Node(K k, V v, NodePtr l, NodePtr r, long h)
+        : kv(std::move(k), std::move(v)),
+          left(std::move(l)),
+          right(std::move(r)),
+          height(h) {}
+    const std::pair<K, V> kv;
+    const NodePtr left;
+    const NodePtr right;
+    const long height;
+  };
+  NodePtr root_;
+
+  explicit AVL(NodePtr root) : root_(std::move(root)) {}
+
+  template <class F>
+  static void ForEachImpl(const Node* n, F&& f) {
+    if (n == nullptr) return;
+    ForEachImpl(n->left.get(), std::forward<F>(f));
+    f(const_cast<const K&>(n->kv.first), const_cast<const V&>(n->kv.second));
+    ForEachImpl(n->right.get(), std::forward<F>(f));
+  }
+
+  static long Height(const NodePtr& n) { return n ? n->height : 0; }
+
+  static NodePtr MakeNode(K key, V value, const NodePtr& left,
+                          const NodePtr& right) {
+    return std::make_shared<Node>(std::move(key), std::move(value), left, right,
+                                  1 + std::max(Height(left), Height(right)));
+  }
+
+  static NodePtr Get(const NodePtr& node, const K& key) {
+    if (node == nullptr) {
+      return nullptr;
+    }
+
+    if (node->kv.first > key) {
+      return Get(node->left, key);
+    } else if (node->kv.first < key) {
+      return Get(node->right, key);
+    } else {
+      return node;
+    }
+  }
+
+  static NodePtr GetBelow(const NodePtr& node, const K& key) {
+    if (!node) return nullptr;
+    if (node->kv.first > key) {
+      return GetBelow(node->left, key);
+    } else if (node->kv.first < key) {
+      NodePtr n = GetBelow(node->right, key);
+      if (n == nullptr) n = node;
+      return n;
+    } else {
+      return node;
+    }
+  }
+
+  static NodePtr RotateLeft(K key, V value, const NodePtr& left,
+                            const NodePtr& right) {
+    return MakeNode(
+        right->kv.first, right->kv.second,
+        MakeNode(std::move(key), std::move(value), left, right->left),
+        right->right);
+  }
+
+  static NodePtr RotateRight(K key, V value, const NodePtr& left,
+                             const NodePtr& right) {
+    return MakeNode(
+        left->kv.first, left->kv.second, left->left,
+        MakeNode(std::move(key), std::move(value), left->right, right));
+  }
+
+  static NodePtr RotateLeftRight(K key, V value, const NodePtr& left,
+                                 const NodePtr& right) {
+    /* rotate_right(..., rotate_left(left), right) */
+    return MakeNode(
+        left->right->kv.first, left->right->kv.second,
+        MakeNode(left->kv.first, left->kv.second, left->left,
+                 left->right->left),
+        MakeNode(std::move(key), std::move(value), left->right->right, right));
+  }
+
+  static NodePtr RotateRightLeft(K key, V value, const NodePtr& left,
+                                 const NodePtr& right) {
+    /* rotate_left(..., left, rotate_right(right)) */
+    return MakeNode(
+        right->left->kv.first, right->left->kv.second,
+        MakeNode(std::move(key), std::move(value), left, right->left->left),
+        MakeNode(right->kv.first, right->kv.second, right->left->right,
+                 right->right));
+  }
+
+  static NodePtr Rebalance(K key, V value, const NodePtr& left,
+                           const NodePtr& right) {
+    switch (Height(left) - Height(right)) {
+      case 2:
+        if (Height(left->left) - Height(left->right) == -1) {
+          return RotateLeftRight(std::move(key), std::move(value), left, right);
+        } else {
+          return RotateRight(std::move(key), std::move(value), left, right);
+        }
+      case -2:
+        if (Height(right->left) - Height(right->right) == 1) {
+          return RotateRightLeft(std::move(key), std::move(value), left, right);
+        } else {
+          return RotateLeft(std::move(key), std::move(value), left, right);
+        }
+      default:
+        return MakeNode(key, value, left, right);
+    }
+  }
+
+  static NodePtr AddKey(const NodePtr& node, K key, V value) {
+    if (!node) {
+      return MakeNode(std::move(key), std::move(value), nullptr, nullptr);
+    }
+    if (node->kv.first < key) {
+      return Rebalance(node->kv.first, node->kv.second, node->left,
+                       AddKey(node->right, std::move(key), std::move(value)));
+    }
+    if (key < node->kv.first) {
+      return Rebalance(node->kv.first, node->kv.second,
+                       AddKey(node->left, std::move(key), std::move(value)),
+                       node->right);
+    }
+    return MakeNode(std::move(key), std::move(value), node->left, node->right);
+  }
+
+  static NodePtr InOrderHead(NodePtr node) {
+    while (node->left != nullptr) {
+      node = node->left;
+    }
+    return node;
+  }
+
+  static NodePtr InOrderTail(NodePtr node) {
+    while (node->right != nullptr) {
+      node = node->right;
+    }
+    return node;
+  }
+
+  static NodePtr RemoveKey(const NodePtr& node, const K& key) {
+    if (node == nullptr) {
+      return nullptr;
+    }
+    if (key < node->kv.first) {
+      return Rebalance(node->kv.first, node->kv.second,
+                       RemoveKey(node->left, key), node->right);
+    } else if (node->kv.first < key) {
+      return Rebalance(node->kv.first, node->kv.second, node->left,
+                       RemoveKey(node->right, key));
+    } else {
+      if (node->left == nullptr) {
+        return node->right;
+      } else if (node->right == nullptr) {
+        return node->left;
+      } else if (node->left->height < node->right->height) {
+        NodePtr h = InOrderHead(node->right);
+        return Rebalance(h->kv.first, h->kv.second, node->left,
+                         RemoveKey(node->right, h->kv.first));
+      } else {
+        NodePtr h = InOrderTail(node->left);
+        return Rebalance(h->kv.first, h->kv.second,
+                         RemoveKey(node->left, h->kv.first), node->right);
+      }
+    }
+    abort();
+  }
+};
+
+template <class K>
+class AVL<K, void> {
+ public:
+  AVL() {}
+
+  AVL Add(K key) const { return AVL(AddKey(root_, std::move(key))); }
+  AVL Remove(const K& key) const { return AVL(RemoveKey(root_, key)); }
+  bool Lookup(const K& key) const { return Get(root_, key) != nullptr; }
+  bool Empty() const { return root_ == nullptr; }
+
+  template <class F>
+  void ForEach(F&& f) const {
+    ForEachImpl(root_.get(), std::forward<F>(f));
+  }
+
+  bool SameIdentity(AVL avl) const { return root_ == avl.root_; }
+
+ private:
+  struct Node;
+  typedef std::shared_ptr<Node> NodePtr;
+  struct Node : public std::enable_shared_from_this<Node> {
+    Node(K k, NodePtr l, NodePtr r, long h)
+        : key(std::move(k)),
+          left(std::move(l)),
+          right(std::move(r)),
+          height(h) {}
+    const K key;
+    const NodePtr left;
+    const NodePtr right;
+    const long height;
+  };
+  NodePtr root_;
+
+  explicit AVL(NodePtr root) : root_(std::move(root)) {}
+
+  template <class F>
+  static void ForEachImpl(const Node* n, F&& f) {
+    if (n == nullptr) return;
+    ForEachImpl(n->left.get(), std::forward<F>(f));
+    f(const_cast<const K&>(n->key));
+    ForEachImpl(n->right.get(), std::forward<F>(f));
+  }
+
+  static long Height(const NodePtr& n) { return n ? n->height : 0; }
+
+  static NodePtr MakeNode(K key, const NodePtr& left, const NodePtr& right) {
+    return std::make_shared<Node>(std::move(key), left, right,
+                                  1 + std::max(Height(left), Height(right)));
+  }
+
+  static NodePtr Get(const NodePtr& node, const K& key) {
+    if (node == nullptr) {
+      return nullptr;
+    }
+
+    if (node->key > key) {
+      return Get(node->left, key);
+    } else if (node->key < key) {
+      return Get(node->right, key);
+    } else {
+      return node;
+    }
+  }
+
+  static NodePtr RotateLeft(K key, const NodePtr& left, const NodePtr& right) {
+    return MakeNode(right->key, MakeNode(std::move(key), left, right->left),
+                    right->right);
+  }
+
+  static NodePtr RotateRight(K key, const NodePtr& left, const NodePtr& right) {
+    return MakeNode(left->key, left->left,
+                    MakeNode(std::move(key), left->right, right));
+  }
+
+  static NodePtr RotateLeftRight(K key, const NodePtr& left,
+                                 const NodePtr& right) {
+    /* rotate_right(..., rotate_left(left), right) */
+    return MakeNode(left->right->key,
+                    MakeNode(left->key, left->left, left->right->left),
+                    MakeNode(std::move(key), left->right->right, right));
+  }
+
+  static NodePtr RotateRightLeft(K key, const NodePtr& left,
+                                 const NodePtr& right) {
+    /* rotate_left(..., left, rotate_right(right)) */
+    return MakeNode(right->left->key,
+                    MakeNode(std::move(key), left, right->left->left),
+                    MakeNode(right->key, right->left->right, right->right));
+  }
+
+  static NodePtr Rebalance(K key, const NodePtr& left, const NodePtr& right) {
+    switch (Height(left) - Height(right)) {
+      case 2:
+        if (Height(left->left) - Height(left->right) == -1) {
+          return RotateLeftRight(std::move(key), left, right);
+        } else {
+          return RotateRight(std::move(key), left, right);
+        }
+      case -2:
+        if (Height(right->left) - Height(right->right) == 1) {
+          return RotateRightLeft(std::move(key), left, right);
+        } else {
+          return RotateLeft(std::move(key), left, right);
+        }
+      default:
+        return MakeNode(key, left, right);
+    }
+  }
+
+  static NodePtr AddKey(const NodePtr& node, K key) {
+    if (!node) {
+      return MakeNode(std::move(key), nullptr, nullptr);
+    }
+    if (node->key < key) {
+      return Rebalance(node->key, node->left,
+                       AddKey(node->right, std::move(key)));
+    }
+    if (key < node->key) {
+      return Rebalance(node->key, AddKey(node->left, std::move(key)),
+                       node->right);
+    }
+    return MakeNode(std::move(key), node->left, node->right);
+  }
+
+  static NodePtr InOrderHead(NodePtr node) {
+    while (node->left != nullptr) {
+      node = node->left;
+    }
+    return node;
+  }
+
+  static NodePtr InOrderTail(NodePtr node) {
+    while (node->right != nullptr) {
+      node = node->right;
+    }
+    return node;
+  }
+
+  static NodePtr RemoveKey(const NodePtr& node, const K& key) {
+    if (node == nullptr) {
+      return nullptr;
+    }
+    if (key < node->key) {
+      return Rebalance(node->key, RemoveKey(node->left, key), node->right);
+    } else if (node->key < key) {
+      return Rebalance(node->key, node->left, RemoveKey(node->right, key));
+    } else {
+      if (node->left == nullptr) {
+        return node->right;
+      } else if (node->right == nullptr) {
+        return node->left;
+      } else if (node->left->height < node->right->height) {
+        NodePtr h = InOrderHead(node->right);
+        return Rebalance(h->key, node->left, RemoveKey(node->right, h->key));
+      } else {
+        NodePtr h = InOrderTail(node->left);
+        return Rebalance(h->key, RemoveKey(node->left, h->key), node->right);
+      }
+    }
+    abort();
+  }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_AVL_AVL_H

data/src/core/lib/backoff/backoff.cc

@@ -39,7 +39,7 @@ double generate_uniform_random_number(uint32_t* rng_state) {
 double generate_uniform_random_number_between(uint32_t* rng_state, double a,
                                               double b) {
   if (a == b) return a;
-  if (a > b) GPR_SWAP(double, a, b);  // make sure a < b
+  if (a > b) std::swap(a, b);  // make sure a < b
   const double range = b - a;
   return a + generate_uniform_random_number(rng_state) * range;
 }
@@ -55,7 +55,7 @@ BackOff::BackOff(const Options& options)
 grpc_millis BackOff::NextAttemptTime() {
   if (initial_) {
     initial_ = false;
-    return current_backoff_ + grpc_core::ExecCtx::Get()->Now();
+    return current_backoff_ + ExecCtx::Get()->Now();
   }
   current_backoff_ = static_cast<grpc_millis>(
       std::min(current_backoff_ * options_.multiplier(),
@@ -65,7 +65,7 @@ grpc_millis BackOff::NextAttemptTime() {
       options_.jitter() * current_backoff_);
   const grpc_millis next_timeout =
       static_cast<grpc_millis>(current_backoff_ + jitter);
-  return next_timeout + grpc_core::ExecCtx::Get()->Now();
+  return next_timeout + ExecCtx::Get()->Now();
 }
 
 void BackOff::Reset() {

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

@@ -18,22 +18,23 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/channel/channel_args.h"
+
 #include <limits.h>
 #include <string.h>
 
 #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"
 
@@ -145,7 +146,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,11 +154,12 @@ 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);
+      c = grpc_core::QsortCompare(a->value.pointer.p, b->value.pointer.p);
       if (c != 0) {
-        c = GPR_ICMP(a->value.pointer.vtable, b->value.pointer.vtable);
+        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);
@@ -174,7 +176,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 +226,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 +368,23 @@ std::string grpc_channel_args_string(const grpc_channel_args* args) {
   return absl::StrJoin(arg_strings, ", ");
 }
 
+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;
+}
+}  // namespace grpc_core
+
 namespace {
 grpc_channel_args_client_channel_creation_mutator g_mutator = nullptr;
 }  // namespace

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

@@ -23,7 +23,7 @@
 
 #include <string>
 
-#include <grpc/grpc.h>
+#include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/lib/surface/channel_stack_type.h"
 
@@ -119,6 +119,16 @@ 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 {
+/** 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);
+}  // 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,