grpc 1.56.2 → 1.58.0

data/src/core/ext/xds/xds_http_rbac_filter.cc

@@ -575,17 +575,12 @@ ChannelArgs XdsHttpRbacFilter::ModifyChannelArgs(
 absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
 XdsHttpRbacFilter::GenerateServiceConfig(
     const FilterConfig& hcm_filter_config,
-    const FilterConfig* filter_config_override,
-    absl::string_view filter_name) const {
+    const FilterConfig* filter_config_override) const {
   const Json& policy_json = filter_config_override != nullptr
                                 ? filter_config_override->config
                                 : hcm_filter_config.config;
-  auto json_object = policy_json.object();
-  json_object.emplace("filter_name",
-                      Json::FromString(std::string(filter_name)));
-  // The policy JSON may be empty other than the filter name, that's allowed.
-  return ServiceConfigJsonEntry{"rbacPolicy",
-                                JsonDump(Json::FromObject(json_object))};
+  // The policy JSON may be empty and that's allowed.
+  return ServiceConfigJsonEntry{"rbacPolicy", JsonDump(policy_json)};
 }
 
 }  // namespace grpc_core

data/src/core/ext/xds/xds_http_rbac_filter.h

@@ -48,8 +48,7 @@ class XdsHttpRbacFilter : public XdsHttpFilterImpl {
   ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const override;
   absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
       const FilterConfig& hcm_filter_config,
-      const FilterConfig* filter_config_override,
-      absl::string_view filter_name) const override;
+      const FilterConfig* filter_config_override) const override;
   bool IsSupportedOnClients() const override { return false; }
   bool IsSupportedOnServers() const override { return true; }
 };

data/src/core/ext/xds/xds_http_stateful_session_filter.cc

@@ -211,8 +211,7 @@ ChannelArgs XdsHttpStatefulSessionFilter::ModifyChannelArgs(
 absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
 XdsHttpStatefulSessionFilter::GenerateServiceConfig(
     const FilterConfig& hcm_filter_config,
-    const FilterConfig* filter_config_override,
-    absl::string_view /*filter_name*/) const {
+    const FilterConfig* filter_config_override) const {
   const Json& config = filter_config_override != nullptr
                            ? filter_config_override->config
                            : hcm_filter_config.config;

data/src/core/ext/xds/xds_http_stateful_session_filter.h

@@ -48,8 +48,7 @@ class XdsHttpStatefulSessionFilter : public XdsHttpFilterImpl {
   ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const override;
   absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
       const FilterConfig& hcm_filter_config,
-      const FilterConfig* filter_config_override,
-      absl::string_view filter_name) const override;
+      const FilterConfig* filter_config_override) const override;
   bool IsSupportedOnClients() const override { return true; }
   bool IsSupportedOnServers() const override { return false; }
 };

data/src/core/ext/xds/xds_lb_policy_registry.cc

@@ -29,6 +29,7 @@
 #include "absl/types/variant.h"
 #include "envoy/config/core/v3/extension.upb.h"
 #include "envoy/extensions/load_balancing_policies/client_side_weighted_round_robin/v3/client_side_weighted_round_robin.upb.h"
+#include "envoy/extensions/load_balancing_policies/pick_first/v3/pick_first.upb.h"
 #include "envoy/extensions/load_balancing_policies/ring_hash/v3/ring_hash.upb.h"
 #include "envoy/extensions/load_balancing_policies/wrr_locality/v3/wrr_locality.upb.h"
 #include "google/protobuf/wrappers.upb.h"
@@ -254,6 +255,38 @@ class WrrLocalityLbPolicyConfigFactory
   }
 };
 
+class PickFirstLbPolicyConfigFactory
+    : public XdsLbPolicyRegistry::ConfigFactory {
+ public:
+  Json::Object ConvertXdsLbPolicyConfig(
+      const XdsLbPolicyRegistry* /*registry*/,
+      const XdsResourceType::DecodeContext& context,
+      absl::string_view configuration, ValidationErrors* errors,
+      int /*recursion_depth*/) override {
+    const auto* resource =
+        envoy_extensions_load_balancing_policies_pick_first_v3_PickFirst_parse(
+            configuration.data(), configuration.size(), context.arena);
+    if (resource == nullptr) {
+      errors->AddError("can't decode PickFirst LB policy config");
+      return {};
+    }
+    bool shuffle_address_list =
+        envoy_extensions_load_balancing_policies_pick_first_v3_PickFirst_shuffle_address_list(
+            resource);
+    return Json::Object{
+        {"pick_first",
+         Json::FromObject({
+             {"shuffleAddressList", Json::FromBool(shuffle_address_list)},
+         })}};
+  }
+
+  absl::string_view type() override { return Type(); }
+
+  static absl::string_view Type() {
+    return "envoy.extensions.load_balancing_policies.pick_first.v3.PickFirst";
+  }
+};
+
 }  // namespace
 
 //
@@ -273,6 +306,9 @@ XdsLbPolicyRegistry::XdsLbPolicyRegistry() {
   policy_config_factories_.emplace(
       WrrLocalityLbPolicyConfigFactory::Type(),
       std::make_unique<WrrLocalityLbPolicyConfigFactory>());
+  policy_config_factories_.emplace(
+      PickFirstLbPolicyConfigFactory::Type(),
+      std::make_unique<PickFirstLbPolicyConfigFactory>());
 }
 
 Json::Array XdsLbPolicyRegistry::ConvertXdsLbPolicyConfig(

data/src/core/ext/xds/xds_route_config.cc

@@ -349,6 +349,10 @@ XdsRouteConfigResource::ClusterSpecifierPluginMap ClusterSpecifierPluginParse(
     const envoy_config_core_v3_TypedExtensionConfig* typed_extension_config =
         envoy_config_route_v3_ClusterSpecifierPlugin_extension(
             cluster_specifier_plugin[i]);
+    if (typed_extension_config == nullptr) {
+      errors->AddError("field not present");
+      continue;
+    }
     std::string name = UpbStringToStdString(
         envoy_config_core_v3_TypedExtensionConfig_name(typed_extension_config));
     if (cluster_specifier_plugin_map.find(name) !=

data/src/core/ext/xds/xds_routing.cc

@@ -248,8 +248,8 @@ XdsRouting::GeneratePerHTTPFilterConfigs(
         FindFilterConfigOverride(http_filter.name, vhost, route,
                                  cluster_weight);
     // Generate service config for filter.
-    auto method_config_field = filter_impl->GenerateServiceConfig(
-        http_filter.config, config_override, http_filter.name);
+    auto method_config_field =
+        filter_impl->GenerateServiceConfig(http_filter.config, config_override);
     if (!method_config_field.ok()) {
       return absl::FailedPreconditionError(absl::StrCat(
           "failed to generate method config for HTTP filter ", http_filter.name,

data/src/core/ext/xds/xds_transport_grpc.cc

@@ -29,6 +29,7 @@
 #include <grpc/byte_buffer.h>
 #include <grpc/byte_buffer_reader.h>
 #include <grpc/grpc.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/impl/propagation_bits.h>
 #include <grpc/slice.h>
@@ -47,7 +48,6 @@
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/pollset_set.h"
-#include "src/core/lib/json/json.h"
 #include "src/core/lib/security/credentials/channel_creds_registry.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/slice/slice.h"
@@ -256,8 +256,7 @@ grpc_channel* CreateXdsChannel(const ChannelArgs& args,
                                const GrpcXdsBootstrap::GrpcXdsServer& server) {
   RefCountedPtr<grpc_channel_credentials> channel_creds =
       CoreConfiguration::Get().channel_creds_registry().CreateChannelCreds(
-          server.channel_creds_type(),
-          Json::FromObject(server.channel_creds_config()));
+          server.channel_creds_config());
   return grpc_channel_create(server.server_uri().c_str(), channel_creds.get(),
                              args.ToC().get());
 }

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

@@ -20,6 +20,12 @@
 
 #include "src/core/lib/address_utils/parse_address.h"
 
+#include "src/core/lib/iomgr/port.h"  // IWYU pragma: keep
+
+#ifdef GRPC_HAVE_VSOCK
+#include <linux/vm_sockets.h>
+#endif
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -38,7 +44,6 @@
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/grpc_if_nametoindex.h"
-#include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
 
@@ -144,6 +149,60 @@ grpc_error_handle UnixAbstractSockaddrPopulate(
 }  // namespace grpc_core
 #endif  // GRPC_HAVE_UNIX_SOCKET
 
+#ifdef GRPC_HAVE_VSOCK
+
+bool grpc_parse_vsock(const grpc_core::URI& uri,
+                      grpc_resolved_address* resolved_addr) {
+  if (uri.scheme() != "vsock") {
+    gpr_log(GPR_ERROR, "Expected 'vsock' scheme, got '%s'",
+            uri.scheme().c_str());
+    return false;
+  }
+  grpc_error_handle error =
+      grpc_core::VSockaddrPopulate(uri.path(), resolved_addr);
+  if (!error.ok()) {
+    gpr_log(GPR_ERROR, "%s", grpc_core::StatusToString(error).c_str());
+    return false;
+  }
+  return true;
+}
+
+namespace grpc_core {
+
+grpc_error_handle VSockaddrPopulate(absl::string_view path,
+                                    grpc_resolved_address* resolved_addr) {
+  memset(resolved_addr, 0, sizeof(*resolved_addr));
+  struct sockaddr_vm* vm =
+      reinterpret_cast<struct sockaddr_vm*>(resolved_addr->addr);
+  vm->svm_family = AF_VSOCK;
+  std::string s = std::string(path);
+  if (sscanf(s.c_str(), "%u:%u", &vm->svm_cid, &vm->svm_port) != 2) {
+    return GRPC_ERROR_CREATE(
+        absl::StrCat("Failed to parse vsock cid/port: ", s));
+  }
+  resolved_addr->len = static_cast<socklen_t>(sizeof(*vm));
+  return absl::OkStatus();
+}
+
+}  // namespace grpc_core
+
+#else   // GRPC_HAVE_VSOCK
+
+bool grpc_parse_vsock(const grpc_core::URI& /* uri */,
+                      grpc_resolved_address* /* resolved_addr */) {
+  GPR_UNREACHABLE_CODE(return false);
+}
+
+namespace grpc_core {
+
+grpc_error_handle VSockaddrPopulate(
+    absl::string_view /* path */, grpc_resolved_address* /* resolved_addr */) {
+  GPR_UNREACHABLE_CODE(return absl::InvalidArgumentError("vsock unsupported."));
+}
+
+}  // namespace grpc_core
+#endif  // GRPC_HAVE_VSOCK
+
 bool grpc_parse_ipv4_hostport(absl::string_view hostport,
                               grpc_resolved_address* addr, bool log_errors) {
   bool success = false;
@@ -299,6 +358,9 @@ bool grpc_parse_uri(const grpc_core::URI& uri,
   if (uri.scheme() == "unix-abstract") {
     return grpc_parse_unix_abstract(uri, resolved_addr);
   }
+  if (uri.scheme() == "vsock") {
+    return grpc_parse_vsock(uri, resolved_addr);
+  }
   if (uri.scheme() == "ipv4") {
     return grpc_parse_ipv4(uri, resolved_addr);
   }

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

@@ -40,6 +40,11 @@ bool grpc_parse_unix(const grpc_core::URI& uri,
 bool grpc_parse_unix_abstract(const grpc_core::URI& uri,
                               grpc_resolved_address* resolved_addr);
 
+/// Populate \a resolved_addr from \a uri, whose path is expected to contain a
+/// vsock cid:port pair. Returns true upon success.
+bool grpc_parse_vsock(const grpc_core::URI& uri,
+                      grpc_resolved_address* resolved_addr);
+
 /// Populate \a resolved_addr from \a uri, whose path is expected to contain an
 /// IPv4 host:port pair. Returns true upon success.
 bool grpc_parse_ipv4(const grpc_core::URI& uri,
@@ -81,6 +86,9 @@ grpc_error_handle UnixSockaddrPopulate(absl::string_view path,
 grpc_error_handle UnixAbstractSockaddrPopulate(
     absl::string_view path, grpc_resolved_address* resolved_addr);
 
+/// Populate \a resolved_addr to be a vsock at \a path
+grpc_error_handle VSockaddrPopulate(absl::string_view path,
+                                    grpc_resolved_address* resolved_addr);
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_ADDRESS_UTILS_PARSE_ADDRESS_H

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

@@ -22,6 +22,9 @@
 
 #include <errno.h>
 #include <inttypes.h>
+#ifdef GRPC_HAVE_VSOCK
+#include <linux/vm_sockets.h>
+#endif
 #include <string.h>
 
 #include <initializer_list>
@@ -77,6 +80,25 @@ static absl::StatusOr<std::string> grpc_sockaddr_to_uri_unix_if_possible(
 }
 #endif
 
+#ifdef GRPC_HAVE_VSOCK
+static absl::StatusOr<std::string> grpc_sockaddr_to_uri_vsock_if_possible(
+    const grpc_resolved_address* resolved_addr) {
+  const grpc_sockaddr* addr =
+      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
+  if (addr->sa_family != AF_VSOCK) {
+    return absl::InvalidArgumentError(
+        absl::StrCat("Socket family is not AF_VSOCK: ", addr->sa_family));
+  }
+  const auto* vsock_addr = reinterpret_cast<const struct sockaddr_vm*>(addr);
+  return absl::StrCat("vsock:", vsock_addr->svm_cid, ":", vsock_addr->svm_port);
+}
+#else
+static absl::StatusOr<std::string> grpc_sockaddr_to_uri_vsock_if_possible(
+    const grpc_resolved_address* /* addr */) {
+  return absl::InvalidArgumentError("VSOCK is not supported.");
+}
+#endif
+
 static const uint8_t kV4MappedPrefix[] = {0, 0, 0, 0, 0,    0,
                                           0, 0, 0, 0, 0xff, 0xff};
 
@@ -224,6 +246,14 @@ absl::StatusOr<std::string> grpc_sockaddr_to_string(
   }
 #endif
 
+#ifdef GRPC_HAVE_VSOCK
+  if (addr->sa_family == GRPC_AF_VSOCK) {
+    const sockaddr_vm* addr_vm = reinterpret_cast<const sockaddr_vm*>(addr);
+    out = absl::StrCat(addr_vm->svm_cid, ":", addr_vm->svm_port);
+    return out;
+  }
+#endif
+
   const void* ip = nullptr;
   int port = 0;
   uint32_t sin6_scope_id = 0;
@@ -269,9 +299,16 @@ absl::StatusOr<std::string> grpc_sockaddr_to_uri(
     resolved_addr = &addr_normalized;
   }
   const char* scheme = grpc_sockaddr_get_uri_scheme(resolved_addr);
-  if (scheme == nullptr || strcmp("unix", scheme) == 0) {
+  if (scheme == nullptr) {
+    return absl::InvalidArgumentError("Unknown address type");
+  }
+  if (strcmp("unix", scheme) == 0) {
     return grpc_sockaddr_to_uri_unix_if_possible(resolved_addr);
   }
+  if (strcmp("vsock", scheme) == 0) {
+    return grpc_sockaddr_to_uri_vsock_if_possible(resolved_addr);
+  }
+
   auto path = grpc_sockaddr_to_string(resolved_addr, false /* normalize */);
   if (!path.ok()) return path;
   absl::StatusOr<grpc_core::URI> uri =
@@ -292,6 +329,10 @@ const char* grpc_sockaddr_get_uri_scheme(
       return "ipv6";
     case GRPC_AF_UNIX:
       return "unix";
+#ifdef GRPC_HAVE_VSOCK
+    case GRPC_AF_VSOCK:
+      return "vsock";
+#endif
   }
   return nullptr;
 }
@@ -315,6 +356,10 @@ int grpc_sockaddr_get_port(const grpc_resolved_address* resolved_addr) {
 #ifdef GRPC_HAVE_UNIX_SOCKET
     case AF_UNIX:
       return 1;
+#endif
+#ifdef GRPC_HAVE_VSOCK
+    case AF_VSOCK:
+      return 1;
 #endif
     default:
       gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_get_port",

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

@@ -67,8 +67,8 @@ int grpc_sockaddr_set_port(grpc_resolved_address* addr, int port);
 // Currently, only the AF_INET, AF_INET6, and AF_UNIX families are recognized.
 // If the normalize flag is enabled, ::ffff:0.0.0.0/96 IPv6 addresses are
 // displayed as plain IPv4.
-absl::StatusOr<std::string> grpc_sockaddr_to_string(
-    const grpc_resolved_address* addr, bool normalize) GRPC_MUST_USE_RESULT;
+GRPC_MUST_USE_RESULT absl::StatusOr<std::string> grpc_sockaddr_to_string(
+    const grpc_resolved_address* addr, bool normalize);
 
 // Returns the URI string corresponding to \a addr
 absl::StatusOr<std::string> grpc_sockaddr_to_uri(

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

@@ -20,10 +20,11 @@
 #include <stdlib.h>
 
 #include <algorithm>  // IWYU pragma: keep
-#include <memory>
 #include <utility>
 
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 
 namespace grpc_core {
 
@@ -42,12 +43,12 @@ class AVL {
   template <typename SomethingLikeK>
   const V* Lookup(const SomethingLikeK& key) const {
     NodePtr n = Get(root_, key);
-    return n ? &n->kv.second : nullptr;
+    return n != nullptr ? &n->kv.second : nullptr;
   }
 
   const std::pair<K, V>* LookupBelow(const K& key) const {
     NodePtr n = GetBelow(root_, *key);
-    return n ? &n->kv : nullptr;
+    return n != nullptr ? &n->kv : nullptr;
   }
 
   bool Empty() const { return root_ == nullptr; }
@@ -95,8 +96,8 @@ class AVL {
  private:
   struct Node;
 
-  typedef std::shared_ptr<Node> NodePtr;
-  struct Node : public std::enable_shared_from_this<Node> {
+  typedef RefCountedPtr<Node> NodePtr;
+  struct Node : public RefCounted<Node, NonPolymorphicRefCount> {
     Node(K k, V v, NodePtr l, NodePtr r, long h)
         : kv(std::move(k), std::move(v)),
           left(std::move(l)),
@@ -167,12 +168,12 @@ class AVL {
     ForEachImpl(n->right.get(), std::forward<F>(f));
   }
 
-  static long Height(const NodePtr& n) { return n ? n->height : 0; }
+  static long Height(const NodePtr& n) { return n != nullptr ? 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)));
+    return MakeRefCounted<Node>(std::move(key), std::move(value), left, right,
+                                1 + std::max(Height(left), Height(right)));
   }
 
   template <typename SomethingLikeK>
@@ -259,7 +260,7 @@ class AVL {
   }
 
   static NodePtr AddKey(const NodePtr& node, K key, V value) {
-    if (!node) {
+    if (node == nullptr) {
       return MakeNode(std::move(key), std::move(value), nullptr, nullptr);
     }
     if (node->kv.first < key) {
@@ -318,170 +319,6 @@ class AVL {
   }
 };
 
-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_SRC_CORE_LIB_AVL_AVL_H