grpc 1.70.1 → 1.72.0

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

@@ -16,7 +16,6 @@
 
 #include "src/core/xds/grpc/xds_listener_parser.h"
 
-#include <grpc/support/port_platform.h>
 #include <stdint.h>
 
 #include <set>
@@ -48,6 +47,7 @@
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/util/down_cast.h"
 #include "src/core/util/host_port.h"
 #include "src/core/util/match.h"
 #include "src/core/util/upb_utils.h"
@@ -135,7 +135,7 @@ void MaybeLogHttpConnectionManager(
     const XdsResourceType::DecodeContext& context,
     const envoy_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager*
         http_connection_manager_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_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager_getmsgdef(
             context.symtab);
@@ -158,7 +158,7 @@ XdsListenerResource::HttpConnectionManager HttpConnectionManagerParse(
     return {};
   }
   auto* serialized_hcm_config =
-      absl::get_if<absl::string_view>(&extension.value);
+      std::get_if<absl::string_view>(&extension.value);
   if (serialized_hcm_config == nullptr) {
     errors->AddError("could not parse HttpConnectionManager config");
     return {};
@@ -211,7 +211,7 @@ XdsListenerResource::HttpConnectionManager HttpConnectionManagerParse(
   {
     ValidationErrors::ScopedField field(errors, ".http_filters");
     const auto& http_filter_registry =
-        static_cast<const GrpcXdsBootstrap&>(context.client->bootstrap())
+        DownCast<const GrpcXdsBootstrap&>(context.client->bootstrap())
             .http_filter_registry();
     size_t num_filters = 0;
     const auto* http_filters =
@@ -264,7 +264,7 @@ XdsListenerResource::HttpConnectionManager HttpConnectionManagerParse(
           }
           continue;
         }
-        absl::optional<XdsHttpFilterImpl::FilterConfig> filter_config =
+        std::optional<XdsHttpFilterImpl::FilterConfig> filter_config =
             filter_impl->GenerateFilterConfig(name, context,
                                               std::move(*extension), errors);
         if (filter_config.has_value()) {
@@ -379,7 +379,7 @@ XdsListenerResource::DownstreamTlsContext DownstreamTlsContextParse(
     return {};
   }
   absl::string_view* serialized_downstream_tls_context =
-      absl::get_if<absl::string_view>(&extension->value);
+      std::get_if<absl::string_view>(&extension->value);
   if (serialized_downstream_tls_context == nullptr) {
     errors->AddError("can't decode DownstreamTlsContext");
     return {};
@@ -404,7 +404,7 @@ XdsListenerResource::DownstreamTlsContext DownstreamTlsContextParse(
     // errors, because we don't know which fields they were found in
     // inside of CommonTlsContext, so we make the error message a bit
     // more verbose to compensate.
-    if (absl::holds_alternative<
+    if (std::holds_alternative<
             CommonTlsContext::CertificateValidationContext::SystemRootCerts>(
             downstream_tls_context.common_tls_context
                 .certificate_validation_context.ca_certs)) {
@@ -433,7 +433,7 @@ XdsListenerResource::DownstreamTlsContext DownstreamTlsContextParse(
         google_protobuf_BoolValue_value(require_client_certificate);
     if (downstream_tls_context.require_client_certificate) {
       auto* ca_cert_provider =
-          absl::get_if<CommonTlsContext::CertificateProviderPluginInstance>(
+          std::get_if<CommonTlsContext::CertificateProviderPluginInstance>(
               &downstream_tls_context.common_tls_context
                    .certificate_validation_context.ca_certs);
       if (ca_cert_provider == nullptr ||
@@ -461,7 +461,7 @@ XdsListenerResource::DownstreamTlsContext DownstreamTlsContextParse(
   return downstream_tls_context;
 }
 
-absl::optional<XdsListenerResource::FilterChainMap::CidrRange> CidrRangeParse(
+std::optional<XdsListenerResource::FilterChainMap::CidrRange> CidrRangeParse(
     const envoy_config_core_v3_CidrRange* cidr_range_proto,
     ValidationErrors* errors) {
   ValidationErrors::ScopedField field(errors, ".address_prefix");
@@ -471,7 +471,7 @@ absl::optional<XdsListenerResource::FilterChainMap::CidrRange> CidrRangeParse(
   auto address = StringToSockaddr(address_prefix, /*port=*/0);
   if (!address.ok()) {
     errors->AddError(address.status().message());
-    return absl::nullopt;
+    return std::nullopt;
   }
   cidr_range.address = *address;
   cidr_range.prefix_len = 0;
@@ -490,7 +490,7 @@ absl::optional<XdsListenerResource::FilterChainMap::CidrRange> CidrRangeParse(
   return cidr_range;
 }
 
-absl::optional<FilterChain::FilterChainMatch> FilterChainMatchParse(
+std::optional<FilterChain::FilterChainMatch> FilterChainMatchParse(
     const envoy_config_listener_v3_FilterChainMatch* filter_chain_match_proto,
     ValidationErrors* errors) {
   FilterChain::FilterChainMatch filter_chain_match;
@@ -560,11 +560,11 @@ absl::optional<FilterChain::FilterChainMatch> FilterChainMatchParse(
         UpbStringToStdString(application_protocols[i]));
   }
   // Return result.
-  if (errors->size() != original_error_size) return absl::nullopt;
+  if (errors->size() != original_error_size) return std::nullopt;
   return filter_chain_match;
 }
 
-absl::optional<FilterChain> FilterChainParse(
+std::optional<FilterChain> FilterChainParse(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_listener_v3_FilterChain* filter_chain_proto,
     ValidationErrors* errors) {
@@ -617,23 +617,23 @@ absl::optional<FilterChain> FilterChainParse(
         DownstreamTlsContextParse(context, transport_socket, errors);
   }
   // Return result.
-  if (errors->size() != original_error_size) return absl::nullopt;
+  if (errors->size() != original_error_size) return std::nullopt;
   return filter_chain;
 }
 
-absl::optional<std::string> AddressParse(
+std::optional<std::string> AddressParse(
     const envoy_config_core_v3_Address* address_proto,
     ValidationErrors* errors) {
   if (address_proto == nullptr) {
     errors->AddError("field not present");
-    return absl::nullopt;
+    return std::nullopt;
   }
   ValidationErrors::ScopedField field(errors, ".socket_address");
   const auto* socket_address =
       envoy_config_core_v3_Address_socket_address(address_proto);
   if (socket_address == nullptr) {
     errors->AddError("field not present");
-    return absl::nullopt;
+    return std::nullopt;
   }
   {
     ValidationErrors::ScopedField field(errors, ".protocol");
@@ -646,7 +646,7 @@ absl::optional<std::string> AddressParse(
   uint32_t port = envoy_config_core_v3_SocketAddress_port_value(socket_address);
   if (port > 65535) {
     errors->AddError("invalid port");
-    return absl::nullopt;
+    return std::nullopt;
   }
   return JoinHostPort(
       UpbStringToAbsl(
@@ -662,7 +662,7 @@ struct InternalFilterChainMap {
       std::map<std::string, XdsListenerResource::FilterChainMap::SourceIp>;
   using ConnectionSourceTypesArray = std::array<SourceIpMap, 3>;
   struct DestinationIp {
-    absl::optional<XdsListenerResource::FilterChainMap::CidrRange> prefix_range;
+    std::optional<XdsListenerResource::FilterChainMap::CidrRange> prefix_range;
     bool transport_protocol_raw_buffer_provided = false;
     ConnectionSourceTypesArray source_types_array;
   };
@@ -674,10 +674,14 @@ void AddFilterChainDataForSourcePort(
     const FilterChain& filter_chain, uint32_t port,
     XdsListenerResource::FilterChainMap::SourcePortsMap* ports_map,
     ValidationErrors* errors) {
-  auto insert_result = ports_map->emplace(
-      port, XdsListenerResource::FilterChainMap::FilterChainDataSharedPtr{
-                filter_chain.filter_chain_data});
-  if (!insert_result.second) {
+  auto inserted =
+      ports_map
+          ->emplace(
+              port,
+              XdsListenerResource::FilterChainMap::FilterChainDataSharedPtr{
+                  filter_chain.filter_chain_data})
+          .second;
+  if (!inserted) {
     errors->AddError(absl::StrCat(
         "duplicate matching rules detected when adding filter chain: ",
         filter_chain.filter_chain_match.ToString()));
@@ -702,10 +706,12 @@ void AddFilterChainDataForSourceIpRange(
     InternalFilterChainMap::SourceIpMap* source_ip_map,
     ValidationErrors* errors) {
   if (filter_chain.filter_chain_match.source_prefix_ranges.empty()) {
-    auto insert_result = source_ip_map->emplace(
-        "", XdsListenerResource::FilterChainMap::SourceIp());
-    AddFilterChainDataForSourcePorts(
-        filter_chain, &insert_result.first->second.ports_map, errors);
+    auto it = source_ip_map
+                  ->emplace("", XdsListenerResource::FilterChainMap::SourceIp())
+                  .first;
+    auto& [_, source_ip] = *it;
+    AddFilterChainDataForSourcePorts(filter_chain, &source_ip.ports_map,
+                                     errors);
   } else {
     for (const auto& prefix_range :
          filter_chain.filter_chain_match.source_prefix_ranges) {
@@ -716,14 +722,15 @@ void AddFilterChainDataForSourceIpRange(
             addr_str.status().message()));
         continue;
       }
-      auto insert_result = source_ip_map->emplace(
+      auto [it, inserted] = source_ip_map->emplace(
           absl::StrCat(*addr_str, "/", prefix_range.prefix_len),
           XdsListenerResource::FilterChainMap::SourceIp());
-      if (insert_result.second) {
-        insert_result.first->second.prefix_range.emplace(prefix_range);
+      auto& [_, source_ip] = *it;
+      if (inserted) {
+        source_ip.prefix_range.emplace(prefix_range);
       }
-      AddFilterChainDataForSourcePorts(
-          filter_chain, &insert_result.first->second.ports_map, errors);
+      AddFilterChainDataForSourcePorts(filter_chain, &source_ip.ports_map,
+                                       errors);
     }
   }
 }
@@ -796,10 +803,11 @@ void AddFilterChainDataForDestinationIpRange(
     InternalFilterChainMap::DestinationIpMap* destination_ip_map,
     ValidationErrors* errors) {
   if (filter_chain.filter_chain_match.prefix_ranges.empty()) {
-    auto insert_result = destination_ip_map->emplace(
-        "", InternalFilterChainMap::DestinationIp());
-    AddFilterChainDataForServerNames(filter_chain, &insert_result.first->second,
-                                     errors);
+    auto it =
+        destination_ip_map->emplace("", InternalFilterChainMap::DestinationIp())
+            .first;
+    auto& [_, destination_ip] = *it;
+    AddFilterChainDataForServerNames(filter_chain, &destination_ip, errors);
   } else {
     for (const auto& prefix_range :
          filter_chain.filter_chain_match.prefix_ranges) {
@@ -810,14 +818,14 @@ void AddFilterChainDataForDestinationIpRange(
             addr_str.status().message()));
         continue;
       }
-      auto insert_result = destination_ip_map->emplace(
+      auto [it, inserted] = destination_ip_map->emplace(
           absl::StrCat(*addr_str, "/", prefix_range.prefix_len),
           InternalFilterChainMap::DestinationIp());
-      if (insert_result.second) {
-        insert_result.first->second.prefix_range.emplace(prefix_range);
+      auto& [_, destination_ip] = *it;
+      if (inserted) {
+        destination_ip.prefix_range.emplace(prefix_range);
       }
-      AddFilterChainDataForServerNames(filter_chain,
-                                       &insert_result.first->second, errors);
+      AddFilterChainDataForServerNames(filter_chain, &destination_ip, errors);
     }
   }
 }
@@ -825,15 +833,14 @@ void AddFilterChainDataForDestinationIpRange(
 XdsListenerResource::FilterChainMap BuildFromInternalFilterChainMap(
     InternalFilterChainMap* internal_filter_chain_map) {
   XdsListenerResource::FilterChainMap filter_chain_map;
-  for (auto& destination_ip_pair :
+  for (auto& [_, internal_destination_ip] :
        internal_filter_chain_map->destination_ip_map) {
     XdsListenerResource::FilterChainMap::DestinationIp destination_ip;
-    destination_ip.prefix_range = destination_ip_pair.second.prefix_range;
-    for (int i = 0; i < 3; i++) {
-      auto& source_ip_map = destination_ip_pair.second.source_types_array[i];
-      for (auto& source_ip_pair : source_ip_map) {
-        destination_ip.source_types_array[i].push_back(
-            std::move(source_ip_pair.second));
+    destination_ip.prefix_range = internal_destination_ip.prefix_range;
+    for (int i = 0; i < 3; ++i) {
+      auto& source_ip_map = internal_destination_ip.source_types_array[i];
+      for (auto& [_, source_ip] : source_ip_map) {
+        destination_ip.source_types_array[i].push_back(std::move(source_ip));
       }
     }
     filter_chain_map.destination_ip_vector.push_back(std::move(destination_ip));
@@ -945,7 +952,7 @@ absl::StatusOr<std::shared_ptr<const XdsListenerResource>> LdsResourceParse(
 
 void MaybeLogListener(const XdsResourceType::DecodeContext& context,
                       const envoy_config_listener_v3_Listener* listener) {
-  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_listener_v3_Listener_getmsgdef(context.symtab);
     char buf[10240];
@@ -975,13 +982,13 @@ XdsResourceType::DecodeResult XdsListenerResourceType::Decode(
       UpbStringToStdString(envoy_config_listener_v3_Listener_name(resource));
   auto listener = LdsResourceParse(context, resource);
   if (!listener.ok()) {
-    if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer)) {
+    if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
       LOG(ERROR) << "[xds_client " << context.client << "] invalid Listener "
                  << *result.name << ": " << listener.status();
     }
     result.resource = listener.status();
   } else {
-    if (GRPC_TRACE_FLAG_ENABLED_OBJ(*context.tracer)) {
+    if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
       LOG(INFO) << "[xds_client " << context.client << "] parsed Listener "
                 << *result.name << ": " << (*listener)->ToString();
     }

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

@@ -20,6 +20,7 @@
 #include "absl/strings/string_view.h"
 #include "envoy/config/listener/v3/listener.upbdefs.h"
 #include "envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upbdefs.h"
+#include "src/core/util/down_cast.h"
 #include "src/core/xds/grpc/xds_bootstrap_grpc.h"
 #include "src/core/xds/grpc/xds_http_filter_registry.h"
 #include "src/core/xds/grpc/xds_listener.h"
@@ -48,7 +49,7 @@ class XdsListenerResourceType final
     envoy_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager_getmsgdef(
         symtab);
     const auto& http_filter_registry =
-        static_cast<const GrpcXdsBootstrap&>(xds_client->bootstrap())
+        DownCast<const GrpcXdsBootstrap&>(xds_client->bootstrap())
             .http_filter_registry();
     http_filter_registry.PopulateSymtab(symtab);
   }

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

@@ -42,18 +42,18 @@ const XdsMetadataValue* XdsMetadataMap::Find(absl::string_view key) const {
 
 bool XdsMetadataMap::operator==(const XdsMetadataMap& other) const {
   if (map_.size() != other.map_.size()) return false;
-  for (const auto& p : map_) {
-    auto it = other.map_.find(p.first);
+  for (const auto& [key, value] : map_) {
+    auto it = other.map_.find(key);
     if (it == other.map_.end()) return false;
-    if (*p.second != *it->second) return false;
+    if (*value != *it->second) return false;
   }
   return true;
 }
 
 std::string XdsMetadataMap::ToString() const {
   std::vector<std::string> entries;
-  for (const auto& p : map_) {
-    entries.push_back(absl::StrCat(p.first, "=", p.second->ToString()));
+  for (const auto& [key, value] : map_) {
+    entries.push_back(absl::StrCat(key, "=", value->ToString()));
   }
   std::sort(entries.begin(), entries.end());
   return absl::StrCat("{", absl::StrJoin(entries, ", "), "}");

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

@@ -17,10 +17,10 @@
 
 #include <memory>
 #include <utility>
+#include <variant>
 
 #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/core/v3/address.upbdefs.h"
 #include "envoy/extensions/filters/http/gcp_authn/v3/gcp_authn.upb.h"
@@ -34,6 +34,9 @@
 #include "src/core/xds/grpc/xds_common_types.h"
 #include "src/core/xds/grpc/xds_common_types_parser.h"
 #include "upb/base/string_view.h"
+#include "upb/message/array.h"
+#include "upb/message/map.h"
+#include "upb/message/message.h"
 #include "upb/text/encode.h"
 
 namespace grpc_core {
@@ -53,7 +56,7 @@ std::unique_ptr<XdsMetadataValue> ParseGcpAuthnAudience(
     const XdsResourceType::DecodeContext& context, XdsExtension extension,
     ValidationErrors* errors) {
   absl::string_view* serialized_proto =
-      absl::get_if<absl::string_view>(&extension.value);
+      std::get_if<absl::string_view>(&extension.value);
   if (serialized_proto == nullptr) {
     errors->AddError("could not parse audience metadata");
     return nullptr;
@@ -64,7 +67,7 @@ std::unique_ptr<XdsMetadataValue> ParseGcpAuthnAudience(
     errors->AddError("could not parse audience metadata");
     return nullptr;
   }
-  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_extensions_filters_http_gcp_authn_v3_Audience_getmsgdef(
             context.symtab);
@@ -88,7 +91,7 @@ std::unique_ptr<XdsMetadataValue> ParseAddress(
     const XdsResourceType::DecodeContext& context, XdsExtension extension,
     ValidationErrors* errors) {
   absl::string_view* serialized_proto =
-      absl::get_if<absl::string_view>(&extension.value);
+      std::get_if<absl::string_view>(&extension.value);
   if (serialized_proto == nullptr) {
     errors->AddError("could not parse address metadata");
     return nullptr;
@@ -99,7 +102,7 @@ std::unique_ptr<XdsMetadataValue> ParseAddress(
     errors->AddError("could not parse address metadata");
     return nullptr;
   }
-  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_core_v3_Address_getmsgdef(context.symtab);
     char buf[10240];
@@ -126,56 +129,66 @@ XdsMetadataMap ParseXdsMetadataMap(
   XdsMetadataMap metadata_map;
   if (metadata == nullptr) return metadata_map;  // Not present == empty.
   // First, try typed_filter_metadata.
-  size_t iter = kUpb_Map_Begin;
-  const envoy_config_core_v3_Metadata_TypedFilterMetadataEntry* typed_entry;
-  while (
-      (typed_entry = envoy_config_core_v3_Metadata_typed_filter_metadata_next(
-           metadata, &iter)) != nullptr) {
-    absl::string_view key = UpbStringToAbsl(
-        envoy_config_core_v3_Metadata_TypedFilterMetadataEntry_key(
-            typed_entry));
-    ValidationErrors::ScopedField field(
-        errors, absl::StrCat(".typed_filter_metadata[", key, "]"));
-    auto extension = ExtractXdsExtension(
-        context,
-        envoy_config_core_v3_Metadata_TypedFilterMetadataEntry_value(
-            typed_entry),
-        errors);
-    if (!extension.has_value()) continue;
-    // TODO(roth): If we start to need a lot of types here, refactor
-    // this into a separate registry.
-    std::unique_ptr<XdsMetadataValue> metadata_value;
-    if (XdsGcpAuthFilterEnabled() &&
-        extension->type == XdsGcpAuthnAudienceMetadataValue::Type()) {
-      metadata_value =
-          ParseGcpAuthnAudience(context, std::move(*extension), errors);
-    } else if (XdsHttpConnectEnabled() &&
-               extension->type == XdsAddressMetadataValue::Type()) {
-      metadata_value = ParseAddress(context, std::move(*extension), errors);
-    }
-    if (metadata_value != nullptr) {
-      metadata_map.Insert(key, std::move(metadata_value));
+  // TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto
+  // v30.0.
+  envoy_config_core_v3_Metadata* metadata_upb =
+      (envoy_config_core_v3_Metadata*)metadata;
+  const upb_Map* typed_filter_metadata_upb_map =
+      _envoy_config_core_v3_Metadata_typed_filter_metadata_upb_map(
+          metadata_upb);
+  if (typed_filter_metadata_upb_map) {
+    size_t iter = kUpb_Map_Begin;
+    upb_MessageValue k, v;
+    while (upb_Map_Next(typed_filter_metadata_upb_map, &k, &v, &iter)) {
+      upb_StringView typed_filter_metadata_key_view = k.str_val;
+      const google_protobuf_Any* typed_filter_metadata_val =
+          (google_protobuf_Any*)v.msg_val;
+      absl::string_view key = UpbStringToAbsl(typed_filter_metadata_key_view);
+      ValidationErrors::ScopedField field(
+          errors, absl::StrCat(".typed_filter_metadata[", key, "]"));
+      auto extension =
+          ExtractXdsExtension(context, typed_filter_metadata_val, errors);
+      if (!extension.has_value()) continue;
+      // TODO(roth): If we start to need a lot of types here, refactor
+      // this into a separate registry.
+      std::unique_ptr<XdsMetadataValue> metadata_value;
+      if (XdsGcpAuthFilterEnabled() &&
+          extension->type == XdsGcpAuthnAudienceMetadataValue::Type()) {
+        metadata_value =
+            ParseGcpAuthnAudience(context, std::move(*extension), errors);
+      } else if (XdsHttpConnectEnabled() &&
+                 extension->type == XdsAddressMetadataValue::Type()) {
+        metadata_value = ParseAddress(context, std::move(*extension), errors);
+      }
+      if (metadata_value != nullptr) {
+        metadata_map.Insert(key, std::move(metadata_value));
+      }
     }
   }
   // Then, try filter_metadata.
-  iter = kUpb_Map_Begin;
-  const envoy_config_core_v3_Metadata_FilterMetadataEntry* entry;
-  while ((entry = envoy_config_core_v3_Metadata_filter_metadata_next(
-              metadata, &iter)) != nullptr) {
-    absl::string_view key = UpbStringToAbsl(
-        envoy_config_core_v3_Metadata_FilterMetadataEntry_key(entry));
-    auto json = ParseProtobufStructToJson(
-        context,
-        envoy_config_core_v3_Metadata_FilterMetadataEntry_value(entry));
-    if (!json.ok()) {
-      ValidationErrors::ScopedField field(
-          errors, absl::StrCat(".filter_metadata[", key, "]"));
-      errors->AddError(json.status().message());
-    }
-    // Add only if not already added from typed_filter_metadata.
-    else if (metadata_map.Find(key) == nullptr) {
-      metadata_map.Insert(
-          key, std::make_unique<XdsStructMetadataValue>(std::move(*json)));
+  // TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto
+  // v30.0.
+  const upb_Map* filter_metadata_upb_map =
+      _envoy_config_core_v3_Metadata_filter_metadata_upb_map(metadata_upb);
+  if (filter_metadata_upb_map) {
+    size_t iter = kUpb_Map_Begin;
+    upb_MessageValue k, v;
+    while (upb_Map_Next(filter_metadata_upb_map, &k, &v, &iter)) {
+      upb_StringView filter_metadata_key_view = k.str_val;
+      const google_protobuf_Struct* filter_metadata_val =
+          (google_protobuf_Struct*)v.msg_val;
+      absl::string_view key = UpbStringToAbsl(filter_metadata_key_view);
+      auto json = ParseProtobufStructToJson(context, filter_metadata_val);
+      if (!json.ok()) {
+        ValidationErrors::ScopedField field(
+            errors, absl::StrCat(".filter_metadata[", key, "]"));
+        errors->AddError(json.status().message());
+      }
+      // Add only if not already added from typed_filter_metadata.
+      else if (metadata_map.Find(key) == nullptr) {
+        metadata_map.Insert(
+            key, std::make_unique<XdsStructMetadataValue>(std::move(*json)));
+      }
     }
   }
   return metadata_map;

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

@@ -16,15 +16,15 @@
 
 #include "src/core/xds/grpc/xds_route_config.h"
 
+#include <optional>
 #include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "re2/re2.h"
 #include "src/core/util/match.h"
 #include "src/core/util/matchers.h"
@@ -155,9 +155,7 @@ XdsRouteConfigResource::Route::RouteAction::ClusterWeight::ToString() const {
   contents.push_back(absl::StrCat("weight=", weight));
   if (!typed_per_filter_config.empty()) {
     std::vector<std::string> parts;
-    for (const auto& p : typed_per_filter_config) {
-      const std::string& key = p.first;
-      const auto& config = p.second;
+    for (const auto& [key, config] : typed_per_filter_config) {
       parts.push_back(absl::StrCat(key, "=", config.ToString()));
     }
     contents.push_back(absl::StrCat("typed_per_filter_config={",
@@ -211,10 +209,10 @@ std::string XdsRouteConfigResource::Route::ToString() const {
   std::vector<std::string> contents;
   contents.push_back(matchers.ToString());
   auto* route_action =
-      absl::get_if<XdsRouteConfigResource::Route::RouteAction>(&action);
+      std::get_if<XdsRouteConfigResource::Route::RouteAction>(&action);
   if (route_action != nullptr) {
     contents.push_back(absl::StrCat("route=", route_action->ToString()));
-  } else if (absl::holds_alternative<
+  } else if (std::holds_alternative<
                  XdsRouteConfigResource::Route::NonForwardingAction>(action)) {
     contents.push_back("non_forwarding_action={}");
   } else {
@@ -222,9 +220,7 @@ std::string XdsRouteConfigResource::Route::ToString() const {
   }
   if (!typed_per_filter_config.empty()) {
     contents.push_back("typed_per_filter_config={");
-    for (const auto& p : typed_per_filter_config) {
-      const std::string& name = p.first;
-      const auto& config = p.second;
+    for (const auto& [name, config] : typed_per_filter_config) {
       contents.push_back(absl::StrCat("  ", name, "=", config.ToString()));
     }
     contents.push_back("}");
@@ -251,9 +247,7 @@ std::string XdsRouteConfigResource::VirtualHost::ToString() const {
   }
   parts.push_back("  ]\n");
   parts.push_back("  typed_per_filter_config={\n");
-  for (const auto& p : typed_per_filter_config) {
-    const std::string& name = p.first;
-    const auto& config = p.second;
+  for (const auto& [name, config] : typed_per_filter_config) {
     parts.push_back(absl::StrCat("    ", name, "=", config.ToString(), "\n"));
   }
   parts.push_back("  }\n");
@@ -272,8 +266,8 @@ std::string XdsRouteConfigResource::ToString() const {
     parts.push_back(vhost.ToString());
   }
   parts.push_back("cluster_specifier_plugins={\n");
-  for (const auto& it : cluster_specifier_plugin_map) {
-    parts.push_back(absl::StrFormat("%s={%s}\n", it.first, it.second));
+  for (const auto& [name, plugin] : cluster_specifier_plugin_map) {
+    parts.push_back(absl::StrFormat("%s={%s}\n", name, plugin));
   }
   parts.push_back("}");
   return absl::StrJoin(parts, "");

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

@@ -22,13 +22,13 @@
 #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/call/status_util.h"
 #include "src/core/util/matchers.h"
 #include "src/core/util/time.h"
 #include "src/core/xds/grpc/xds_http_filter.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 {