grpc 1.58.0 → 1.59.0

data/src/core/ext/upbdefs-generated/google/protobuf/descriptor.upbdefs.h

@@ -107,6 +107,11 @@ UPB_INLINE const upb_MessageDef *google_protobuf_FieldOptions_getmsgdef(upb_DefP
   return upb_DefPool_FindMessageByName(s, "google.protobuf.FieldOptions");
 }
 
+UPB_INLINE const upb_MessageDef *google_protobuf_FieldOptions_EditionDefault_getmsgdef(upb_DefPool *s) {
+  _upb_DefPool_LoadDefInit(s, &google_protobuf_descriptor_proto_upbdefinit);
+  return upb_DefPool_FindMessageByName(s, "google.protobuf.FieldOptions.EditionDefault");
+}
+
 UPB_INLINE const upb_MessageDef *google_protobuf_OneofOptions_getmsgdef(upb_DefPool *s) {
   _upb_DefPool_LoadDefInit(s, &google_protobuf_descriptor_proto_upbdefinit);
   return upb_DefPool_FindMessageByName(s, "google.protobuf.OneofOptions");
@@ -142,6 +147,11 @@ UPB_INLINE const upb_MessageDef *google_protobuf_UninterpretedOption_NamePart_ge
   return upb_DefPool_FindMessageByName(s, "google.protobuf.UninterpretedOption.NamePart");
 }
 
+UPB_INLINE const upb_MessageDef *google_protobuf_FeatureSet_getmsgdef(upb_DefPool *s) {
+  _upb_DefPool_LoadDefInit(s, &google_protobuf_descriptor_proto_upbdefinit);
+  return upb_DefPool_FindMessageByName(s, "google.protobuf.FeatureSet");
+}
+
 UPB_INLINE const upb_MessageDef *google_protobuf_SourceCodeInfo_getmsgdef(upb_DefPool *s) {
   _upb_DefPool_LoadDefInit(s, &google_protobuf_descriptor_proto_upbdefinit);
   return upb_DefPool_FindMessageByName(s, "google.protobuf.SourceCodeInfo");

data/src/core/ext/xds/xds_client.cc

@@ -865,15 +865,12 @@ void XdsClient::ChannelState::AdsCallState::AdsResponseParser::ParseResource(
       std::string(serialized_resource), result_.version, update_time_);
   // Notify watchers.
   auto& watchers_list = resource_state.watchers;
-  auto* value =
-      result_.type->CopyResource(resource_state.resource.get()).release();
   xds_client()->work_serializer_.Schedule(
-      [watchers_list, value]()
+      [watchers_list, value = resource_state.resource]()
           ABSL_EXCLUSIVE_LOCKS_REQUIRED(&xds_client()->work_serializer_) {
             for (const auto& p : watchers_list) {
               p.first->OnGenericResourceChanged(value);
             }
-            delete value;
           },
       DEBUG_LOCATION);
 }
@@ -1494,6 +1491,7 @@ XdsClient::XdsClient(
       xds_federation_enabled_(XdsFederationEnabled()),
       api_(this, &grpc_xds_client_trace, bootstrap_->node(), &symtab_,
            std::move(user_agent_name), std::move(user_agent_version)),
+      work_serializer_(engine),
       engine_(std::move(engine)) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
     gpr_log(GPR_INFO, "[xds_client %p] creating xds client", this);
@@ -1604,12 +1602,11 @@ void XdsClient::WatchResource(const XdsResourceType* type,
                 "[xds_client %p] returning cached listener data for %s", this,
                 std::string(name).c_str());
       }
-      auto* value = type->CopyResource(resource_state.resource.get()).release();
       work_serializer_.Schedule(
-          [watcher, value]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) {
-            watcher->OnGenericResourceChanged(value);
-            delete value;
-          },
+          [watcher, value = resource_state.resource]()
+              ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) {
+                watcher->OnGenericResourceChanged(value);
+              },
           DEBUG_LOCATION);
     } else if (resource_state.meta.client_status ==
                XdsApi::ResourceMetadata::DOES_NOT_EXIST) {

data/src/core/ext/xds/xds_client.h

@@ -63,7 +63,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
   class ResourceWatcherInterface : public RefCounted<ResourceWatcherInterface> {
    public:
     virtual void OnGenericResourceChanged(
-        const XdsResourceType::ResourceData* resource)
+        std::shared_ptr<const XdsResourceType::ResourceData> resource)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
     virtual void OnError(absl::Status status)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&work_serializer_) = 0;
@@ -238,7 +238,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
     std::map<ResourceWatcherInterface*, RefCountedPtr<ResourceWatcherInterface>>
         watchers;
     // The latest data seen for the resource.
-    std::unique_ptr<XdsResourceType::ResourceData> resource;
+    std::shared_ptr<const XdsResourceType::ResourceData> resource;
     XdsApi::ResourceMetadata meta;
     bool ignored_deletion = false;
   };

data/src/core/ext/xds/xds_cluster.cc

@@ -20,6 +20,8 @@
 
 #include <stddef.h>
 
+#include <algorithm>
+#include <memory>
 #include <utility>
 
 #include "absl/status/status.h"
@@ -57,8 +59,6 @@
 #include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -70,15 +70,6 @@
 
 namespace grpc_core {
 
-// TODO(eostroukhov): Remove once this feature is no longer experimental.
-bool XdsOverrideHostEnabled() {
-  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_ENABLE_OVERRIDE_HOST");
-  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;
-}
-
 //
 // XdsClusterResource
 //
@@ -416,18 +407,18 @@ void ParseLbPolicyConfig(const XdsResourceType::DecodeContext& context,
   }
 }
 
-absl::StatusOr<XdsClusterResource> CdsResourceParse(
+absl::StatusOr<std::shared_ptr<const XdsClusterResource>> CdsResourceParse(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_cluster_v3_Cluster* cluster) {
-  XdsClusterResource cds_update;
+  auto cds_update = std::make_shared<XdsClusterResource>();
   ValidationErrors errors;
   // Check the cluster discovery type.
   if (envoy_config_cluster_v3_Cluster_type(cluster) ==
       envoy_config_cluster_v3_Cluster_EDS) {
-    cds_update.type = EdsConfigParse(cluster, &errors);
+    cds_update->type = EdsConfigParse(cluster, &errors);
   } else if (envoy_config_cluster_v3_Cluster_type(cluster) ==
              envoy_config_cluster_v3_Cluster_LOGICAL_DNS) {
-    cds_update.type = LogicalDnsParse(cluster, &errors);
+    cds_update->type = LogicalDnsParse(cluster, &errors);
   } else if (envoy_config_cluster_v3_Cluster_has_cluster_type(cluster)) {
     ValidationErrors::ScopedField field(&errors, ".cluster_type");
     const auto* custom_cluster_type =
@@ -454,7 +445,7 @@ absl::StatusOr<XdsClusterResource> CdsResourceParse(
             ".value[envoy.extensions.clusters.aggregate.v3.ClusterConfig]");
         absl::string_view serialized_config =
             UpbStringToAbsl(google_protobuf_Any_value(typed_config));
-        cds_update.type =
+        cds_update->type =
             AggregateClusterParse(context, serialized_config, &errors);
       }
     }
@@ -463,13 +454,13 @@ absl::StatusOr<XdsClusterResource> CdsResourceParse(
     errors.AddError("unknown discovery type");
   }
   // Check the LB policy.
-  ParseLbPolicyConfig(context, cluster, &cds_update, &errors);
+  ParseLbPolicyConfig(context, cluster, cds_update.get(), &errors);
   // transport_socket
   auto* transport_socket =
       envoy_config_cluster_v3_Cluster_transport_socket(cluster);
   if (transport_socket != nullptr) {
     ValidationErrors::ScopedField field(&errors, ".transport_socket");
-    cds_update.common_tls_context =
+    cds_update->common_tls_context =
         UpstreamTlsContextParse(context, transport_socket, &errors);
   }
   // Record LRS server name (if any).
@@ -480,7 +471,7 @@ absl::StatusOr<XdsClusterResource> CdsResourceParse(
       ValidationErrors::ScopedField field(&errors, ".lrs_server");
       errors.AddError("ConfigSource is not self");
     }
-    cds_update.lrs_load_reporting_server.emplace(
+    cds_update->lrs_load_reporting_server.emplace(
         static_cast<const GrpcXdsBootstrap::GrpcXdsServer&>(context.server));
   }
   // The Cluster resource encodes the circuit breaking parameters in a list of
@@ -502,7 +493,7 @@ absl::StatusOr<XdsClusterResource> CdsResourceParse(
             envoy_config_cluster_v3_CircuitBreakers_Thresholds_max_requests(
                 threshold);
         if (max_requests != nullptr) {
-          cds_update.max_concurrent_requests =
+          cds_update->max_concurrent_requests =
               google_protobuf_UInt32Value_value(max_requests);
         }
         break;
@@ -629,27 +620,25 @@ absl::StatusOr<XdsClusterResource> CdsResourceParse(
             failure_percentage_ejection;
       }
     }
-    cds_update.outlier_detection = outlier_detection_update;
+    cds_update->outlier_detection = outlier_detection_update;
   }
   // Validate override host status.
-  if (XdsOverrideHostEnabled()) {
-    const auto* common_lb_config =
-        envoy_config_cluster_v3_Cluster_common_lb_config(cluster);
-    if (common_lb_config != nullptr) {
-      ValidationErrors::ScopedField field(&errors, ".common_lb_config");
-      const auto* override_host_status =
-          envoy_config_cluster_v3_Cluster_CommonLbConfig_override_host_status(
-              common_lb_config);
-      if (override_host_status != nullptr) {
-        ValidationErrors::ScopedField field(&errors, ".override_host_status");
-        size_t size;
-        const int32_t* statuses = envoy_config_core_v3_HealthStatusSet_statuses(
-            override_host_status, &size);
-        for (size_t i = 0; i < size; ++i) {
-          auto status = XdsHealthStatus::FromUpb(statuses[i]);
-          if (status.has_value()) {
-            cds_update.override_host_statuses.insert(*status);
-          }
+  const auto* common_lb_config =
+      envoy_config_cluster_v3_Cluster_common_lb_config(cluster);
+  if (common_lb_config != nullptr) {
+    ValidationErrors::ScopedField field(&errors, ".common_lb_config");
+    const auto* override_host_status =
+        envoy_config_cluster_v3_Cluster_CommonLbConfig_override_host_status(
+            common_lb_config);
+    if (override_host_status != nullptr) {
+      ValidationErrors::ScopedField field(&errors, ".override_host_status");
+      size_t size;
+      const int32_t* statuses = envoy_config_core_v3_HealthStatusSet_statuses(
+          override_host_status, &size);
+      for (size_t i = 0; i < size; ++i) {
+        auto status = XdsHealthStatus::FromUpb(statuses[i]);
+        if (status.has_value()) {
+          cds_update->override_host_statuses.insert(*status);
         }
       }
     }
@@ -703,10 +692,9 @@ XdsResourceType::DecodeResult XdsClusterResourceType::Decode(
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_INFO, "[xds_client %p] parsed Cluster %s: %s", context.client,
-              result.name->c_str(), cds_resource->ToString().c_str());
+              result.name->c_str(), (*cds_resource)->ToString().c_str());
     }
-    result.resource =
-        std::make_unique<XdsClusterResource>(std::move(*cds_resource));
+    result.resource = std::move(*cds_resource);
   }
   return result;
 }

data/src/core/ext/xds/xds_cluster.h

@@ -21,8 +21,6 @@
 
 #include <stdint.h>
 
-#include <algorithm>
-#include <memory>
 #include <set>
 #include <string>
 #include <vector>
@@ -47,8 +45,6 @@
 
 namespace grpc_core {
 
-bool XdsOverrideHostEnabled();
-
 struct XdsClusterResource : public XdsResourceType::ResourceData {
   struct Eds {
     // If empty, defaults to the cluster name.

data/src/core/ext/xds/xds_endpoint.cc

@@ -23,6 +23,7 @@
 
 #include <algorithm>
 #include <limits>
+#include <memory>
 #include <set>
 #include <vector>
 
@@ -33,7 +34,6 @@
 #include "absl/types/optional.h"
 #include "envoy/config/core/v3/address.upb.h"
 #include "envoy/config/core/v3/base.upb.h"
-#include "envoy/config/core/v3/health_check.upb.h"
 #include "envoy/config/endpoint/v3/endpoint.upb.h"
 #include "envoy/config/endpoint/v3/endpoint.upbdefs.h"
 #include "envoy/config/endpoint/v3/endpoint_components.upb.h"
@@ -44,7 +44,6 @@
 #include <grpc/support/log.h>
 
 #include "src/core/ext/xds/upb_utils.h"
-#include "src/core/ext/xds/xds_cluster.h"
 #include "src/core/ext/xds/xds_health_status.h"
 #include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/lib/address_utils/parse_address.h"
@@ -157,11 +156,6 @@ absl::optional<ServerAddress> ServerAddressParse(
   // health_status
   const int32_t health_status =
       envoy_config_endpoint_v3_LbEndpoint_health_status(lb_endpoint);
-  if (!XdsOverrideHostEnabled() &&
-      health_status != envoy_config_core_v3_UNKNOWN &&
-      health_status != envoy_config_core_v3_HEALTHY) {
-    return absl::nullopt;
-  }
   auto status = XdsHealthStatus::FromUpb(health_status);
   if (!status.has_value()) return absl::nullopt;
   // load_balancing_weight
@@ -353,12 +347,12 @@ void DropParseAndAppend(
   drop_config->AddCategory(std::move(category), numerator);
 }
 
-absl::StatusOr<XdsEndpointResource> EdsResourceParse(
+absl::StatusOr<std::shared_ptr<const XdsEndpointResource>> EdsResourceParse(
     const XdsResourceType::DecodeContext& /*context*/,
     const envoy_config_endpoint_v3_ClusterLoadAssignment*
         cluster_load_assignment) {
   ValidationErrors errors;
-  XdsEndpointResource eds_resource;
+  auto eds_resource = std::make_shared<XdsEndpointResource>();
   // endpoints
   {
     ValidationErrors::ScopedField field(&errors, "endpoints");
@@ -374,11 +368,11 @@ absl::StatusOr<XdsEndpointResource> EdsResourceParse(
         GPR_ASSERT(parsed_locality->locality.lb_weight != 0);
         // Make sure prorities is big enough. Note that they might not
         // arrive in priority order.
-        if (eds_resource.priorities.size() < parsed_locality->priority + 1) {
-          eds_resource.priorities.resize(parsed_locality->priority + 1);
+        if (eds_resource->priorities.size() < parsed_locality->priority + 1) {
+          eds_resource->priorities.resize(parsed_locality->priority + 1);
         }
         auto& locality_map =
-            eds_resource.priorities[parsed_locality->priority].localities;
+            eds_resource->priorities[parsed_locality->priority].localities;
         auto it = locality_map.find(parsed_locality->locality.name.get());
         if (it != locality_map.end()) {
           errors.AddError(absl::StrCat(
@@ -391,8 +385,8 @@ absl::StatusOr<XdsEndpointResource> EdsResourceParse(
         }
       }
     }
-    for (size_t i = 0; i < eds_resource.priorities.size(); ++i) {
-      const auto& priority = eds_resource.priorities[i];
+    for (size_t i = 0; i < eds_resource->priorities.size(); ++i) {
+      const auto& priority = eds_resource->priorities[i];
       if (priority.localities.empty()) {
         errors.AddError(absl::StrCat("priority ", i, " empty"));
       } else {
@@ -412,7 +406,7 @@ absl::StatusOr<XdsEndpointResource> EdsResourceParse(
     }
   }
   // policy
-  eds_resource.drop_config = MakeRefCounted<XdsEndpointResource::DropConfig>();
+  eds_resource->drop_config = MakeRefCounted<XdsEndpointResource::DropConfig>();
   const auto* policy = envoy_config_endpoint_v3_ClusterLoadAssignment_policy(
       cluster_load_assignment);
   if (policy != nullptr) {
@@ -424,7 +418,7 @@ absl::StatusOr<XdsEndpointResource> EdsResourceParse(
     for (size_t i = 0; i < drop_size; ++i) {
       ValidationErrors::ScopedField field(
           &errors, absl::StrCat(".drop_overloads[", i, "]"));
-      DropParseAndAppend(drop_overload[i], eds_resource.drop_config.get(),
+      DropParseAndAppend(drop_overload[i], eds_resource->drop_config.get(),
                          &errors);
     }
   }
@@ -466,10 +460,9 @@ XdsResourceType::DecodeResult XdsEndpointResourceType::Decode(
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_INFO, "[xds_client %p] parsed ClusterLoadAssignment %s: %s",
               context.client, result.name->c_str(),
-              eds_resource->ToString().c_str());
+              (*eds_resource)->ToString().c_str());
     }
-    result.resource =
-        std::make_unique<XdsEndpointResource>(std::move(*eds_resource));
+    result.resource = std::move(*eds_resource);
   }
   return result;
 }

data/src/core/ext/xds/xds_endpoint.h

@@ -23,7 +23,6 @@
 
 #include <algorithm>
 #include <map>
-#include <memory>
 #include <string>
 #include <utility>
 #include <vector>

data/src/core/ext/xds/xds_http_filters.cc

@@ -29,7 +29,6 @@
 
 #include <grpc/support/log.h>
 
-#include "src/core/ext/xds/xds_cluster.h"
 #include "src/core/ext/xds/xds_http_fault_filter.h"
 #include "src/core/ext/xds/xds_http_rbac_filter.h"
 #include "src/core/ext/xds/xds_http_stateful_session_filter.h"
@@ -88,9 +87,7 @@ XdsHttpFilterRegistry::XdsHttpFilterRegistry(bool register_builtins) {
     RegisterFilter(std::make_unique<XdsHttpRouterFilter>());
     RegisterFilter(std::make_unique<XdsHttpFaultFilter>());
     RegisterFilter(std::make_unique<XdsHttpRbacFilter>());
-    if (XdsOverrideHostEnabled()) {
-      RegisterFilter(std::make_unique<XdsHttpStatefulSessionFilter>());
-    }
+    RegisterFilter(std::make_unique<XdsHttpStatefulSessionFilter>());
   }
 }
 

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

@@ -77,7 +77,6 @@ Json::Object ValidateStatefulSession(
       envoy_extensions_filters_http_stateful_session_v3_StatefulSession_session_state(
           stateful_session);
   if (session_state == nullptr) {
-    errors->AddError("field not present");
     return {};
   }
   ValidationErrors::ScopedField field2(errors, ".typed_config");
@@ -188,9 +187,7 @@ XdsHttpStatefulSessionFilter::GenerateFilterConfigOverride(
     const auto* stateful_session =
         envoy_extensions_filters_http_stateful_session_v3_StatefulSessionPerRoute_stateful_session(
             stateful_session_per_route);
-    if (stateful_session == nullptr) {
-      errors->AddError("field not present");
-    } else {
+    if (stateful_session != nullptr) {
       config = ValidateStatefulSession(context, stateful_session, errors);
     }
   }

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

@@ -74,8 +74,8 @@ std::string XdsListenerResource::HttpConnectionManager::ToString() const {
       [](const std::string& rds_name) {
         return absl::StrCat("rds_name=", rds_name);
       },
-      [](const XdsRouteConfigResource& route_config) {
-        return absl::StrCat("route_config=", route_config.ToString());
+      [](const std::shared_ptr<const XdsRouteConfigResource>& route_config) {
+        return absl::StrCat("route_config=", route_config->ToString());
       }));
   contents.push_back(absl::StrCat("http_max_stream_duration=",
                                   http_max_stream_duration.ToString()));
@@ -490,17 +490,18 @@ XdsListenerResource::HttpConnectionManager HttpConnectionManagerParse(
   return http_connection_manager;
 }
 
-absl::StatusOr<XdsListenerResource> LdsResourceParseClient(
+absl::StatusOr<std::shared_ptr<const XdsListenerResource>>
+LdsResourceParseClient(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_listener_v3_ApiListener* api_listener) {
-  XdsListenerResource lds_update;
+  auto lds_update = std::make_shared<XdsListenerResource>();
   ValidationErrors errors;
   ValidationErrors::ScopedField field(&errors, "api_listener.api_listener");
   auto* api_listener_field =
       envoy_config_listener_v3_ApiListener_api_listener(api_listener);
   auto extension = ExtractXdsExtension(context, api_listener_field, &errors);
   if (extension.has_value()) {
-    lds_update.listener = HttpConnectionManagerParse(
+    lds_update->listener = HttpConnectionManagerParse(
         /*is_client=*/true, context, std::move(*extension), &errors);
   }
   if (!errors.ok()) {
@@ -991,9 +992,9 @@ XdsListenerResource::FilterChainMap BuildFilterChainMap(
   return BuildFromInternalFilterChainMap(&internal_filter_chain_map);
 }
 
-absl::StatusOr<XdsListenerResource> LdsResourceParseServer(
-    const XdsResourceType::DecodeContext& context,
-    const envoy_config_listener_v3_Listener* listener) {
+absl::StatusOr<std::shared_ptr<const XdsListenerResource>>
+LdsResourceParseServer(const XdsResourceType::DecodeContext& context,
+                       const envoy_config_listener_v3_Listener* listener) {
   ValidationErrors errors;
   XdsListenerResource::TcpListener tcp_listener;
   // address
@@ -1054,12 +1055,12 @@ absl::StatusOr<XdsListenerResource> LdsResourceParseServer(
     return errors.status(absl::StatusCode::kInvalidArgument,
                          "errors validating server Listener");
   }
-  XdsListenerResource lds_update;
-  lds_update.listener = std::move(tcp_listener);
+  auto lds_update = std::make_shared<XdsListenerResource>();
+  lds_update->listener = std::move(tcp_listener);
   return lds_update;
 }
 
-absl::StatusOr<XdsListenerResource> LdsResourceParse(
+absl::StatusOr<std::shared_ptr<const XdsListenerResource>> LdsResourceParse(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_listener_v3_Listener* listener) {
   // Check whether it's a client or server listener.
@@ -1127,10 +1128,9 @@ XdsResourceType::DecodeResult XdsListenerResourceType::Decode(
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_INFO, "[xds_client %p] parsed Listener %s: %s",
               context.client, result.name->c_str(),
-              listener->ToString().c_str());
+              (*listener)->ToString().c_str());
     }
-    result.resource =
-        std::make_unique<XdsListenerResource>(std::move(*listener));
+    result.resource = std::move(*listener);
   }
   return result;
 }

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

@@ -51,7 +51,8 @@ namespace grpc_core {
 struct XdsListenerResource : public XdsResourceType::ResourceData {
   struct HttpConnectionManager {
     // The RDS resource name or inline RouteConfiguration.
-    absl::variant<std::string, XdsRouteConfigResource> route_config;
+    absl::variant<std::string, std::shared_ptr<const XdsRouteConfigResource>>
+        route_config;
 
     // Storing the Http Connection Manager Common Http Protocol Option
     // max_stream_duration
@@ -70,8 +71,17 @@ struct XdsListenerResource : public XdsResourceType::ResourceData {
     std::vector<HttpFilter> http_filters;
 
     bool operator==(const HttpConnectionManager& other) const {
-      return route_config == other.route_config &&
-             http_max_stream_duration == other.http_max_stream_duration &&
+      if (absl::holds_alternative<std::string>(route_config)) {
+        if (route_config != other.route_config) return false;
+      } else {
+        auto& rc1 = absl::get<std::shared_ptr<const XdsRouteConfigResource>>(
+            route_config);
+        auto* rc2 = absl::get_if<std::shared_ptr<const XdsRouteConfigResource>>(
+            &other.route_config);
+        if (rc2 == nullptr) return false;
+        if (!(*rc1 == **rc2)) return false;
+      }
+      return http_max_stream_duration == other.http_max_stream_duration &&
              http_filters == other.http_filters;
     }
 

data/src/core/ext/xds/xds_resource_type.h

@@ -61,7 +61,7 @@ class XdsResourceType {
     // non-OK status.
     absl::optional<std::string> name;
     // The parsed and validated resource, or an error status.
-    absl::StatusOr<std::unique_ptr<ResourceData>> resource;
+    absl::StatusOr<std::shared_ptr<const ResourceData>> resource;
   };
 
   virtual ~XdsResourceType() = default;
@@ -79,12 +79,6 @@ class XdsResourceType {
   virtual bool ResourcesEqual(const ResourceData* r1,
                               const ResourceData* r2) const = 0;
 
-  // Returns a copy of resource.
-  // Must be invoked only on resources returned by this object's Decode()
-  // method.
-  virtual std::unique_ptr<ResourceData> CopyResource(
-      const ResourceData* resource) const = 0;
-
   // Indicates whether the resource type requires that all resources must
   // be present in every SotW response from the server.  If true, a
   // response that does not include a previously seen resource will be

data/src/core/ext/xds/xds_resource_type_impl.h

@@ -19,6 +19,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <memory>
+#include <utility>
 
 #include "absl/strings/string_view.h"
 
@@ -30,8 +31,8 @@ namespace grpc_core {
 
 // Base class for XdsResourceType implementations.
 // Handles all down-casting logic for a particular resource type struct.
-// ResourceTypeStruct must inherit from XdsResourceType::ResourceData,
-// must be copy-constructible, and must implement operator==().
+// ResourceTypeStruct must inherit from XdsResourceType::ResourceData
+// and must implement operator==().
 template <typename Subclass, typename ResourceTypeStruct>
 class XdsResourceTypeImpl : public XdsResourceType {
  public:
@@ -40,14 +41,17 @@ class XdsResourceTypeImpl : public XdsResourceType {
   // XdsClient watcher that handles down-casting.
   class WatcherInterface : public XdsClient::ResourceWatcherInterface {
    public:
-    virtual void OnResourceChanged(ResourceType listener) = 0;
+    virtual void OnResourceChanged(
+        std::shared_ptr<const ResourceType> resource) = 0;
 
    private:
     // Get result from XdsClient generic watcher interface, perform
     // down-casting, and invoke the caller's OnResourceChanged() method.
     void OnGenericResourceChanged(
-        const XdsResourceType::ResourceData* resource) override {
-      OnResourceChanged(*static_cast<const ResourceType*>(resource));
+        std::shared_ptr<const XdsResourceType::ResourceData> resource)
+        override {
+      OnResourceChanged(
+          std::static_pointer_cast<const ResourceType>(std::move(resource)));
     }
   };
 
@@ -75,12 +79,6 @@ class XdsResourceTypeImpl : public XdsResourceType {
     return *static_cast<const ResourceType*>(r1) ==
            *static_cast<const ResourceType*>(r2);
   }
-
-  std::unique_ptr<ResourceData> CopyResource(
-      const ResourceData* resource) const override {
-    return std::make_unique<ResourceType>(
-        *static_cast<const ResourceType*>(resource));
-  }
 };
 
 }  // namespace grpc_core

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

@@ -1036,20 +1036,20 @@ absl::optional<XdsRouteConfigResource::Route> ParseRoute(
 
 }  // namespace
 
-XdsRouteConfigResource XdsRouteConfigResource::Parse(
+std::shared_ptr<const XdsRouteConfigResource> XdsRouteConfigResource::Parse(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_route_v3_RouteConfiguration* route_config,
     ValidationErrors* errors) {
-  XdsRouteConfigResource rds_update;
+  auto rds_update = std::make_shared<XdsRouteConfigResource>();
   // Get the cluster spcifier plugin map.
   if (XdsRlsEnabled()) {
-    rds_update.cluster_specifier_plugin_map =
+    rds_update->cluster_specifier_plugin_map =
         ClusterSpecifierPluginParse(context, route_config, errors);
   }
   // 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) {
+  for (auto& plugin : rds_update->cluster_specifier_plugin_map) {
     cluster_specifier_plugins_not_seen.emplace(plugin.first);
   }
   // Get the virtual hosts.
@@ -1060,9 +1060,9 @@ XdsRouteConfigResource XdsRouteConfigResource::Parse(
   for (size_t i = 0; i < num_virtual_hosts; ++i) {
     ValidationErrors::ScopedField field(
         errors, absl::StrCat(".virtual_hosts[", i, "]"));
-    rds_update.virtual_hosts.emplace_back();
+    rds_update->virtual_hosts.emplace_back();
     XdsRouteConfigResource::VirtualHost& vhost =
-        rds_update.virtual_hosts.back();
+        rds_update->virtual_hosts.back();
     // Parse domains.
     size_t domain_size;
     upb_StringView const* domains = envoy_config_route_v3_VirtualHost_domains(
@@ -1111,7 +1111,7 @@ XdsRouteConfigResource XdsRouteConfigResource::Parse(
     for (size_t j = 0; j < num_routes; ++j) {
       ValidationErrors::ScopedField field(errors, absl::StrCat("[", j, "]"));
       auto route = ParseRoute(context, routes[j], virtual_host_retry_policy,
-                              rds_update.cluster_specifier_plugin_map,
+                              rds_update->cluster_specifier_plugin_map,
                               &cluster_specifier_plugins_not_seen, errors);
       if (route.has_value()) vhost.routes.emplace_back(std::move(*route));
     }
@@ -1119,7 +1119,7 @@ XdsRouteConfigResource XdsRouteConfigResource::Parse(
   // For cluster specifier plugins that were not used in any route action,
   // delete them from the update, since they will never be used.
   for (auto& unused_plugin : cluster_specifier_plugins_not_seen) {
-    rds_update.cluster_specifier_plugin_map.erase(std::string(unused_plugin));
+    rds_update->cluster_specifier_plugin_map.erase(std::string(unused_plugin));
   }
   return rds_update;
 }
@@ -1177,10 +1177,9 @@ XdsResourceType::DecodeResult XdsRouteConfigResourceType::Decode(
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_INFO, "[xds_client %p] parsed RouteConfiguration %s: %s",
               context.client, result.name->c_str(),
-              rds_update.ToString().c_str());
+              rds_update->ToString().c_str());
     }
-    result.resource =
-        std::make_unique<XdsRouteConfigResource>(std::move(rds_update));
+    result.resource = std::move(rds_update);
   }
   return result;
 }