grpc 1.70.1 → 1.71.0

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

@@ -21,10 +21,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/config/core/v3/extension.upb.h"
 #include "envoy/extensions/filters/http/stateful_session/v3/stateful_session.upb.h"
 #include "envoy/extensions/filters/http/stateful_session/v3/stateful_session.upbdefs.h"
@@ -90,7 +90,7 @@ Json::Object ValidateStatefulSession(
     return {};
   }
   absl::string_view* serialized_session_state =
-      absl::get_if<absl::string_view>(&extension->value);
+      std::get_if<absl::string_view>(&extension->value);
   if (serialized_session_state == nullptr) {
     errors->AddError("could not parse session state config");
     return {};
@@ -138,16 +138,16 @@ Json::Object ValidateStatefulSession(
 
 }  // namespace
 
-absl::optional<XdsHttpFilterImpl::FilterConfig>
+std::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpStatefulSessionFilter::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 stateful session filter config");
-    return absl::nullopt;
+    return std::nullopt;
   }
   auto* stateful_session =
       envoy_extensions_filters_http_stateful_session_v3_StatefulSession_parse(
@@ -155,23 +155,23 @@ XdsHttpStatefulSessionFilter::GenerateFilterConfig(
           context.arena);
   if (stateful_session == nullptr) {
     errors->AddError("could not parse stateful session filter config");
-    return absl::nullopt;
+    return std::nullopt;
   }
   return FilterConfig{ConfigProtoName(),
                       Json::FromObject(ValidateStatefulSession(
                           context, stateful_session, errors))};
 }
 
-absl::optional<XdsHttpFilterImpl::FilterConfig>
+std::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpStatefulSessionFilter::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 stateful session filter override config");
-    return absl::nullopt;
+    return std::nullopt;
   }
   auto* stateful_session_per_route =
       envoy_extensions_filters_http_stateful_session_v3_StatefulSessionPerRoute_parse(
@@ -179,7 +179,7 @@ XdsHttpStatefulSessionFilter::GenerateFilterConfigOverride(
           context.arena);
   if (stateful_session_per_route == nullptr) {
     errors->AddError("could not parse stateful session filter override config");
-    return absl::nullopt;
+    return std::nullopt;
   }
   Json::Object config;
   if (!envoy_extensions_filters_http_stateful_session_v3_StatefulSessionPerRoute_disabled(

data/src/core/xds/grpc/xds_http_stateful_session_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 XdsHttpStatefulSessionFilter 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_lb_policy_registry.cc

@@ -21,12 +21,12 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <optional>
 #include <string>
 #include <utility>
+#include <variant>
 
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "envoy/config/core/v3/extension.upb.h"
 #include "envoy/extensions/load_balancing_policies/client_side_weighted_round_robin/v3/client_side_weighted_round_robin.upb.h"
 #include "envoy/extensions/load_balancing_policies/pick_first/v3/pick_first.upb.h"
@@ -337,7 +337,7 @@ Json::Array XdsLbPolicyRegistry::ConvertXdsLbPolicyConfig(
     if (!extension.has_value()) return {};
     // Check for registered LB policy type.
     absl::string_view* serialized_value =
-        absl::get_if<absl::string_view>(&extension->value);
+        std::get_if<absl::string_view>(&extension->value);
     if (serialized_value != nullptr) {
       auto config_factory_it = policy_config_factories_.find(extension->type);
       if (config_factory_it != policy_config_factories_.end()) {
@@ -347,7 +347,7 @@ Json::Array XdsLbPolicyRegistry::ConvertXdsLbPolicyConfig(
       }
     }
     // Check for custom LB policy type.
-    Json* json = absl::get_if<Json>(&extension->value);
+    Json* json = std::get_if<Json>(&extension->value);
     if (json != nullptr &&
         CoreConfiguration::Get().lb_policy_registry().LoadBalancingPolicyExists(
             extension->type, nullptr)) {

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

@@ -107,7 +107,7 @@ std::string XdsListenerResource::FilterChainMap::ToString() const {
     for (int source_type = 0; source_type < 3; ++source_type) {
       for (const auto& source_ip :
            destination_ip.source_types_array[source_type]) {
-        for (const auto& source_port_pair : source_ip.ports_map) {
+        for (const auto& [port, filter_chain] : source_ip.ports_map) {
           std::vector<std::string> match_contents;
           if (destination_ip.prefix_range.has_value()) {
             match_contents.push_back(
@@ -126,14 +126,12 @@ std::string XdsListenerResource::FilterChainMap::ToString() const {
                 absl::StrCat("source_prefix_ranges={",
                              source_ip.prefix_range->ToString(), "}"));
           }
-          if (source_port_pair.first != 0) {
-            match_contents.push_back(
-                absl::StrCat("source_ports={", source_port_pair.first, "}"));
+          if (port != 0) {
+            match_contents.push_back(absl::StrCat("source_ports={", port, "}"));
           }
           contents.push_back(absl::StrCat(
               "{filter_chain_match={", absl::StrJoin(match_contents, ", "),
-              "}, filter_chain=", source_port_pair.second.data->ToString(),
-              "}"));
+              "}, filter_chain=", filter_chain.data->ToString(), "}"));
         }
       }
     }

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

@@ -24,11 +24,11 @@
 #include <array>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
+#include <variant>
 #include <vector>
 
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/util/time.h"
 #include "src/core/xds/grpc/xds_common_types.h"
@@ -42,7 +42,7 @@ namespace grpc_core {
 struct XdsListenerResource : public XdsResourceType::ResourceData {
   struct HttpConnectionManager {
     // The RDS resource name or inline RouteConfiguration.
-    absl::variant<std::string, std::shared_ptr<const XdsRouteConfigResource>>
+    std::variant<std::string, std::shared_ptr<const XdsRouteConfigResource>>
         route_config;
 
     // Storing the Http Connection Manager Common Http Protocol Option
@@ -62,12 +62,12 @@ struct XdsListenerResource : public XdsResourceType::ResourceData {
     std::vector<HttpFilter> http_filters;
 
     bool operator==(const HttpConnectionManager& other) const {
-      if (absl::holds_alternative<std::string>(route_config)) {
+      if (std::holds_alternative<std::string>(route_config)) {
         if (route_config != other.route_config) return false;
       } else {
-        auto& rc1 = absl::get<std::shared_ptr<const XdsRouteConfigResource>>(
+        auto& rc1 = std::get<std::shared_ptr<const XdsRouteConfigResource>>(
             route_config);
-        auto* rc2 = absl::get_if<std::shared_ptr<const XdsRouteConfigResource>>(
+        auto* rc2 = std::get_if<std::shared_ptr<const XdsRouteConfigResource>>(
             &other.route_config);
         if (rc2 == nullptr) return false;
         if (!(*rc1 == **rc2)) return false;
@@ -142,7 +142,7 @@ struct XdsListenerResource : public XdsResourceType::ResourceData {
     };
     using SourcePortsMap = std::map<uint16_t, FilterChainDataSharedPtr>;
     struct SourceIp {
-      absl::optional<CidrRange> prefix_range;
+      std::optional<CidrRange> prefix_range;
       SourcePortsMap ports_map;
 
       bool operator==(const SourceIp& other) const {
@@ -154,7 +154,7 @@ struct XdsListenerResource : public XdsResourceType::ResourceData {
     enum class ConnectionSourceType { kAny = 0, kSameIpOrLoopback, kExternal };
     using ConnectionSourceTypesArray = std::array<SourceIpVector, 3>;
     struct DestinationIp {
-      absl::optional<CidrRange> prefix_range;
+      std::optional<CidrRange> prefix_range;
       // We always fail match on server name, so those filter chains are not
       // included here.
       ConnectionSourceTypesArray source_types_array;
@@ -178,7 +178,7 @@ struct XdsListenerResource : public XdsResourceType::ResourceData {
   struct TcpListener {
     std::string address;  // host:port listening address
     FilterChainMap filter_chain_map;
-    absl::optional<FilterChainData> default_filter_chain;
+    std::optional<FilterChainData> default_filter_chain;
 
     bool operator==(const TcpListener& other) const {
       return address == other.address &&
@@ -189,7 +189,7 @@ struct XdsListenerResource : public XdsResourceType::ResourceData {
     std::string ToString() const;
   };
 
-  absl::variant<HttpConnectionManager, TcpListener> listener;
+  std::variant<HttpConnectionManager, TcpListener> listener;
 
   bool operator==(const XdsListenerResource& other) const {
     return listener == other.listener;

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, ", "), "}");