grpc 1.53.0 → 1.59.2

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"
@@ -55,22 +54,24 @@
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/no_destruct.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
 
@@ -212,7 +213,8 @@ class XdsClusterResolverLb : public LoadBalancingPolicy {
       ~EndpointWatcher() override {
         discovery_mechanism_.reset(DEBUG_LOCATION, "EndpointWatcher");
       }
-      void OnResourceChanged(XdsEndpointResource update) override {
+      void OnResourceChanged(
+          std::shared_ptr<const XdsEndpointResource> update) override {
         RefCountedPtr<EndpointWatcher> self = Ref();
         discovery_mechanism_->parent()->work_serializer()->Run(
             [self = std::move(self), update = std::move(update)]() mutable {
@@ -241,15 +243,16 @@ class XdsClusterResolverLb : public LoadBalancingPolicy {
       // Code accessing protected methods of `DiscoveryMechanism` need to be
       // in methods of this class rather than in lambdas to work around an MSVC
       // bug.
-      void OnResourceChangedHelper(XdsEndpointResource update) {
+      void OnResourceChangedHelper(
+          std::shared_ptr<const XdsEndpointResource> update) {
         std::string resolution_note;
-        if (update.priorities.empty()) {
+        if (update->priorities.empty()) {
           resolution_note = absl::StrCat(
               "EDS resource ", discovery_mechanism_->GetEdsResourceName(),
               " contains no localities");
         } else {
           std::set<std::string> empty_localities;
-          for (const auto& priority : update.priorities) {
+          for (const auto& priority : update->priorities) {
             for (const auto& p : priority.localities) {
               if (p.second.endpoints.empty()) {
                 empty_localities.insert(p.first->AsHumanReadableString());
@@ -307,10 +310,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; };
@@ -345,7 +348,7 @@ class XdsClusterResolverLb : public LoadBalancingPolicy {
   struct DiscoveryMechanismEntry {
     OrphanablePtr<DiscoveryMechanism> discovery_mechanism;
     // Most recent update reported by the discovery mechanism.
-    absl::optional<XdsEndpointResource> latest_update;
+    std::shared_ptr<const XdsEndpointResource> latest_update;
     // Last resolution note reported by the discovery mechanism, if any.
     std::string resolution_note;
     // State used to retain child policy names for priority policy.
@@ -358,38 +361,26 @@ 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;
 
   void ShutdownLocked() override;
 
-  void OnEndpointChanged(size_t index, XdsEndpointResource update,
+  void OnEndpointChanged(size_t index,
+                         std::shared_ptr<const XdsEndpointResource> update,
                          std::string resolution_note);
   void OnError(size_t index, std::string resolution_note);
   void OnResourceDoesNotExist(size_t index, std::string resolution_note);
@@ -420,53 +411,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
 //
@@ -563,14 +507,14 @@ void XdsClusterResolverLb::LogicalDNSDiscoveryMechanism::ResolverResultHandler::
     return;
   }
   // Convert resolver result to EDS update.
-  XdsEndpointResource update;
+  auto update = std::make_shared<XdsEndpointResource>();
   XdsEndpointResource::Priority::Locality locality;
   locality.name = MakeRefCounted<XdsLocalityName>("", "", "");
   locality.lb_weight = 1;
   locality.endpoints = std::move(*result.addresses);
   XdsEndpointResource::Priority priority;
   priority.localities.emplace(locality.name.get(), std::move(locality));
-  update.priorities.emplace_back(std::move(priority));
+  update->priorities.emplace_back(std::move(priority));
   lb_policy->OnEndpointChanged(index, std::move(update),
                                std::move(result.resolution_note));
 }
@@ -683,9 +627,21 @@ void XdsClusterResolverLb::ExitIdleLocked() {
   if (child_policy_ != nullptr) child_policy_->ExitIdleLocked();
 }
 
-void XdsClusterResolverLb::OnEndpointChanged(size_t index,
-                                             XdsEndpointResource update,
-                                             std::string resolution_note) {
+// We need at least one priority for each discovery mechanism, just so that we
+// have a child in which to create the xds_cluster_impl policy.  This ensures
+// that we properly handle the case of a discovery mechanism dropping 100% of
+// calls, the OnError() case, and the OnResourceDoesNotExist() case.
+const XdsEndpointResource::PriorityList& GetUpdatePriorityList(
+    const XdsEndpointResource& update) {
+  static const NoDestruct<XdsEndpointResource::PriorityList>
+      kPriorityListWithEmptyPriority(1);
+  if (update.priorities.empty()) return *kPriorityListWithEmptyPriority;
+  return update.priorities;
+}
+
+void XdsClusterResolverLb::OnEndpointChanged(
+    size_t index, std::shared_ptr<const XdsEndpointResource> update,
+    std::string resolution_note) {
   if (shutting_down_) return;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_cluster_resolver_trace)) {
     gpr_log(GPR_INFO,
@@ -694,11 +650,8 @@ void XdsClusterResolverLb::OnEndpointChanged(size_t index,
             this, index, resolution_note.c_str());
   }
   DiscoveryMechanismEntry& discovery_entry = discovery_mechanisms_[index];
-  // We need at least one priority for each discovery mechanism, just so that we
-  // have a child in which to create the xds_cluster_impl policy.  This ensures
-  // that we properly handle the case of a discovery mechanism dropping 100% of
-  // calls, the OnError() case, and the OnResourceDoesNotExist() case.
-  if (update.priorities.empty()) update.priorities.emplace_back();
+  const XdsEndpointResource::PriorityList& priority_list =
+      GetUpdatePriorityList(*update);
   // Update priority_child_numbers, reusing old child numbers in an
   // intelligent way to avoid unnecessary churn.
   // First, build some maps from locality to child number and the reverse
@@ -707,8 +660,9 @@ void XdsClusterResolverLb::OnEndpointChanged(size_t index,
       locality_child_map;
   std::map<size_t, std::set<XdsLocalityName*, XdsLocalityName::Less>>
       child_locality_map;
-  if (discovery_entry.latest_update.has_value()) {
-    const auto& prev_priority_list = discovery_entry.latest_update->priorities;
+  if (discovery_entry.latest_update != nullptr) {
+    const auto& prev_priority_list =
+        GetUpdatePriorityList(*discovery_entry.latest_update);
     for (size_t priority = 0; priority < prev_priority_list.size();
          ++priority) {
       size_t child_number = discovery_entry.priority_child_numbers[priority];
@@ -722,8 +676,8 @@ void XdsClusterResolverLb::OnEndpointChanged(size_t index,
   }
   // Construct new list of children.
   std::vector<size_t> priority_child_numbers;
-  for (size_t priority = 0; priority < update.priorities.size(); ++priority) {
-    const auto& localities = update.priorities[priority].localities;
+  for (size_t priority = 0; priority < priority_list.size(); ++priority) {
+    const auto& localities = priority_list[priority].localities;
     absl::optional<size_t> child_number;
     // If one of the localities in this priority already existed, reuse its
     // child number.
@@ -776,7 +730,7 @@ void XdsClusterResolverLb::OnEndpointChanged(size_t index,
   // will put the channel into TRANSIENT_FAILURE instead of CONNECTING
   // while we're still waiting for the other discovery mechanism(s).
   for (DiscoveryMechanismEntry& mechanism : discovery_mechanisms_) {
-    if (!mechanism.latest_update.has_value()) return;
+    if (mechanism.latest_update == nullptr) return;
   }
   // Update child policy.
   // TODO(roth): If the child policy reports an error with the update,
@@ -790,10 +744,11 @@ void XdsClusterResolverLb::OnError(size_t index, std::string resolution_note) {
           " reported error: %s",
           this, index, resolution_note.c_str());
   if (shutting_down_) return;
-  if (!discovery_mechanisms_[index].latest_update.has_value()) {
+  if (discovery_mechanisms_[index].latest_update == nullptr) {
     // Call OnEndpointChanged() with an empty update just like
     // OnResourceDoesNotExist().
-    OnEndpointChanged(index, XdsEndpointResource(), std::move(resolution_note));
+    OnEndpointChanged(index, std::make_shared<XdsEndpointResource>(),
+                      std::move(resolution_note));
   }
 }
 
@@ -805,7 +760,8 @@ void XdsClusterResolverLb::OnResourceDoesNotExist(size_t index,
           this, index, resolution_note.c_str());
   if (shutting_down_) return;
   // Call OnEndpointChanged() with an empty update.
-  OnEndpointChanged(index, XdsEndpointResource(), std::move(resolution_note));
+  OnEndpointChanged(index, std::make_shared<XdsEndpointResource>(),
+                    std::move(resolution_note));
 }
 
 //
@@ -815,38 +771,31 @@ void XdsClusterResolverLb::OnResourceDoesNotExist(size_t index,
 ServerAddressList XdsClusterResolverLb::CreateChildPolicyAddressesLocked() {
   ServerAddressList addresses;
   for (const auto& discovery_entry : discovery_mechanisms_) {
-    for (size_t priority = 0;
-         priority < discovery_entry.latest_update->priorities.size();
-         ++priority) {
-      const auto& priority_entry =
-          discovery_entry.latest_update->priorities[priority];
+    const auto& priority_list =
+        GetUpdatePriorityList(*discovery_entry.latest_update);
+    for (size_t priority = 0; priority < priority_list.size(); ++priority) {
+      const auto& priority_entry = priority_list[priority];
       std::string priority_child_name =
           discovery_entry.GetChildPolicyName(priority);
       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));
         }
       }
     }
@@ -869,16 +818,16 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
   Json::Object priority_children;
   Json::Array priority_priorities;
   for (const auto& discovery_entry : discovery_mechanisms_) {
+    const auto& priority_list =
+        GetUpdatePriorityList(*discovery_entry.latest_update);
     const auto& discovery_config = discovery_entry.config();
-    for (size_t priority = 0;
-         priority < discovery_entry.latest_update->priorities.size();
-         ++priority) {
+    for (size_t priority = 0; priority < priority_list.size(); ++priority) {
       // Determine what xDS LB policy to use.
       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 +837,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 +876,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 +1012,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 +1027,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 +1064,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 +1097,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");
   }