grpc 1.81.1 → 1.82.0.pre2

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

@@ -20,13 +20,13 @@
 #include <optional>
 #include <string>
 
-#include "src/core/filter/blackboard.h"
 #include "src/core/filter/filter_chain.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_writer.h"
 #include "src/core/util/validation_errors.h"
+#include "src/core/xds/grpc/blackboard.h"
 #include "src/core/xds/grpc/xds_common_types.h"
 #include "src/core/xds/xds_client/xds_resource_type.h"
 #include "upb/reflection/def.h"
@@ -67,19 +67,15 @@ class XdsHttpFilterImpl {
       const XdsExtension& extension, ValidationErrors* errors) const = 0;
 
   // Returns a new filter config that takes into account any necessary
-  // overrides.  Base class returns the most specific filter config;
-  // subclasses can override if needed.
+  // overrides.  May also add objects to config from the blackboard.
+  // Base class returns the most specific filter config; subclasses can
+  // override if needed.
   virtual RefCountedPtr<const FilterConfig> MergeConfigs(
       RefCountedPtr<const FilterConfig> top_level_config,
       RefCountedPtr<const FilterConfig> virtual_host_override_config,
       RefCountedPtr<const FilterConfig> route_override_config,
-      RefCountedPtr<const FilterConfig> cluster_weight_override_config) const;
-
-  // Adds state to new_blackboard if needed for the specified filter
-  // config.  Copies existing state from old_blackboard as appropriate.
-  virtual void UpdateBlackboard(const FilterConfig& /*config*/,
-                                const Blackboard* /*old_blackboard*/,
-                                Blackboard* /*new_blackboard*/) const {}
+      RefCountedPtr<const FilterConfig> cluster_weight_override_config,
+      Blackboard& blackboard) const;
 
   // Returns true if the filter is supported on clients; false otherwise
   virtual bool IsSupportedOnClients() const = 0;
@@ -151,12 +147,6 @@ class XdsHttpFilterImpl {
   // Currently used only on the client side.
   virtual absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
       const Json& hcm_filter_config) const = 0;
-
-  // Adds state to new_blackboard if needed for the specified filter
-  // config.  Copies existing state from old_blackboard as appropriate.
-  virtual void UpdateBlackboard(const Json& /*hcm_filter_config*/,
-                                const Blackboard* /*old_blackboard*/,
-                                Blackboard* /*new_blackboard*/) const {}
 };
 
 }  // namespace grpc_core

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

@@ -113,8 +113,6 @@ RefCountedPtr<const FilterConfig> XdsHttpRouterFilter::ParseOverrideConfig(
 namespace {
 
 bool XdsCompositeFilterEnabled() {
-  // This experiment is a prereq.
-  if (!IsXdsChannelFilterChainPerRouteEnabled()) return false;
   auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_COMPOSITE_FILTER");
   if (!value.has_value()) return false;
   bool parsed_value;

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

@@ -25,7 +25,6 @@
 #include "envoy/extensions/filters/http/gcp_authn/v3/gcp_authn.upb.h"
 #include "envoy/extensions/filters/http/gcp_authn/v3/gcp_authn.upbdefs.h"
 #include "src/core/ext/filters/gcp_authentication/gcp_authentication_filter.h"
-#include "src/core/ext/filters/gcp_authentication/gcp_authentication_service_config_parser.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_writer.h"
@@ -51,64 +50,6 @@ void XdsHttpGcpAuthnFilter::PopulateSymtab(upb_DefPool* symtab) const {
       symtab);
 }
 
-namespace {
-
-Json::Object ValidateFilterConfig(
-    absl::string_view instance_name,
-    const envoy_extensions_filters_http_gcp_authn_v3_GcpAuthnFilterConfig*
-        gcp_auth,
-    ValidationErrors* errors) {
-  Json::Object config = {
-      {"filter_instance_name", Json::FromString(std::string(instance_name))}};
-  const auto* cache_config =
-      envoy_extensions_filters_http_gcp_authn_v3_GcpAuthnFilterConfig_cache_config(
-          gcp_auth);
-  if (cache_config == nullptr) return config;
-  uint64_t cache_size =
-      ParseUInt64Value(
-          envoy_extensions_filters_http_gcp_authn_v3_TokenCacheConfig_cache_size(
-              cache_config))
-          .value_or(10);
-  if (cache_size == 0) {
-    ValidationErrors::ScopedField field(errors, ".cache_config.cache_size");
-    errors->AddError("must be greater than 0");
-  }
-  config["cache_size"] = Json::FromNumber(cache_size);
-  return config;
-}
-
-}  // namespace
-
-std::optional<Json> XdsHttpGcpAuthnFilter::GenerateFilterConfig(
-    absl::string_view instance_name,
-    const XdsResourceType::DecodeContext& context,
-    const XdsExtension& extension, ValidationErrors* errors) const {
-  const absl::string_view* serialized_filter_config =
-      std::get_if<absl::string_view>(&extension.value);
-  if (serialized_filter_config == nullptr) {
-    errors->AddError("could not parse GCP auth filter config");
-    return std::nullopt;
-  }
-  auto* gcp_auth =
-      envoy_extensions_filters_http_gcp_authn_v3_GcpAuthnFilterConfig_parse(
-          serialized_filter_config->data(), serialized_filter_config->size(),
-          context.arena);
-  if (gcp_auth == nullptr) {
-    errors->AddError("could not parse GCP auth filter config");
-    return std::nullopt;
-  }
-  return Json::FromObject(
-      ValidateFilterConfig(instance_name, gcp_auth, errors));
-}
-
-std::optional<Json> XdsHttpGcpAuthnFilter::GenerateFilterConfigOverride(
-    absl::string_view /*instance_name*/,
-    const XdsResourceType::DecodeContext& /*context*/,
-    const XdsExtension& /*extension*/, ValidationErrors* errors) const {
-  errors->AddError("GCP auth filter does not support config override");
-  return std::nullopt;
-}
-
 const grpc_channel_filter* XdsHttpGcpAuthnFilter::channel_filter() const {
   return &GcpAuthenticationFilter::kFilterVtable;
 }
@@ -119,66 +60,31 @@ void XdsHttpGcpAuthnFilter::AddFilter(
   builder.AddFilter<GcpAuthenticationFilter>(std::move(config));
 }
 
-ChannelArgs XdsHttpGcpAuthnFilter::ModifyChannelArgs(
-    const ChannelArgs& args) const {
-  return args.Set(GRPC_ARG_PARSE_GCP_AUTHENTICATION_METHOD_CONFIG, 1);
-}
-
-absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
-XdsHttpGcpAuthnFilter::GenerateMethodConfig(
-    const Json& /*hcm_filter_config*/,
-    const Json* /*filter_config_override*/) const {
-  return ServiceConfigJsonEntry{"", ""};
-}
-
-absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
-XdsHttpGcpAuthnFilter::GenerateServiceConfig(
-    const Json& hcm_filter_config) const {
-  return ServiceConfigJsonEntry{"gcp_authentication",
-                                JsonDump(hcm_filter_config)};
-}
-
-void XdsHttpGcpAuthnFilter::UpdateBlackboard(const Json& hcm_filter_config,
-                                             const Blackboard* old_blackboard,
-                                             Blackboard* new_blackboard) const {
-  ValidationErrors errors;
-  auto config = LoadFromJson<GcpAuthenticationParsedConfig::Config>(
-      hcm_filter_config, JsonArgs(), &errors);
-  CHECK(errors.ok()) << errors.message("filter config validation failed");
-  RefCountedPtr<GcpAuthenticationFilter::CallCredentialsCache> cache;
-  if (old_blackboard != nullptr) {
-    cache = old_blackboard->Get<GcpAuthenticationFilter::CallCredentialsCache>(
-        config.filter_instance_name);
-  }
-  if (cache != nullptr) {
-    cache->SetMaxSize(config.cache_size);
-  } else {
-    cache = MakeRefCounted<GcpAuthenticationFilter::CallCredentialsCache>(
-        config.cache_size);
-  }
-  CHECK_NE(new_blackboard, nullptr);
-  new_blackboard->Set(config.filter_instance_name, std::move(cache));
-}
-
-void XdsHttpGcpAuthnFilter::UpdateBlackboard(const FilterConfig& config,
-                                             const Blackboard* old_blackboard,
-                                             Blackboard* new_blackboard) const {
-  const auto& filter_config =
-      DownCast<const GcpAuthenticationFilter::Config&>(config);
-  ValidationErrors errors;
-  RefCountedPtr<GcpAuthenticationFilter::CallCredentialsCache> cache;
-  if (old_blackboard != nullptr) {
-    cache = old_blackboard->Get<GcpAuthenticationFilter::CallCredentialsCache>(
-        filter_config.instance_name);
-  }
-  if (cache != nullptr) {
-    cache->SetMaxSize(filter_config.cache_size);
-  } else {
-    cache = MakeRefCounted<GcpAuthenticationFilter::CallCredentialsCache>(
-        filter_config.cache_size);
-  }
-  CHECK_NE(new_blackboard, nullptr);
-  new_blackboard->Set(filter_config.instance_name, std::move(cache));
+RefCountedPtr<const FilterConfig> XdsHttpGcpAuthnFilter::MergeConfigs(
+    RefCountedPtr<const FilterConfig> top_level_config,
+    RefCountedPtr<const FilterConfig> /*virtual_host_override_config*/,
+    RefCountedPtr<const FilterConfig> /*route_override_config*/,
+    RefCountedPtr<const FilterConfig> /*cluster_weight_override_config*/,
+    Blackboard& blackboard) const {
+  // Make a copy of the parsed config.
+  const auto& parsed_config =
+      DownCast<const GcpAuthenticationFilter::Config&>(*top_level_config);
+  auto new_config = MakeRefCounted<GcpAuthenticationFilter::Config>();
+  new_config->instance_name = parsed_config.instance_name;
+  new_config->cache_size = parsed_config.cache_size;
+  // Get the cache from the blackboard, adding it if necessary.
+  bool constructed = false;
+  new_config->cache = blackboard.GetOrSet<
+      GcpAuthenticationFilter::CallCredentialsCache>(
+      new_config->instance_name, [&]() {
+        constructed = true;
+        return MakeRefCounted<GcpAuthenticationFilter::CallCredentialsCache>(
+            new_config->cache_size);
+      });
+  // If we didn't just construct the cache object, make sure it has the
+  // right size.
+  if (!constructed) new_config->cache->SetMaxSize(new_config->cache_size);
+  return new_config;
 }
 
 RefCountedPtr<const FilterConfig> XdsHttpGcpAuthnFilter::ParseTopLevelConfig(

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

@@ -37,20 +37,31 @@ class XdsHttpGcpAuthnFilter final : public XdsHttpFilterImpl {
   absl::string_view OverrideConfigProtoName() const override;
   void PopulateSymtab(upb_DefPool* symtab) const override;
   std::optional<Json> GenerateFilterConfig(
-      absl::string_view instance_name,
-      const XdsResourceType::DecodeContext& context,
-      const XdsExtension& extension, ValidationErrors* errors) const override;
+      absl::string_view /*instance_name*/,
+      const XdsResourceType::DecodeContext& /*context*/,
+      const XdsExtension& /*extension*/,
+      ValidationErrors* /*errors*/) const override {
+    return std::nullopt;
+  }
   std::optional<Json> GenerateFilterConfigOverride(
-      absl::string_view instance_name,
-      const XdsResourceType::DecodeContext& context,
-      const XdsExtension& extension, ValidationErrors* errors) const override;
+      absl::string_view /*instance_name*/,
+      const XdsResourceType::DecodeContext& /*context*/,
+      const XdsExtension& /*extension*/,
+      ValidationErrors* /*errors*/) const override {
+    return std::nullopt;
+  }
   const grpc_channel_filter* channel_filter() const override;
-  ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const override;
   absl::StatusOr<ServiceConfigJsonEntry> GenerateMethodConfig(
-      const Json& hcm_filter_config,
-      const Json* filter_config_override) const override;
+      const Json& /*hcm_filter_config*/,
+      const Json* /*filter_config_override*/) const override {
+    return absl::UnimplementedError(
+        "old-style filter config APIs not supported");
+  }
   absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
-      const Json& hcm_filter_config) const override;
+      const Json& /*hcm_filter_config*/) const override {
+    return absl::UnimplementedError(
+        "old-style filter config APIs not supported");
+  }
   void AddFilter(FilterChainBuilder& builder,
                  RefCountedPtr<const FilterConfig> config) const override;
   RefCountedPtr<const FilterConfig> ParseTopLevelConfig(
@@ -61,11 +72,12 @@ class XdsHttpGcpAuthnFilter final : public XdsHttpFilterImpl {
       absl::string_view instance_name,
       const XdsResourceType::DecodeContext& context,
       const XdsExtension& extension, ValidationErrors* errors) const override;
-  void UpdateBlackboard(const Json& config, const Blackboard* old_blackboard,
-                        Blackboard* new_blackboard) const override;
-  void UpdateBlackboard(const FilterConfig& config,
-                        const Blackboard* old_blackboard,
-                        Blackboard* new_blackboard) const override;
+  RefCountedPtr<const FilterConfig> MergeConfigs(
+      RefCountedPtr<const FilterConfig> top_level_config,
+      RefCountedPtr<const FilterConfig> /*virtual_host_override_config*/,
+      RefCountedPtr<const FilterConfig> /*route_override_config*/,
+      RefCountedPtr<const FilterConfig> /*cluster_weight_override_config*/,
+      Blackboard& blackboard) const override;
   bool IsSupportedOnClients() const override { return true; }
   bool IsSupportedOnServers() const override { return false; }
 };

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

@@ -30,7 +30,6 @@
 #include "envoy/extensions/http/stateful_session/cookie/v3/cookie.upbdefs.h"
 #include "envoy/type/http/v3/cookie.upb.h"
 #include "src/core/ext/filters/stateful_session/stateful_session_filter.h"
-#include "src/core/ext/filters/stateful_session/stateful_session_service_config_parser.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_writer.h"
@@ -64,134 +63,6 @@ void XdsHttpStatefulSessionFilter::PopulateSymtab(upb_DefPool* symtab) const {
       symtab);
 }
 
-namespace {
-
-Json::Object ValidateStatefulSession(
-    const XdsResourceType::DecodeContext& context,
-    const envoy_extensions_filters_http_stateful_session_v3_StatefulSession*
-        stateful_session,
-    ValidationErrors* errors) {
-  ValidationErrors::ScopedField field(errors, ".session_state");
-  const auto* session_state =
-      envoy_extensions_filters_http_stateful_session_v3_StatefulSession_session_state(
-          stateful_session);
-  if (session_state == nullptr) {
-    return {};
-  }
-  ValidationErrors::ScopedField field2(errors, ".typed_config");
-  const auto* typed_config =
-      envoy_config_core_v3_TypedExtensionConfig_typed_config(session_state);
-  auto extension = ExtractXdsExtension(context, typed_config, errors);
-  if (!extension.has_value()) return {};
-  if (extension->type !=
-      "envoy.extensions.http.stateful_session.cookie.v3"
-      ".CookieBasedSessionState") {
-    errors->AddError("unsupported session state type");
-    return {};
-  }
-  absl::string_view* serialized_session_state =
-      std::get_if<absl::string_view>(&extension->value);
-  if (serialized_session_state == nullptr) {
-    errors->AddError("could not parse session state config");
-    return {};
-  }
-  auto* cookie_state =
-      envoy_extensions_http_stateful_session_cookie_v3_CookieBasedSessionState_parse(
-          serialized_session_state->data(), serialized_session_state->size(),
-          context.arena);
-  if (cookie_state == nullptr) {
-    errors->AddError("could not parse session state config");
-    return {};
-  }
-  ValidationErrors::ScopedField field3(errors, ".cookie");
-  const auto* cookie =
-      envoy_extensions_http_stateful_session_cookie_v3_CookieBasedSessionState_cookie(
-          cookie_state);
-  if (cookie == nullptr) {
-    errors->AddError("field not present");
-    return {};
-  }
-  Json::Object cookie_config;
-  // name
-  std::string cookie_name =
-      UpbStringToStdString(envoy_type_http_v3_Cookie_name(cookie));
-  if (cookie_name.empty()) {
-    ValidationErrors::ScopedField field(errors, ".name");
-    errors->AddError("field not present");
-  }
-  cookie_config["name"] = Json::FromString(std::move(cookie_name));
-  // ttl
-  {
-    ValidationErrors::ScopedField field(errors, ".ttl");
-    const auto* duration = envoy_type_http_v3_Cookie_ttl(cookie);
-    if (duration != nullptr) {
-      Duration ttl = ParseDuration(duration, errors);
-      cookie_config["ttl"] = Json::FromString(ttl.ToJsonString());
-    }
-  }
-  // path
-  std::string path =
-      UpbStringToStdString(envoy_type_http_v3_Cookie_path(cookie));
-  if (!path.empty()) cookie_config["path"] = Json::FromString(std::move(path));
-  return cookie_config;
-}
-
-}  // namespace
-
-std::optional<Json> XdsHttpStatefulSessionFilter::GenerateFilterConfig(
-    absl::string_view /*instance_name*/,
-    const XdsResourceType::DecodeContext& context,
-    const XdsExtension& extension, ValidationErrors* errors) const {
-  const absl::string_view* serialized_filter_config =
-      std::get_if<absl::string_view>(&extension.value);
-  if (serialized_filter_config == nullptr) {
-    errors->AddError("could not parse stateful session filter config");
-    return std::nullopt;
-  }
-  auto* stateful_session =
-      envoy_extensions_filters_http_stateful_session_v3_StatefulSession_parse(
-          serialized_filter_config->data(), serialized_filter_config->size(),
-          context.arena);
-  if (stateful_session == nullptr) {
-    errors->AddError("could not parse stateful session filter config");
-    return std::nullopt;
-  }
-  return Json::FromObject(
-      ValidateStatefulSession(context, stateful_session, errors));
-}
-
-std::optional<Json> XdsHttpStatefulSessionFilter::GenerateFilterConfigOverride(
-    absl::string_view /*instance_name*/,
-    const XdsResourceType::DecodeContext& context,
-    const XdsExtension& extension, ValidationErrors* errors) const {
-  const absl::string_view* serialized_filter_config =
-      std::get_if<absl::string_view>(&extension.value);
-  if (serialized_filter_config == nullptr) {
-    errors->AddError("could not parse stateful session filter override config");
-    return std::nullopt;
-  }
-  auto* stateful_session_per_route =
-      envoy_extensions_filters_http_stateful_session_v3_StatefulSessionPerRoute_parse(
-          serialized_filter_config->data(), serialized_filter_config->size(),
-          context.arena);
-  if (stateful_session_per_route == nullptr) {
-    errors->AddError("could not parse stateful session filter override config");
-    return std::nullopt;
-  }
-  Json::Object config;
-  if (!envoy_extensions_filters_http_stateful_session_v3_StatefulSessionPerRoute_disabled(
-          stateful_session_per_route)) {
-    ValidationErrors::ScopedField field(errors, ".stateful_session");
-    const auto* stateful_session =
-        envoy_extensions_filters_http_stateful_session_v3_StatefulSessionPerRoute_stateful_session(
-            stateful_session_per_route);
-    if (stateful_session != nullptr) {
-      config = ValidateStatefulSession(context, stateful_session, errors);
-    }
-  }
-  return Json::FromObject(std::move(config));
-}
-
 const grpc_channel_filter* XdsHttpStatefulSessionFilter::channel_filter()
     const {
   return &StatefulSessionFilter::kFilterVtable;
@@ -203,26 +74,6 @@ void XdsHttpStatefulSessionFilter::AddFilter(
   builder.AddFilter<StatefulSessionFilter>(std::move(config));
 }
 
-ChannelArgs XdsHttpStatefulSessionFilter::ModifyChannelArgs(
-    const ChannelArgs& args) const {
-  return args.Set(GRPC_ARG_PARSE_STATEFUL_SESSION_METHOD_CONFIG, 1);
-}
-
-absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
-XdsHttpStatefulSessionFilter::GenerateMethodConfig(
-    const Json& hcm_filter_config, const Json* filter_config_override) const {
-  const Json& config = filter_config_override != nullptr
-                           ? *filter_config_override
-                           : hcm_filter_config;
-  return ServiceConfigJsonEntry{"stateful_session", JsonDump(config)};
-}
-
-absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
-XdsHttpStatefulSessionFilter::GenerateServiceConfig(
-    const Json& /*hcm_filter_config*/) const {
-  return ServiceConfigJsonEntry{"", ""};
-}
-
 namespace {
 
 RefCountedPtr<StatefulSessionFilter::Config> ParseStatefulSession(

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

@@ -40,19 +40,30 @@ class XdsHttpStatefulSessionFilter final : public XdsHttpFilterImpl {
   void PopulateSymtab(upb_DefPool* symtab) const override;
   std::optional<Json> GenerateFilterConfig(
       absl::string_view /*instance_name*/,
-      const XdsResourceType::DecodeContext& context,
-      const XdsExtension& extension, ValidationErrors* errors) const override;
+      const XdsResourceType::DecodeContext& /*context*/,
+      const XdsExtension& /*extension*/,
+      ValidationErrors* /*errors*/) const override {
+    return std::nullopt;
+  }
   std::optional<Json> GenerateFilterConfigOverride(
       absl::string_view /*instance_name*/,
-      const XdsResourceType::DecodeContext& context,
-      const XdsExtension& extension, ValidationErrors* errors) const override;
+      const XdsResourceType::DecodeContext& /*context*/,
+      const XdsExtension& /*extension*/,
+      ValidationErrors* /*errors*/) const override {
+    return std::nullopt;
+  }
   const grpc_channel_filter* channel_filter() const override;
-  ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const override;
   absl::StatusOr<ServiceConfigJsonEntry> GenerateMethodConfig(
-      const Json& hcm_filter_config,
-      const Json* filter_config_override) const override;
+      const Json& /*hcm_filter_config*/,
+      const Json* /*filter_config_override*/) const override {
+    return absl::UnimplementedError(
+        "old-style filter config APIs not supported");
+  }
   absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
-      const Json& hcm_filter_config) const override;
+      const Json& /*hcm_filter_config*/) const override {
+    return absl::UnimplementedError(
+        "old-style filter config APIs not supported");
+  }
   void AddFilter(FilterChainBuilder& builder,
                  RefCountedPtr<const FilterConfig> config) const override;
   RefCountedPtr<const FilterConfig> ParseTopLevelConfig(

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

@@ -32,8 +32,10 @@
 #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"
+#include "src/core/client_channel/client_channel_service_config.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/load_balancing/lb_policy_registry.h"
+#include "src/core/load_balancing/weighted_round_robin/weighted_round_robin.h"
 #include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"
 #include "src/core/xds/grpc/xds_common_types.h"
@@ -135,6 +137,22 @@ class ClientSideWeightedRoundRobinLbPolicyConfigFactory final
       }
       config["errorUtilizationPenalty"] = Json::FromNumber(value);
     }
+    // metric_names_for_computing_utilization
+    if (WrrCustomMetricsEnabled()) {
+      size_t size;
+      auto metric_names_for_computing_utilization =
+          envoy_extensions_load_balancing_policies_client_side_weighted_round_robin_v3_ClientSideWeightedRoundRobin_metric_names_for_computing_utilization(
+              resource, &size);
+      if (metric_names_for_computing_utilization != nullptr && size != 0) {
+        Json::Array metric_names;
+        for (size_t i = 0; i < size; ++i) {
+          metric_names.emplace_back(Json::FromString(
+              UpbStringToStdString(metric_names_for_computing_utilization[i])));
+        }
+        config["metricNamesForComputingUtilization"] =
+            Json::FromArray(std::move(metric_names));
+      }
+    }
     return Json::Object{
         {"weighted_round_robin", Json::FromObject(std::move(config))}};
   }

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

@@ -306,17 +306,15 @@ XdsListenerResource::HttpConnectionManager HttpConnectionManagerParse(
         auto& entry = http_connection_manager.http_filters.back();
         entry.name = std::string(name);
         entry.config_proto_type = filter_impl->ConfigProtoName();
-        if (!is_client || !IsXdsChannelFilterChainPerRouteEnabled()) {
+        if (!is_client) {
           std::optional<Json> filter_config = filter_impl->GenerateFilterConfig(
               name, context, *extension, errors);
           if (filter_config.has_value()) {
             entry.config = std::move(*filter_config);
           }
         }
-        if (IsXdsChannelFilterChainPerRouteEnabled()) {
-          entry.filter_config = filter_impl->ParseTopLevelConfig(
-              name, context, *extension, errors);
-        }
+        entry.filter_config =
+            filter_impl->ParseTopLevelConfig(name, context, *extension, errors);
       }
     }
     if (errors->size() == original_error_size &&
@@ -559,10 +557,16 @@ std::optional<FilterChain::FilterChainMatch> FilterChainMatchParse(
     }
   }
   // source_type
-  filter_chain_match.source_type =
-      static_cast<XdsListenerResource::FilterChainMap::ConnectionSourceType>(
-          envoy_config_listener_v3_FilterChainMatch_source_type(
-              filter_chain_match_proto));
+  int32_t source_type = envoy_config_listener_v3_FilterChainMatch_source_type(
+      filter_chain_match_proto);
+  if (source_type < 0 || source_type > 2) {
+    ValidationErrors::ScopedField field(errors, ".source_type");
+    errors->AddError("invalid value");
+  } else {
+    filter_chain_match.source_type =
+        static_cast<XdsListenerResource::FilterChainMap::ConnectionSourceType>(
+            source_type);
+  }
   // source_prefix_ranges
   auto* source_prefix_ranges =
       envoy_config_listener_v3_FilterChainMatch_source_prefix_ranges(

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

@@ -59,7 +59,7 @@ struct XdsRouteConfigResource : public XdsResourceType::ResourceData {
                std::string /*LB policy config*/>;
 
   struct RetryPolicy {
-    internal::StatusCodeSet retry_on;
+    StatusCodeSet retry_on;
     uint32_t num_retries;
 
     struct RetryBackOff {

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

@@ -411,10 +411,8 @@ XdsRouteConfigResource::TypedPerFilterConfig ParseTypedPerFilterConfig(
     if (filter_config.has_value()) {
       entry.config = std::move(*filter_config);
     }
-    if (IsXdsChannelFilterChainPerRouteEnabled()) {
-      entry.filter_config = filter_impl->ParseOverrideConfig(
-          key, context, *extension_to_use, errors);
-    }
+    entry.filter_config = filter_impl->ParseOverrideConfig(
+        key, context, *extension_to_use, errors);
   }
   return typed_per_filter_config;
 }
@@ -778,7 +776,7 @@ std::shared_ptr<const XdsRouteConfigResource> XdsRouteConfigResourceParse(
     const envoy_config_route_v3_RouteConfiguration* route_config,
     ValidationErrors* errors) {
   auto rds_update = std::make_shared<XdsRouteConfigResource>();
-  // Get the cluster spcifier plugin map.
+  // Get the cluster specifier plugin map.
   if (XdsRlsEnabled()) {
     rds_update->cluster_specifier_plugin_map =
         ClusterSpecifierPluginParse(context, route_config, errors);

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

@@ -197,13 +197,12 @@ XdsRouting::PerRouteFilterChainBuilder::PerRouteFilterChainBuilder(
     const XdsRouteConfigResource::VirtualHost& vhost,
     FilterChainBuilder& builder,
     absl::AnyInvocable<void(FilterChainBuilder&)> add_last_filter,
-    const Blackboard* old_blackboard, Blackboard* new_blackboard)
+    Blackboard& blackboard)
     : hcm_filter_configs_(hcm_filter_configs),
       vhost_(vhost),
       builder_(builder),
       add_last_filter_(std::move(add_last_filter)),
-      old_blackboard_(old_blackboard),
-      new_blackboard_(new_blackboard) {
+      blackboard_(blackboard) {
   filter_impls_.reserve(hcm_filter_configs.size());
   for (const auto& http_filter : hcm_filter_configs) {
     // Find filter.  This is guaranteed to succeed, because it's checked
@@ -246,9 +245,7 @@ XdsRouting::PerRouteFilterChainBuilder::GetDefaultFilterChain() {
             filter_impl, vhost_.typed_per_filter_config, filter_config.name);
         config = filter_impl->MergeConfigs(filter_config.filter_config,
                                            std::move(vhost_override_config),
-                                           nullptr, nullptr);
-        filter_impl->UpdateBlackboard(*config, old_blackboard_,
-                                      new_blackboard_);
+                                           nullptr, nullptr, blackboard_);
       }
       GRPC_TRACE_LOG(xds_resolver, INFO)
           << "  Adding filter=" << filter_config.name
@@ -282,8 +279,7 @@ XdsRouting::PerRouteFilterChainBuilder::BuildFilterChainForRoute(
           filter_impl, route.typed_per_filter_config, filter_config.name);
       config = filter_impl->MergeConfigs(
           filter_config.filter_config, std::move(vhost_override_config),
-          std::move(route_override_config), nullptr);
-      filter_impl->UpdateBlackboard(*config, old_blackboard_, new_blackboard_);
+          std::move(route_override_config), nullptr, blackboard_);
     }
     GRPC_TRACE_LOG(xds_resolver, INFO)
         << "  Adding filter=" << filter_config.name
@@ -340,9 +336,7 @@ void XdsRouting::PerRouteFilterChainBuilder::
           config = filter_impl->MergeConfigs(
               filter_config.filter_config, std::move(vhost_override_config),
               std::move(route_override_config),
-              std::move(cluster_weight_override_config));
-          filter_impl->UpdateBlackboard(*config, old_blackboard_,
-                                        new_blackboard_);
+              std::move(cluster_weight_override_config), blackboard_);
         }
         GRPC_TRACE_LOG(xds_resolver, INFO)
             << "  Adding filter=" << filter_config.name << " config="