grpc 1.56.0 → 1.61.0

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

@@ -18,7 +18,6 @@
 
 #include "src/core/ext/xds/xds_http_filters.h"
 
-#include <algorithm>
 #include <map>
 #include <utility>
 #include <vector>
@@ -29,7 +28,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 +86,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_filters.h

@@ -112,8 +112,7 @@ class XdsHttpFilterImpl {
   // there is no override in any of those locations.
   virtual absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
       const FilterConfig& hcm_filter_config,
-      const FilterConfig* filter_config_override,
-      absl::string_view filter_name) const = 0;
+      const FilterConfig* filter_config_override) const = 0;
 
   // Returns true if the filter is supported on clients; false otherwise
   virtual bool IsSupportedOnClients() const = 0;
@@ -139,8 +138,7 @@ class XdsHttpRouterFilter : public XdsHttpFilterImpl {
   const grpc_channel_filter* channel_filter() const override { return nullptr; }
   absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
       const FilterConfig& /*hcm_filter_config*/,
-      const FilterConfig* /*filter_config_override*/,
-      absl::string_view /*filter_name*/) const override {
+      const FilterConfig* /*filter_config_override*/) const override {
     // This will never be called, since channel_filter() returns null.
     return absl::UnimplementedError("router filter should never be called");
   }

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

@@ -40,7 +40,7 @@
 #include "envoy/type/matcher/v3/string.upb.h"
 #include "envoy/type/v3/range.upb.h"
 #include "google/protobuf/wrappers.upb.h"
-#include "upb/collections/map.h"
+#include "upb/message/map.h"
 
 #include <grpc/support/json.h>
 
@@ -486,8 +486,10 @@ Json ParseHttpRbacToJson(const XdsResourceType::DecodeContext& context,
           ValidationErrors::ScopedField field(errors, ".audit_condition");
           errors->AddError("invalid audit condition");
       }
-      if (envoy_config_rbac_v3_RBAC_AuditLoggingOptions_has_logger_configs(
-              audit_logging_options)) {
+      size_t size;
+      envoy_config_rbac_v3_RBAC_AuditLoggingOptions_logger_configs(
+          audit_logging_options, &size);
+      if (size != 0) {
         inner_rbac_json.emplace("audit_loggers",
                                 ParseAuditLoggerConfigsToJson(
                                     context, audit_logging_options, errors));
@@ -575,17 +577,12 @@ ChannelArgs XdsHttpRbacFilter::ModifyChannelArgs(
 absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
 XdsHttpRbacFilter::GenerateServiceConfig(
     const FilterConfig& hcm_filter_config,
-    const FilterConfig* filter_config_override,
-    absl::string_view filter_name) const {
+    const FilterConfig* filter_config_override) const {
   const Json& policy_json = filter_config_override != nullptr
                                 ? filter_config_override->config
                                 : hcm_filter_config.config;
-  auto json_object = policy_json.object();
-  json_object.emplace("filter_name",
-                      Json::FromString(std::string(filter_name)));
-  // The policy JSON may be empty other than the filter name, that's allowed.
-  return ServiceConfigJsonEntry{"rbacPolicy",
-                                JsonDump(Json::FromObject(json_object))};
+  // The policy JSON may be empty and that's allowed.
+  return ServiceConfigJsonEntry{"rbacPolicy", JsonDump(policy_json)};
 }
 
 }  // namespace grpc_core

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

@@ -48,8 +48,7 @@ class XdsHttpRbacFilter : public XdsHttpFilterImpl {
   ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const override;
   absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
       const FilterConfig& hcm_filter_config,
-      const FilterConfig* filter_config_override,
-      absl::string_view filter_name) const override;
+      const FilterConfig* filter_config_override) const override;
   bool IsSupportedOnClients() const override { return false; }
   bool IsSupportedOnServers() const override { return true; }
 };

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);
     }
   }
@@ -211,8 +208,7 @@ ChannelArgs XdsHttpStatefulSessionFilter::ModifyChannelArgs(
 absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
 XdsHttpStatefulSessionFilter::GenerateServiceConfig(
     const FilterConfig& hcm_filter_config,
-    const FilterConfig* filter_config_override,
-    absl::string_view /*filter_name*/) const {
+    const FilterConfig* filter_config_override) const {
   const Json& config = filter_config_override != nullptr
                            ? filter_config_override->config
                            : hcm_filter_config.config;

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

@@ -48,8 +48,7 @@ class XdsHttpStatefulSessionFilter : public XdsHttpFilterImpl {
   ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const override;
   absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
       const FilterConfig& hcm_filter_config,
-      const FilterConfig* filter_config_override,
-      absl::string_view filter_name) const override;
+      const FilterConfig* filter_config_override) const override;
   bool IsSupportedOnClients() const override { return true; }
   bool IsSupportedOnServers() const override { return false; }
 };

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

@@ -29,6 +29,7 @@
 #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"
 #include "envoy/extensions/load_balancing_policies/ring_hash/v3/ring_hash.upb.h"
 #include "envoy/extensions/load_balancing_policies/wrr_locality/v3/wrr_locality.upb.h"
 #include "google/protobuf/wrappers.upb.h"
@@ -254,6 +255,38 @@ class WrrLocalityLbPolicyConfigFactory
   }
 };
 
+class PickFirstLbPolicyConfigFactory
+    : public XdsLbPolicyRegistry::ConfigFactory {
+ public:
+  Json::Object ConvertXdsLbPolicyConfig(
+      const XdsLbPolicyRegistry* /*registry*/,
+      const XdsResourceType::DecodeContext& context,
+      absl::string_view configuration, ValidationErrors* errors,
+      int /*recursion_depth*/) override {
+    const auto* resource =
+        envoy_extensions_load_balancing_policies_pick_first_v3_PickFirst_parse(
+            configuration.data(), configuration.size(), context.arena);
+    if (resource == nullptr) {
+      errors->AddError("can't decode PickFirst LB policy config");
+      return {};
+    }
+    bool shuffle_address_list =
+        envoy_extensions_load_balancing_policies_pick_first_v3_PickFirst_shuffle_address_list(
+            resource);
+    return Json::Object{
+        {"pick_first",
+         Json::FromObject({
+             {"shuffleAddressList", Json::FromBool(shuffle_address_list)},
+         })}};
+  }
+
+  absl::string_view type() override { return Type(); }
+
+  static absl::string_view Type() {
+    return "envoy.extensions.load_balancing_policies.pick_first.v3.PickFirst";
+  }
+};
+
 }  // namespace
 
 //
@@ -273,6 +306,9 @@ XdsLbPolicyRegistry::XdsLbPolicyRegistry() {
   policy_config_factories_.emplace(
       WrrLocalityLbPolicyConfigFactory::Type(),
       std::make_unique<WrrLocalityLbPolicyConfigFactory>());
+  policy_config_factories_.emplace(
+      PickFirstLbPolicyConfigFactory::Type(),
+      std::make_unique<PickFirstLbPolicyConfigFactory>());
 }
 
 Json::Array XdsLbPolicyRegistry::ConvertXdsLbPolicyConfig(

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

@@ -20,7 +20,6 @@
 
 #include <stdint.h>
 
-#include <initializer_list>
 #include <set>
 #include <utility>
 
@@ -37,7 +36,6 @@
 #include "envoy/config/listener/v3/listener.upb.h"
 #include "envoy/config/listener/v3/listener.upbdefs.h"
 #include "envoy/config/listener/v3/listener_components.upb.h"
-#include "envoy/config/rbac/v3/rbac.upb.h"
 #include "envoy/config/route/v3/route.upb.h"
 #include "envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upb.h"
 #include "envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upbdefs.h"
@@ -45,7 +43,6 @@
 #include "google/protobuf/any.upb.h"
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/wrappers.upb.h"
-#include "upb/base/string_view.h"
 #include "upb/text/encode.h"
 
 #include <grpc/support/log.h>
@@ -60,6 +57,7 @@
 #include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/matchers/matchers.h"
 
 namespace grpc_core {
 
@@ -74,8 +72,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()));
@@ -293,8 +291,9 @@ void MaybeLogHttpConnectionManager(
         envoy_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager_getmsgdef(
             context.symtab);
     char buf[10240];
-    upb_TextEncode(http_connection_manager_config, msg_type, nullptr, 0, buf,
-                   sizeof(buf));
+    upb_TextEncode(
+        reinterpret_cast<const upb_Message*>(http_connection_manager_config),
+        msg_type, nullptr, 0, buf, sizeof(buf));
     gpr_log(GPR_DEBUG, "[xds_client %p] HttpConnectionManager: %s",
             context.client, buf);
   }
@@ -334,11 +333,15 @@ XdsListenerResource::HttpConnectionManager HttpConnectionManagerParse(
   }
   // original_ip_detection_extensions -- must be empty as per
   // https://github.com/grpc/proposal/blob/master/A41-xds-rbac.md
-  if (envoy_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager_has_original_ip_detection_extensions(
-          http_connection_manager_proto)) {
-    ValidationErrors::ScopedField field(errors,
-                                        ".original_ip_detection_extensions");
-    errors->AddError("must be empty");
+  {
+    size_t size;
+    envoy_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager_original_ip_detection_extensions(
+        http_connection_manager_proto, &size);
+    if (size != 0) {
+      ValidationErrors::ScopedField field(errors,
+                                          ".original_ip_detection_extensions");
+      errors->AddError("must be empty");
+    }
   }
   // common_http_protocol_options
   const envoy_config_core_v3_HttpProtocolOptions* options =
@@ -490,17 +493,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 +995,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 +1058,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.
@@ -1092,7 +1096,8 @@ void MaybeLogListener(const XdsResourceType::DecodeContext& context,
     const upb_MessageDef* msg_type =
         envoy_config_listener_v3_Listener_getmsgdef(context.symtab);
     char buf[10240];
-    upb_TextEncode(listener, msg_type, nullptr, 0, buf, sizeof(buf));
+    upb_TextEncode(reinterpret_cast<const upb_Message*>(listener), msg_type,
+                   nullptr, 0, buf, sizeof(buf));
     gpr_log(GPR_DEBUG, "[xds_client %p] Listener: %s", context.client, buf);
   }
 }
@@ -1127,10 +1132,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,19 @@ 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,
+        RefCountedPtr<XdsClient::ReadDelayHandle> read_delay_handle) = 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,
+        RefCountedPtr<XdsClient::ReadDelayHandle> read_delay_handle) override {
+      OnResourceChanged(
+          std::static_pointer_cast<const ResourceType>(std::move(resource)),
+          std::move(read_delay_handle));
     }
   };
 
@@ -75,12 +81,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

@@ -21,7 +21,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include <initializer_list>
 #include <limits>
 #include <map>
 #include <memory>
@@ -53,7 +52,7 @@
 #include "google/protobuf/wrappers.upb.h"
 #include "re2/re2.h"
 #include "upb/base/string_view.h"
-#include "upb/collections/map.h"
+#include "upb/message/map.h"
 #include "upb/text/encode.h"
 
 #include <grpc/status.h>
@@ -289,33 +288,44 @@ std::string XdsRouteConfigResource::Route::ToString() const {
   return absl::StrJoin(contents, "\n");
 }
 
+//
+// XdsRouteConfigResource::Route
+//
+
+std::string XdsRouteConfigResource::VirtualHost::ToString() const {
+  std::vector<std::string> parts;
+  parts.push_back(
+      absl::StrCat("vhost={\n"
+                   "  domains=[",
+                   absl::StrJoin(domains, ", "),
+                   "]\n"
+                   "  routes=[\n"));
+  for (const XdsRouteConfigResource::Route& route : routes) {
+    parts.push_back("    {\n");
+    parts.push_back(route.ToString());
+    parts.push_back("\n    }\n");
+  }
+  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;
+    parts.push_back(absl::StrCat("    ", name, "=", config.ToString(), "\n"));
+  }
+  parts.push_back("  }\n");
+  parts.push_back("}\n");
+  return absl::StrJoin(parts, "");
+}
+
 //
 // XdsRouteConfigResource
 //
 
 std::string XdsRouteConfigResource::ToString() const {
   std::vector<std::string> parts;
+  parts.reserve(virtual_hosts.size());
   for (const VirtualHost& vhost : virtual_hosts) {
-    parts.push_back(
-        absl::StrCat("vhost={\n"
-                     "  domains=[",
-                     absl::StrJoin(vhost.domains, ", "),
-                     "]\n"
-                     "  routes=[\n"));
-    for (const XdsRouteConfigResource::Route& route : vhost.routes) {
-      parts.push_back("    {\n");
-      parts.push_back(route.ToString());
-      parts.push_back("\n    }\n");
-    }
-    parts.push_back("  ]\n");
-    parts.push_back("  typed_per_filter_config={\n");
-    for (const auto& p : vhost.typed_per_filter_config) {
-      const std::string& name = p.first;
-      const auto& config = p.second;
-      parts.push_back(absl::StrCat("    ", name, "=", config.ToString(), "\n"));
-    }
-    parts.push_back("  }\n");
-    parts.push_back("]\n");
+    parts.push_back(vhost.ToString());
   }
   parts.push_back("cluster_specifier_plugins={\n");
   for (const auto& it : cluster_specifier_plugin_map) {
@@ -349,6 +359,10 @@ XdsRouteConfigResource::ClusterSpecifierPluginMap ClusterSpecifierPluginParse(
     const envoy_config_core_v3_TypedExtensionConfig* typed_extension_config =
         envoy_config_route_v3_ClusterSpecifierPlugin_extension(
             cluster_specifier_plugin[i]);
+    if (typed_extension_config == nullptr) {
+      errors->AddError("field not present");
+      continue;
+    }
     std::string name = UpbStringToStdString(
         envoy_config_core_v3_TypedExtensionConfig_name(typed_extension_config));
     if (cluster_specifier_plugin_map.find(name) !=
@@ -1032,20 +1046,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.
@@ -1056,9 +1070,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(
@@ -1107,7 +1121,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));
     }
@@ -1115,7 +1129,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;
 }
@@ -1134,7 +1148,8 @@ void MaybeLogRouteConfiguration(
     const upb_MessageDef* msg_type =
         envoy_config_route_v3_RouteConfiguration_getmsgdef(context.symtab);
     char buf[10240];
-    upb_TextEncode(route_config, msg_type, nullptr, 0, buf, sizeof(buf));
+    upb_TextEncode(reinterpret_cast<const upb_Message*>(route_config), msg_type,
+                   nullptr, 0, buf, sizeof(buf));
     gpr_log(GPR_DEBUG, "[xds_client %p] RouteConfiguration: %s", context.client,
             buf);
   }
@@ -1173,10 +1188,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;
 }

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

@@ -209,6 +209,7 @@ struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
       return domains == other.domains && routes == other.routes &&
              typed_per_filter_config == other.typed_per_filter_config;
     }
+    std::string ToString() const;
   };
 
   std::vector<VirtualHost> virtual_hosts;
@@ -220,7 +221,7 @@ struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
   }
   std::string ToString() const;
 
-  static XdsRouteConfigResource Parse(
+  static std::shared_ptr<const XdsRouteConfigResource> Parse(
       const XdsResourceType::DecodeContext& context,
       const envoy_config_route_v3_RouteConfiguration* route_config,
       ValidationErrors* errors);

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

@@ -248,8 +248,8 @@ XdsRouting::GeneratePerHTTPFilterConfigs(
         FindFilterConfigOverride(http_filter.name, vhost, route,
                                  cluster_weight);
     // Generate service config for filter.
-    auto method_config_field = filter_impl->GenerateServiceConfig(
-        http_filter.config, config_override, http_filter.name);
+    auto method_config_field =
+        filter_impl->GenerateServiceConfig(http_filter.config, config_override);
     if (!method_config_field.ok()) {
       return absl::FailedPreconditionError(absl::StrCat(
           "failed to generate method config for HTTP filter ", http_filter.name,