grpc 1.48.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

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

@@ -20,7 +20,6 @@
 
 #include <stddef.h>
 
-#include <type_traits>
 #include <utility>
 
 #include "absl/memory/memory.h"
@@ -47,12 +46,12 @@
 
 #include <grpc/support/log.h>
 
+#include "src/core/ext/xds/upb_utils.h"
 #include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/time.h"
-#include "src/core/lib/iomgr/error.h"
 
 namespace grpc_core {
 
@@ -104,15 +103,15 @@ std::string XdsClusterResource::ToString() const {
 
 namespace {
 
-grpc_error_handle UpstreamTlsContextParse(
-    const XdsEncodingContext& context,
-    const envoy_config_core_v3_TransportSocket* transport_socket,
-    CommonTlsContext* common_tls_context) {
+absl::StatusOr<CommonTlsContext> UpstreamTlsContextParse(
+    const XdsResourceType::DecodeContext& context,
+    const envoy_config_core_v3_TransportSocket* transport_socket) {
+  CommonTlsContext common_tls_context;
   // Record Upstream tls context
   absl::string_view name = UpbStringToAbsl(
       envoy_config_core_v3_TransportSocket_name(transport_socket));
   if (name != "envoy.transport_sockets.tls") {
-    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+    return absl::InvalidArgumentError(
         absl::StrCat("Unrecognized transport socket: ", name));
   }
   auto* typed_config =
@@ -125,38 +124,37 @@ grpc_error_handle UpstreamTlsContextParse(
             encoded_upstream_tls_context.data,
             encoded_upstream_tls_context.size, context.arena);
     if (upstream_tls_context == nullptr) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "Can't decode upstream tls context.");
+      return absl::InvalidArgumentError("Can't decode upstream tls context.");
     }
     auto* common_tls_context_proto =
         envoy_extensions_transport_sockets_tls_v3_UpstreamTlsContext_common_tls_context(
             upstream_tls_context);
     if (common_tls_context_proto != nullptr) {
-      grpc_error_handle error = CommonTlsContext::Parse(
-          context, common_tls_context_proto, common_tls_context);
-      if (!GRPC_ERROR_IS_NONE(error)) {
-        return grpc_error_add_child(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                                        "Error parsing UpstreamTlsContext"),
-                                    error);
+      auto common_context =
+          CommonTlsContext::Parse(context, common_tls_context_proto);
+      if (!common_context.ok()) {
+        return absl::InvalidArgumentError(
+            absl::StrCat("Error parsing UpstreamTlsContext: ",
+                         common_context.status().message()));
       }
+      common_tls_context = std::move(*common_context);
     }
   }
-  if (common_tls_context->certificate_validation_context
+  if (common_tls_context.certificate_validation_context
           .ca_certificate_provider_instance.instance_name.empty()) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+    return absl::InvalidArgumentError(
         "UpstreamTlsContext: TLS configuration provided but no "
         "ca_certificate_provider_instance found.");
   }
-  return GRPC_ERROR_NONE;
+  return common_tls_context;
 }
 
-grpc_error_handle CdsLogicalDnsParse(
-    const envoy_config_cluster_v3_Cluster* cluster,
-    XdsClusterResource* cds_update) {
+absl::Status CdsLogicalDnsParse(const envoy_config_cluster_v3_Cluster* cluster,
+                                XdsClusterResource* cds_update) {
   const auto* load_assignment =
       envoy_config_cluster_v3_Cluster_load_assignment(cluster);
   if (load_assignment == nullptr) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+    return absl::InvalidArgumentError(
         "load_assignment not present for LOGICAL_DNS cluster");
   }
   size_t num_localities;
@@ -164,7 +162,7 @@ grpc_error_handle CdsLogicalDnsParse(
       envoy_config_endpoint_v3_ClusterLoadAssignment_endpoints(load_assignment,
                                                                &num_localities);
   if (num_localities != 1) {
-    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+    return absl::InvalidArgumentError(
         absl::StrCat("load_assignment for LOGICAL_DNS cluster must have "
                      "exactly one locality, found ",
                      num_localities));
@@ -174,7 +172,7 @@ grpc_error_handle CdsLogicalDnsParse(
       envoy_config_endpoint_v3_LocalityLbEndpoints_lb_endpoints(localities[0],
                                                                 &num_endpoints);
   if (num_endpoints != 1) {
-    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+    return absl::InvalidArgumentError(
         absl::StrCat("locality for LOGICAL_DNS cluster must have "
                      "exactly one endpoint, found ",
                      num_endpoints));
@@ -182,54 +180,48 @@ grpc_error_handle CdsLogicalDnsParse(
   const auto* endpoint =
       envoy_config_endpoint_v3_LbEndpoint_endpoint(endpoints[0]);
   if (endpoint == nullptr) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "LbEndpoint endpoint field not set");
+    return absl::InvalidArgumentError("LbEndpoint endpoint field not set");
   }
   const auto* address = envoy_config_endpoint_v3_Endpoint_address(endpoint);
   if (address == nullptr) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "Endpoint address field not set");
+    return absl::InvalidArgumentError("Endpoint address field not set");
   }
   const auto* socket_address =
       envoy_config_core_v3_Address_socket_address(address);
   if (socket_address == nullptr) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "Address socket_address field not set");
+    return absl::InvalidArgumentError("Address socket_address field not set");
   }
   if (envoy_config_core_v3_SocketAddress_resolver_name(socket_address).size !=
       0) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+    return absl::InvalidArgumentError(
         "LOGICAL_DNS clusters must NOT have a custom resolver name set");
   }
   absl::string_view address_str = UpbStringToAbsl(
       envoy_config_core_v3_SocketAddress_address(socket_address));
   if (address_str.empty()) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "SocketAddress address field not set");
+    return absl::InvalidArgumentError("SocketAddress address field not set");
   }
   if (!envoy_config_core_v3_SocketAddress_has_port_value(socket_address)) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "SocketAddress port_value field not set");
+    return absl::InvalidArgumentError("SocketAddress port_value field not set");
   }
   cds_update->dns_hostname = JoinHostPort(
       address_str,
       envoy_config_core_v3_SocketAddress_port_value(socket_address));
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
-grpc_error_handle CdsResourceParse(
-    const XdsEncodingContext& context,
-    const envoy_config_cluster_v3_Cluster* cluster, bool /*is_v2*/,
-    XdsClusterResource* cds_update) {
-  std::vector<grpc_error_handle> errors;
+absl::StatusOr<XdsClusterResource> CdsResourceParse(
+    const XdsResourceType::DecodeContext& context,
+    const envoy_config_cluster_v3_Cluster* cluster, bool /*is_v2*/) {
+  XdsClusterResource cds_update;
+  std::vector<std::string> errors;
   // Check the cluster_discovery_type.
   if (!envoy_config_cluster_v3_Cluster_has_type(cluster) &&
       !envoy_config_cluster_v3_Cluster_has_cluster_type(cluster)) {
-    errors.push_back(
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("DiscoveryType not found."));
+    errors.emplace_back("DiscoveryType not found.");
   } else if (envoy_config_cluster_v3_Cluster_type(cluster) ==
              envoy_config_cluster_v3_Cluster_EDS) {
-    cds_update->cluster_type = XdsClusterResource::ClusterType::EDS;
+    cds_update.cluster_type = XdsClusterResource::ClusterType::EDS;
     // Check the EDS config source.
     const envoy_config_cluster_v3_Cluster_EdsClusterConfig* eds_cluster_config =
         envoy_config_cluster_v3_Cluster_eds_cluster_config(cluster);
@@ -238,25 +230,23 @@ grpc_error_handle CdsResourceParse(
             eds_cluster_config);
     if (!envoy_config_core_v3_ConfigSource_has_ads(eds_config) &&
         !envoy_config_core_v3_ConfigSource_has_self(eds_config)) {
-      errors.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "EDS ConfigSource is not ADS or SELF."));
+      errors.emplace_back("EDS ConfigSource is not ADS or SELF.");
     }
     // Record EDS service_name (if any).
     upb_StringView service_name =
         envoy_config_cluster_v3_Cluster_EdsClusterConfig_service_name(
             eds_cluster_config);
     if (service_name.size != 0) {
-      cds_update->eds_service_name = UpbStringToStdString(service_name);
+      cds_update.eds_service_name = UpbStringToStdString(service_name);
     }
   } else if (envoy_config_cluster_v3_Cluster_type(cluster) ==
              envoy_config_cluster_v3_Cluster_LOGICAL_DNS) {
-    cds_update->cluster_type = XdsClusterResource::ClusterType::LOGICAL_DNS;
-    grpc_error_handle error = CdsLogicalDnsParse(cluster, cds_update);
-    if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
+    cds_update.cluster_type = XdsClusterResource::ClusterType::LOGICAL_DNS;
+    absl::Status status = CdsLogicalDnsParse(cluster, &cds_update);
+    if (!status.ok()) errors.emplace_back(status.message());
   } else {
     if (!envoy_config_cluster_v3_Cluster_has_cluster_type(cluster)) {
-      errors.push_back(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("DiscoveryType is not valid."));
+      errors.push_back("DiscoveryType is not valid.");
     } else {
       const envoy_config_cluster_v3_Cluster_CustomClusterType*
           custom_cluster_type =
@@ -265,10 +255,9 @@ grpc_error_handle CdsResourceParse(
           envoy_config_cluster_v3_Cluster_CustomClusterType_name(
               custom_cluster_type);
       if (UpbStringToAbsl(type_name) != "envoy.clusters.aggregate") {
-        errors.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "DiscoveryType is not valid."));
+        errors.emplace_back("DiscoveryType is not valid.");
       } else {
-        cds_update->cluster_type = XdsClusterResource::ClusterType::AGGREGATE;
+        cds_update.cluster_type = XdsClusterResource::ClusterType::AGGREGATE;
         // Retrieve aggregate clusters.
         const google_protobuf_Any* typed_config =
             envoy_config_cluster_v3_Cluster_CustomClusterType_typed_config(
@@ -282,8 +271,7 @@ grpc_error_handle CdsResourceParse(
                     aggregate_cluster_config_upb_stringview.size,
                     context.arena);
         if (aggregate_cluster_config == nullptr) {
-          errors.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "Can't parse aggregate cluster."));
+          errors.emplace_back("Can't parse aggregate cluster.");
         } else {
           size_t size;
           const upb_StringView* clusters =
@@ -291,7 +279,7 @@ grpc_error_handle CdsResourceParse(
                   aggregate_cluster_config, &size);
           for (size_t i = 0; i < size; ++i) {
             const upb_StringView cluster = clusters[i];
-            cds_update->prioritized_cluster_names.emplace_back(
+            cds_update.prioritized_cluster_names.emplace_back(
                 UpbStringToStdString(cluster));
           }
         }
@@ -301,10 +289,10 @@ grpc_error_handle CdsResourceParse(
   // Check the LB policy.
   if (envoy_config_cluster_v3_Cluster_lb_policy(cluster) ==
       envoy_config_cluster_v3_Cluster_ROUND_ROBIN) {
-    cds_update->lb_policy = "ROUND_ROBIN";
+    cds_update.lb_policy = "ROUND_ROBIN";
   } else if (envoy_config_cluster_v3_Cluster_lb_policy(cluster) ==
              envoy_config_cluster_v3_Cluster_RING_HASH) {
-    cds_update->lb_policy = "RING_HASH";
+    cds_update.lb_policy = "RING_HASH";
     // Record ring hash lb config
     auto* ring_hash_config =
         envoy_config_cluster_v3_Cluster_ring_hash_lb_config(cluster);
@@ -313,51 +301,49 @@ grpc_error_handle CdsResourceParse(
           envoy_config_cluster_v3_Cluster_RingHashLbConfig_maximum_ring_size(
               ring_hash_config);
       if (max_ring_size != nullptr) {
-        cds_update->max_ring_size =
+        cds_update.max_ring_size =
             google_protobuf_UInt64Value_value(max_ring_size);
-        if (cds_update->max_ring_size > 8388608 ||
-            cds_update->max_ring_size == 0) {
-          errors.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "max_ring_size is not in the range of 1 to 8388608."));
+        if (cds_update.max_ring_size > 8388608 ||
+            cds_update.max_ring_size == 0) {
+          errors.emplace_back(
+              "max_ring_size is not in the range of 1 to 8388608.");
         }
       }
       const google_protobuf_UInt64Value* min_ring_size =
           envoy_config_cluster_v3_Cluster_RingHashLbConfig_minimum_ring_size(
               ring_hash_config);
       if (min_ring_size != nullptr) {
-        cds_update->min_ring_size =
+        cds_update.min_ring_size =
             google_protobuf_UInt64Value_value(min_ring_size);
-        if (cds_update->min_ring_size > 8388608 ||
-            cds_update->min_ring_size == 0) {
-          errors.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "min_ring_size is not in the range of 1 to 8388608."));
+        if (cds_update.min_ring_size > 8388608 ||
+            cds_update.min_ring_size == 0) {
+          errors.emplace_back(
+              "min_ring_size is not in the range of 1 to 8388608.");
         }
-        if (cds_update->min_ring_size > cds_update->max_ring_size) {
-          errors.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "min_ring_size cannot be greater than max_ring_size."));
+        if (cds_update.min_ring_size > cds_update.max_ring_size) {
+          errors.emplace_back(
+              "min_ring_size cannot be greater than max_ring_size.");
         }
       }
       if (envoy_config_cluster_v3_Cluster_RingHashLbConfig_hash_function(
               ring_hash_config) !=
           envoy_config_cluster_v3_Cluster_RingHashLbConfig_XX_HASH) {
-        errors.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "ring hash lb config has invalid hash function."));
+        errors.emplace_back("ring hash lb config has invalid hash function.");
       }
     }
   } else {
-    errors.push_back(
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("LB policy is not supported."));
+    errors.emplace_back("LB policy is not supported.");
   }
   auto* transport_socket =
       envoy_config_cluster_v3_Cluster_transport_socket(cluster);
   if (transport_socket != nullptr) {
-    grpc_error_handle error = UpstreamTlsContextParse(
-        context, transport_socket, &cds_update->common_tls_context);
-    if (!GRPC_ERROR_IS_NONE(error)) {
-      errors.push_back(
-          grpc_error_add_child(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                                   "Error parsing security configuration"),
-                               error));
+    auto common_tls_context =
+        UpstreamTlsContextParse(context, transport_socket);
+    if (!common_tls_context.ok()) {
+      errors.emplace_back(absl::StrCat("Error parsing security configuration: ",
+                                       common_tls_context.status().message()));
+    } else {
+      cds_update.common_tls_context = std::move(*common_tls_context);
     }
   }
   // Record LRS server name (if any).
@@ -365,10 +351,9 @@ grpc_error_handle CdsResourceParse(
       envoy_config_cluster_v3_Cluster_lrs_server(cluster);
   if (lrs_server != nullptr) {
     if (!envoy_config_core_v3_ConfigSource_has_self(lrs_server)) {
-      errors.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          ": LRS ConfigSource is not self."));
+      errors.emplace_back("LRS ConfigSource is not self.");
     }
-    cds_update->lrs_load_reporting_server.emplace(context.server);
+    cds_update.lrs_load_reporting_server.emplace(context.server);
   }
   // The Cluster resource encodes the circuit breaking parameters in a list of
   // Thresholds messages, where each message specifies the parameters for a
@@ -389,7 +374,7 @@ grpc_error_handle CdsResourceParse(
             envoy_config_cluster_v3_CircuitBreakers_Thresholds_max_requests(
                 threshold);
         if (max_requests != nullptr) {
-          cds_update->max_concurrent_requests =
+          cds_update.max_concurrent_requests =
               google_protobuf_UInt32Value_value(max_requests);
         }
         break;
@@ -497,12 +482,17 @@ grpc_error_handle CdsResourceParse(
             failure_percentage_ejection;
       }
     }
-    cds_update->outlier_detection = outlier_detection_update;
+    cds_update.outlier_detection = outlier_detection_update;
+  }
+  // Return result.
+  if (!errors.empty()) {
+    return absl::InvalidArgumentError(absl::StrCat(
+        "errors parsing CDS resource: [", absl::StrJoin(errors, "; "), "]"));
   }
-  return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing CDS resource", &errors);
+  return cds_update;
 }
 
-void MaybeLogCluster(const XdsEncodingContext& context,
+void MaybeLogCluster(const XdsResourceType::DecodeContext& context,
                      const envoy_config_cluster_v3_Cluster* cluster) {
   if (GRPC_TRACE_FLAG_ENABLED(*context.tracer) &&
       gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
@@ -517,8 +507,8 @@ void MaybeLogCluster(const XdsEncodingContext& context,
 }  // namespace
 
 absl::StatusOr<XdsResourceType::DecodeResult> XdsClusterResourceType::Decode(
-    const XdsEncodingContext& context, absl::string_view serialized_resource,
-    bool is_v2) const {
+    const XdsResourceType::DecodeContext& context,
+    absl::string_view serialized_resource, bool is_v2) const {
   // Parse serialized proto.
   auto* resource = envoy_config_cluster_v3_Cluster_parse(
       serialized_resource.data(), serialized_resource.size(), context.arena);
@@ -530,23 +520,22 @@ absl::StatusOr<XdsResourceType::DecodeResult> XdsClusterResourceType::Decode(
   DecodeResult result;
   result.name =
       UpbStringToStdString(envoy_config_cluster_v3_Cluster_name(resource));
-  auto cluster_data = absl::make_unique<ResourceDataSubclass>();
-  grpc_error_handle error =
-      CdsResourceParse(context, resource, is_v2, &cluster_data->resource);
-  if (!GRPC_ERROR_IS_NONE(error)) {
-    std::string error_str = grpc_error_std_string(error);
-    GRPC_ERROR_UNREF(error);
+  auto cds_resource = CdsResourceParse(context, resource, is_v2);
+  if (!cds_resource.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_ERROR, "[xds_client %p] invalid Cluster %s: %s",
-              context.client, result.name.c_str(), error_str.c_str());
+              context.client, result.name.c_str(),
+              cds_resource.status().ToString().c_str());
     }
-    result.resource = absl::InvalidArgumentError(error_str);
+    result.resource = cds_resource.status();
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_INFO, "[xds_client %p] parsed Cluster %s: %s", context.client,
-              result.name.c_str(), cluster_data->resource.ToString().c_str());
+              result.name.c_str(), cds_resource->ToString().c_str());
     }
-    result.resource = std::move(cluster_data);
+    auto resource = absl::make_unique<ResourceDataSubclass>();
+    resource->resource = std::move(*cds_resource);
+    result.resource = std::move(resource);
   }
   return std::move(result);
 }

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

@@ -35,9 +35,9 @@
 #include "upb/def.h"
 
 #include "src/core/ext/filters/client_channel/lb_policy/outlier_detection/outlier_detection.h"
-#include "src/core/ext/xds/upb_utils.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_common_types.h"
+#include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/ext/xds/xds_resource_type_impl.h"
 
 namespace grpc_core {
@@ -84,7 +84,8 @@ struct XdsClusterResource {
            lb_policy == other.lb_policy &&
            min_ring_size == other.min_ring_size &&
            max_ring_size == other.max_ring_size &&
-           max_concurrent_requests == other.max_concurrent_requests;
+           max_concurrent_requests == other.max_concurrent_requests &&
+           outlier_detection == other.outlier_detection;
   }
 
   std::string ToString() const;
@@ -100,9 +101,9 @@ class XdsClusterResourceType
     return "envoy.api.v2.Cluster";
   }
 
-  absl::StatusOr<DecodeResult> Decode(const XdsEncodingContext& context,
-                                      absl::string_view serialized_resource,
-                                      bool is_v2) const override;
+  absl::StatusOr<DecodeResult> Decode(
+      const XdsResourceType::DecodeContext& context,
+      absl::string_view serialized_resource, bool is_v2) const override;
 
   bool AllResourcesRequiredInSotW() const override { return true; }
 

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

@@ -28,13 +28,13 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "upb/json_encode.h"
+#include "upb/status.h"
 #include "upb/upb.hpp"
 
 #include <grpc/support/log.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy_registry.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/load_balancing/lb_policy_registry.h"
 #include "src/proto/grpc/lookup/v1/rls_config.upb.h"
 #include "src/proto/grpc/lookup/v1/rls_config.upbdefs.h"
 
@@ -78,10 +78,9 @@ XdsRouteLookupClusterSpecifierPlugin::GenerateLoadBalancingPolicyConfig(
   upb_JsonEncode(plugin_config, msg_type, symtab, 0,
                  reinterpret_cast<char*>(buf), json_size + 1, status.ptr());
   Json::Object rls_policy;
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  rls_policy["routeLookupConfig"] =
-      Json::Parse(reinterpret_cast<char*>(buf), &error);
-  GPR_ASSERT(GRPC_ERROR_IS_NONE(error));
+  auto json = Json::Parse(reinterpret_cast<char*>(buf));
+  GPR_ASSERT(json.ok());
+  rls_policy["routeLookupConfig"] = std::move(*json);
   Json::Object cds_policy;
   cds_policy["cds_experimental"] = Json::Object();
   Json::Array child_policy;
@@ -93,20 +92,17 @@ XdsRouteLookupClusterSpecifierPlugin::GenerateLoadBalancingPolicyConfig(
   Json::Array policies;
   policies.emplace_back(std::move(policy));
   Json lb_policy_config(std::move(policies));
-  grpc_error_handle parse_error = GRPC_ERROR_NONE;
   // TODO(roth): If/when we ever add a second plugin, refactor this code
   // somehow such that we automatically validate the resulting config against
   // the gRPC LB policy registry instead of requiring each plugin to do that
   // itself.
-  LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(lb_policy_config,
-                                                        &parse_error);
-  if (!GRPC_ERROR_IS_NONE(parse_error)) {
-    absl::Status status = absl::InvalidArgumentError(absl::StrCat(
+  auto config =
+      LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(lb_policy_config);
+  if (!config.ok()) {
+    return absl::InvalidArgumentError(absl::StrCat(
         kXdsRouteLookupClusterSpecifierPluginConfigName,
         " ClusterSpecifierPlugin returned invalid LB policy config: ",
-        grpc_error_std_string(parse_error)));
-    GRPC_ERROR_UNREF(parse_error);
-    return status;
+        config.status().message()));
   }
   return lb_policy_config.Dump();
 }

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

@@ -24,6 +24,7 @@
 
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
+#include "upb/arena.h"
 #include "upb/def.h"
 #include "upb/upb.h"