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

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

@@ -21,13 +21,13 @@
 #include <stdlib.h>
 
 #include <algorithm>
-#include <type_traits>
 #include <vector>
 
 #include "absl/memory/memory.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
+#include "absl/types/optional.h"
 #include "envoy/config/core/v3/address.upb.h"
 #include "envoy/config/core/v3/base.upb.h"
 #include "envoy/config/core/v3/health_check.upb.h"
@@ -43,9 +43,8 @@
 #include "src/core/ext/xds/upb_utils.h"
 #include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/lib/address_utils/parse_address.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/resolved_address.h"
 
 namespace grpc_core {
 
@@ -126,7 +125,7 @@ std::string XdsEndpointResource::ToString() const {
 namespace {
 
 void MaybeLogClusterLoadAssignment(
-    const XdsEncodingContext& context,
+    const XdsResourceType::DecodeContext& context,
     const envoy_config_endpoint_v3_ClusterLoadAssignment* cla) {
   if (GRPC_TRACE_FLAG_ENABLED(*context.tracer) &&
       gpr_should_log(GPR_LOG_SEVERITY_DEBUG)) {
@@ -140,15 +139,14 @@ void MaybeLogClusterLoadAssignment(
   }
 }
 
-grpc_error_handle ServerAddressParseAndAppend(
-    const envoy_config_endpoint_v3_LbEndpoint* lb_endpoint,
-    ServerAddressList* list) {
+absl::StatusOr<absl::optional<ServerAddress>> ServerAddressParse(
+    const envoy_config_endpoint_v3_LbEndpoint* lb_endpoint) {
   // If health_status is not HEALTHY or UNKNOWN, skip this endpoint.
   const int32_t health_status =
       envoy_config_endpoint_v3_LbEndpoint_health_status(lb_endpoint);
   if (health_status != envoy_config_core_v3_UNKNOWN &&
       health_status != envoy_config_core_v3_HEALTHY) {
-    return GRPC_ERROR_NONE;
+    return absl::nullopt;
   }
   // Find the ip:port.
   const envoy_config_endpoint_v3_Endpoint* endpoint =
@@ -161,7 +159,7 @@ grpc_error_handle ServerAddressParseAndAppend(
       envoy_config_core_v3_SocketAddress_address(socket_address));
   uint32_t port = envoy_config_core_v3_SocketAddress_port_value(socket_address);
   if (GPR_UNLIKELY(port >> 16) != 0) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Invalid port.");
+    return absl::InvalidArgumentError("Invalid port.");
   }
   // Find load_balancing_weight for the endpoint.
   uint32_t weight = 1;
@@ -170,44 +168,42 @@ grpc_error_handle ServerAddressParseAndAppend(
   if (load_balancing_weight != nullptr) {
     weight = google_protobuf_UInt32Value_value(load_balancing_weight);
     if (weight == 0) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "Invalid endpoint weight of 0.");
+      return absl::InvalidArgumentError("Invalid endpoint weight of 0.");
     }
   }
   // Populate grpc_resolved_address.
-  grpc_resolved_address addr;
-  grpc_error_handle error =
-      grpc_string_to_sockaddr(&addr, address_str.c_str(), port);
-  if (!GRPC_ERROR_IS_NONE(error)) return error;
+  auto addr = StringToSockaddr(address_str, port);
+  if (!addr.ok()) return addr.status();
   // Append the address to the list.
   std::map<const char*, std::unique_ptr<ServerAddress::AttributeInterface>>
       attributes;
   attributes[ServerAddressWeightAttribute::kServerAddressWeightAttributeKey] =
       absl::make_unique<ServerAddressWeightAttribute>(weight);
-  list->emplace_back(addr, nullptr, std::move(attributes));
-  return GRPC_ERROR_NONE;
+  return ServerAddress(*addr, ChannelArgs(), std::move(attributes));
 }
 
-grpc_error_handle LocalityParse(
-    const envoy_config_endpoint_v3_LocalityLbEndpoints* locality_lb_endpoints,
-    XdsEndpointResource::Priority::Locality* output_locality,
-    size_t* priority) {
+struct ParsedLocality {
+  size_t priority;
+  XdsEndpointResource::Priority::Locality locality;
+};
+
+absl::StatusOr<ParsedLocality> LocalityParse(
+    const envoy_config_endpoint_v3_LocalityLbEndpoints* locality_lb_endpoints) {
+  ParsedLocality parsed_locality;
   // Parse LB weight.
   const google_protobuf_UInt32Value* lb_weight =
       envoy_config_endpoint_v3_LocalityLbEndpoints_load_balancing_weight(
           locality_lb_endpoints);
   // If LB weight is not specified, it means this locality is assigned no load.
-  // TODO(juanlishen): When we support CDS to configure the inter-locality
-  // policy, we should change the LB weight handling.
-  output_locality->lb_weight =
+  parsed_locality.locality.lb_weight =
       lb_weight != nullptr ? google_protobuf_UInt32Value_value(lb_weight) : 0;
-  if (output_locality->lb_weight == 0) return GRPC_ERROR_NONE;
+  if (parsed_locality.locality.lb_weight == 0) return parsed_locality;
   // Parse locality name.
   const envoy_config_core_v3_Locality* locality =
       envoy_config_endpoint_v3_LocalityLbEndpoints_locality(
           locality_lb_endpoints);
   if (locality == nullptr) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Empty locality.");
+    return absl::InvalidArgumentError("Empty locality.");
   }
   std::string region =
       UpbStringToStdString(envoy_config_core_v3_Locality_region(locality));
@@ -215,7 +211,7 @@ grpc_error_handle LocalityParse(
       UpbStringToStdString(envoy_config_core_v3_Locality_zone(locality));
   std::string sub_zone =
       UpbStringToStdString(envoy_config_core_v3_Locality_sub_zone(locality));
-  output_locality->name = MakeRefCounted<XdsLocalityName>(
+  parsed_locality.locality.name = MakeRefCounted<XdsLocalityName>(
       std::move(region), std::move(zone), std::move(sub_zone));
   // Parse the addresses.
   size_t size;
@@ -223,17 +219,20 @@ grpc_error_handle LocalityParse(
       envoy_config_endpoint_v3_LocalityLbEndpoints_lb_endpoints(
           locality_lb_endpoints, &size);
   for (size_t i = 0; i < size; ++i) {
-    grpc_error_handle error = ServerAddressParseAndAppend(
-        lb_endpoints[i], &output_locality->endpoints);
-    if (!GRPC_ERROR_IS_NONE(error)) return error;
+    auto address = ServerAddressParse(lb_endpoints[i]);
+    if (!address.ok()) return address.status();
+    if (address->has_value()) {
+      parsed_locality.locality.endpoints.push_back(std::move(**address));
+    }
   }
   // Parse the priority.
-  *priority = envoy_config_endpoint_v3_LocalityLbEndpoints_priority(
-      locality_lb_endpoints);
-  return GRPC_ERROR_NONE;
+  parsed_locality.priority =
+      envoy_config_endpoint_v3_LocalityLbEndpoints_priority(
+          locality_lb_endpoints);
+  return parsed_locality;
 }
 
-grpc_error_handle DropParseAndAppend(
+absl::Status DropParseAndAppend(
     const envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_DropOverload*
         drop_overload,
     XdsEndpointResource::DropConfig* drop_config) {
@@ -242,7 +241,7 @@ grpc_error_handle DropParseAndAppend(
       envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_DropOverload_category(
           drop_overload));
   if (category.empty()) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Empty drop category name");
+    return absl::InvalidArgumentError("Empty drop category name");
   }
   // Get the drop rate (per million).
   const envoy_type_v3_FractionalPercent* drop_percentage =
@@ -264,58 +263,60 @@ grpc_error_handle DropParseAndAppend(
     case envoy_type_v3_FractionalPercent_MILLION:
       break;
     default:
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Unknown denominator type");
+      return absl::InvalidArgumentError(
+          "drop config: unknown denominator type");
   }
   // Cap numerator to 1000000.
   numerator = std::min(numerator, 1000000u);
   drop_config->AddCategory(std::move(category), numerator);
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
-grpc_error_handle EdsResourceParse(
-    const XdsEncodingContext& /*context*/,
+absl::StatusOr<XdsEndpointResource> EdsResourceParse(
+    const XdsResourceType::DecodeContext& /*context*/,
     const envoy_config_endpoint_v3_ClusterLoadAssignment*
         cluster_load_assignment,
-    bool /*is_v2*/, XdsEndpointResource* eds_update) {
-  std::vector<grpc_error_handle> errors;
+    bool /*is_v2*/) {
+  XdsEndpointResource eds_resource;
+  std::vector<std::string> errors;
   // Get the endpoints.
   size_t locality_size;
   const envoy_config_endpoint_v3_LocalityLbEndpoints* const* endpoints =
       envoy_config_endpoint_v3_ClusterLoadAssignment_endpoints(
           cluster_load_assignment, &locality_size);
   for (size_t j = 0; j < locality_size; ++j) {
-    size_t priority;
-    XdsEndpointResource::Priority::Locality locality;
-    grpc_error_handle error = LocalityParse(endpoints[j], &locality, &priority);
-    if (!GRPC_ERROR_IS_NONE(error)) {
-      errors.push_back(error);
+    auto parsed_locality = LocalityParse(endpoints[j]);
+    if (!parsed_locality.ok()) {
+      errors.emplace_back(parsed_locality.status().message());
       continue;
     }
     // Filter out locality with weight 0.
-    if (locality.lb_weight == 0) continue;
+    if (parsed_locality->locality.lb_weight == 0) continue;
     // Make sure prorities is big enough. Note that they might not
     // arrive in priority order.
-    if (eds_update->priorities.size() < priority + 1) {
-      eds_update->priorities.resize(priority + 1);
+    if (eds_resource.priorities.size() < parsed_locality->priority + 1) {
+      eds_resource.priorities.resize(parsed_locality->priority + 1);
     }
-    auto& locality_map = eds_update->priorities[priority].localities;
-    auto it = locality_map.find(locality.name.get());
+    auto& locality_map =
+        eds_resource.priorities[parsed_locality->priority].localities;
+    auto it = locality_map.find(parsed_locality->locality.name.get());
     if (it != locality_map.end()) {
-      errors.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
-          "duplicate locality ", locality.name->AsHumanReadableString(),
-          " found in priority ", priority)));
+      errors.emplace_back(
+          absl::StrCat("duplicate locality ",
+                       parsed_locality->locality.name->AsHumanReadableString(),
+                       " found in priority ", parsed_locality->priority));
     } else {
-      locality_map.emplace(locality.name.get(), std::move(locality));
+      locality_map.emplace(parsed_locality->locality.name.get(),
+                           std::move(parsed_locality->locality));
     }
   }
-  for (const auto& priority : eds_update->priorities) {
+  for (const auto& priority : eds_resource.priorities) {
     if (priority.localities.empty()) {
-      errors.push_back(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("sparse priority list"));
+      errors.emplace_back("sparse priority list");
     }
   }
   // Get the drop config.
-  eds_update->drop_config = MakeRefCounted<XdsEndpointResource::DropConfig>();
+  eds_resource.drop_config = MakeRefCounted<XdsEndpointResource::DropConfig>();
   const envoy_config_endpoint_v3_ClusterLoadAssignment_Policy* policy =
       envoy_config_endpoint_v3_ClusterLoadAssignment_policy(
           cluster_load_assignment);
@@ -326,24 +327,24 @@ grpc_error_handle EdsResourceParse(
             envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_drop_overloads(
                 policy, &drop_size);
     for (size_t j = 0; j < drop_size; ++j) {
-      grpc_error_handle error =
-          DropParseAndAppend(drop_overload[j], eds_update->drop_config.get());
-      if (!GRPC_ERROR_IS_NONE(error)) {
-        errors.push_back(
-            grpc_error_add_child(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                                     "drop config validation error"),
-                                 error));
-      }
+      absl::Status status =
+          DropParseAndAppend(drop_overload[j], eds_resource.drop_config.get());
+      if (!status.ok()) errors.emplace_back(status.message());
     }
   }
-  return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing EDS resource", &errors);
+  // Return result.
+  if (!errors.empty()) {
+    return absl::InvalidArgumentError(absl::StrCat(
+        "errors parsing EDS resource: [", absl::StrJoin(errors, "; "), "]"));
+  }
+  return eds_resource;
 }
 
 }  // namespace
 
 absl::StatusOr<XdsResourceType::DecodeResult> XdsEndpointResourceType::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_endpoint_v3_ClusterLoadAssignment_parse(
       serialized_resource.data(), serialized_resource.size(), context.arena);
@@ -356,24 +357,23 @@ absl::StatusOr<XdsResourceType::DecodeResult> XdsEndpointResourceType::Decode(
   DecodeResult result;
   result.name = UpbStringToStdString(
       envoy_config_endpoint_v3_ClusterLoadAssignment_cluster_name(resource));
-  auto endpoint_data = absl::make_unique<ResourceDataSubclass>();
-  grpc_error_handle error =
-      EdsResourceParse(context, resource, is_v2, &endpoint_data->resource);
-  if (!GRPC_ERROR_IS_NONE(error)) {
-    std::string error_str = grpc_error_std_string(error);
-    GRPC_ERROR_UNREF(error);
+  auto eds_resource = EdsResourceParse(context, resource, is_v2);
+  if (!eds_resource.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_ERROR, "[xds_client %p] invalid ClusterLoadAssignment %s: %s",
-              context.client, result.name.c_str(), error_str.c_str());
+              context.client, result.name.c_str(),
+              eds_resource.status().ToString().c_str());
     }
-    result.resource = absl::InvalidArgumentError(error_str);
+    result.resource = eds_resource.status();
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_INFO, "[xds_client %p] parsed ClusterLoadAssignment %s: %s",
               context.client, result.name.c_str(),
-              endpoint_data->resource.ToString().c_str());
+              eds_resource->ToString().c_str());
     }
-    result.resource = std::move(endpoint_data);
+    auto resource = absl::make_unique<ResourceDataSubclass>();
+    resource->resource = std::move(*eds_resource);
+    result.resource = std::move(resource);
   }
   return std::move(result);
 }

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

@@ -33,8 +33,8 @@
 #include "envoy/config/endpoint/v3/endpoint.upbdefs.h"
 #include "upb/def.h"
 
-#include "src/core/ext/xds/upb_utils.h"
 #include "src/core/ext/xds/xds_client_stats.h"
+#include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/ext/xds/xds_resource_type_impl.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -129,9 +129,9 @@ class XdsEndpointResourceType
     return "envoy.api.v2.ClusterLoadAssignment";
   }
 
-  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;
 
   void InitUpbSymtab(upb_DefPool* symtab) const override {
     envoy_config_endpoint_v3_ClusterLoadAssignment_getmsgdef(symtab);

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

@@ -109,7 +109,7 @@ absl::StatusOr<Json> ParseHttpFaultIntoJson(
       int abort_http_status_code =
           envoy_extensions_filters_http_fault_v3_FaultAbort_http_status(
               fault_abort);
-      if (abort_http_status_code != 0 and abort_http_status_code != 200) {
+      if (abort_http_status_code != 0 && abort_http_status_code != 200) {
         abort_grpc_status_code =
             grpc_http2_status_to_grpc_status(abort_http_status_code);
       }
@@ -203,16 +203,9 @@ const grpc_channel_filter* XdsHttpFaultFilter::channel_filter() const {
   return &FaultInjectionFilter::kFilter;
 }
 
-grpc_channel_args* XdsHttpFaultFilter::ModifyChannelArgs(
-    grpc_channel_args* args) const {
-  grpc_arg args_to_add = grpc_channel_arg_integer_create(
-      const_cast<char*>(GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG), 1);
-  grpc_channel_args* new_args =
-      grpc_channel_args_copy_and_add(args, &args_to_add, 1);
-  // Since this function takes the ownership of the channel args, it needs to
-  // deallocate the old ones to prevent leak.
-  grpc_channel_args_destroy(args);
-  return new_args;
+ChannelArgs XdsHttpFaultFilter::ModifyChannelArgs(
+    const ChannelArgs& args) const {
+  return args.Set(GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG, 1);
 }
 
 absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>

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

@@ -20,12 +20,12 @@
 #include <grpc/support/port_platform.h>
 
 #include "absl/status/statusor.h"
+#include "upb/arena.h"
 #include "upb/def.h"
 #include "upb/upb.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-
 #include "src/core/ext/xds/xds_http_filters.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 
 namespace grpc_core {
@@ -49,7 +49,7 @@ class XdsHttpFaultFilter : public XdsHttpFilterImpl {
   const grpc_channel_filter* channel_filter() const override;
 
   // Overrides the ModifyChannelArgs method
-  grpc_channel_args* ModifyChannelArgs(grpc_channel_args* args) const override;
+  ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const override;
 
   // Overrides the GenerateServiceConfig method
   absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(

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

@@ -26,11 +26,11 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "upb/arena.h"
 #include "upb/def.h"
 #include "upb/upb.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
-
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/json/json.h"
 
@@ -88,7 +88,7 @@ class XdsHttpFilterImpl {
   // Modifies channel args that may affect service config parsing (not
   // visible to the channel as a whole).
   // Takes ownership of args.  Caller takes ownership of return value.
-  virtual grpc_channel_args* ModifyChannelArgs(grpc_channel_args* args) const {
+  virtual ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const {
     return args;
   }
 

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

@@ -24,13 +24,13 @@
 #include <cstdint>
 #include <map>
 #include <string>
-#include <type_traits>
 #include <utility>
 #include <vector>
 
 #include "absl/status/status.h"
 #include "absl/strings/match.h"
-#include "absl/strings/str_format.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
 #include "envoy/config/core/v3/address.upb.h"
 #include "envoy/config/rbac/v3/rbac.upb.h"
@@ -48,8 +48,6 @@
 #include "src/core/ext/filters/rbac/rbac_service_config_parser.h"
 #include "src/core/ext/xds/upb_utils.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/json/json.h"
 
 namespace grpc_core {
@@ -77,15 +75,13 @@ Json ParseInt64RangeToJson(const envoy_type_v3_Int64Range* range) {
 absl::StatusOr<Json> ParseHeaderMatcherToJson(
     const envoy_config_route_v3_HeaderMatcher* header) {
   Json::Object header_json;
-  std::vector<absl::Status> error_list;
+  std::vector<std::string> errors;
   std::string name =
       UpbStringToStdString(envoy_config_route_v3_HeaderMatcher_name(header));
   if (name == ":scheme") {
-    error_list.push_back(
-        absl::InvalidArgumentError("':scheme' not allowed in header"));
+    errors.emplace_back("':scheme' not allowed in header");
   } else if (absl::StartsWith(name, "grpc-")) {
-    error_list.push_back(
-        absl::InvalidArgumentError("'grpc-' prefixes not allowed in header"));
+    errors.emplace_back("'grpc-' prefixes not allowed in header");
   }
   header_json.emplace("name", std::move(name));
   if (envoy_config_route_v3_HeaderMatcher_has_exact_match(header)) {
@@ -123,13 +119,11 @@ absl::StatusOr<Json> ParseHeaderMatcherToJson(
         UpbStringToStdString(
             envoy_config_route_v3_HeaderMatcher_contains_match(header)));
   } else {
-    error_list.push_back(
-        absl::InvalidArgumentError("Invalid route header matcher specified."));
+    errors.emplace_back("Invalid route header matcher specified.");
   }
-  if (!error_list.empty()) {
-    return StatusCreate(absl::StatusCode::kInvalidArgument,
-                        "Error parsing HeaderMatcher", DEBUG_LOCATION,
-                        std::move(error_list));
+  if (!errors.empty()) {
+    return absl::InvalidArgumentError(absl::StrCat(
+        "errors parsing HeaderMatcher: [", absl::StrJoin(errors, "; "), "]"));
   }
   header_json.emplace("invertMatch",
                       envoy_config_route_v3_HeaderMatcher_invert_match(header));
@@ -217,7 +211,7 @@ absl::StatusOr<Json> ParsePermissionToJson(
   auto parse_permission_set_to_json =
       [](const envoy_config_rbac_v3_Permission_Set* set)
       -> absl::StatusOr<Json> {
-    std::vector<absl::Status> error_list;
+    std::vector<std::string> errors;
     Json::Array rules_json;
     size_t size;
     const envoy_config_rbac_v3_Permission* const* rules =
@@ -225,15 +219,14 @@ absl::StatusOr<Json> ParsePermissionToJson(
     for (size_t i = 0; i < size; ++i) {
       auto permission_json = ParsePermissionToJson(rules[i]);
       if (!permission_json.ok()) {
-        error_list.push_back(permission_json.status());
+        errors.emplace_back(permission_json.status().message());
       } else {
         rules_json.emplace_back(std::move(*permission_json));
       }
     }
-    if (!error_list.empty()) {
-      return StatusCreate(absl::StatusCode::kInvalidArgument,
-                          "Error parsing Set", DEBUG_LOCATION,
-                          std::move(error_list));
+    if (!errors.empty()) {
+      return absl::InvalidArgumentError(absl::StrCat(
+          "errors parsing Set: [", absl::StrJoin(errors, "; "), "]"));
     }
     return Json::Object({{"rules", std::move(rules_json)}});
   };
@@ -313,7 +306,7 @@ absl::StatusOr<Json> ParsePrincipalToJson(
       [](const envoy_config_rbac_v3_Principal_Set* set)
       -> absl::StatusOr<Json> {
     Json::Object json;
-    std::vector<absl::Status> error_list;
+    std::vector<std::string> errors;
     Json::Array ids_json;
     size_t size;
     const envoy_config_rbac_v3_Principal* const* ids =
@@ -321,15 +314,14 @@ absl::StatusOr<Json> ParsePrincipalToJson(
     for (size_t i = 0; i < size; ++i) {
       auto principal_json = ParsePrincipalToJson(ids[i]);
       if (!principal_json.ok()) {
-        error_list.push_back(principal_json.status());
+        errors.emplace_back(principal_json.status().message());
       } else {
         ids_json.emplace_back(std::move(*principal_json));
       }
     }
-    if (!error_list.empty()) {
-      return StatusCreate(absl::StatusCode::kInvalidArgument,
-                          "Error parsing Set", DEBUG_LOCATION,
-                          std::move(error_list));
+    if (!errors.empty()) {
+      return absl::InvalidArgumentError(absl::StrCat(
+          "errors parsing Set: [", absl::StrJoin(errors, "; "), "]"));
     }
     return Json::Object({{"ids", std::move(ids_json)}});
   };
@@ -412,7 +404,7 @@ absl::StatusOr<Json> ParsePrincipalToJson(
 absl::StatusOr<Json> ParsePolicyToJson(
     const envoy_config_rbac_v3_Policy* policy) {
   Json::Object policy_json;
-  std::vector<absl::Status> error_list;
+  std::vector<std::string> errors;
   size_t size;
   Json::Array permissions_json;
   const envoy_config_rbac_v3_Permission* const* permissions =
@@ -420,7 +412,7 @@ absl::StatusOr<Json> ParsePolicyToJson(
   for (size_t i = 0; i < size; ++i) {
     auto permission_json = ParsePermissionToJson(permissions[i]);
     if (!permission_json.ok()) {
-      error_list.push_back(permission_json.status());
+      errors.emplace_back(permission_json.status().message());
     } else {
       permissions_json.emplace_back(std::move(*permission_json));
     }
@@ -432,24 +424,21 @@ absl::StatusOr<Json> ParsePolicyToJson(
   for (size_t i = 0; i < size; ++i) {
     auto principal_json = ParsePrincipalToJson(principals[i]);
     if (!principal_json.ok()) {
-      error_list.push_back(principal_json.status());
+      errors.emplace_back(principal_json.status().message());
     } else {
       principals_json.emplace_back(std::move(*principal_json));
     }
   }
   policy_json.emplace("principals", std::move(principals_json));
   if (envoy_config_rbac_v3_Policy_has_condition(policy)) {
-    error_list.push_back(
-        absl::InvalidArgumentError("Policy: condition not supported"));
+    errors.emplace_back("Policy: condition not supported");
   }
   if (envoy_config_rbac_v3_Policy_has_checked_condition(policy)) {
-    error_list.push_back(
-        absl::InvalidArgumentError("Policy: checked condition not supported"));
+    errors.emplace_back("Policy: checked condition not supported");
   }
-  if (!error_list.empty()) {
-    return StatusCreate(absl::StatusCode::kInvalidArgument,
-                        "Error parsing Policy", DEBUG_LOCATION,
-                        std::move(error_list));
+  if (!errors.empty()) {
+    return absl::InvalidArgumentError(absl::StrCat(
+        "errors parsing Policy: [", absl::StrJoin(errors, "; "), "]"));
   }
   return policy_json;
 }
@@ -457,7 +446,7 @@ absl::StatusOr<Json> ParsePolicyToJson(
 absl::StatusOr<Json> ParseHttpRbacToJson(
     const envoy_extensions_filters_http_rbac_v3_RBAC* rbac) {
   Json::Object rbac_json;
-  std::vector<absl::Status> error_list;
+  std::vector<std::string> errors;
   const auto* rules = envoy_extensions_filters_http_rbac_v3_RBAC_rules(rbac);
   if (rules != nullptr) {
     int action = envoy_config_rbac_v3_RBAC_action(rules);
@@ -478,13 +467,11 @@ absl::StatusOr<Json> ParseHttpRbacToJson(
         auto policy = ParsePolicyToJson(
             envoy_config_rbac_v3_RBAC_PoliciesEntry_value(entry));
         if (!policy.ok()) {
-          error_list.push_back(StatusCreate(
-              absl::StatusCode::kInvalidArgument,
-              absl::StrFormat(
-                  "RBAC PoliciesEntry key:%s",
-                  UpbStringToStdString(
-                      envoy_config_rbac_v3_RBAC_PoliciesEntry_key(entry))),
-              DEBUG_LOCATION, {policy.status()}));
+          errors.emplace_back(absl::StrCat(
+              "RBAC PoliciesEntry key:",
+              UpbStringToStdString(
+                  envoy_config_rbac_v3_RBAC_PoliciesEntry_key(entry)),
+              " error:", policy.status().message()));
         } else {
           policies_object.emplace(
               UpbStringToStdString(
@@ -496,10 +483,9 @@ absl::StatusOr<Json> ParseHttpRbacToJson(
     }
     rbac_json.emplace("rules", std::move(inner_rbac_json));
   }
-  if (!error_list.empty()) {
-    return StatusCreate(absl::StatusCode::kInvalidArgument,
-                        "Error parsing RBAC", DEBUG_LOCATION,
-                        std::move(error_list));
+  if (!errors.empty()) {
+    return absl::InvalidArgumentError(absl::StrCat(
+        "errors parsing RBAC: [", absl::StrJoin(errors, "; "), "]"));
   }
   return rbac_json;
 }
@@ -555,14 +541,9 @@ const grpc_channel_filter* XdsHttpRbacFilter::channel_filter() const {
   return &RbacFilter::kFilterVtable;
 }
 
-grpc_channel_args* XdsHttpRbacFilter::ModifyChannelArgs(
-    grpc_channel_args* args) const {
-  grpc_arg arg_to_add = grpc_channel_arg_integer_create(
-      const_cast<char*>(GRPC_ARG_PARSE_RBAC_METHOD_CONFIG), 1);
-  grpc_channel_args* new_args =
-      grpc_channel_args_copy_and_add(args, &arg_to_add, 1);
-  grpc_channel_args_destroy(args);
-  return new_args;
+ChannelArgs XdsHttpRbacFilter::ModifyChannelArgs(
+    const ChannelArgs& args) const {
+  return args.Set(GRPC_ARG_PARSE_RBAC_METHOD_CONFIG, 1);
 }
 
 absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>