grpc 1.54.3 → 1.58.0

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

@@ -19,6 +19,7 @@
 #include <stddef.h>
 
 #include <algorithm>
+#include <functional>
 #include <map>
 #include <memory>
 #include <string>
@@ -54,10 +55,10 @@
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/json/json_args.h"
 #include "src/core/lib/json/json_object_loader.h"
+#include "src/core/lib/load_balancing/delegating_helper.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/load_balancing/lb_policy_factory.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
-#include "src/core/lib/load_balancing/subchannel_interface.h"
 #include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/transport/connectivity_state.h"
 
@@ -123,8 +124,8 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
   class ClusterPicker : public SubchannelPicker {
    public:
     // Maintains a map of cluster names to pickers.
-    using ClusterMap =
-        std::map<std::string /*cluster_name*/, RefCountedPtr<SubchannelPicker>>;
+    using ClusterMap = std::map<std::string /*cluster_name*/,
+                                RefCountedPtr<SubchannelPicker>, std::less<>>;
 
     // It is required that the keys of cluster_map have to live at least as long
     // as the ClusterPicker instance.
@@ -160,7 +161,7 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
     RefCountedPtr<SubchannelPicker> picker() const { return picker_; }
 
    private:
-    class Helper : public ChannelControlHelper {
+    class Helper : public DelegatingChannelControlHelper {
      public:
       explicit Helper(RefCountedPtr<ClusterChild> xds_cluster_manager_child)
           : xds_cluster_manager_child_(std::move(xds_cluster_manager_child)) {}
@@ -169,18 +170,16 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
         xds_cluster_manager_child_.reset(DEBUG_LOCATION, "Helper");
       }
 
-      RefCountedPtr<SubchannelInterface> CreateSubchannel(
-          ServerAddress address, const ChannelArgs& args) override;
       void UpdateState(grpc_connectivity_state state,
                        const absl::Status& status,
                        RefCountedPtr<SubchannelPicker> picker) override;
-      void RequestReresolution() override;
-      absl::string_view GetAuthority() override;
-      EventEngine* GetEventEngine() override;
-      void AddTraceEvent(TraceSeverity severity,
-                         absl::string_view message) override;
 
      private:
+      ChannelControlHelper* parent_helper() const override {
+        return xds_cluster_manager_child_->xds_cluster_manager_policy_
+            ->channel_control_helper();
+      }
+
       RefCountedPtr<ClusterChild> xds_cluster_manager_child_;
     };
 
@@ -199,7 +198,7 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
     OrphanablePtr<LoadBalancingPolicy> child_policy_;
 
     RefCountedPtr<SubchannelPicker> picker_;
-    grpc_connectivity_state connectivity_state_ = GRPC_CHANNEL_IDLE;
+    grpc_connectivity_state connectivity_state_ = GRPC_CHANNEL_CONNECTING;
 
     // States for delayed removal.
     absl::optional<EventEngine::TaskHandle> delayed_removal_timer_handle_;
@@ -230,9 +229,13 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
 XdsClusterManagerLb::PickResult XdsClusterManagerLb::ClusterPicker::Pick(
     PickArgs args) {
   auto* call_state = static_cast<ClientChannelLbCallState*>(args.call_state);
-  auto cluster_name =
-      call_state->GetCallAttribute(XdsClusterAttributeTypeName());
-  auto it = cluster_map_.find(std::string(cluster_name));
+  auto* cluster_name_attribute = static_cast<XdsClusterAttribute*>(
+      call_state->GetCallAttribute(XdsClusterAttribute::TypeName()));
+  absl::string_view cluster_name;
+  if (cluster_name_attribute != nullptr) {
+    cluster_name = cluster_name_attribute->cluster();
+  }
+  auto it = cluster_map_.find(cluster_name);
   if (it != cluster_map_.end()) {
     return it->second->Pick(args);
   }
@@ -404,7 +407,8 @@ XdsClusterManagerLb::ClusterChild::ClusterChild(
     RefCountedPtr<XdsClusterManagerLb> xds_cluster_manager_policy,
     const std::string& name)
     : xds_cluster_manager_policy_(std::move(xds_cluster_manager_policy)),
-      name_(name) {
+      name_(name),
+      picker_(MakeRefCounted<QueuePicker>(nullptr)) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_cluster_manager_lb_trace)) {
     gpr_log(GPR_INFO,
             "[xds_cluster_manager_lb %p] created ClusterChild %p for %s",
@@ -550,17 +554,6 @@ void XdsClusterManagerLb::ClusterChild::OnDelayedRemovalTimerLocked() {
 // XdsClusterManagerLb::ClusterChild::Helper
 //
 
-RefCountedPtr<SubchannelInterface>
-XdsClusterManagerLb::ClusterChild::Helper::CreateSubchannel(
-    ServerAddress address, const ChannelArgs& args) {
-  if (xds_cluster_manager_child_->xds_cluster_manager_policy_->shutting_down_) {
-    return nullptr;
-  }
-  return xds_cluster_manager_child_->xds_cluster_manager_policy_
-      ->channel_control_helper()
-      ->CreateSubchannel(std::move(address), args);
-}
-
 void XdsClusterManagerLb::ClusterChild::Helper::UpdateState(
     grpc_connectivity_state state, const absl::Status& status,
     RefCountedPtr<SubchannelPicker> picker) {
@@ -590,37 +583,6 @@ void XdsClusterManagerLb::ClusterChild::Helper::UpdateState(
   xds_cluster_manager_child_->xds_cluster_manager_policy_->UpdateStateLocked();
 }
 
-void XdsClusterManagerLb::ClusterChild::Helper::RequestReresolution() {
-  if (xds_cluster_manager_child_->xds_cluster_manager_policy_->shutting_down_) {
-    return;
-  }
-  xds_cluster_manager_child_->xds_cluster_manager_policy_
-      ->channel_control_helper()
-      ->RequestReresolution();
-}
-
-absl::string_view XdsClusterManagerLb::ClusterChild::Helper::GetAuthority() {
-  return xds_cluster_manager_child_->xds_cluster_manager_policy_
-      ->channel_control_helper()
-      ->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_) {
-    return;
-  }
-  xds_cluster_manager_child_->xds_cluster_manager_policy_
-      ->channel_control_helper()
-      ->AddTraceEvent(severity, message);
-}
-
 //
 // factory
 //
@@ -637,8 +599,8 @@ void XdsClusterManagerLbConfig::Child::JsonPostLoad(const Json& json,
                                                     const JsonArgs&,
                                                     ValidationErrors* errors) {
   ValidationErrors::ScopedField field(errors, ".childPolicy");
-  auto it = json.object_value().find("childPolicy");
-  if (it == json.object_value().end()) {
+  auto it = json.object().find("childPolicy");
+  if (it == json.object().end()) {
     errors->AddError("field not present");
     return;
   }
@@ -672,15 +634,7 @@ class XdsClusterManagerLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::JSON_NULL) {
-      // xds_cluster_manager was mentioned as a policy in the deprecated
-      // loadBalancingPolicy field or in the client API.
-      return absl::InvalidArgumentError(
-          "field:loadBalancingPolicy error:xds_cluster_manager policy requires "
-          "configuration.  Please use loadBalancingConfig field of service "
-          "config instead.");
-    }
-    return LoadRefCountedFromJson<XdsClusterManagerLbConfig>(
+    return LoadFromJson<RefCountedPtr<XdsClusterManagerLbConfig>>(
         json, JsonArgs(),
         "errors validating xds_cluster_manager LB policy config");
   }

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

@@ -35,14 +35,13 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#include <grpc/event_engine/event_engine.h>
-#include <grpc/grpc.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/impl/connectivity_state.h>
+#include <grpc/support/json.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/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"
@@ -57,20 +56,21 @@
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/ref_counted_string.h"
 #include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/iomgr/pollset_set.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"
+#include "src/core/lib/json/json_writer.h"
+#include "src/core/lib/load_balancing/delegating_helper.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/load_balancing/lb_policy_factory.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
-#include "src/core/lib/load_balancing/subchannel_interface.h"
 #include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resolver/resolver_registry.h"
 #include "src/core/lib/resolver/server_address.h"
-#include "src/core/lib/transport/connectivity_state.h"
 
 #define GRPC_EDS_DEFAULT_FALLBACK_TIMEOUT 10000
 
@@ -307,10 +307,10 @@ class XdsClusterResolverLb : public LoadBalancingPolicy {
     void Start() override;
     void Orphan() override;
     Json::Array override_child_policy() override {
-      return Json::Array{
-          Json::Object{
-              {"pick_first", Json::Object()},
-          },
+      return {
+          Json::FromObject({
+              {"pick_first", Json::FromObject({})},
+          }),
       };
     }
     bool disable_reresolution() override { return false; };
@@ -358,31 +358,18 @@ class XdsClusterResolverLb : public LoadBalancingPolicy {
     std::string GetChildPolicyName(size_t priority) const;
   };
 
-  class Helper : public ChannelControlHelper {
+  class Helper : public ParentOwningDelegatingChannelControlHelper<
+                     XdsClusterResolverLb> {
    public:
     explicit Helper(
         RefCountedPtr<XdsClusterResolverLb> xds_cluster_resolver_policy)
-        : xds_cluster_resolver_policy_(std::move(xds_cluster_resolver_policy)) {
-    }
-
-    ~Helper() override {
-      xds_cluster_resolver_policy_.reset(DEBUG_LOCATION, "Helper");
-    }
+        : ParentOwningDelegatingChannelControlHelper(
+              std::move(xds_cluster_resolver_policy)) {}
 
-    RefCountedPtr<SubchannelInterface> CreateSubchannel(
-        ServerAddress address, const ChannelArgs& args) override;
-    void UpdateState(grpc_connectivity_state state, const absl::Status& status,
-                     RefCountedPtr<SubchannelPicker> picker) override;
     // This is a no-op, because we get the addresses from the xds
     // client, which is a watch-based API.
+    // TODO(roth): Don't we need to propagate this for LOGICAL_DNS clusters?
     void RequestReresolution() override {}
-    absl::string_view GetAuthority() override;
-    grpc_event_engine::experimental::EventEngine* GetEventEngine() override;
-    void AddTraceEvent(TraceSeverity severity,
-                       absl::string_view message) override;
-
-   private:
-    RefCountedPtr<XdsClusterResolverLb> xds_cluster_resolver_policy_;
   };
 
   ~XdsClusterResolverLb() override;
@@ -420,53 +407,6 @@ class XdsClusterResolverLb : public LoadBalancingPolicy {
   OrphanablePtr<LoadBalancingPolicy> child_policy_;
 };
 
-//
-// XdsClusterResolverLb::Helper
-//
-
-RefCountedPtr<SubchannelInterface>
-XdsClusterResolverLb::Helper::CreateSubchannel(ServerAddress address,
-                                               const ChannelArgs& args) {
-  if (xds_cluster_resolver_policy_->shutting_down_) return nullptr;
-  return xds_cluster_resolver_policy_->channel_control_helper()
-      ->CreateSubchannel(std::move(address), args);
-}
-
-void XdsClusterResolverLb::Helper::UpdateState(
-    grpc_connectivity_state state, const absl::Status& status,
-    RefCountedPtr<SubchannelPicker> picker) {
-  if (xds_cluster_resolver_policy_->shutting_down_ ||
-      xds_cluster_resolver_policy_->child_policy_ == nullptr) {
-    return;
-  }
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_cluster_resolver_trace)) {
-    gpr_log(GPR_INFO,
-            "[xds_cluster_resolver_lb %p] child policy updated state=%s (%s) "
-            "picker=%p",
-            xds_cluster_resolver_policy_.get(), ConnectivityStateName(state),
-            status.ToString().c_str(), picker.get());
-  }
-  xds_cluster_resolver_policy_->channel_control_helper()->UpdateState(
-      state, status, std::move(picker));
-}
-
-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;
-  xds_cluster_resolver_policy_->channel_control_helper()->AddTraceEvent(
-      severity, message);
-}
-
 //
 // XdsClusterResolverLb::EdsDiscoveryMechanism
 //
@@ -825,28 +765,22 @@ ServerAddressList XdsClusterResolverLb::CreateChildPolicyAddressesLocked() {
       for (const auto& p : priority_entry.localities) {
         const auto& locality_name = p.first;
         const auto& locality = p.second;
-        std::vector<std::string> hierarchical_path = {
-            priority_child_name, locality_name->AsHumanReadableString()};
+        std::vector<RefCountedStringValue> hierarchical_path = {
+            RefCountedStringValue(priority_child_name),
+            RefCountedStringValue(locality_name->AsHumanReadableString())};
+        auto hierarchical_path_attr =
+            MakeRefCounted<HierarchicalPathArg>(std::move(hierarchical_path));
         for (const auto& endpoint : locality.endpoints) {
-          const ServerAddressWeightAttribute* weight_attribute = static_cast<
-              const ServerAddressWeightAttribute*>(endpoint.GetAttribute(
-              ServerAddressWeightAttribute::kServerAddressWeightAttributeKey));
-          uint32_t weight = locality.lb_weight;
-          if (weight_attribute != nullptr) {
-            weight = locality.lb_weight * weight_attribute->weight();
-          }
+          uint32_t endpoint_weight =
+              locality.lb_weight *
+              endpoint.args().GetInt(GRPC_ARG_ADDRESS_WEIGHT).value_or(1);
           addresses.emplace_back(
-              endpoint
-                  .WithAttribute(
-                      kHierarchicalPathAttributeKey,
-                      MakeHierarchicalPathAttribute(hierarchical_path))
-                  .WithAttribute(kXdsLocalityNameAttributeKey,
-                                 std::make_unique<XdsLocalityAttribute>(
-                                     locality_name->Ref(), locality.lb_weight))
-                  .WithAttribute(
-                      ServerAddressWeightAttribute::
-                          kServerAddressWeightAttributeKey,
-                      std::make_unique<ServerAddressWeightAttribute>(weight)));
+              endpoint.address(),
+              endpoint.args()
+                  .SetObject(hierarchical_path_attr)
+                  .Set(GRPC_ARG_ADDRESS_WEIGHT, endpoint_weight)
+                  .SetObject(locality_name->Ref())
+                  .Set(GRPC_ARG_XDS_LOCALITY_WEIGHT, locality.lb_weight));
         }
       }
     }
@@ -877,8 +811,8 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
       Json child_policy;
       if (!discovery_entry.discovery_mechanism->override_child_policy()
                .empty()) {
-        child_policy =
-            discovery_entry.discovery_mechanism->override_child_policy();
+        child_policy = Json::FromArray(
+            discovery_entry.discovery_mechanism->override_child_policy());
       } else {
         child_policy = config_->xds_lb_policy();
       }
@@ -888,32 +822,34 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
       };
       if (!discovery_config.override_host_statuses.empty()) {
         xds_override_host_lb_config["overrideHostStatus"] =
-            discovery_config.override_host_statuses;
+            Json::FromArray(discovery_config.override_host_statuses);
       }
-      Json::Array xds_override_host_config = {Json::Object{
+      Json::Array xds_override_host_config = {Json::FromObject({
           {"xds_override_host_experimental",
-           std::move(xds_override_host_lb_config)},
-      }};
+           Json::FromObject(std::move(xds_override_host_lb_config))},
+      })};
       // Wrap it in the xds_cluster_impl policy.
       Json::Array drop_categories;
       if (discovery_entry.latest_update->drop_config != nullptr) {
         for (const auto& category :
              discovery_entry.latest_update->drop_config->drop_category_list()) {
-          drop_categories.push_back(Json::Object{
-              {"category", category.name},
-              {"requests_per_million", category.parts_per_million},
-          });
+          drop_categories.push_back(Json::FromObject({
+              {"category", Json::FromString(category.name)},
+              {"requests_per_million",
+               Json::FromNumber(category.parts_per_million)},
+          }));
         }
       }
       Json::Object xds_cluster_impl_config = {
-          {"clusterName", discovery_config.cluster_name},
-          {"childPolicy", std::move(xds_override_host_config)},
-          {"dropCategories", std::move(drop_categories)},
-          {"maxConcurrentRequests", discovery_config.max_concurrent_requests},
+          {"clusterName", Json::FromString(discovery_config.cluster_name)},
+          {"childPolicy", Json::FromArray(std::move(xds_override_host_config))},
+          {"dropCategories", Json::FromArray(std::move(drop_categories))},
+          {"maxConcurrentRequests",
+           Json::FromNumber(discovery_config.max_concurrent_requests)},
       };
       if (!discovery_config.eds_service_name.empty()) {
         xds_cluster_impl_config["edsServiceName"] =
-            discovery_config.eds_service_name;
+            Json::FromString(discovery_config.eds_service_name);
       }
       if (discovery_config.lrs_load_reporting_server.has_value()) {
         xds_cluster_impl_config["lrsLoadReportingServer"] =
@@ -925,38 +861,39 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
         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_config["childPolicy"] =
+          Json::FromArray({Json::FromObject({
+              {"xds_cluster_impl_experimental",
+               Json::FromObject(std::move(xds_cluster_impl_config))},
+          })});
+      Json locality_picking_policy = Json::FromArray({Json::FromObject({
           {"outlier_detection_experimental",
-           std::move(outlier_detection_config)},
-      }};
+           Json::FromObject(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);
+      priority_priorities.emplace_back(Json::FromString(child_name));
       Json::Object child_config = {
           {"config", std::move(locality_picking_policy)},
       };
       if (discovery_entry.discovery_mechanism->disable_reresolution()) {
-        child_config["ignore_reresolution_requests"] = true;
+        child_config["ignore_reresolution_requests"] = Json::FromBool(true);
       }
-      priority_children[child_name] = std::move(child_config);
+      priority_children[child_name] = Json::FromObject(std::move(child_config));
     }
   }
-  Json json = Json::Array{Json::Object{
+  Json json = Json::FromArray({Json::FromObject({
       {"priority_experimental",
-       Json::Object{
-           {"children", std::move(priority_children)},
-           {"priorities", std::move(priority_priorities)},
-       }},
-  }};
+       Json::FromObject({
+           {"children", Json::FromObject(std::move(priority_children))},
+           {"priorities", Json::FromArray(std::move(priority_priorities))},
+       })},
+  })});
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_cluster_resolver_trace)) {
-    std::string json_str = json.Dump(/*indent=*/1);
     gpr_log(
         GPR_INFO,
         "[xds_cluster_resolver_lb %p] generated config for child policy: %s",
-        this, json_str.c_str());
+        this, JsonDump(json, /*indent=*/1).c_str());
   }
   auto config =
       CoreConfiguration::Get().lb_policy_registry().ParseLoadBalancingConfig(
@@ -1060,8 +997,8 @@ void XdsClusterResolverLbConfig::DiscoveryMechanism::JsonPostLoad(
     const Json& json, const JsonArgs& args, ValidationErrors* errors) {
   // Parse "type".
   {
-    auto type_field = LoadJsonObjectField<std::string>(json.object_value(),
-                                                       args, "type", errors);
+    auto type_field =
+        LoadJsonObjectField<std::string>(json.object(), args, "type", errors);
     if (type_field.has_value()) {
       if (*type_field == "EDS") {
         type = DiscoveryMechanismType::EDS;
@@ -1075,14 +1012,14 @@ void XdsClusterResolverLbConfig::DiscoveryMechanism::JsonPostLoad(
   }
   // Parse "edsServiceName" if type is EDS.
   if (type == DiscoveryMechanismType::EDS) {
-    auto value = LoadJsonObjectField<std::string>(json.object_value(), args,
+    auto value = LoadJsonObjectField<std::string>(json.object(), args,
                                                   "edsServiceName", errors,
                                                   /*required=*/false);
     if (value.has_value()) eds_service_name = std::move(*value);
   }
   // Parse "dnsHostname" if type is LOGICAL_DNS.
   if (type == DiscoveryMechanismType::LOGICAL_DNS) {
-    auto value = LoadJsonObjectField<std::string>(json.object_value(), args,
+    auto value = LoadJsonObjectField<std::string>(json.object(), args,
                                                   "dnsHostname", errors);
     if (value.has_value()) dns_hostname = std::move(*value);
   }
@@ -1112,8 +1049,8 @@ void XdsClusterResolverLbConfig::JsonPostLoad(const Json& json, const JsonArgs&,
   // Parse "xdsLbPolicy".
   {
     ValidationErrors::ScopedField field(errors, ".xdsLbPolicy");
-    auto it = json.object_value().find("xdsLbPolicy");
-    if (it == json.object_value().end()) {
+    auto it = json.object().find("xdsLbPolicy");
+    if (it == json.object().end()) {
       errors->AddError("field not present");
     } else {
       auto lb_config = CoreConfiguration::Get()
@@ -1145,15 +1082,7 @@ class XdsClusterResolverLbFactory : public LoadBalancingPolicyFactory {
 
   absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
   ParseLoadBalancingConfig(const Json& json) const override {
-    if (json.type() == Json::Type::JSON_NULL) {
-      // xds_cluster_resolver was mentioned as a policy in the deprecated
-      // loadBalancingPolicy field or in the client API.
-      return absl::InvalidArgumentError(
-          "field:loadBalancingPolicy error:xds_cluster_resolver policy "
-          "requires configuration. "
-          "Please use loadBalancingConfig field of service config instead.");
-    }
-    return LoadRefCountedFromJson<XdsClusterResolverLbConfig>(
+    return LoadFromJson<RefCountedPtr<XdsClusterResolverLbConfig>>(
         json, JsonArgs(),
         "errors validating xds_cluster_resolver LB policy config");
   }