grpc 1.69.0 → 1.71.0

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

@@ -22,11 +22,11 @@
 #include <algorithm>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
+#include <variant>
 #include <vector>
 
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "re2/re2.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/util/matchers.h"
@@ -73,7 +73,7 @@ struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
     struct Matchers {
       StringMatcher path_matcher;
       std::vector<HeaderMatcher> header_matchers;
-      absl::optional<uint32_t> fraction_per_million;
+      std::optional<uint32_t> fraction_per_million;
 
       bool operator==(const Matchers& other) const {
         return path_matcher == other.path_matcher &&
@@ -114,7 +114,7 @@ struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
           bool operator==(const ChannelId&) const { return true; }
         };
 
-        absl::variant<Header, ChannelId> policy;
+        std::variant<Header, ChannelId> policy;
         bool terminal = false;
 
         bool operator==(const HashPolicy& other) const {
@@ -153,18 +153,18 @@ struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
       };
 
       std::vector<HashPolicy> hash_policies;
-      absl::optional<RetryPolicy> retry_policy;
+      std::optional<RetryPolicy> retry_policy;
 
       // Action for this route.
-      absl::variant<ClusterName, std::vector<ClusterWeight>,
-                    ClusterSpecifierPluginName>
+      std::variant<ClusterName, std::vector<ClusterWeight>,
+                   ClusterSpecifierPluginName>
           action;
 
       // Storing the timeout duration from route action:
       // RouteAction.max_stream_duration.grpc_timeout_header_max or
       // RouteAction.max_stream_duration.max_stream_duration if the former is
       // not set.
-      absl::optional<Duration> max_stream_duration;
+      std::optional<Duration> max_stream_duration;
 
       bool auto_host_rewrite = false;
 
@@ -183,7 +183,7 @@ struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
       }
     };
 
-    absl::variant<UnknownAction, RouteAction, NonForwardingAction> action;
+    std::variant<UnknownAction, RouteAction, NonForwardingAction> action;
     TypedPerFilterConfig typed_per_filter_config;
 
     bool operator==(const Route& other) const {

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

@@ -17,16 +17,17 @@
 #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"
@@ -38,8 +39,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"
@@ -57,6 +56,7 @@
 #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/json/json.h"
 #include "src/core/util/json/json_writer.h"
@@ -110,7 +110,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 +181,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 +195,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,17 +212,17 @@ 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)) {
@@ -234,14 +234,14 @@ absl::optional<StringMatcher> RoutePathMatchParse(
         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);
 }
@@ -386,69 +386,71 @@ 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*),
-    ValidationErrors* errors) {
+    const upb_Map* (*upb_map_func)(ParentType*), 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));
-    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;
-    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);
-      if (serialized_config == nullptr) {
-        errors->AddError("could not parse FilterConfig");
-        continue;
+  // TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto
+  // v30.0.
+  const upb_Map* parent_upb_map = upb_map_func((ParentType*)parent);
+  if (parent_upb_map) {
+    size_t filter_it = kUpb_Map_Begin;
+    upb_MessageValue k, v;
+    while (upb_Map_Next(parent_upb_map, &k, &v, &filter_it)) {
+      upb_StringView key_view = k.str_val;
+      const google_protobuf_Any* any = (google_protobuf_Any*)v.msg_val;
+      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");
+      auto extension = ExtractXdsExtension(context, any, errors);
+      if (!extension.has_value()) continue;
+      auto* extension_to_use = &*extension;
+      std::optional<XdsExtension> nested_extension;
+      bool is_optional = false;
+      if (extension->type == "envoy.config.route.v3.FilterConfig") {
+        absl::string_view* serialized_config =
+            std::get_if<absl::string_view>(&extension->value);
+        if (serialized_config == nullptr) {
+          errors->AddError("could not parse FilterConfig");
+          continue;
+        }
+        const auto* filter_config = envoy_config_route_v3_FilterConfig_parse(
+            serialized_config->data(), serialized_config->size(),
+            context.arena);
+        if (filter_config == nullptr) {
+          errors->AddError("could not parse FilterConfig");
+          continue;
+        }
+        is_optional =
+            envoy_config_route_v3_FilterConfig_is_optional(filter_config);
+        any = envoy_config_route_v3_FilterConfig_config(filter_config);
+        extension->validation_fields.emplace_back(errors, ".config");
+        nested_extension = ExtractXdsExtension(context, any, errors);
+        if (!nested_extension.has_value()) continue;
+        extension_to_use = &*nested_extension;
       }
-      const auto* filter_config = envoy_config_route_v3_FilterConfig_parse(
-          serialized_config->data(), serialized_config->size(), context.arena);
-      if (filter_config == nullptr) {
-        errors->AddError("could not parse FilterConfig");
+      const auto& http_filter_registry =
+          DownCast<const GrpcXdsBootstrap&>(context.client->bootstrap())
+              .http_filter_registry();
+      const XdsHttpFilterImpl* filter_impl =
+          http_filter_registry.GetFilterForType(extension_to_use->type);
+      if (filter_impl == nullptr) {
+        if (!is_optional) errors->AddError("unsupported filter type");
         continue;
       }
-      is_optional =
-          envoy_config_route_v3_FilterConfig_is_optional(filter_config);
-      any = envoy_config_route_v3_FilterConfig_config(filter_config);
-      extension->validation_fields.emplace_back(errors, ".config");
-      nested_extension = ExtractXdsExtension(context, any, errors);
-      if (!nested_extension.has_value()) continue;
-      extension_to_use = &*nested_extension;
-    }
-    const auto& http_filter_registry =
-        static_cast<const GrpcXdsBootstrap&>(context.client->bootstrap())
-            .http_filter_registry();
-    const XdsHttpFilterImpl* filter_impl =
-        http_filter_registry.GetFilterForType(extension_to_use->type);
-    if (filter_impl == nullptr) {
-      if (!is_optional) errors->AddError("unsupported filter type");
-      continue;
-    }
-    absl::optional<XdsHttpFilterImpl::FilterConfig> filter_config =
-        filter_impl->GenerateFilterConfigOverride(
-            key, context, std::move(*extension_to_use), errors);
-    if (filter_config.has_value()) {
-      typed_per_filter_config[std::string(key)] = std::move(*filter_config);
+      std::optional<XdsHttpFilterImpl::FilterConfig> filter_config =
+          filter_impl->GenerateFilterConfigOverride(
+              key, context, std::move(*extension_to_use), errors);
+      if (filter_config.has_value()) {
+        typed_per_filter_config[std::string(key)] = std::move(*filter_config);
+      }
     }
   }
   return typed_per_filter_config;
 }
 
 XdsRouteConfigResource::RetryPolicy RetryPolicyParse(
-    const XdsResourceType::DecodeContext& context,
     const envoy_config_route_v3_RetryPolicy* retry_policy_proto,
     ValidationErrors* errors) {
   XdsRouteConfigResource::RetryPolicy retry_policy;
@@ -467,7 +469,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 +517,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 +530,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,7 +625,7 @@ 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() &&
@@ -667,13 +668,12 @@ absl::optional<XdsRouteConfigResource::Route::RouteAction> RouteActionParse(
       // typed_per_filter_config
       {
         ValidationErrors::ScopedField field(errors, ".typed_per_filter_config");
+        // TODO(b/397931390): Clean up the code after gRPC OSS migrates to
+        // proto v30.0.
         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,
+            _envoy_config_route_v3_WeightedCluster_ClusterWeight_typed_per_filter_config_upb_map,
             errors);
       }
       // name
@@ -715,7 +715,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 +724,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,16 +752,16 @@ 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);
     RouteRuntimeFractionParse(match, &route, errors);
@@ -773,14 +773,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 +797,13 @@ 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);
+    // TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto
+    // v30.0.
+    route.typed_per_filter_config =
+        ParseTypedPerFilterConfig<envoy_config_route_v3_Route>(
+            context, route_proto,
+            _envoy_config_route_v3_Route_typed_per_filter_config_upb_map,
+            errors);
   }
   return route;
 }
@@ -823,8 +823,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 +858,22 @@ std::shared_ptr<const XdsRouteConfigResource> XdsRouteConfigResourceParse(
     // Parse typed_per_filter_config.
     {
       ValidationErrors::ScopedField field(errors, ".typed_per_filter_config");
+      // TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto
+      // v30.0.
       vhost.typed_per_filter_config = ParseTypedPerFilterConfig<
-          envoy_config_route_v3_VirtualHost,
-          envoy_config_route_v3_VirtualHost_TypedPerFilterConfigEntry>(
+          envoy_config_route_v3_VirtualHost>(
           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,
+          _envoy_config_route_v3_VirtualHost_typed_per_filter_config_upb_map,
           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 +905,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 +940,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/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

@@ -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
@@ -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";
   }

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

@@ -23,12 +23,12 @@
 #include <stddef.h>
 
 #include <map>
+#include <optional>
 #include <string>
 #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/transport/metadata_batch.h"
 #include "src/core/xds/grpc/xds_http_filter_registry.h"
@@ -60,12 +60,12 @@ class XdsRouting final {
   };
 
   // Returns the index of the selected virtual host in the list.
-  static absl::optional<size_t> FindVirtualHostForDomain(
+  static std::optional<size_t> FindVirtualHostForDomain(
       const VirtualHostListIterator& vhost_iterator, absl::string_view domain);
 
   // Returns the index in route_list_iterator to use for a request with
   // the specified path and metadata, or nullopt if no route matches.
-  static absl::optional<size_t> GetRouteForRequest(
+  static std::optional<size_t> GetRouteForRequest(
       const RouteListIterator& route_list_iterator, absl::string_view path,
       grpc_metadata_batch* initial_metadata);
 
@@ -74,9 +74,9 @@ class XdsRouting final {
   static bool IsValidDomainPattern(absl::string_view domain_pattern);
 
   // Returns the metadata value(s) for the specified key.
-  // As special cases, binary headers return a value of absl::nullopt, and
+  // As special cases, binary headers return a value of std::nullopt, and
   // "content-type" header returns "application/grpc".
-  static absl::optional<absl::string_view> GetHeaderValue(
+  static std::optional<absl::string_view> GetHeaderValue(
       grpc_metadata_batch* initial_metadata, absl::string_view header_name,
       std::string* concatenated_value);