grpc 1.70.1 → 1.76.0

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

@@ -17,19 +17,19 @@
 #include "src/core/xds/grpc/xds_route_config_parser.h"
 
 #include <grpc/status.h>
-#include <grpc/support/port_platform.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <map>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -38,8 +38,6 @@
 #include "absl/strings/str_join.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "envoy/config/core/v3/base.upb.h"
 #include "envoy/config/core/v3/extension.upb.h"
 #include "envoy/config/route/v3/route.upb.h"
@@ -53,11 +51,13 @@
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/wrappers.upb.h"
 #include "re2/re2.h"
+#include "src/core/call/status_util.h"
 #include "src/core/config/core_configuration.h"
-#include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/load_balancing/lb_policy_registry.h"
+#include "src/core/util/down_cast.h"
 #include "src/core/util/env.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_writer.h"
 #include "src/core/util/match.h"
@@ -88,15 +88,6 @@ bool XdsRlsEnabled() {
   return parse_succeeded && parsed_value;
 }
 
-// TODO(roth): Remove this once the feature passes interop tests.
-bool XdsAuthorityRewriteEnabled() {
-  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_AUTHORITY_REWRITE");
-  if (!value.has_value()) return false;
-  bool parsed_value;
-  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
-  return parse_succeeded && parsed_value;
-}
-
 //
 // XdsRouteConfigResourceParse()
 //
@@ -110,7 +101,7 @@ XdsRouteConfigResource::ClusterSpecifierPluginMap ClusterSpecifierPluginParse(
   XdsRouteConfigResource::ClusterSpecifierPluginMap
       cluster_specifier_plugin_map;
   const auto& cluster_specifier_plugin_registry =
-      static_cast<const GrpcXdsBootstrap&>(context.client->bootstrap())
+      DownCast<const GrpcXdsBootstrap&>(context.client->bootstrap())
           .cluster_specifier_plugin_registry();
   size_t num_cluster_specifier_plugins;
   const envoy_config_route_v3_ClusterSpecifierPlugin* const*
@@ -181,7 +172,7 @@ XdsRouteConfigResource::ClusterSpecifierPluginMap ClusterSpecifierPluginParse(
   return cluster_specifier_plugin_map;
 }
 
-absl::optional<StringMatcher> RoutePathMatchParse(
+std::optional<StringMatcher> RoutePathMatchParse(
     const envoy_config_route_v3_RouteMatch* match, ValidationErrors* errors) {
   bool case_sensitive =
       ParseBoolValue(envoy_config_route_v3_RouteMatch_case_sensitive(match),
@@ -195,14 +186,14 @@ absl::optional<StringMatcher> RoutePathMatchParse(
     // ignore the route.
     if (!prefix.empty()) {
       // Does not start with a slash.
-      if (prefix[0] != '/') return absl::nullopt;
+      if (prefix[0] != '/') return std::nullopt;
       std::vector<absl::string_view> prefix_elements =
           absl::StrSplit(prefix.substr(1), absl::MaxSplits('/', 2));
       // More than 2 slashes.
-      if (prefix_elements.size() > 2) return absl::nullopt;
+      if (prefix_elements.size() > 2) return std::nullopt;
       // Two consecutive slashes.
       if (prefix_elements.size() == 2 && prefix_elements[0].empty()) {
-        return absl::nullopt;
+        return std::nullopt;
       }
     }
     type = StringMatcher::Type::kPrefix;
@@ -212,41 +203,42 @@ absl::optional<StringMatcher> RoutePathMatchParse(
         UpbStringToAbsl(envoy_config_route_v3_RouteMatch_path(match));
     // For any path not of the form "/service/method", ignore the route.
     // Empty path.
-    if (path.empty()) return absl::nullopt;
+    if (path.empty()) return std::nullopt;
     // Does not start with a slash.
-    if (path[0] != '/') return absl::nullopt;
+    if (path[0] != '/') return std::nullopt;
     std::vector<absl::string_view> path_elements =
         absl::StrSplit(path.substr(1), absl::MaxSplits('/', 2));
     // Number of slashes does not equal 2.
-    if (path_elements.size() != 2) return absl::nullopt;
+    if (path_elements.size() != 2) return std::nullopt;
     // Empty service name.
-    if (path_elements[0].empty()) return absl::nullopt;
+    if (path_elements[0].empty()) return std::nullopt;
     // Empty method name.
-    if (path_elements[1].empty()) return absl::nullopt;
+    if (path_elements[1].empty()) return std::nullopt;
     type = StringMatcher::Type::kExact;
     match_string = std::string(path);
   } else if (envoy_config_route_v3_RouteMatch_has_safe_regex(match)) {
     const envoy_type_matcher_v3_RegexMatcher* regex_matcher =
         envoy_config_route_v3_RouteMatch_safe_regex(match);
-    CHECK_NE(regex_matcher, nullptr);
+    GRPC_CHECK_NE(regex_matcher, nullptr);
     type = StringMatcher::Type::kSafeRegex;
     match_string = UpbStringToStdString(
         envoy_type_matcher_v3_RegexMatcher_regex(regex_matcher));
   } else {
     errors->AddError("invalid path specifier");
-    return absl::nullopt;
+    return std::nullopt;
   }
   absl::StatusOr<StringMatcher> string_matcher =
       StringMatcher::Create(type, match_string, case_sensitive);
   if (!string_matcher.ok()) {
     errors->AddError(absl::StrCat("error creating path matcher: ",
                                   string_matcher.status().message()));
-    return absl::nullopt;
+    return std::nullopt;
   }
   return std::move(*string_matcher);
 }
 
-void RouteHeaderMatchersParse(const envoy_config_route_v3_RouteMatch* match,
+void RouteHeaderMatchersParse(const XdsResourceType::DecodeContext& context,
+                              const envoy_config_route_v3_RouteMatch* match,
                               XdsRouteConfigResource::Route* route,
                               ValidationErrors* errors) {
   size_t size;
@@ -256,9 +248,21 @@ void RouteHeaderMatchersParse(const envoy_config_route_v3_RouteMatch* match,
     ValidationErrors::ScopedField field(errors,
                                         absl::StrCat(".headers[", i, "]"));
     const envoy_config_route_v3_HeaderMatcher* header = headers[i];
-    CHECK_NE(header, nullptr);
+    GRPC_CHECK_NE(header, nullptr);
     const std::string name =
         UpbStringToStdString(envoy_config_route_v3_HeaderMatcher_name(header));
+    const bool invert_match =
+        envoy_config_route_v3_HeaderMatcher_invert_match(header);
+    if (envoy_config_route_v3_HeaderMatcher_has_string_match(header)) {
+      ValidationErrors::ScopedField field(errors, ".string_match");
+      auto string_matcher = StringMatcherParse(
+          context, envoy_config_route_v3_HeaderMatcher_string_match(header),
+          errors);
+      route->matchers.header_matchers.emplace_back(
+          HeaderMatcher::CreateFromStringMatcher(
+              name, std::move(string_matcher), invert_match));
+      continue;
+    }
     HeaderMatcher::Type type;
     std::string match_string;
     int64_t range_start = 0;
@@ -285,7 +289,7 @@ void RouteHeaderMatchersParse(const envoy_config_route_v3_RouteMatch* match,
                    header)) {
       const envoy_type_matcher_v3_RegexMatcher* regex_matcher =
           envoy_config_route_v3_HeaderMatcher_safe_regex_match(header);
-      CHECK_NE(regex_matcher, nullptr);
+      GRPC_CHECK_NE(regex_matcher, nullptr);
       type = HeaderMatcher::Type::kSafeRegex;
       match_string = UpbStringToStdString(
           envoy_type_matcher_v3_RegexMatcher_regex(regex_matcher));
@@ -293,52 +297,16 @@ void RouteHeaderMatchersParse(const envoy_config_route_v3_RouteMatch* match,
       type = HeaderMatcher::Type::kRange;
       const envoy_type_v3_Int64Range* range_matcher =
           envoy_config_route_v3_HeaderMatcher_range_match(header);
-      CHECK_NE(range_matcher, nullptr);
+      GRPC_CHECK_NE(range_matcher, nullptr);
       range_start = envoy_type_v3_Int64Range_start(range_matcher);
       range_end = envoy_type_v3_Int64Range_end(range_matcher);
     } else if (envoy_config_route_v3_HeaderMatcher_has_present_match(header)) {
       type = HeaderMatcher::Type::kPresent;
       present_match = envoy_config_route_v3_HeaderMatcher_present_match(header);
-    } else if (envoy_config_route_v3_HeaderMatcher_has_string_match(header)) {
-      ValidationErrors::ScopedField field(errors, ".string_match");
-      const auto* matcher =
-          envoy_config_route_v3_HeaderMatcher_string_match(header);
-      CHECK_NE(matcher, nullptr);
-      if (envoy_type_matcher_v3_StringMatcher_has_exact(matcher)) {
-        type = HeaderMatcher::Type::kExact;
-        match_string = UpbStringToStdString(
-            envoy_type_matcher_v3_StringMatcher_exact(matcher));
-      } else if (envoy_type_matcher_v3_StringMatcher_has_prefix(matcher)) {
-        type = HeaderMatcher::Type::kPrefix;
-        match_string = UpbStringToStdString(
-            envoy_type_matcher_v3_StringMatcher_prefix(matcher));
-      } else if (envoy_type_matcher_v3_StringMatcher_has_suffix(matcher)) {
-        type = HeaderMatcher::Type::kSuffix;
-        match_string = UpbStringToStdString(
-            envoy_type_matcher_v3_StringMatcher_suffix(matcher));
-      } else if (envoy_type_matcher_v3_StringMatcher_has_contains(matcher)) {
-        type = HeaderMatcher::Type::kContains;
-        match_string = UpbStringToStdString(
-            envoy_type_matcher_v3_StringMatcher_contains(matcher));
-      } else if (envoy_type_matcher_v3_StringMatcher_has_safe_regex(matcher)) {
-        type = HeaderMatcher::Type::kSafeRegex;
-        const auto* regex_matcher =
-            envoy_type_matcher_v3_StringMatcher_safe_regex(matcher);
-        CHECK_NE(regex_matcher, nullptr);
-        match_string = UpbStringToStdString(
-            envoy_type_matcher_v3_RegexMatcher_regex(regex_matcher));
-      } else {
-        errors->AddError("invalid string matcher");
-        continue;
-      }
-      case_sensitive =
-          !envoy_type_matcher_v3_StringMatcher_ignore_case(matcher);
     } else {
       errors->AddError("invalid header matcher");
       continue;
     }
-    bool invert_match =
-        envoy_config_route_v3_HeaderMatcher_invert_match(header);
     absl::StatusOr<HeaderMatcher> header_matcher =
         HeaderMatcher::Create(name, type, match_string, range_start, range_end,
                               present_match, invert_match, case_sensitive);
@@ -386,30 +354,28 @@ void RouteRuntimeFractionParse(const envoy_config_route_v3_RouteMatch* match,
   }
 }
 
-template <typename ParentType, typename EntryType>
+template <typename ParentType>
 XdsRouteConfigResource::TypedPerFilterConfig ParseTypedPerFilterConfig(
     const XdsResourceType::DecodeContext& context, const ParentType* parent,
-    const EntryType* (*entry_func)(const ParentType*, size_t*),
-    upb_StringView (*key_func)(const EntryType*),
-    const google_protobuf_Any* (*value_func)(const EntryType*),
+    bool (*upb_next_func)(const ParentType*, upb_StringView*,
+                          const struct google_protobuf_Any**, size_t* iter),
     ValidationErrors* errors) {
   XdsRouteConfigResource::TypedPerFilterConfig typed_per_filter_config;
   size_t filter_it = kUpb_Map_Begin;
-  while (true) {
-    const auto* filter_entry = entry_func(parent, &filter_it);
-    if (filter_entry == nullptr) break;
-    absl::string_view key = UpbStringToAbsl(key_func(filter_entry));
+  upb_StringView key_view;
+  const struct google_protobuf_Any* any;
+  while (upb_next_func(parent, &key_view, &any, &filter_it)) {
+    absl::string_view key = UpbStringToAbsl(key_view);
     ValidationErrors::ScopedField field(errors, absl::StrCat("[", key, "]"));
     if (key.empty()) errors->AddError("filter name must be non-empty");
-    const google_protobuf_Any* any = value_func(filter_entry);
     auto extension = ExtractXdsExtension(context, any, errors);
     if (!extension.has_value()) continue;
     auto* extension_to_use = &*extension;
-    absl::optional<XdsExtension> nested_extension;
+    std::optional<XdsExtension> nested_extension;
     bool is_optional = false;
     if (extension->type == "envoy.config.route.v3.FilterConfig") {
       absl::string_view* serialized_config =
-          absl::get_if<absl::string_view>(&extension->value);
+          std::get_if<absl::string_view>(&extension->value);
       if (serialized_config == nullptr) {
         errors->AddError("could not parse FilterConfig");
         continue;
@@ -429,7 +395,7 @@ XdsRouteConfigResource::TypedPerFilterConfig ParseTypedPerFilterConfig(
       extension_to_use = &*nested_extension;
     }
     const auto& http_filter_registry =
-        static_cast<const GrpcXdsBootstrap&>(context.client->bootstrap())
+        DownCast<const GrpcXdsBootstrap&>(context.client->bootstrap())
             .http_filter_registry();
     const XdsHttpFilterImpl* filter_impl =
         http_filter_registry.GetFilterForType(extension_to_use->type);
@@ -437,7 +403,7 @@ XdsRouteConfigResource::TypedPerFilterConfig ParseTypedPerFilterConfig(
       if (!is_optional) errors->AddError("unsupported filter type");
       continue;
     }
-    absl::optional<XdsHttpFilterImpl::FilterConfig> filter_config =
+    std::optional<XdsHttpFilterImpl::FilterConfig> filter_config =
         filter_impl->GenerateFilterConfigOverride(
             key, context, std::move(*extension_to_use), errors);
     if (filter_config.has_value()) {
@@ -448,7 +414,6 @@ XdsRouteConfigResource::TypedPerFilterConfig ParseTypedPerFilterConfig(
 }
 
 XdsRouteConfigResource::RetryPolicy RetryPolicyParse(
-    const XdsResourceType::DecodeContext& context,
     const envoy_config_route_v3_RetryPolicy* retry_policy_proto,
     ValidationErrors* errors) {
   XdsRouteConfigResource::RetryPolicy retry_policy;
@@ -467,7 +432,7 @@ XdsRouteConfigResource::RetryPolicy RetryPolicyParse(
     } else if (code == "unavailable") {
       retry_policy.retry_on.Add(GRPC_STATUS_UNAVAILABLE);
     } else {
-      if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer)) {
+      if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
         LOG(INFO) << "Unsupported retry_on policy " << code;
       }
     }
@@ -515,7 +480,7 @@ XdsRouteConfigResource::RetryPolicy RetryPolicyParse(
   return retry_policy;
 }
 
-absl::optional<XdsRouteConfigResource::Route::RouteAction> RouteActionParse(
+std::optional<XdsRouteConfigResource::Route::RouteAction> RouteActionParse(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_route_v3_RouteAction* route_action_proto,
     const std::map<std::string /*cluster_specifier_plugin_name*/,
@@ -528,20 +493,19 @@ absl::optional<XdsRouteConfigResource::Route::RouteAction> RouteActionParse(
       envoy_config_route_v3_RouteAction_max_stream_duration(route_action_proto);
   if (max_stream_duration != nullptr) {
     ValidationErrors::ScopedField field(errors, ".max_stream_duration");
-    const google_protobuf_Duration* duration =
-        envoy_config_route_v3_RouteAction_MaxStreamDuration_grpc_timeout_header_max(
-            max_stream_duration);
-    if (duration != nullptr) {
+    if (const google_protobuf_Duration* duration =
+            envoy_config_route_v3_RouteAction_MaxStreamDuration_grpc_timeout_header_max(
+                max_stream_duration);
+        duration != nullptr) {
       ValidationErrors::ScopedField field(errors, ".grpc_timeout_header_max");
       route_action.max_stream_duration = ParseDuration(duration, errors);
-    } else {
-      duration =
-          envoy_config_route_v3_RouteAction_MaxStreamDuration_max_stream_duration(
-              max_stream_duration);
-      if (duration != nullptr) {
-        ValidationErrors::ScopedField field(errors, ".max_stream_duration");
-        route_action.max_stream_duration = ParseDuration(duration, errors);
-      }
+    } else if (
+        duration =
+            envoy_config_route_v3_RouteAction_MaxStreamDuration_max_stream_duration(
+                max_stream_duration);
+        duration != nullptr) {
+      ValidationErrors::ScopedField field(errors, ".max_stream_duration");
+      route_action.max_stream_duration = ParseDuration(duration, errors);
     }
   }
   // hash_policy
@@ -624,11 +588,10 @@ absl::optional<XdsRouteConfigResource::Route::RouteAction> RouteActionParse(
       envoy_config_route_v3_RouteAction_retry_policy(route_action_proto);
   if (retry_policy != nullptr) {
     ValidationErrors::ScopedField field(errors, ".retry_policy");
-    route_action.retry_policy = RetryPolicyParse(context, retry_policy, errors);
+    route_action.retry_policy = RetryPolicyParse(retry_policy, errors);
   }
   // Host rewrite field.
-  if (XdsAuthorityRewriteEnabled() &&
-      DownCast<const GrpcXdsServer&>(context.server).TrustedXdsServer()) {
+  if (DownCast<const GrpcXdsServer&>(context.server).TrustedXdsServer()) {
     route_action.auto_host_rewrite =
         ParseBoolValue(envoy_config_route_v3_RouteAction_auto_host_rewrite(
             route_action_proto));
@@ -651,7 +614,7 @@ absl::optional<XdsRouteConfigResource::Route::RouteAction> RouteActionParse(
     ValidationErrors::ScopedField field(errors, ".weighted_clusters");
     const envoy_config_route_v3_WeightedCluster* weighted_clusters_proto =
         envoy_config_route_v3_RouteAction_weighted_clusters(route_action_proto);
-    CHECK_NE(weighted_clusters_proto, nullptr);
+    GRPC_CHECK_NE(weighted_clusters_proto, nullptr);
     std::vector<XdsRouteConfigResource::Route::RouteAction::ClusterWeight>
         action_weighted_clusters;
     uint64_t total_weight = 0;
@@ -668,12 +631,9 @@ absl::optional<XdsRouteConfigResource::Route::RouteAction> RouteActionParse(
       {
         ValidationErrors::ScopedField field(errors, ".typed_per_filter_config");
         cluster.typed_per_filter_config = ParseTypedPerFilterConfig<
-            envoy_config_route_v3_WeightedCluster_ClusterWeight,
-            envoy_config_route_v3_WeightedCluster_ClusterWeight_TypedPerFilterConfigEntry>(
+            envoy_config_route_v3_WeightedCluster_ClusterWeight>(
             context, cluster_proto,
             envoy_config_route_v3_WeightedCluster_ClusterWeight_typed_per_filter_config_next,
-            envoy_config_route_v3_WeightedCluster_ClusterWeight_TypedPerFilterConfigEntry_key,
-            envoy_config_route_v3_WeightedCluster_ClusterWeight_TypedPerFilterConfigEntry_value,
             errors);
       }
       // name
@@ -715,7 +675,7 @@ absl::optional<XdsRouteConfigResource::Route::RouteAction> RouteActionParse(
             route_action_proto));
     if (plugin_name.empty()) {
       errors->AddError("must be non-empty");
-      return absl::nullopt;
+      return std::nullopt;
     }
     auto it = cluster_specifier_plugin_map.find(plugin_name);
     if (it == cluster_specifier_plugin_map.end()) {
@@ -724,22 +684,22 @@ absl::optional<XdsRouteConfigResource::Route::RouteAction> RouteActionParse(
     } else {
       // If the cluster specifier config is empty, that means that the
       // plugin was unsupported but optional.  In that case, skip this route.
-      if (it->second.empty()) return absl::nullopt;
+      if (it->second.empty()) return std::nullopt;
     }
     route_action.action =
         XdsRouteConfigResource::Route::RouteAction::ClusterSpecifierPluginName{
             std::move(plugin_name)};
   } else {
     // Not a supported cluster specifier, so ignore this route.
-    return absl::nullopt;
+    return std::nullopt;
   }
   return route_action;
 }
 
-absl::optional<XdsRouteConfigResource::Route> ParseRoute(
+std::optional<XdsRouteConfigResource::Route> ParseRoute(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_route_v3_Route* route_proto,
-    const absl::optional<XdsRouteConfigResource::RetryPolicy>&
+    const std::optional<XdsRouteConfigResource::RetryPolicy>&
         virtual_host_retry_policy,
     const XdsRouteConfigResource::ClusterSpecifierPluginMap&
         cluster_specifier_plugin_map,
@@ -752,18 +712,18 @@ absl::optional<XdsRouteConfigResource::Route> ParseRoute(
     const auto* match = envoy_config_route_v3_Route_match(route_proto);
     if (match == nullptr) {
       errors->AddError("field not present");
-      return absl::nullopt;
+      return std::nullopt;
     }
     // Skip routes with query_parameters set.
     size_t query_parameters_size;
     static_cast<void>(envoy_config_route_v3_RouteMatch_query_parameters(
         match, &query_parameters_size));
-    if (query_parameters_size > 0) return absl::nullopt;
+    if (query_parameters_size > 0) return std::nullopt;
     // Parse matchers.
     auto path_matcher = RoutePathMatchParse(match, errors);
-    if (!path_matcher.has_value()) return absl::nullopt;
+    if (!path_matcher.has_value()) return std::nullopt;
     route.matchers.path_matcher = std::move(*path_matcher);
-    RouteHeaderMatchersParse(match, &route, errors);
+    RouteHeaderMatchersParse(context, match, &route, errors);
     RouteRuntimeFractionParse(match, &route, errors);
   }
   // Parse route action.
@@ -773,14 +733,14 @@ absl::optional<XdsRouteConfigResource::Route> ParseRoute(
     ValidationErrors::ScopedField field(errors, ".route");
     auto route_action = RouteActionParse(context, route_action_proto,
                                          cluster_specifier_plugin_map, errors);
-    if (!route_action.has_value()) return absl::nullopt;
+    if (!route_action.has_value()) return std::nullopt;
     // If the route does not have a retry policy but the vhost does,
     // use the vhost retry policy for this route.
     if (!route_action->retry_policy.has_value()) {
       route_action->retry_policy = virtual_host_retry_policy;
     }
     // Mark off plugins used in route action.
-    auto* cluster_specifier_action = absl::get_if<
+    auto* cluster_specifier_action = std::get_if<
         XdsRouteConfigResource::Route::RouteAction::ClusterSpecifierPluginName>(
         &route_action->action);
     if (cluster_specifier_action != nullptr) {
@@ -797,13 +757,10 @@ absl::optional<XdsRouteConfigResource::Route> ParseRoute(
   // Parse typed_per_filter_config.
   {
     ValidationErrors::ScopedField field(errors, ".typed_per_filter_config");
-    route.typed_per_filter_config = ParseTypedPerFilterConfig<
-        envoy_config_route_v3_Route,
-        envoy_config_route_v3_Route_TypedPerFilterConfigEntry>(
-        context, route_proto,
-        envoy_config_route_v3_Route_typed_per_filter_config_next,
-        envoy_config_route_v3_Route_TypedPerFilterConfigEntry_key,
-        envoy_config_route_v3_Route_TypedPerFilterConfigEntry_value, errors);
+    route.typed_per_filter_config =
+        ParseTypedPerFilterConfig<envoy_config_route_v3_Route>(
+            context, route_proto,
+            envoy_config_route_v3_Route_typed_per_filter_config_next, errors);
   }
   return route;
 }
@@ -823,8 +780,8 @@ std::shared_ptr<const XdsRouteConfigResource> XdsRouteConfigResourceParse(
   // Build a set of configured cluster_specifier_plugin names to make sure
   // each is actually referenced by a route action.
   std::set<absl::string_view> cluster_specifier_plugins_not_seen;
-  for (auto& plugin : rds_update->cluster_specifier_plugin_map) {
-    cluster_specifier_plugins_not_seen.emplace(plugin.first);
+  for (auto& [name, _] : rds_update->cluster_specifier_plugin_map) {
+    cluster_specifier_plugins_not_seen.emplace(name);
   }
   // Get the virtual hosts.
   size_t num_virtual_hosts;
@@ -858,24 +815,20 @@ std::shared_ptr<const XdsRouteConfigResource> XdsRouteConfigResourceParse(
     // Parse typed_per_filter_config.
     {
       ValidationErrors::ScopedField field(errors, ".typed_per_filter_config");
-      vhost.typed_per_filter_config = ParseTypedPerFilterConfig<
-          envoy_config_route_v3_VirtualHost,
-          envoy_config_route_v3_VirtualHost_TypedPerFilterConfigEntry>(
-          context, virtual_hosts[i],
-          envoy_config_route_v3_VirtualHost_typed_per_filter_config_next,
-          envoy_config_route_v3_VirtualHost_TypedPerFilterConfigEntry_key,
-          envoy_config_route_v3_VirtualHost_TypedPerFilterConfigEntry_value,
-          errors);
+      vhost.typed_per_filter_config =
+          ParseTypedPerFilterConfig<envoy_config_route_v3_VirtualHost>(
+              context, virtual_hosts[i],
+              envoy_config_route_v3_VirtualHost_typed_per_filter_config_next,
+              errors);
     }
     // Parse retry policy.
-    absl::optional<XdsRouteConfigResource::RetryPolicy>
+    std::optional<XdsRouteConfigResource::RetryPolicy>
         virtual_host_retry_policy;
     const envoy_config_route_v3_RetryPolicy* retry_policy =
         envoy_config_route_v3_VirtualHost_retry_policy(virtual_hosts[i]);
     if (retry_policy != nullptr) {
       ValidationErrors::ScopedField field(errors, ".retry_policy");
-      virtual_host_retry_policy =
-          RetryPolicyParse(context, retry_policy, errors);
+      virtual_host_retry_policy = RetryPolicyParse(retry_policy, errors);
     }
     // Parse routes.
     ValidationErrors::ScopedField field2(errors, ".routes");
@@ -907,7 +860,7 @@ namespace {
 void MaybeLogRouteConfiguration(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_route_v3_RouteConfiguration* route_config) {
-  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_route_v3_RouteConfiguration_getmsgdef(context.symtab);
     char buf[10240];
@@ -942,14 +895,14 @@ XdsResourceType::DecodeResult XdsRouteConfigResourceType::Decode(
     absl::Status status =
         errors.status(absl::StatusCode::kInvalidArgument,
                       "errors validating RouteConfiguration resource");
-    if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer)) {
+    if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
       LOG(ERROR) << "[xds_client " << context.client
                  << "] invalid RouteConfiguration " << *result.name << ": "
                  << status;
     }
     result.resource = std::move(status);
   } else {
-    if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer)) {
+    if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
       LOG(INFO) << "[xds_client " << context.client
                 << "] parsed RouteConfiguration " << *result.name << ": "
                 << rds_update->ToString();

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

@@ -17,22 +17,22 @@
 #ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_ROUTE_CONFIG_PARSER_H
 #define GRPC_SRC_CORE_XDS_GRPC_XDS_ROUTE_CONFIG_PARSER_H
 
-#include <grpc/support/port_platform.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
+#include <variant>
 #include <vector>
 
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "envoy/config/route/v3/route.upb.h"
 #include "envoy/config/route/v3/route.upbdefs.h"
 #include "re2/re2.h"
-#include "src/core/lib/channel/status_util.h"
+#include "src/core/call/status_util.h"
+#include "src/core/util/down_cast.h"
 #include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"
 #include "src/core/xds/grpc/xds_bootstrap_grpc.h"
@@ -66,7 +66,7 @@ class XdsRouteConfigResourceType final
                      upb_DefPool* symtab) const override {
     envoy_config_route_v3_RouteConfiguration_getmsgdef(symtab);
     const auto& cluster_specifier_plugin_registry =
-        static_cast<const GrpcXdsBootstrap&>(xds_client->bootstrap())
+        DownCast<const GrpcXdsBootstrap&>(xds_client->bootstrap())
             .cluster_specifier_plugin_registry();
     cluster_specifier_plugin_registry.PopulateSymtab(symtab);
   }

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

@@ -26,12 +26,12 @@
 #include <cctype>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/matchers.h"
 #include "src/core/xds/grpc/xds_http_filter.h"
 
@@ -92,7 +92,7 @@ MatchType DomainPatternMatchType(absl::string_view domain_pattern) {
 
 }  // namespace
 
-absl::optional<size_t> XdsRouting::FindVirtualHostForDomain(
+std::optional<size_t> XdsRouting::FindVirtualHostForDomain(
     const VirtualHostListIterator& vhost_iterator, absl::string_view domain) {
   // Find the best matched virtual host.
   // The search order for 4 groups of domain patterns:
@@ -103,7 +103,7 @@ absl::optional<size_t> XdsRouting::FindVirtualHostForDomain(
   // Within each group, longest match wins.
   // If the same best matched domain pattern appears in multiple virtual
   // hosts, the first matched virtual host wins.
-  absl::optional<size_t> target_index;
+  std::optional<size_t> target_index;
   MatchType best_match_type = INVALID_MATCH;
   size_t longest_match = 0;
   // Check each domain pattern in each virtual host to determine the best
@@ -115,7 +115,7 @@ absl::optional<size_t> XdsRouting::FindVirtualHostForDomain(
       // than current match.
       const MatchType match_type = DomainPatternMatchType(domain_pattern);
       // This should be caught by RouteConfigParse().
-      CHECK(match_type != INVALID_MATCH);
+      GRPC_CHECK(match_type != INVALID_MATCH);
       if (match_type > best_match_type) continue;
       if (match_type == best_match_type &&
           domain_pattern.size() <= longest_match) {
@@ -156,7 +156,7 @@ bool UnderFraction(const uint32_t fraction_per_million) {
 
 }  // namespace
 
-absl::optional<size_t> XdsRouting::GetRouteForRequest(
+std::optional<size_t> XdsRouting::GetRouteForRequest(
     const RouteListIterator& route_list_iterator, absl::string_view path,
     grpc_metadata_batch* initial_metadata) {
   for (size_t i = 0; i < route_list_iterator.Size(); ++i) {
@@ -169,21 +169,21 @@ absl::optional<size_t> XdsRouting::GetRouteForRequest(
       return i;
     }
   }
-  return absl::nullopt;
+  return std::nullopt;
 }
 
 bool XdsRouting::IsValidDomainPattern(absl::string_view domain_pattern) {
   return DomainPatternMatchType(domain_pattern) != INVALID_MATCH;
 }
 
-absl::optional<absl::string_view> XdsRouting::GetHeaderValue(
+std::optional<absl::string_view> XdsRouting::GetHeaderValue(
     grpc_metadata_batch* initial_metadata, absl::string_view header_name,
     std::string* concatenated_value) {
   // Note: If we ever allow binary headers here, we still need to
   // special-case ignore "grpc-tags-bin" and "grpc-trace-bin", since
   // they are not visible to the LB policy in grpc-go.
   if (absl::EndsWith(header_name, "-bin")) {
-    return absl::nullopt;
+    return std::nullopt;
   } else if (header_name == "content-type") {
     return "application/grpc";
   }
@@ -231,7 +231,7 @@ GeneratePerHTTPFilterConfigs(
     const XdsHttpFilterImpl* filter_impl =
         http_filter_registry.GetFilterForType(
             http_filter.config.config_proto_type_name);
-    CHECK_NE(filter_impl, nullptr);
+    GRPC_CHECK_NE(filter_impl, nullptr);
     // If there is not actually any C-core filter associated with this
     // xDS filter, then it won't need any config, so skip it.
     if (filter_impl->channel_filter() == nullptr) continue;