grpc 1.48.0 → 1.49.1

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

@@ -32,23 +32,20 @@
 #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 "absl/types/variant.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.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.h"
 #include "src/core/ext/filters/client_channel/lb_policy/xds/xds_channel_args.h"
-#include "src/core/ext/filters/client_channel/lb_policy_factory.h"
-#include "src/core/ext/filters/client_channel/lb_policy_registry.h"
-#include "src/core/ext/filters/client_channel/subchannel_interface.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_client.h"
+#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/lib/channel/channel_args.h"
@@ -62,6 +59,10 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/json/json.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"
 
@@ -137,7 +138,7 @@ CircuitBreakerCallCounterMap::CallCounter::~CallCounter() {
 // LB policy
 //
 
-constexpr char kXdsClusterImpl[] = "xds_cluster_impl_experimental";
+constexpr absl::string_view kXdsClusterImpl = "xds_cluster_impl_experimental";
 
 // Config for xDS Cluster Impl LB policy.
 class XdsClusterImplLbConfig : public LoadBalancingPolicy::Config {
@@ -155,7 +156,7 @@ class XdsClusterImplLbConfig : public LoadBalancingPolicy::Config {
         max_concurrent_requests_(max_concurrent_requests),
         drop_config_(std::move(drop_config)) {}
 
-  const char* name() const override { return kXdsClusterImpl; }
+  absl::string_view name() const override { return kXdsClusterImpl; }
 
   RefCountedPtr<LoadBalancingPolicy::Config> child_policy() const {
     return child_policy_;
@@ -185,7 +186,7 @@ class XdsClusterImplLb : public LoadBalancingPolicy {
  public:
   XdsClusterImplLb(RefCountedPtr<XdsClient> xds_client, Args args);
 
-  const char* name() const override { return kXdsClusterImpl; }
+  absl::string_view name() const override { return kXdsClusterImpl; }
 
   void UpdateLocked(UpdateArgs args) override;
   void ExitIdleLocked() override;
@@ -247,7 +248,7 @@ class XdsClusterImplLb : public LoadBalancingPolicy {
     }
 
     RefCountedPtr<SubchannelInterface> CreateSubchannel(
-        ServerAddress address, const grpc_channel_args& args) override;
+        ServerAddress address, const ChannelArgs& args) override;
     void UpdateState(grpc_connectivity_state state, const absl::Status& status,
                      std::unique_ptr<SubchannelPicker> picker) override;
     void RequestReresolution() override;
@@ -264,9 +265,10 @@ class XdsClusterImplLb : public LoadBalancingPolicy {
   void ShutdownLocked() override;
 
   OrphanablePtr<LoadBalancingPolicy> CreateChildPolicyLocked(
-      const grpc_channel_args* args);
+      const ChannelArgs& args);
   void UpdateChildPolicyLocked(absl::StatusOr<ServerAddressList> addresses,
-                               const grpc_channel_args* args);
+                               std::string resolution_note,
+                               const ChannelArgs& args);
 
   void MaybeUpdatePickerLocked();
 
@@ -465,7 +467,7 @@ void XdsClusterImplLb::ShutdownLocked() {
   // the child.
   picker_.reset();
   drop_stats_.reset();
-  xds_client_.reset();
+  xds_client_.reset(DEBUG_LOCATION, "XdsClusterImpl");
 }
 
 void XdsClusterImplLb::ExitIdleLocked() {
@@ -519,7 +521,8 @@ void XdsClusterImplLb::UpdateLocked(UpdateArgs args) {
     MaybeUpdatePickerLocked();
   }
   // Update child policy.
-  UpdateChildPolicyLocked(std::move(args.addresses), args.args);
+  UpdateChildPolicyLocked(std::move(args.addresses),
+                          std::move(args.resolution_note), args.args);
 }
 
 void XdsClusterImplLb::MaybeUpdatePickerLocked() {
@@ -553,7 +556,7 @@ void XdsClusterImplLb::MaybeUpdatePickerLocked() {
 }
 
 OrphanablePtr<LoadBalancingPolicy> XdsClusterImplLb::CreateChildPolicyLocked(
-    const grpc_channel_args* args) {
+    const ChannelArgs& args) {
   LoadBalancingPolicy::Args lb_policy_args;
   lb_policy_args.work_serializer = work_serializer();
   lb_policy_args.args = args;
@@ -576,8 +579,8 @@ OrphanablePtr<LoadBalancingPolicy> XdsClusterImplLb::CreateChildPolicyLocked(
 }
 
 void XdsClusterImplLb::UpdateChildPolicyLocked(
-    absl::StatusOr<ServerAddressList> addresses,
-    const grpc_channel_args* args) {
+    absl::StatusOr<ServerAddressList> addresses, std::string resolution_note,
+    const ChannelArgs& args) {
   // Create policy if needed.
   if (child_policy_ == nullptr) {
     child_policy_ = CreateChildPolicyLocked(args);
@@ -585,11 +588,10 @@ void XdsClusterImplLb::UpdateChildPolicyLocked(
   // Construct update args.
   UpdateArgs update_args;
   update_args.addresses = std::move(addresses);
+  update_args.resolution_note = std::move(resolution_note);
   update_args.config = config_->child_policy();
-  grpc_arg cluster_arg = grpc_channel_arg_string_create(
-      const_cast<char*>(GRPC_ARG_XDS_CLUSTER_NAME),
-      const_cast<char*>(config_->cluster_name().c_str()));
-  update_args.args = grpc_channel_args_copy_and_add(args, &cluster_arg, 1);
+  update_args.args =
+      args.Set(GRPC_ARG_XDS_CLUSTER_NAME, config_->cluster_name());
   // Update the policy.
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_cluster_impl_lb_trace)) {
     gpr_log(GPR_INFO,
@@ -604,7 +606,7 @@ void XdsClusterImplLb::UpdateChildPolicyLocked(
 //
 
 RefCountedPtr<SubchannelInterface> XdsClusterImplLb::Helper::CreateSubchannel(
-    ServerAddress address, const grpc_channel_args& args) {
+    ServerAddress address, const ChannelArgs& args) {
   if (xds_cluster_impl_policy_->shutting_down_) return nullptr;
   // If load reporting is enabled, wrap the subchannel such that it
   // includes the locality stats object, which will be used by the EdsPicker.
@@ -690,8 +692,8 @@ class XdsClusterImplLbFactory : public LoadBalancingPolicyFactory {
  public:
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       LoadBalancingPolicy::Args args) const override {
-    RefCountedPtr<XdsClient> xds_client =
-        XdsClient::GetFromChannelArgs(*args.args);
+    auto xds_client = args.args.GetObjectRef<GrpcXdsClient>(DEBUG_LOCATION,
+                                                            "XdsClusterImplLb");
     if (xds_client == nullptr) {
       gpr_log(GPR_ERROR,
               "XdsClient not present in channel args -- cannot instantiate "
@@ -702,48 +704,41 @@ class XdsClusterImplLbFactory : public LoadBalancingPolicyFactory {
                                             std::move(args));
   }
 
-  const char* name() const override { return kXdsClusterImpl; }
+  absl::string_view name() const override { return kXdsClusterImpl; }
 
-  RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
-      const Json& json, grpc_error_handle* error) const override {
-    GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
+  absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
+  ParseLoadBalancingConfig(const Json& json) const override {
     if (json.type() == Json::Type::JSON_NULL) {
       // This policy was configured in the deprecated loadBalancingPolicy
       // field or in the client API.
-      *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+      return absl::InvalidArgumentError(
           "field:loadBalancingPolicy error:xds_cluster_impl policy requires "
           "configuration. Please use loadBalancingConfig field of service "
           "config instead.");
-      return nullptr;
     }
-    std::vector<grpc_error_handle> error_list;
+    std::vector<std::string> errors;
     // Child policy.
     RefCountedPtr<LoadBalancingPolicy::Config> child_policy;
     auto it = json.object_value().find("childPolicy");
     if (it == json.object_value().end()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:childPolicy error:required field missing"));
+      errors.emplace_back("field:childPolicy error:required field missing");
     } else {
-      grpc_error_handle parse_error = GRPC_ERROR_NONE;
-      child_policy = LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
-          it->second, &parse_error);
-      if (child_policy == nullptr) {
-        GPR_DEBUG_ASSERT(!GRPC_ERROR_IS_NONE(parse_error));
-        std::vector<grpc_error_handle> child_errors;
-        child_errors.push_back(parse_error);
-        error_list.push_back(
-            GRPC_ERROR_CREATE_FROM_VECTOR("field:childPolicy", &child_errors));
+      auto config =
+          LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(it->second);
+      if (!config.ok()) {
+        errors.emplace_back(absl::StrCat("field:childPolicy error:",
+                                         config.status().message()));
+      } else {
+        child_policy = std::move(*config);
       }
     }
     // Cluster name.
     std::string cluster_name;
     it = json.object_value().find("clusterName");
     if (it == json.object_value().end()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:clusterName error:required field missing"));
+      errors.emplace_back("field:clusterName error:required field missing");
     } else if (it->second.type() != Json::Type::STRING) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:clusterName error:type should be string"));
+      errors.emplace_back("field:clusterName error:type should be string");
     } else {
       cluster_name = it->second.string_value();
     }
@@ -752,8 +747,7 @@ class XdsClusterImplLbFactory : public LoadBalancingPolicyFactory {
     it = json.object_value().find("edsServiceName");
     if (it != json.object_value().end()) {
       if (it->second.type() != Json::Type::STRING) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:edsServiceName error:type should be string"));
+        errors.emplace_back("field:edsServiceName error:type should be string");
       } else {
         eds_service_name = it->second.string_value();
       }
@@ -763,16 +757,17 @@ class XdsClusterImplLbFactory : public LoadBalancingPolicyFactory {
     it = json.object_value().find("lrsLoadReportingServer");
     if (it != json.object_value().end()) {
       if (it->second.type() != Json::Type::OBJECT) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:lrsLoadReportingServer error:type should be object"));
+        errors.emplace_back(
+            "field:lrsLoadReportingServer error:type should be object");
       } else {
         grpc_error_handle parser_error;
         lrs_load_reporting_server = XdsBootstrap::XdsServer::Parse(
             it->second.object_value(), &parser_error);
         if (!GRPC_ERROR_IS_NONE(parser_error)) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
-              absl::StrCat("errors parsing lrs_load_reporting_server")));
-          error_list.push_back(parser_error);
+          errors.emplace_back(
+              absl::StrCat("error parsing lrs_load_reporting_server: ",
+                           grpc_error_std_string(parser_error)));
+          GRPC_ERROR_UNREF(parser_error);
         }
       }
     }
@@ -781,8 +776,8 @@ class XdsClusterImplLbFactory : public LoadBalancingPolicyFactory {
     it = json.object_value().find("maxConcurrentRequests");
     if (it != json.object_value().end()) {
       if (it->second.type() != Json::Type::NUMBER) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:max_concurrent_requests error:must be of type number"));
+        errors.emplace_back(
+            "field:max_concurrent_requests error:must be of type number");
       } else {
         max_concurrent_requests =
             gpr_parse_nonnegative_int(it->second.string_value().c_str());
@@ -792,20 +787,15 @@ class XdsClusterImplLbFactory : public LoadBalancingPolicyFactory {
     auto drop_config = MakeRefCounted<XdsEndpointResource::DropConfig>();
     it = json.object_value().find("dropCategories");
     if (it == json.object_value().end()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:dropCategories error:required field missing"));
+      errors.emplace_back("field:dropCategories error:required field missing");
     } else {
-      std::vector<grpc_error_handle> child_errors =
-          ParseDropCategories(it->second, drop_config.get());
-      if (!child_errors.empty()) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_VECTOR(
-            "field:dropCategories", &child_errors));
-      }
+      absl::Status status = ParseDropCategories(it->second, drop_config.get());
+      if (!status.ok()) errors.emplace_back(status.message());
     }
-    if (!error_list.empty()) {
-      *error = GRPC_ERROR_CREATE_FROM_VECTOR(
-          "xds_cluster_impl_experimental LB policy config", &error_list);
-      return nullptr;
+    if (!errors.empty()) {
+      return absl::InvalidArgumentError(absl::StrCat(
+          "errors parseing xds_cluster_impl_experimental LB policy config: [",
+          absl::StrJoin(errors, "; "), "]"));
     }
     return MakeRefCounted<XdsClusterImplLbConfig>(
         std::move(child_policy), std::move(cluster_name),
@@ -814,65 +804,59 @@ class XdsClusterImplLbFactory : public LoadBalancingPolicyFactory {
   }
 
  private:
-  static std::vector<grpc_error_handle> ParseDropCategories(
+  static absl::Status ParseDropCategories(
       const Json& json, XdsEndpointResource::DropConfig* drop_config) {
-    std::vector<grpc_error_handle> error_list;
     if (json.type() != Json::Type::ARRAY) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "dropCategories field is not an array"));
-      return error_list;
+      return absl::InvalidArgumentError("dropCategories field is not an array");
     }
+    std::vector<std::string> errors;
     for (size_t i = 0; i < json.array_value().size(); ++i) {
       const Json& entry = json.array_value()[i];
-      std::vector<grpc_error_handle> child_errors =
-          ParseDropCategory(entry, drop_config);
-      if (!child_errors.empty()) {
-        grpc_error_handle error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
-            absl::StrCat("errors parsing index ", i));
-        for (size_t i = 0; i < child_errors.size(); ++i) {
-          error = grpc_error_add_child(error, child_errors[i]);
-        }
-        error_list.push_back(error);
+      absl::Status status = ParseDropCategory(entry, drop_config);
+      if (!status.ok()) {
+        errors.emplace_back(
+            absl::StrCat("error parsing index ", i, ": ", status.message()));
       }
     }
-    return error_list;
+    if (!errors.empty()) {
+      return absl::InvalidArgumentError(
+          absl::StrCat("errors parsing dropCategories field: [",
+                       absl::StrJoin(errors, "; "), "]"));
+    }
+    return absl::OkStatus();
   }
 
-  static std::vector<grpc_error_handle> ParseDropCategory(
+  static absl::Status ParseDropCategory(
       const Json& json, XdsEndpointResource::DropConfig* drop_config) {
-    std::vector<grpc_error_handle> error_list;
     if (json.type() != Json::Type::OBJECT) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "dropCategories entry is not an object"));
-      return error_list;
+      return absl::InvalidArgumentError(
+          "dropCategories entry is not an object");
     }
+    std::vector<std::string> errors;
     std::string category;
     auto it = json.object_value().find("category");
     if (it == json.object_value().end()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "\"category\" field not present"));
+      errors.emplace_back("\"category\" field not present");
     } else if (it->second.type() != Json::Type::STRING) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "\"category\" field is not a string"));
+      errors.emplace_back("\"category\" field is not a string");
     } else {
       category = it->second.string_value();
     }
     uint32_t requests_per_million = 0;
     it = json.object_value().find("requests_per_million");
     if (it == json.object_value().end()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "\"requests_per_million\" field is not present"));
+      errors.emplace_back("\"requests_per_million\" field is not present");
     } else if (it->second.type() != Json::Type::NUMBER) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "\"requests_per_million\" field is not a number"));
+      errors.emplace_back("\"requests_per_million\" field is not a number");
     } else {
       requests_per_million =
           gpr_parse_nonnegative_int(it->second.string_value().c_str());
     }
-    if (error_list.empty()) {
-      drop_config->AddCategory(std::move(category), requests_per_million);
+    if (!errors.empty()) {
+      return absl::InvalidArgumentError(absl::StrJoin(errors, "; "));
     }
-    return error_list;
+    drop_config->AddCategory(std::move(category), requests_per_million);
+    return absl::OkStatus();
   }
 };
 

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

@@ -30,19 +30,15 @@
 #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 <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/client_channel.h"
-#include "src/core/ext/filters/client_channel/lb_policy.h"
 #include "src/core/ext/filters/client_channel/lb_policy/child_policy_handler.h"
-#include "src/core/ext/filters/client_channel/lb_policy_factory.h"
-#include "src/core/ext/filters/client_channel/lb_policy_registry.h"
 #include "src/core/ext/filters/client_channel/resolver/xds/xds_resolver.h"
-#include "src/core/ext/filters/client_channel/subchannel_interface.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -50,13 +46,17 @@
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.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/iomgr/work_serializer.h"
 #include "src/core/lib/json/json.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"
 
@@ -68,7 +68,8 @@ TraceFlag grpc_xds_cluster_manager_lb_trace(false, "xds_cluster_manager_lb");
 
 namespace {
 
-constexpr char kXdsClusterManager[] = "xds_cluster_manager_experimental";
+constexpr absl::string_view kXdsClusterManager =
+    "xds_cluster_manager_experimental";
 
 // Config for xds_cluster_manager LB policy.
 class XdsClusterManagerLbConfig : public LoadBalancingPolicy::Config {
@@ -79,7 +80,7 @@ class XdsClusterManagerLbConfig : public LoadBalancingPolicy::Config {
   explicit XdsClusterManagerLbConfig(ClusterMap cluster_map)
       : cluster_map_(std::move(cluster_map)) {}
 
-  const char* name() const override { return kXdsClusterManager; }
+  absl::string_view name() const override { return kXdsClusterManager; }
 
   const ClusterMap& cluster_map() const { return cluster_map_; }
 
@@ -92,7 +93,7 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
  public:
   explicit XdsClusterManagerLb(Args args);
 
-  const char* name() const override { return kXdsClusterManager; }
+  absl::string_view name() const override { return kXdsClusterManager; }
 
   void UpdateLocked(UpdateArgs args) override;
   void ExitIdleLocked() override;
@@ -144,7 +145,7 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
 
     void UpdateLocked(RefCountedPtr<LoadBalancingPolicy::Config> config,
                       const absl::StatusOr<ServerAddressList>& addresses,
-                      const grpc_channel_args* args);
+                      const ChannelArgs& args);
     void ExitIdleLocked();
     void ResetBackoffLocked();
     void DeactivateLocked();
@@ -167,7 +168,7 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
       }
 
       RefCountedPtr<SubchannelInterface> CreateSubchannel(
-          ServerAddress address, const grpc_channel_args& args) override;
+          ServerAddress address, const ChannelArgs& args) override;
       void UpdateState(grpc_connectivity_state state,
                        const absl::Status& status,
                        std::unique_ptr<SubchannelPicker> picker) override;
@@ -182,7 +183,7 @@ class XdsClusterManagerLb : public LoadBalancingPolicy {
 
     // Methods for dealing with the child policy.
     OrphanablePtr<LoadBalancingPolicy> CreateChildPolicyLocked(
-        const grpc_channel_args* args);
+        const ChannelArgs& args);
 
     static void OnDelayedRemovalTimer(void* arg, grpc_error_handle error);
     void OnDelayedRemovalTimerLocked(grpc_error_handle error);
@@ -441,7 +442,7 @@ void XdsClusterManagerLb::ClusterChild::Orphan() {
 
 OrphanablePtr<LoadBalancingPolicy>
 XdsClusterManagerLb::ClusterChild::CreateChildPolicyLocked(
-    const grpc_channel_args* args) {
+    const ChannelArgs& args) {
   LoadBalancingPolicy::Args lb_policy_args;
   lb_policy_args.work_serializer =
       xds_cluster_manager_policy_->work_serializer();
@@ -471,7 +472,7 @@ XdsClusterManagerLb::ClusterChild::CreateChildPolicyLocked(
 void XdsClusterManagerLb::ClusterChild::UpdateLocked(
     RefCountedPtr<LoadBalancingPolicy::Config> config,
     const absl::StatusOr<ServerAddressList>& addresses,
-    const grpc_channel_args* args) {
+    const ChannelArgs& args) {
   if (xds_cluster_manager_policy_->shutting_down_) return;
   // Update child weight.
   // Reactivate if needed.
@@ -487,7 +488,7 @@ void XdsClusterManagerLb::ClusterChild::UpdateLocked(
   UpdateArgs update_args;
   update_args.config = std::move(config);
   update_args.addresses = addresses;
-  update_args.args = grpc_channel_args_copy(args);
+  update_args.args = args;
   // Update the policy.
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_cluster_manager_lb_trace)) {
     gpr_log(GPR_INFO,
@@ -547,7 +548,7 @@ void XdsClusterManagerLb::ClusterChild::OnDelayedRemovalTimerLocked(
 
 RefCountedPtr<SubchannelInterface>
 XdsClusterManagerLb::ClusterChild::Helper::CreateSubchannel(
-    ServerAddress address, const grpc_channel_args& args) {
+    ServerAddress address, const ChannelArgs& args) {
   if (xds_cluster_manager_child_->xds_cluster_manager_policy_->shutting_down_) {
     return nullptr;
   }
@@ -623,89 +624,80 @@ class XdsClusterManagerLbFactory : public LoadBalancingPolicyFactory {
     return MakeOrphanable<XdsClusterManagerLb>(std::move(args));
   }
 
-  const char* name() const override { return kXdsClusterManager; }
+  absl::string_view name() const override { return kXdsClusterManager; }
 
-  RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
-      const Json& json, grpc_error_handle* error) const override {
-    GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
+  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.
-      *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+      return absl::InvalidArgumentError(
           "field:loadBalancingPolicy error:xds_cluster_manager policy requires "
           "configuration.  Please use loadBalancingConfig field of service "
           "config instead.");
-      return nullptr;
     }
-    std::vector<grpc_error_handle> error_list;
+    std::vector<std::string> errors;
     XdsClusterManagerLbConfig::ClusterMap cluster_map;
     std::set<std::string /*cluster_name*/> clusters_to_be_used;
     auto it = json.object_value().find("children");
     if (it == json.object_value().end()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:children error:required field not present"));
+      errors.emplace_back("field:children error:required field not present");
     } else if (it->second.type() != Json::Type::OBJECT) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:children error:type should be object"));
+      errors.emplace_back("field:children error:type should be object");
     } else {
       for (const auto& p : it->second.object_value()) {
         const std::string& child_name = p.first;
         if (child_name.empty()) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:children element error: name cannot be empty"));
+          errors.emplace_back("field:children error: name cannot be empty");
           continue;
         }
-        RefCountedPtr<LoadBalancingPolicy::Config> child_config;
-        std::vector<grpc_error_handle> child_errors =
-            ParseChildConfig(p.second, &child_config);
-        if (!child_errors.empty()) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_VECTOR_AND_CPP_STRING(
-              absl::StrCat("field:children name:", child_name), &child_errors));
+        auto config = ParseChildConfig(p.second);
+        if (!config.ok()) {
+          errors.emplace_back(
+              absl::StrCat("field:children name:", child_name,
+                           " error:", config.status().message()));
         } else {
-          cluster_map[child_name] = std::move(child_config);
+          cluster_map[child_name] = std::move(*config);
           clusters_to_be_used.insert(child_name);
         }
       }
     }
     if (cluster_map.empty()) {
-      error_list.push_back(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("no valid children configured"));
+      errors.emplace_back("no valid children configured");
     }
-    if (!error_list.empty()) {
-      *error = GRPC_ERROR_CREATE_FROM_VECTOR(
-          "xds_cluster_manager_experimental LB policy config", &error_list);
-      return nullptr;
+    if (!errors.empty()) {
+      return absl::InvalidArgumentError(absl::StrCat(
+          "errors parsing xds_cluster_manager_experimental LB policy config: [",
+          absl::StrJoin(errors, "; "), "]"));
     }
     return MakeRefCounted<XdsClusterManagerLbConfig>(std::move(cluster_map));
   }
 
  private:
-  static std::vector<grpc_error_handle> ParseChildConfig(
-      const Json& json,
-      RefCountedPtr<LoadBalancingPolicy::Config>* child_config) {
-    std::vector<grpc_error_handle> error_list;
+  static absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
+  ParseChildConfig(const Json& json) {
     if (json.type() != Json::Type::OBJECT) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "value should be of type object"));
-      return error_list;
+      return absl::InvalidArgumentError("value should be of type object");
     }
+    RefCountedPtr<LoadBalancingPolicy::Config> child_config;
+    std::vector<std::string> errors;
     auto it = json.object_value().find("childPolicy");
     if (it == json.object_value().end()) {
-      error_list.push_back(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("did not find childPolicy"));
+      errors.emplace_back("did not find childPolicy");
     } else {
-      grpc_error_handle parse_error = GRPC_ERROR_NONE;
-      *child_config = LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
-          it->second, &parse_error);
-      if (*child_config == nullptr) {
-        GPR_DEBUG_ASSERT(!GRPC_ERROR_IS_NONE(parse_error));
-        std::vector<grpc_error_handle> child_errors;
-        child_errors.push_back(parse_error);
-        error_list.push_back(
-            GRPC_ERROR_CREATE_FROM_VECTOR("field:childPolicy", &child_errors));
+      auto config =
+          LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(it->second);
+      if (!config.ok()) {
+        errors.emplace_back(absl::StrCat("field:childPolicy error:",
+                                         config.status().message()));
+      } else {
+        child_config = std::move(*config);
       }
     }
-    return error_list;
+    if (!errors.empty()) {
+      return absl::InvalidArgumentError(absl::StrJoin(errors, "; "));
+    }
+    return child_config;
   }
 };