grpc 1.70.1 → 1.71.0

data/src/core/xds/grpc/xds_endpoint_parser.cc

@@ -23,6 +23,7 @@
 #include <algorithm>
 #include <limits>
 #include <memory>
+#include <optional>
 #include <set>
 #include <vector>
 
@@ -32,7 +33,6 @@
 #include "absl/status/statusor.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/endpoint/v3/endpoint.upb.h"
@@ -88,7 +88,7 @@ bool XdsEndpointHashKeyBackwardCompatEnabled() {
 void MaybeLogClusterLoadAssignment(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_endpoint_v3_ClusterLoadAssignment* cla) {
-  if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer) && ABSL_VLOG_IS_ON(2)) {
+  if (GRPC_TRACE_FLAG_ENABLED(xds_client) && ABSL_VLOG_IS_ON(2)) {
     const upb_MessageDef* msg_type =
         envoy_config_endpoint_v3_ClusterLoadAssignment_getmsgdef(
             context.symtab);
@@ -118,7 +118,7 @@ std::string GetHashKeyFromMetadata(const XdsMetadataMap& metadata_map) {
       .value_or("");
 }
 
-absl::optional<EndpointAddresses> EndpointAddressesParse(
+std::optional<EndpointAddresses> EndpointAddressesParse(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_endpoint_v3_LbEndpoint* lb_endpoint,
     absl::string_view locality_proxy_address, ValidationErrors* errors) {
@@ -126,7 +126,7 @@ absl::optional<EndpointAddresses> EndpointAddressesParse(
   const int32_t health_status =
       envoy_config_endpoint_v3_LbEndpoint_health_status(lb_endpoint);
   auto status = XdsHealthStatus::FromUpb(health_status);
-  if (!status.has_value()) return absl::nullopt;
+  if (!status.has_value()) return std::nullopt;
   // load_balancing_weight
   uint32_t weight;
   {
@@ -162,7 +162,7 @@ absl::optional<EndpointAddresses> EndpointAddressesParse(
         envoy_config_endpoint_v3_LbEndpoint_endpoint(lb_endpoint);
     if (endpoint == nullptr) {
       errors->AddError("field not present");
-      return absl::nullopt;
+      return std::nullopt;
     }
     {
       ValidationErrors::ScopedField field(errors, ".address");
@@ -188,7 +188,7 @@ absl::optional<EndpointAddresses> EndpointAddressesParse(
     hostname =
         UpbStringToAbsl(envoy_config_endpoint_v3_Endpoint_hostname(endpoint));
   }
-  if (addresses.empty()) return absl::nullopt;
+  if (addresses.empty()) return std::nullopt;
   // Convert to EndpointAddresses.
   auto args = ChannelArgs()
                   .Set(GRPC_ARG_ADDRESS_WEIGHT, weight)
@@ -222,7 +222,7 @@ struct ResolvedAddressLessThan {
 using ResolvedAddressSet =
     std::set<grpc_resolved_address, ResolvedAddressLessThan>;
 
-absl::optional<ParsedLocality> LocalityParse(
+std::optional<ParsedLocality> LocalityParse(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_endpoint_v3_LocalityLbEndpoints* locality_lb_endpoints,
     ResolvedAddressSet* address_set, ValidationErrors* errors) {
@@ -236,7 +236,7 @@ absl::optional<ParsedLocality> LocalityParse(
           envoy_config_endpoint_v3_LocalityLbEndpoints_load_balancing_weight(
               locality_lb_endpoints))
           .value_or(0);
-  if (parsed_locality.locality.lb_weight == 0) return absl::nullopt;
+  if (parsed_locality.locality.lb_weight == 0) return std::nullopt;
   // locality
   const envoy_config_core_v3_Locality* locality =
       envoy_config_endpoint_v3_LocalityLbEndpoints_locality(
@@ -244,7 +244,7 @@ absl::optional<ParsedLocality> LocalityParse(
   if (locality == nullptr) {
     ValidationErrors::ScopedField field(errors, ".locality");
     errors->AddError("field not present");
-    return absl::nullopt;
+    return std::nullopt;
   }
   // region
   std::string region =
@@ -294,7 +294,7 @@ absl::optional<ParsedLocality> LocalityParse(
       envoy_config_endpoint_v3_LocalityLbEndpoints_priority(
           locality_lb_endpoints);
   // Return result.
-  if (original_error_size != errors->size()) return absl::nullopt;
+  if (original_error_size != errors->size()) return std::nullopt;
   return parsed_locality;
 }
 
@@ -395,8 +395,8 @@ absl::StatusOr<std::shared_ptr<const XdsEndpointResource>> EdsResourceParse(
         // Check that the sum of the locality weights in this priority
         // does not exceed the max value for a uint32.
         uint64_t total_weight = 0;
-        for (const auto& p : priority.localities) {
-          total_weight += p.second.lb_weight;
+        for (const auto& [_, locality] : priority.localities) {
+          total_weight += locality.lb_weight;
           if (total_weight > std::numeric_limits<uint32_t>::max()) {
             errors.AddError(
                 absl::StrCat("sum of locality weights for priority ", i,
@@ -455,14 +455,14 @@ XdsResourceType::DecodeResult XdsEndpointResourceType::Decode(
       envoy_config_endpoint_v3_ClusterLoadAssignment_cluster_name(resource));
   auto eds_resource = EdsResourceParse(context, resource);
   if (!eds_resource.ok()) {
-    if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer)) {
+    if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
       LOG(ERROR) << "[xds_client " << context.client
                  << "] invalid ClusterLoadAssignment " << *result.name << ": "
                  << eds_resource.status();
     }
     result.resource = eds_resource.status();
   } else {
-    if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer)) {
+    if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
       LOG(INFO) << "[xds_client " << context.client
                 << "] parsed ClusterLoadAssignment " << *result.name << ": "
                 << (*eds_resource)->ToString();

data/src/core/xds/grpc/xds_health_status.cc

@@ -24,7 +24,7 @@
 
 namespace grpc_core {
 
-absl::optional<XdsHealthStatus> XdsHealthStatus::FromUpb(uint32_t status) {
+std::optional<XdsHealthStatus> XdsHealthStatus::FromUpb(uint32_t status) {
   switch (status) {
     case envoy_config_core_v3_UNKNOWN:
       return XdsHealthStatus(kUnknown);
@@ -33,16 +33,16 @@ absl::optional<XdsHealthStatus> XdsHealthStatus::FromUpb(uint32_t status) {
     case envoy_config_core_v3_DRAINING:
       return XdsHealthStatus(kDraining);
     default:
-      return absl::nullopt;
+      return std::nullopt;
   }
 }
 
-absl::optional<XdsHealthStatus> XdsHealthStatus::FromString(
+std::optional<XdsHealthStatus> XdsHealthStatus::FromString(
     absl::string_view status) {
   if (status == "UNKNOWN") return XdsHealthStatus(kUnknown);
   if (status == "HEALTHY") return XdsHealthStatus(kHealthy);
   if (status == "DRAINING") return XdsHealthStatus(kDraining);
-  return absl::nullopt;
+  return std::nullopt;
 }
 
 const char* XdsHealthStatus::ToString() const {

data/src/core/xds/grpc/xds_health_status.h

@@ -19,8 +19,9 @@
 
 #include <stdint.h>
 
+#include <optional>
+
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "absl/types/span.h"
 #include "src/core/resolver/endpoint_addresses.h"
 
@@ -36,8 +37,8 @@ class XdsHealthStatus final {
   enum HealthStatus { kUnknown, kHealthy, kDraining };
 
   // Returns an XdsHealthStatus for supported enum values, else nullopt.
-  static absl::optional<XdsHealthStatus> FromUpb(uint32_t status);
-  static absl::optional<XdsHealthStatus> FromString(absl::string_view status);
+  static std::optional<XdsHealthStatus> FromUpb(uint32_t status);
+  static std::optional<XdsHealthStatus> FromString(absl::string_view status);
 
   explicit XdsHealthStatus(HealthStatus status) : status_(status) {}
 

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

@@ -23,11 +23,11 @@
 
 #include <string>
 #include <utility>
+#include <variant>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
 #include "envoy/extensions/filters/common/fault/v3/fault.upb.h"
 #include "envoy/extensions/filters/http/fault/v3/fault.upb.h"
 #include "envoy/extensions/filters/http/fault/v3/fault.upbdefs.h"
@@ -83,23 +83,23 @@ void XdsHttpFaultFilter::PopulateSymtab(upb_DefPool* symtab) const {
   envoy_extensions_filters_http_fault_v3_HTTPFault_getmsgdef(symtab);
 }
 
-absl::optional<XdsHttpFilterImpl::FilterConfig>
+std::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpFaultFilter::GenerateFilterConfig(
     absl::string_view /*instance_name*/,
     const XdsResourceType::DecodeContext& context, XdsExtension extension,
     ValidationErrors* errors) const {
   absl::string_view* serialized_filter_config =
-      absl::get_if<absl::string_view>(&extension.value);
+      std::get_if<absl::string_view>(&extension.value);
   if (serialized_filter_config == nullptr) {
     errors->AddError("could not parse fault injection filter config");
-    return absl::nullopt;
+    return std::nullopt;
   }
   auto* http_fault = envoy_extensions_filters_http_fault_v3_HTTPFault_parse(
       serialized_filter_config->data(), serialized_filter_config->size(),
       context.arena);
   if (http_fault == nullptr) {
     errors->AddError("could not parse fault injection filter config");
-    return absl::nullopt;
+    return std::nullopt;
   }
   // NOTE(lidiz): Here, we are manually translating the upb messages into the
   // JSON form of the filter config as part of method config, which will be
@@ -116,26 +116,24 @@ XdsHttpFaultFilter::GenerateFilterConfig(
   if (fault_abort != nullptr) {
     ValidationErrors::ScopedField field(errors, ".abort");
     grpc_status_code abort_grpc_status_code = GRPC_STATUS_OK;
-    // Try if gRPC status code is set first
-    int abort_grpc_status_code_raw =
-        envoy_extensions_filters_http_fault_v3_FaultAbort_grpc_status(
-            fault_abort);
-    if (abort_grpc_status_code_raw != 0) {
+    // Try if gRPC status code is set first.  Otherwise, use HTTP status.
+    if (int abort_grpc_status_code_raw =
+            envoy_extensions_filters_http_fault_v3_FaultAbort_grpc_status(
+                fault_abort);
+        abort_grpc_status_code_raw != 0) {
       if (!grpc_status_code_from_int(abort_grpc_status_code_raw,
                                      &abort_grpc_status_code)) {
         ValidationErrors::ScopedField field(errors, ".grpc_status");
         errors->AddError(absl::StrCat("invalid gRPC status code: ",
                                       abort_grpc_status_code_raw));
       }
-    } else {
-      // if gRPC status code is empty, check http status
-      int abort_http_status_code =
-          envoy_extensions_filters_http_fault_v3_FaultAbort_http_status(
-              fault_abort);
-      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);
-      }
+    } else if (
+        int abort_http_status_code =
+            envoy_extensions_filters_http_fault_v3_FaultAbort_http_status(
+                fault_abort);
+        abort_http_status_code != 0 && abort_http_status_code != 200) {
+      abort_grpc_status_code =
+          grpc_http2_status_to_grpc_status(abort_http_status_code);
     }
     // Set the abort_code, even if it's OK
     fault_injection_policy_json["abortCode"] =
@@ -205,7 +203,7 @@ XdsHttpFaultFilter::GenerateFilterConfig(
                       Json::FromObject(std::move(fault_injection_policy_json))};
 }
 
-absl::optional<XdsHttpFilterImpl::FilterConfig>
+std::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpFaultFilter::GenerateFilterConfigOverride(
     absl::string_view instance_name,
     const XdsResourceType::DecodeContext& context, XdsExtension extension,

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

@@ -19,9 +19,10 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
+
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/util/validation_errors.h"
@@ -37,11 +38,11 @@ class XdsHttpFaultFilter final : public XdsHttpFilterImpl {
   absl::string_view ConfigProtoName() const override;
   absl::string_view OverrideConfigProtoName() const override;
   void PopulateSymtab(upb_DefPool* symtab) const override;
-  absl::optional<FilterConfig> GenerateFilterConfig(
+  std::optional<FilterConfig> GenerateFilterConfig(
       absl::string_view /*instance_name*/,
       const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const override;
-  absl::optional<FilterConfig> GenerateFilterConfigOverride(
+  std::optional<FilterConfig> GenerateFilterConfigOverride(
       absl::string_view /*instance_name*/,
       const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const override;

data/src/core/xds/grpc/xds_http_filter.h

@@ -17,12 +17,12 @@
 #ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_HTTP_FILTER_H
 #define GRPC_SRC_CORE_XDS_GRPC_XDS_HTTP_FILTER_H
 
+#include <optional>
 #include <string>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/transport/interception_chain.h"
@@ -79,14 +79,14 @@ class XdsHttpFilterImpl {
 
   // Generates a Config from the xDS filter config proto.
   // Used for the top-level config in the HCM HTTP filter list.
-  virtual absl::optional<FilterConfig> GenerateFilterConfig(
+  virtual std::optional<FilterConfig> GenerateFilterConfig(
       absl::string_view instance_name,
       const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const = 0;
 
   // Generates a Config from the xDS filter config proto.
   // Used for the typed_per_filter_config override in VirtualHost and Route.
-  virtual absl::optional<FilterConfig> GenerateFilterConfigOverride(
+  virtual std::optional<FilterConfig> GenerateFilterConfigOverride(
       absl::string_view instance_name,
       const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const = 0;

data/src/core/xds/grpc/xds_http_filter_registry.cc

@@ -20,10 +20,10 @@
 
 #include <map>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/log/check.h"
-#include "absl/types/variant.h"
 #include "envoy/extensions/filters/http/router/v3/router.upb.h"
 #include "envoy/extensions/filters/http/router/v3/router.upbdefs.h"
 #include "src/core/util/json/json.h"
@@ -51,33 +51,33 @@ void XdsHttpRouterFilter::PopulateSymtab(upb_DefPool* symtab) const {
   envoy_extensions_filters_http_router_v3_Router_getmsgdef(symtab);
 }
 
-absl::optional<XdsHttpFilterImpl::FilterConfig>
+std::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpRouterFilter::GenerateFilterConfig(
     absl::string_view /*instance_name*/,
     const XdsResourceType::DecodeContext& context, XdsExtension extension,
     ValidationErrors* errors) const {
   absl::string_view* serialized_filter_config =
-      absl::get_if<absl::string_view>(&extension.value);
+      std::get_if<absl::string_view>(&extension.value);
   if (serialized_filter_config == nullptr) {
     errors->AddError("could not parse router filter config");
-    return absl::nullopt;
+    return std::nullopt;
   }
   if (envoy_extensions_filters_http_router_v3_Router_parse(
           serialized_filter_config->data(), serialized_filter_config->size(),
           context.arena) == nullptr) {
     errors->AddError("could not parse router filter config");
-    return absl::nullopt;
+    return std::nullopt;
   }
   return FilterConfig{ConfigProtoName(), Json()};
 }
 
-absl::optional<XdsHttpFilterImpl::FilterConfig>
+std::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpRouterFilter::GenerateFilterConfigOverride(
     absl::string_view /*instance_name*/,
     const XdsResourceType::DecodeContext& /*context*/,
     XdsExtension /*extension*/, ValidationErrors* errors) const {
   errors->AddError("router filter does not support config override");
-  return absl::nullopt;
+  return std::nullopt;
 }
 
 //

data/src/core/xds/grpc/xds_http_filter_registry.h

@@ -19,13 +19,13 @@
 
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/transport/interception_chain.h"
@@ -43,11 +43,11 @@ class XdsHttpRouterFilter final : public XdsHttpFilterImpl {
   absl::string_view ConfigProtoName() const override;
   absl::string_view OverrideConfigProtoName() const override;
   void PopulateSymtab(upb_DefPool* symtab) const override;
-  absl::optional<FilterConfig> GenerateFilterConfig(
+  std::optional<FilterConfig> GenerateFilterConfig(
       absl::string_view /*instance_name*/,
       const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const override;
-  absl::optional<FilterConfig> GenerateFilterConfigOverride(
+  std::optional<FilterConfig> GenerateFilterConfigOverride(
       absl::string_view /*instance_name*/,
       const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const override;

data/src/core/xds/grpc/xds_http_gcp_authn_filter.cc

@@ -20,10 +20,10 @@
 
 #include <string>
 #include <utility>
+#include <variant>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
 #include "envoy/extensions/filters/http/gcp_authn/v3/gcp_authn.upb.h"
 #include "envoy/extensions/filters/http/gcp_authn/v3/gcp_authn.upbdefs.h"
 #include "src/core/ext/filters/gcp_authentication/gcp_authentication_filter.h"
@@ -79,16 +79,16 @@ Json::Object ValidateFilterConfig(
 
 }  // namespace
 
-absl::optional<XdsHttpFilterImpl::FilterConfig>
+std::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpGcpAuthnFilter::GenerateFilterConfig(
     absl::string_view instance_name,
     const XdsResourceType::DecodeContext& context, XdsExtension extension,
     ValidationErrors* errors) const {
   absl::string_view* serialized_filter_config =
-      absl::get_if<absl::string_view>(&extension.value);
+      std::get_if<absl::string_view>(&extension.value);
   if (serialized_filter_config == nullptr) {
     errors->AddError("could not parse GCP auth filter config");
-    return absl::nullopt;
+    return std::nullopt;
   }
   auto* gcp_auth =
       envoy_extensions_filters_http_gcp_authn_v3_GcpAuthnFilterConfig_parse(
@@ -96,19 +96,19 @@ XdsHttpGcpAuthnFilter::GenerateFilterConfig(
           context.arena);
   if (gcp_auth == nullptr) {
     errors->AddError("could not parse GCP auth filter config");
-    return absl::nullopt;
+    return std::nullopt;
   }
   return FilterConfig{ConfigProtoName(), Json::FromObject(ValidateFilterConfig(
                                              instance_name, gcp_auth, errors))};
 }
 
-absl::optional<XdsHttpFilterImpl::FilterConfig>
+std::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpGcpAuthnFilter::GenerateFilterConfigOverride(
     absl::string_view /*instance_name*/,
     const XdsResourceType::DecodeContext& /*context*/,
     XdsExtension /*extension*/, ValidationErrors* errors) const {
   errors->AddError("GCP auth filter does not support config override");
-  return absl::nullopt;
+  return std::nullopt;
 }
 
 void XdsHttpGcpAuthnFilter::AddFilter(InterceptionChainBuilder& builder) const {

data/src/core/xds/grpc/xds_http_gcp_authn_filter.h

@@ -17,9 +17,10 @@
 #ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_HTTP_GCP_AUTHN_FILTER_H
 #define GRPC_SRC_CORE_XDS_GRPC_XDS_HTTP_GCP_AUTHN_FILTER_H
 
+#include <optional>
+
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/util/validation_errors.h"
@@ -35,11 +36,11 @@ class XdsHttpGcpAuthnFilter final : public XdsHttpFilterImpl {
   absl::string_view ConfigProtoName() const override;
   absl::string_view OverrideConfigProtoName() const override;
   void PopulateSymtab(upb_DefPool* symtab) const override;
-  absl::optional<FilterConfig> GenerateFilterConfig(
+  std::optional<FilterConfig> GenerateFilterConfig(
       absl::string_view instance_name,
       const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const override;
-  absl::optional<FilterConfig> GenerateFilterConfigOverride(
+  std::optional<FilterConfig> GenerateFilterConfigOverride(
       absl::string_view instance_name,
       const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const override;

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

@@ -17,18 +17,17 @@
 #include "src/core/xds/grpc/xds_http_rbac_filter.h"
 
 #include <grpc/support/json.h>
-#include <grpc/support/port_platform.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <string>
 #include <utility>
+#include <variant>
 
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
 #include "envoy/config/core/v3/address.upb.h"
 #include "envoy/config/rbac/v3/rbac.upb.h"
 #include "envoy/config/route/v3/route_components.upb.h"
@@ -43,6 +42,7 @@
 #include "src/core/ext/filters/rbac/rbac_filter.h"
 #include "src/core/ext/filters/rbac/rbac_service_config_parser.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/util/down_cast.h"
 #include "src/core/util/env.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_writer.h"
@@ -52,6 +52,8 @@
 #include "src/core/xds/grpc/xds_bootstrap_grpc.h"
 #include "src/core/xds/grpc/xds_common_types_parser.h"
 #include "src/core/xds/xds_client/xds_client.h"
+#include "upb/base/string_view.h"
+#include "upb/message/array.h"
 #include "upb/message/map.h"
 
 namespace grpc_core {
@@ -418,7 +420,7 @@ Json ParseAuditLoggerConfigsToJson(
   Json::Array logger_configs_json;
   size_t size;
   const auto& registry =
-      static_cast<const GrpcXdsBootstrap&>(context.client->bootstrap())
+      DownCast<const GrpcXdsBootstrap&>(context.client->bootstrap())
           .audit_logger_registry();
   const envoy_config_rbac_v3_RBAC_AuditLoggingOptions_AuditLoggerConfig* const*
       logger_configs =
@@ -450,19 +452,24 @@ Json ParseHttpRbacToJson(const XdsResourceType::DecodeContext& context,
         "action", Json::FromNumber(envoy_config_rbac_v3_RBAC_action(rules)));
     if (envoy_config_rbac_v3_RBAC_policies_size(rules) != 0) {
       Json::Object policies_object;
-      size_t iter = kUpb_Map_Begin;
-      while (true) {
-        auto* entry = envoy_config_rbac_v3_RBAC_policies_next(rules, &iter);
-        if (entry == nullptr) {
-          break;
+      // TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto
+      // v30.0.
+      envoy_config_rbac_v3_RBAC* rules_upb = (envoy_config_rbac_v3_RBAC*)rules;
+      const upb_Map* rules_upb_map =
+          _envoy_config_rbac_v3_RBAC_policies_upb_map(rules_upb);
+      if (rules_upb_map) {
+        size_t iter = kUpb_Map_Begin;
+        upb_MessageValue k, v;
+        while (upb_Map_Next(rules_upb_map, &k, &v, &iter)) {
+          upb_StringView key_view = k.str_val;
+          const envoy_config_rbac_v3_Policy* val =
+              (envoy_config_rbac_v3_Policy*)v.msg_val;
+          absl::string_view key = UpbStringToAbsl(key_view);
+          ValidationErrors::ScopedField field(
+              errors, absl::StrCat(".policies[", key, "]"));
+          Json policy = ParsePolicyToJson(val, errors);
+          policies_object.emplace(std::string(key), std::move(policy));
         }
-        absl::string_view key =
-            UpbStringToAbsl(envoy_config_rbac_v3_RBAC_PoliciesEntry_key(entry));
-        ValidationErrors::ScopedField field(
-            errors, absl::StrCat(".policies[", key, "]"));
-        Json policy = ParsePolicyToJson(
-            envoy_config_rbac_v3_RBAC_PoliciesEntry_value(entry), errors);
-        policies_object.emplace(std::string(key), std::move(policy));
       }
       inner_rbac_json.emplace("policies",
                               Json::FromObject(std::move(policies_object)));
@@ -516,38 +523,38 @@ void XdsHttpRbacFilter::PopulateSymtab(upb_DefPool* symtab) const {
   envoy_extensions_filters_http_rbac_v3_RBAC_getmsgdef(symtab);
 }
 
-absl::optional<XdsHttpFilterImpl::FilterConfig>
+std::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpRbacFilter::GenerateFilterConfig(
     absl::string_view /*instance_name*/,
     const XdsResourceType::DecodeContext& context, XdsExtension extension,
     ValidationErrors* errors) const {
   absl::string_view* serialized_filter_config =
-      absl::get_if<absl::string_view>(&extension.value);
+      std::get_if<absl::string_view>(&extension.value);
   if (serialized_filter_config == nullptr) {
     errors->AddError("could not parse HTTP RBAC filter config");
-    return absl::nullopt;
+    return std::nullopt;
   }
   auto* rbac = envoy_extensions_filters_http_rbac_v3_RBAC_parse(
       serialized_filter_config->data(), serialized_filter_config->size(),
       context.arena);
   if (rbac == nullptr) {
     errors->AddError("could not parse HTTP RBAC filter config");
-    return absl::nullopt;
+    return std::nullopt;
   }
   return FilterConfig{ConfigProtoName(),
                       ParseHttpRbacToJson(context, rbac, errors)};
 }
 
-absl::optional<XdsHttpFilterImpl::FilterConfig>
+std::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpRbacFilter::GenerateFilterConfigOverride(
     absl::string_view /*instance_name*/,
     const XdsResourceType::DecodeContext& context, XdsExtension extension,
     ValidationErrors* errors) const {
   absl::string_view* serialized_filter_config =
-      absl::get_if<absl::string_view>(&extension.value);
+      std::get_if<absl::string_view>(&extension.value);
   if (serialized_filter_config == nullptr) {
     errors->AddError("could not parse RBACPerRoute");
-    return absl::nullopt;
+    return std::nullopt;
   }
   auto* rbac_per_route =
       envoy_extensions_filters_http_rbac_v3_RBACPerRoute_parse(
@@ -555,7 +562,7 @@ XdsHttpRbacFilter::GenerateFilterConfigOverride(
           context.arena);
   if (rbac_per_route == nullptr) {
     errors->AddError("could not parse RBACPerRoute");
-    return absl::nullopt;
+    return std::nullopt;
   }
   Json rbac_json;
   const auto* rbac =

data/src/core/xds/grpc/xds_http_rbac_filter.h

@@ -19,9 +19,10 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
+
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/util/validation_errors.h"
@@ -37,11 +38,11 @@ class XdsHttpRbacFilter final : public XdsHttpFilterImpl {
   absl::string_view ConfigProtoName() const override;
   absl::string_view OverrideConfigProtoName() const override;
   void PopulateSymtab(upb_DefPool* symtab) const override;
-  absl::optional<FilterConfig> GenerateFilterConfig(
+  std::optional<FilterConfig> GenerateFilterConfig(
       absl::string_view /*instance_name*/,
       const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const override;
-  absl::optional<FilterConfig> GenerateFilterConfigOverride(
+  std::optional<FilterConfig> GenerateFilterConfigOverride(
       absl::string_view /*instance_name*/,
       const XdsResourceType::DecodeContext& context, XdsExtension extension,
       ValidationErrors* errors) const override;