grpc 1.50.0-x86_64-linux → 1.51.0-x86_64-linux

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_cluster_manager.cc

@@ -25,13 +25,14 @@
 #include <utility>
 #include <vector>
 
-#include "absl/memory/memory.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/codegen/connectivity_state.h>
 #include <grpc/support/log.h>
 
@@ -48,10 +49,8 @@
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/gprpp/work_serializer.h"
-#include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/pollset_set.h"
-#include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/json/json_args.h"
 #include "src/core/lib/json/json_object_loader.h"
@@ -62,14 +61,15 @@
 #include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/transport/connectivity_state.h"
 
-#define GRPC_XDS_CLUSTER_MANAGER_CHILD_RETENTION_INTERVAL_MS (15 * 60 * 1000)
-
 namespace grpc_core {
 
 TraceFlag grpc_xds_cluster_manager_lb_trace(false, "xds_cluster_manager_lb");
 
 namespace {
 
+using ::grpc_event_engine::experimental::EventEngine;
+
+constexpr Duration kChildRetentionInterval = Duration::Minutes(15);
 constexpr absl::string_view kXdsClusterManager =
     "xds_cluster_manager_experimental";
 
@@ -195,6 +195,7 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
                        std::unique_ptr<SubchannelPicker> picker) override;
       void RequestReresolution() override;
       absl::string_view GetAuthority() override;
+      EventEngine* GetEventEngine() override;
       void AddTraceEvent(TraceSeverity severity,
                          absl::string_view message) override;
 
@@ -206,8 +207,7 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
     OrphanablePtr<LoadBalancingPolicy> CreateChildPolicyLocked(
         const ChannelArgs& args);
 
-    static void OnDelayedRemovalTimer(void* arg, grpc_error_handle error);
-    void OnDelayedRemovalTimerLocked(grpc_error_handle error);
+    void OnDelayedRemovalTimerLocked();
 
     // The owning LB policy.
     RefCountedPtr<XdsClusterManagerLb> xds_cluster_manager_policy_;
@@ -221,9 +221,7 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
     grpc_connectivity_state connectivity_state_ = GRPC_CHANNEL_IDLE;
 
     // States for delayed removal.
-    grpc_timer delayed_removal_timer_;
-    grpc_closure on_delayed_removal_timer_;
-    bool delayed_removal_timer_callback_pending_ = false;
+    absl::optional<EventEngine::TaskHandle> delayed_removal_timer_handle_;
     bool shutdown_ = false;
   };
 
@@ -376,7 +374,7 @@ void XdsClusterManagerLb::UpdateStateLocked() {
         break;
       }
       default:
-        GPR_UNREACHABLE_CODE(return );
+        GPR_UNREACHABLE_CODE(return);
     }
   }
   // Determine aggregated connectivity state.
@@ -408,11 +406,11 @@ void XdsClusterManagerLb::UpdateStateLocked() {
       }
       child_picker = MakeRefCounted<ChildPickerWrapper>(
           cluster_name,
-          absl::make_unique<QueuePicker>(Ref(DEBUG_LOCATION, "QueuePicker")));
+          std::make_unique<QueuePicker>(Ref(DEBUG_LOCATION, "QueuePicker")));
     }
   }
   std::unique_ptr<SubchannelPicker> picker =
-      absl::make_unique<ClusterPicker>(std::move(cluster_map));
+      std::make_unique<ClusterPicker>(std::move(cluster_map));
   absl::Status status;
   if (connectivity_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
     status = absl::Status(absl::StatusCode::kUnavailable,
@@ -436,8 +434,6 @@ XdsClusterManagerLb::ClusterChild::ClusterChild(
             "[xds_cluster_manager_lb %p] created ClusterChild %p for %s",
             xds_cluster_manager_policy_.get(), this, name_.c_str());
   }
-  GRPC_CLOSURE_INIT(&on_delayed_removal_timer_, OnDelayedRemovalTimer, this,
-                    grpc_schedule_on_exec_ctx);
 }
 
 XdsClusterManagerLb::ClusterChild::~ClusterChild() {
@@ -466,8 +462,10 @@ void XdsClusterManagerLb::ClusterChild::Orphan() {
   // Drop our ref to the child's picker, in case it's holding a ref to
   // the child.
   picker_wrapper_.reset();
-  if (delayed_removal_timer_callback_pending_) {
-    grpc_timer_cancel(&delayed_removal_timer_);
+  if (delayed_removal_timer_handle_.has_value()) {
+    xds_cluster_manager_policy_->channel_control_helper()
+        ->GetEventEngine()
+        ->Cancel(*delayed_removal_timer_handle_);
   }
   shutdown_ = true;
   Unref();
@@ -481,7 +479,7 @@ XdsClusterManagerLb::ClusterChild::CreateChildPolicyLocked(
       xds_cluster_manager_policy_->work_serializer();
   lb_policy_args.args = args;
   lb_policy_args.channel_control_helper =
-      absl::make_unique<Helper>(this->Ref(DEBUG_LOCATION, "Helper"));
+      std::make_unique<Helper>(this->Ref(DEBUG_LOCATION, "Helper"));
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
       MakeOrphanable<ChildPolicyHandler>(std::move(lb_policy_args),
                                          &grpc_xds_cluster_manager_lb_trace);
@@ -509,9 +507,11 @@ absl::Status XdsClusterManagerLb::ClusterChild::UpdateLocked(
   if (xds_cluster_manager_policy_->shutting_down_) return absl::OkStatus();
   // Update child weight.
   // Reactivate if needed.
-  if (delayed_removal_timer_callback_pending_) {
-    delayed_removal_timer_callback_pending_ = false;
-    grpc_timer_cancel(&delayed_removal_timer_);
+  if (delayed_removal_timer_handle_.has_value() &&
+      xds_cluster_manager_policy_->channel_control_helper()
+          ->GetEventEngine()
+          ->Cancel(*delayed_removal_timer_handle_)) {
+    delayed_removal_timer_handle_.reset();
   }
   // Create child policy if needed.
   if (child_policy_ == nullptr) {
@@ -544,35 +544,30 @@ void XdsClusterManagerLb::ClusterChild::ResetBackoffLocked() {
 
 void XdsClusterManagerLb::ClusterChild::DeactivateLocked() {
   // If already deactivated, don't do that again.
-  if (delayed_removal_timer_callback_pending_) return;
-  // Set the child weight to 0 so that future picker won't contain this child.
+  if (delayed_removal_timer_handle_.has_value()) return;
   // Start a timer to delete the child.
-  Ref(DEBUG_LOCATION, "ClusterChild+timer").release();
-  grpc_timer_init(&delayed_removal_timer_,
-                  Timestamp::Now() +
-                      Duration::Milliseconds(
-                          GRPC_XDS_CLUSTER_MANAGER_CHILD_RETENTION_INTERVAL_MS),
-                  &on_delayed_removal_timer_);
-  delayed_removal_timer_callback_pending_ = true;
-}
-
-void XdsClusterManagerLb::ClusterChild::OnDelayedRemovalTimer(
-    void* arg, grpc_error_handle error) {
-  ClusterChild* self = static_cast<ClusterChild*>(arg);
-  (void)GRPC_ERROR_REF(error);  // Ref owned by the lambda
-  self->xds_cluster_manager_policy_->work_serializer()->Run(
-      [self, error]() { self->OnDelayedRemovalTimerLocked(error); },
-      DEBUG_LOCATION);
+  delayed_removal_timer_handle_ =
+      xds_cluster_manager_policy_->channel_control_helper()
+          ->GetEventEngine()
+          ->RunAfter(
+              kChildRetentionInterval,
+              [self = Ref(DEBUG_LOCATION, "ClusterChild+timer")]() mutable {
+                ApplicationCallbackExecCtx application_exec_ctx;
+                ExecCtx exec_ctx;
+                auto* self_ptr = self.get();  // Avoid use-after-move problem.
+                self_ptr->xds_cluster_manager_policy_->work_serializer()->Run(
+                    [self = std::move(self)]() {
+                      self->OnDelayedRemovalTimerLocked();
+                    },
+                    DEBUG_LOCATION);
+              });
 }
 
-void XdsClusterManagerLb::ClusterChild::OnDelayedRemovalTimerLocked(
-    grpc_error_handle error) {
-  delayed_removal_timer_callback_pending_ = false;
-  if (GRPC_ERROR_IS_NONE(error) && !shutdown_) {
+void XdsClusterManagerLb::ClusterChild::OnDelayedRemovalTimerLocked() {
+  delayed_removal_timer_handle_.reset();
+  if (!shutdown_) {
     xds_cluster_manager_policy_->children_.erase(name_);
   }
-  Unref(DEBUG_LOCATION, "ClusterChild+timer");
-  GRPC_ERROR_UNREF(error);
 }
 
 //
@@ -636,6 +631,12 @@ absl::string_view XdsClusterManagerLb::ClusterChild::Helper::GetAuthority() {
       ->GetAuthority();
 }
 
+EventEngine* XdsClusterManagerLb::ClusterChild::Helper::GetEventEngine() {
+  return xds_cluster_manager_child_->xds_cluster_manager_policy_
+      ->channel_control_helper()
+      ->GetEventEngine();
+}
+
 void XdsClusterManagerLb::ClusterChild::Helper::AddTraceEvent(
     TraceSeverity severity, absl::string_view message) {
   if (xds_cluster_manager_child_->xds_cluster_manager_policy_->shutting_down_) {
@@ -725,7 +726,7 @@ class XdsClusterManagerLbFactory : public LoadBalancingPolicyFactory {
 
 void RegisterXdsClusterManagerLbPolicy(CoreConfiguration::Builder* builder) {
   builder->lb_policy_registry()->RegisterLoadBalancingPolicyFactory(
-      absl::make_unique<XdsClusterManagerLbFactory>());
+      std::make_unique<XdsClusterManagerLbFactory>());
 }
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_cluster_resolver.cc

@@ -27,7 +27,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/memory/memory.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -35,15 +34,14 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/codegen/connectivity_state.h>
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy/address_filtering.h"
 #include "src/core/ext/filters/client_channel/lb_policy/child_policy_handler.h"
-#include "src/core/ext/filters/client_channel/lb_policy/outlier_detection/outlier_detection.h"
-#include "src/core/ext/filters/client_channel/lb_policy/ring_hash/ring_hash.h"
-#include "src/core/ext/filters/client_channel/lb_policy/xds/xds.h"
+#include "src/core/ext/filters/client_channel/lb_policy/xds/xds_attributes.h"
 #include "src/core/ext/filters/client_channel/lb_policy/xds/xds_channel_args.h"
 #include "src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
@@ -52,7 +50,6 @@
 #include "src/core/ext/xds/xds_client_grpc.h"
 #include "src/core/ext/xds/xds_client_stats.h"
 #include "src/core/ext/xds/xds_endpoint.h"
-#include "src/core/ext/xds/xds_resource_type_impl.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
@@ -80,8 +77,6 @@ namespace grpc_core {
 
 TraceFlag grpc_lb_xds_cluster_resolver_trace(false, "xds_cluster_resolver_lb");
 
-const char* kXdsLocalityNameAttributeKey = "xds_locality_name";
-
 namespace {
 
 constexpr absl::string_view kXdsClusterResolver =
@@ -149,7 +144,7 @@ class XdsClusterResolverLbConfig : public LoadBalancingPolicy::Config {
 
  private:
   std::vector<DiscoveryMechanism> discovery_mechanisms_;
-  Json xds_lb_policy_ = Json::Object{{"ROUND_ROBIN", Json::Object()}};
+  Json xds_lb_policy_;
 };
 
 // Xds Cluster Resolver LB policy.
@@ -383,6 +378,7 @@ class XdsClusterResolverLb : public LoadBalancingPolicy {
     // client, which is a watch-based API.
     void RequestReresolution() override {}
     absl::string_view GetAuthority() override;
+    grpc_event_engine::experimental::EventEngine* GetEventEngine() override;
     void AddTraceEvent(TraceSeverity severity,
                        absl::string_view message) override;
 
@@ -459,6 +455,12 @@ absl::string_view XdsClusterResolverLb::Helper::GetAuthority() {
   return xds_cluster_resolver_policy_->channel_control_helper()->GetAuthority();
 }
 
+grpc_event_engine::experimental::EventEngine*
+XdsClusterResolverLb::Helper::GetEventEngine() {
+  return xds_cluster_resolver_policy_->channel_control_helper()
+      ->GetEventEngine();
+}
+
 void XdsClusterResolverLb::Helper::AddTraceEvent(TraceSeverity severity,
                                                  absl::string_view message) {
   if (xds_cluster_resolver_policy_->shutting_down_) return;
@@ -515,7 +517,7 @@ void XdsClusterResolverLb::LogicalDNSDiscoveryMechanism::Start() {
   resolver_ = CoreConfiguration::Get().resolver_registry().CreateResolver(
       target.c_str(), args, parent()->interested_parties(),
       parent()->work_serializer(),
-      absl::make_unique<ResolverResultHandler>(
+      std::make_unique<ResolverResultHandler>(
           Ref(DEBUG_LOCATION, "LogicalDNSDiscoveryMechanism")));
   if (resolver_ == nullptr) {
     parent()->OnResourceDoesNotExist(
@@ -840,12 +842,12 @@ ServerAddressList XdsClusterResolverLb::CreateChildPolicyAddressesLocked() {
                       kHierarchicalPathAttributeKey,
                       MakeHierarchicalPathAttribute(hierarchical_path))
                   .WithAttribute(kXdsLocalityNameAttributeKey,
-                                 absl::make_unique<XdsLocalityAttribute>(
-                                     locality_name->Ref()))
+                                 std::make_unique<XdsLocalityAttribute>(
+                                     locality_name->Ref(), locality.lb_weight))
                   .WithAttribute(
                       ServerAddressWeightAttribute::
                           kServerAddressWeightAttributeKey,
-                      absl::make_unique<ServerAddressWeightAttribute>(weight)));
+                      std::make_unique<ServerAddressWeightAttribute>(weight)));
         }
       }
     }
@@ -872,60 +874,13 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
     for (size_t priority = 0;
          priority < discovery_entry.latest_update->priorities.size();
          ++priority) {
-      const auto& priority_entry =
-          discovery_entry.latest_update->priorities[priority];
       Json child_policy;
       if (!discovery_entry.discovery_mechanism->override_child_policy()
                .empty()) {
         child_policy =
             discovery_entry.discovery_mechanism->override_child_policy();
       } else {
-        const auto& xds_lb_policy = config_->xds_lb_policy().object_value();
-        if (xds_lb_policy.find("ROUND_ROBIN") != xds_lb_policy.end()) {
-          const auto& localities = priority_entry.localities;
-          Json::Object weighted_targets;
-          for (const auto& p : localities) {
-            XdsLocalityName* locality_name = p.first;
-            const auto& locality = p.second;
-            // Add weighted target entry.
-            weighted_targets[locality_name->AsHumanReadableString()] =
-                Json::Object{
-                    {"weight", locality.lb_weight},
-                    {"childPolicy",
-                     Json::Array{
-                         Json::Object{
-                             {"round_robin", Json::Object()},
-                         },
-                     }},
-                };
-          }
-          // Construct locality-picking policy.
-          // Start with field from our config and add the "targets" field.
-          child_policy = Json::Array{
-              Json::Object{
-                  {"weighted_target_experimental",
-                   Json::Object{
-                       {"targets", Json::Object()},
-                   }},
-              },
-          };
-          Json::Object& config =
-              *(*child_policy.mutable_array())[0].mutable_object();
-          auto it = config.begin();
-          GPR_ASSERT(it != config.end());
-          (*it->second.mutable_object())["targets"] =
-              std::move(weighted_targets);
-        } else {
-          auto it = xds_lb_policy.find("RING_HASH");
-          GPR_ASSERT(it != xds_lb_policy.end());
-          Json::Object ring_hash_experimental_policy =
-              it->second.object_value();
-          child_policy = Json::Array{
-              Json::Object{
-                  {"ring_hash_experimental", ring_hash_experimental_policy},
-              },
-          };
-        }
+        child_policy = config_->xds_lb_policy();
       }
       // Wrap it in the drop policy.
       Json::Array drop_categories;
@@ -952,27 +907,18 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
         xds_cluster_impl_config["lrsLoadReportingServer"] =
             discovery_config.lrs_load_reporting_server->ToJson();
       }
-      Json locality_picking_policy;
-      if (XdsOutlierDetectionEnabled()) {
-        Json::Object outlier_detection_config;
-        if (discovery_entry.config().outlier_detection_lb_config.has_value()) {
-          outlier_detection_config =
-              discovery_entry.config().outlier_detection_lb_config.value();
-        }
-        outlier_detection_config["childPolicy"] = Json::Array{Json::Object{
-            {"xds_cluster_impl_experimental",
-             std::move(xds_cluster_impl_config)},
-        }};
-        locality_picking_policy = Json::Array{Json::Object{
-            {"outlier_detection_experimental",
-             std::move(outlier_detection_config)},
-        }};
-      } else {
-        locality_picking_policy = Json::Array{Json::Object{
-            {"xds_cluster_impl_experimental",
-             std::move(xds_cluster_impl_config)},
-        }};
+      Json::Object outlier_detection_config;
+      if (discovery_entry.config().outlier_detection_lb_config.has_value()) {
+        outlier_detection_config =
+            discovery_entry.config().outlier_detection_lb_config.value();
       }
+      outlier_detection_config["childPolicy"] = Json::Array{Json::Object{
+          {"xds_cluster_impl_experimental", std::move(xds_cluster_impl_config)},
+      }};
+      Json locality_picking_policy = Json::Array{Json::Object{
+          {"outlier_detection_experimental",
+           std::move(outlier_detection_config)},
+      }};
       // Add priority entry, with the appropriate child name.
       std::string child_name = discovery_entry.GetChildPolicyName(priority);
       priority_priorities.emplace_back(child_name);
@@ -1015,7 +961,7 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
         "config");
     channel_control_helper()->UpdateState(
         GRPC_CHANNEL_TRANSIENT_FAILURE, status,
-        absl::make_unique<TransientFailurePicker>(status));
+        std::make_unique<TransientFailurePicker>(status));
     return nullptr;
   }
   return std::move(*config);
@@ -1052,7 +998,7 @@ XdsClusterResolverLb::CreateChildPolicyLocked(const ChannelArgs& args) {
   lb_policy_args.work_serializer = work_serializer();
   lb_policy_args.args = args;
   lb_policy_args.channel_control_helper =
-      absl::make_unique<Helper>(Ref(DEBUG_LOCATION, "Helper"));
+      std::make_unique<Helper>(Ref(DEBUG_LOCATION, "Helper"));
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
       CoreConfiguration::Get().lb_policy_registry().CreateLoadBalancingPolicy(
           "priority_experimental", std::move(lb_policy_args));
@@ -1090,8 +1036,7 @@ XdsClusterResolverLbConfig::DiscoveryMechanism::JsonLoader(const JsonArgs&) {
           .OptionalField("max_concurrent_requests",
                          &DiscoveryMechanism::max_concurrent_requests)
           .OptionalField("outlierDetection",
-                         &DiscoveryMechanism::outlier_detection_lb_config,
-                         "outlier_detection")
+                         &DiscoveryMechanism::outlier_detection_lb_config)
           .Finish();
   return loader;
 }
@@ -1140,8 +1085,7 @@ const JsonLoaderInterface* XdsClusterResolverLbConfig::JsonLoader(
   return loader;
 }
 
-void XdsClusterResolverLbConfig::JsonPostLoad(const Json& json,
-                                              const JsonArgs& args,
+void XdsClusterResolverLbConfig::JsonPostLoad(const Json& json, const JsonArgs&,
                                               ValidationErrors* errors) {
   // Validate discoveryMechanisms.
   {
@@ -1154,37 +1098,14 @@ void XdsClusterResolverLbConfig::JsonPostLoad(const Json& json,
   {
     ValidationErrors::ScopedField field(errors, ".xdsLbPolicy");
     auto it = json.object_value().find("xdsLbPolicy");
-    if (it != json.object_value().end()) {
-      if (it->second.type() != Json::Type::ARRAY) {
-        errors->AddError("is not an array");
-      } else {
-        const Json::Array& array = it->second.array_value();
-        for (size_t i = 0; i < array.size(); ++i) {
-          ValidationErrors::ScopedField field(errors,
-                                              absl::StrCat("[", i, "]"));
-          if (array[i].type() != Json::Type::OBJECT) {
-            errors->AddError("is not an object");
-            continue;
-          }
-          const Json::Object& policy = array[i].object_value();
-          auto policy_it = policy.find("ROUND_ROBIN");
-          if (policy_it != policy.end()) {
-            ValidationErrors::ScopedField field(errors, "[\"ROUND_ROBIN\"]");
-            if (policy_it->second.type() != Json::Type::OBJECT) {
-              errors->AddError("is not an object");
-            }
-            break;
-          }
-          {
-            ValidationErrors::ScopedField field(errors, "[\"RING_HASH\"]");
-            policy_it = policy.find("RING_HASH");
-            if (policy_it != policy.end()) {
-              LoadFromJson<RingHashConfig>(policy_it->second, args, errors);
-              xds_lb_policy_ = array[i];
-            }
-          }
-        }
-      }
+    if (it == json.object_value().end()) {
+      errors->AddError("field not present");
+    } else {
+      auto lb_config = CoreConfiguration::Get()
+                           .lb_policy_registry()
+                           .ParseLoadBalancingConfig(it->second);
+      if (!lb_config.ok()) errors->AddError(lb_config.status().message());
+      xds_lb_policy_ = it->second;
     }
   }
 }
@@ -1217,15 +1138,8 @@ class XdsClusterResolverLbFactory : public LoadBalancingPolicyFactory {
           "requires configuration. "
           "Please use loadBalancingConfig field of service config instead.");
     }
-    class XdsJsonArgs : public JsonArgs {
-     public:
-      bool IsEnabled(absl::string_view key) const override {
-        if (key == "outlier_detection") return XdsOutlierDetectionEnabled();
-        return true;
-      }
-    };
     return LoadRefCountedFromJson<XdsClusterResolverLbConfig>(
-        json, XdsJsonArgs(),
+        json, JsonArgs(),
         "errors validating xds_cluster_resolver LB policy config");
   }
 
@@ -1294,7 +1208,7 @@ class XdsClusterResolverLbFactory : public LoadBalancingPolicyFactory {
 
 void RegisterXdsClusterResolverLbPolicy(CoreConfiguration::Builder* builder) {
   builder->lb_policy_registry()->RegisterLoadBalancingPolicyFactory(
-      absl::make_unique<XdsClusterResolverLbFactory>());
+      std::make_unique<XdsClusterResolverLbFactory>());
 }
 
 }  // namespace grpc_core