grpc 1.83.1 → 1.84.0

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

@@ -54,7 +54,6 @@
 #include "src/core/util/json/json_writer.h"
 #include "src/core/util/match.h"
 #include "src/core/util/matchers.h"
-#include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/time.h"
 #include "src/core/util/upb_utils.h"
 #include "src/core/xds/grpc/xds_cluster_specifier_plugin.h"
@@ -71,8 +70,6 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/str_join.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 
@@ -245,73 +242,8 @@ void RouteHeaderMatchersParse(const XdsResourceType::DecodeContext& context,
                                         absl::StrCat(".headers[", i, "]"));
     const envoy_config_route_v3_HeaderMatcher* header = headers[i];
     GRPC_CHECK_NE(header, nullptr);
-    const std::string name =
-        UpbStringToStdString(envoy_config_route_v3_HeaderMatcher_name(header));
-    const bool invert_match =
-        envoy_config_route_v3_HeaderMatcher_invert_match(header);
-    if (envoy_config_route_v3_HeaderMatcher_has_string_match(header)) {
-      ValidationErrors::ScopedField field(errors, ".string_match");
-      auto string_matcher = StringMatcherParse(
-          context, envoy_config_route_v3_HeaderMatcher_string_match(header),
-          errors);
-      route->matchers.header_matchers.emplace_back(
-          HeaderMatcher::CreateFromStringMatcher(
-              name, std::move(string_matcher), invert_match));
-      continue;
-    }
-    HeaderMatcher::Type type;
-    std::string match_string;
-    int64_t range_start = 0;
-    int64_t range_end = 0;
-    bool present_match = false;
-    bool case_sensitive = true;
-    if (envoy_config_route_v3_HeaderMatcher_has_exact_match(header)) {
-      type = HeaderMatcher::Type::kExact;
-      match_string = UpbStringToStdString(
-          envoy_config_route_v3_HeaderMatcher_exact_match(header));
-    } else if (envoy_config_route_v3_HeaderMatcher_has_prefix_match(header)) {
-      type = HeaderMatcher::Type::kPrefix;
-      match_string = UpbStringToStdString(
-          envoy_config_route_v3_HeaderMatcher_prefix_match(header));
-    } else if (envoy_config_route_v3_HeaderMatcher_has_suffix_match(header)) {
-      type = HeaderMatcher::Type::kSuffix;
-      match_string = UpbStringToStdString(
-          envoy_config_route_v3_HeaderMatcher_suffix_match(header));
-    } else if (envoy_config_route_v3_HeaderMatcher_has_contains_match(header)) {
-      type = HeaderMatcher::Type::kContains;
-      match_string = UpbStringToStdString(
-          envoy_config_route_v3_HeaderMatcher_contains_match(header));
-    } else if (envoy_config_route_v3_HeaderMatcher_has_safe_regex_match(
-                   header)) {
-      const envoy_type_matcher_v3_RegexMatcher* regex_matcher =
-          envoy_config_route_v3_HeaderMatcher_safe_regex_match(header);
-      GRPC_CHECK_NE(regex_matcher, nullptr);
-      type = HeaderMatcher::Type::kSafeRegex;
-      match_string = UpbStringToStdString(
-          envoy_type_matcher_v3_RegexMatcher_regex(regex_matcher));
-    } else if (envoy_config_route_v3_HeaderMatcher_has_range_match(header)) {
-      type = HeaderMatcher::Type::kRange;
-      const envoy_type_v3_Int64Range* range_matcher =
-          envoy_config_route_v3_HeaderMatcher_range_match(header);
-      GRPC_CHECK_NE(range_matcher, nullptr);
-      range_start = envoy_type_v3_Int64Range_start(range_matcher);
-      range_end = envoy_type_v3_Int64Range_end(range_matcher);
-    } else if (envoy_config_route_v3_HeaderMatcher_has_present_match(header)) {
-      type = HeaderMatcher::Type::kPresent;
-      present_match = envoy_config_route_v3_HeaderMatcher_present_match(header);
-    } else {
-      errors->AddError("invalid header matcher");
-      continue;
-    }
-    absl::StatusOr<HeaderMatcher> header_matcher =
-        HeaderMatcher::Create(name, type, match_string, range_start, range_end,
-                              present_match, invert_match, case_sensitive);
-    if (!header_matcher.ok()) {
-      errors->AddError(absl::StrCat("cannot create header matcher: ",
-                                    header_matcher.status().message()));
-    } else {
-      route->matchers.header_matchers.emplace_back(std::move(*header_matcher));
-    }
+    route->matchers.header_matchers.emplace_back(
+        ParseXdsHeaderMatcher(context, header, errors));
   }
 }
 
@@ -369,6 +301,7 @@ XdsRouteConfigResource::TypedPerFilterConfig ParseTypedPerFilterConfig(
     auto* extension_to_use = &*extension;
     std::optional<XdsExtension> nested_extension;
     bool is_optional = false;
+    bool disabled = false;
     if (extension->type == "envoy.config.route.v3.FilterConfig") {
       absl::string_view* serialized_config =
           std::get_if<absl::string_view>(&extension->value);
@@ -382,9 +315,10 @@ XdsRouteConfigResource::TypedPerFilterConfig ParseTypedPerFilterConfig(
         errors->AddError("could not parse FilterConfig");
         continue;
       }
+      disabled = envoy_config_route_v3_FilterConfig_disabled(filter_config);
+      any = envoy_config_route_v3_FilterConfig_config(filter_config);
       is_optional =
           envoy_config_route_v3_FilterConfig_is_optional(filter_config);
-      any = envoy_config_route_v3_FilterConfig_config(filter_config);
       extension->validation_fields.emplace_back(errors, ".config");
       nested_extension = ExtractXdsExtension(context, any, errors);
       if (!nested_extension.has_value()) continue;
@@ -393,22 +327,22 @@ XdsRouteConfigResource::TypedPerFilterConfig ParseTypedPerFilterConfig(
     const auto& http_filter_registry =
         DownCast<const GrpcXdsBootstrap&>(context.client->bootstrap())
             .http_filter_registry();
-    const XdsHttpFilterImpl* filter_impl =
+    const XdsHttpFilterFactory* factory =
         http_filter_registry.GetFilterForOverrideType(extension_to_use->type);
-    if (filter_impl == nullptr) {
+    if (factory == nullptr) {
       if (!is_optional) errors->AddError("unsupported filter type");
       continue;
     }
     auto& entry = typed_per_filter_config[std::string(key)];
-    entry.config_proto_type = filter_impl->OverrideConfigProtoName();
-    std::optional<Json> filter_config =
-        filter_impl->GenerateFilterConfigOverride(key, context,
-                                                  *extension_to_use, errors);
+    entry.config_proto_type = factory->OverrideConfigProtoName();
+    entry.disabled = disabled;
+    std::optional<Json> filter_config = factory->GenerateFilterConfigOverride(
+        key, context, *extension_to_use, errors);
     if (filter_config.has_value()) {
       entry.config = std::move(*filter_config);
     }
-    entry.filter_config = filter_impl->ParseOverrideConfig(
-        key, context, *extension_to_use, errors);
+    entry.filter_config =
+        factory->ParseOverrideConfig(key, context, *extension_to_use, errors);
   }
   return typed_per_filter_config;
 }

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

@@ -29,13 +29,10 @@
 
 #include "envoy/config/route/v3/route.upb.h"
 #include "envoy/config/route/v3/route.upbdefs.h"
-#include "re2/re2.h"
 #include "src/core/call/status_util.h"
 #include "src/core/util/down_cast.h"
-#include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"
 #include "src/core/xds/grpc/xds_bootstrap_grpc.h"
-#include "src/core/xds/grpc/xds_cluster_specifier_plugin.h"
 #include "src/core/xds/grpc/xds_http_filter.h"
 #include "src/core/xds/grpc/xds_route_config.h"
 #include "src/core/xds/xds_client/xds_client.h"

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

@@ -18,7 +18,6 @@
 
 #include "src/core/xds/grpc/xds_routing.h"
 
-#include <grpc/support/port_platform.h>
 #include <stdint.h>
 #include <stdlib.h>
 
@@ -30,6 +29,8 @@
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/matchers.h"
 #include "src/core/xds/grpc/xds_http_filter.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/functional/function_ref.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/match.h"
@@ -194,23 +195,22 @@ XdsRouting::RouteConfigFilterChainBuilder::RouteConfigFilterChainBuilder(
     const std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>&
         hcm_filter_configs,
     const XdsHttpFilterRegistry& http_filter_registry,
-    FilterChainBuilder& builder,
-    absl::AnyInvocable<void(FilterChainBuilder&)> add_last_filter,
+    XdsFilterChainBuilder& builder, XdsTransportFactory& transport_factory,
     Blackboard& blackboard)
     : hcm_filter_configs_(hcm_filter_configs),
       builder_(builder),
-      add_last_filter_(std::move(add_last_filter)),
-      blackboard_(blackboard) {
-  filter_impls_.reserve(hcm_filter_configs.size());
+      blackboard_(blackboard),
+      transport_factory_(transport_factory) {
+  factories_.reserve(hcm_filter_configs.size());
   for (const auto& http_filter : hcm_filter_configs) {
     // Find filter.  This is guaranteed to succeed, because it's checked
     // at config validation time.
-    const XdsHttpFilterImpl* filter_impl =
+    const XdsHttpFilterFactory* factory =
         http_filter_registry.GetFilterForTopLevelType(
             http_filter.config_proto_type);
-    GRPC_CHECK_NE(filter_impl, nullptr);
+    GRPC_CHECK_NE(factory, nullptr);
     // Add filter to list.
-    filter_impls_.push_back(filter_impl);
+    factories_.push_back(factory);
   }
 }
 
@@ -218,20 +218,21 @@ absl::StatusOr<RefCountedPtr<const FilterChain>>
 XdsRouting::RouteConfigFilterChainBuilder::GetDefaultFilterChain() {
   if (default_filter_chain_.ok() && *default_filter_chain_ == nullptr) {
     GRPC_TRACE_LOG(xds_resolver, INFO) << "Building default filter chain:";
-    for (size_t i = 0; i < filter_impls_.size(); ++i) {
-      auto* filter_impl = filter_impls_[i];
+    for (size_t i = 0; i < factories_.size(); ++i) {
+      auto* factory = factories_[i];
       const auto& filter_config = hcm_filter_configs_[i];
+      if (filter_config.disabled) continue;
       RefCountedPtr<const FilterConfig> config;
       if (filter_config.filter_config != nullptr) {
-        config = filter_impl->MergeConfigs(filter_config.filter_config, nullptr,
-                                           nullptr, nullptr, blackboard_);
+        config =
+            factory->MergeConfigs(filter_config.filter_config, nullptr, nullptr,
+                                  nullptr, transport_factory_, blackboard_);
       }
       GRPC_TRACE_LOG(xds_resolver, INFO)
           << "  Adding filter=" << filter_config.name
           << " config=" << (config == nullptr ? "<null>" : config->ToString());
-      filter_impl->AddFilter(builder_, std::move(config));
+      builder_.AddFilter(factory, std::move(config));
     }
-    if (add_last_filter_ != nullptr) add_last_filter_(builder_);
     default_filter_chain_ = builder_.Build();
     GRPC_TRACE_LOG(xds_resolver, INFO)
         << "Filter chain creation status: " << default_filter_chain_.status();
@@ -242,17 +243,55 @@ XdsRouting::RouteConfigFilterChainBuilder::GetDefaultFilterChain() {
 namespace {
 
 RefCountedPtr<const FilterConfig> GetOverrideConfig(
-    const XdsHttpFilterImpl* filter_impl,
+    const XdsHttpFilterFactory* factory,
     const XdsRouteConfigResource::TypedPerFilterConfig& typed_per_filter_config,
     const std::string& name) {
   auto it = typed_per_filter_config.find(name);
   if (it == typed_per_filter_config.end()) return nullptr;
-  if (it->second.config_proto_type != filter_impl->OverrideConfigProtoName()) {
+  if (it->second.config_proto_type != factory->OverrideConfigProtoName()) {
     return nullptr;
   }
   return it->second.filter_config;
 }
 
+// Returns true if the filter is disabled.
+// The resolution order for the disabled flag is:
+// 1. ClusterWeight override (most specific)
+// 2. Route override
+// 3. VirtualHost override
+// 4. HCM config (least specific, default)
+bool IsFilterDisabled(
+    const XdsHttpFilterFactory* factory,
+    const XdsListenerResource::HttpConnectionManager::HttpFilter&
+        hcm_filter_config,
+    const XdsRouteConfigResource::TypedPerFilterConfig*
+        vhost_typed_per_filter_config,
+    const XdsRouteConfigResource::TypedPerFilterConfig*
+        route_typed_per_filter_config,
+    const XdsRouteConfigResource::TypedPerFilterConfig*
+        cluster_weight_typed_per_filter_config) {
+  if (cluster_weight_typed_per_filter_config != nullptr) {
+    auto it =
+        cluster_weight_typed_per_filter_config->find(hcm_filter_config.name);
+    if (it != cluster_weight_typed_per_filter_config->end()) {
+      return it->second.disabled;
+    }
+  }
+  if (route_typed_per_filter_config != nullptr) {
+    auto it = route_typed_per_filter_config->find(hcm_filter_config.name);
+    if (it != route_typed_per_filter_config->end()) {
+      return it->second.disabled;
+    }
+  }
+  if (vhost_typed_per_filter_config != nullptr) {
+    auto it = vhost_typed_per_filter_config->find(hcm_filter_config.name);
+    if (it != vhost_typed_per_filter_config->end()) {
+      return it->second.disabled;
+    }
+  }
+  return hcm_filter_config.disabled;
+}
+
 }  // namespace
 
 absl::StatusOr<RefCountedPtr<const FilterChain>>
@@ -264,24 +303,26 @@ XdsRouting::RouteConfigFilterChainBuilder::VirtualHostFilterChainBuilder::
       return route_config_builder_.GetDefaultFilterChain();
     }
     GRPC_TRACE_LOG(xds_resolver, INFO) << "Building virtual host filter chain:";
-    for (size_t i = 0; i < route_config_builder_.filter_impls_.size(); ++i) {
-      auto* filter_impl = route_config_builder_.filter_impls_[i];
+    for (size_t i = 0; i < route_config_builder_.factories_.size(); ++i) {
+      auto* factory = route_config_builder_.factories_[i];
       const auto& filter_config = route_config_builder_.hcm_filter_configs_[i];
+      if (IsFilterDisabled(factory, filter_config,
+                           &vhost_.typed_per_filter_config, nullptr, nullptr)) {
+        continue;
+      }
       RefCountedPtr<const FilterConfig> config;
       if (filter_config.filter_config != nullptr) {
         auto vhost_override_config = GetOverrideConfig(
-            filter_impl, vhost_.typed_per_filter_config, filter_config.name);
-        config = filter_impl->MergeConfigs(
+            factory, vhost_.typed_per_filter_config, filter_config.name);
+        config = factory->MergeConfigs(
             filter_config.filter_config, std::move(vhost_override_config),
-            nullptr, nullptr, route_config_builder_.blackboard_);
+            nullptr, nullptr, route_config_builder_.transport_factory_,
+            route_config_builder_.blackboard_);
       }
       GRPC_TRACE_LOG(xds_resolver, INFO)
           << "  Adding filter=" << filter_config.name
           << " config=" << (config == nullptr ? "<null>" : config->ToString());
-      filter_impl->AddFilter(route_config_builder_.builder_, std::move(config));
-    }
-    if (route_config_builder_.add_last_filter_ != nullptr) {
-      route_config_builder_.add_last_filter_(route_config_builder_.builder_);
+      route_config_builder_.builder_.AddFilter(factory, std::move(config));
     }
     vhost_filter_chain_ = route_config_builder_.builder_.Build();
     GRPC_TRACE_LOG(xds_resolver, INFO)
@@ -298,27 +339,30 @@ XdsRouting::RouteConfigFilterChainBuilder::VirtualHostFilterChainBuilder::
   // If there are no per-route overrides, use the vhost filter chain.
   if (route.typed_per_filter_config.empty()) return GetVirtualHostFilterChain();
   // Otherwise, build a new filter chain for the route.
-  for (size_t i = 0; i < route_config_builder_.filter_impls_.size(); ++i) {
-    auto* filter_impl = route_config_builder_.filter_impls_[i];
+  for (size_t i = 0; i < route_config_builder_.factories_.size(); ++i) {
+    auto* factory = route_config_builder_.factories_[i];
     const auto& filter_config = route_config_builder_.hcm_filter_configs_[i];
+    if (IsFilterDisabled(factory, filter_config,
+                         &vhost_.typed_per_filter_config,
+                         &route.typed_per_filter_config, nullptr)) {
+      continue;
+    }
     RefCountedPtr<const FilterConfig> config;
     if (filter_config.filter_config != nullptr) {
       auto vhost_override_config = GetOverrideConfig(
-          filter_impl, vhost_.typed_per_filter_config, filter_config.name);
+          factory, vhost_.typed_per_filter_config, filter_config.name);
       auto route_override_config = GetOverrideConfig(
-          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,
-          route_config_builder_.blackboard_);
+          factory, route.typed_per_filter_config, filter_config.name);
+      config = factory->MergeConfigs(filter_config.filter_config,
+                                     std::move(vhost_override_config),
+                                     std::move(route_override_config), nullptr,
+                                     route_config_builder_.transport_factory_,
+                                     route_config_builder_.blackboard_);
     }
     GRPC_TRACE_LOG(xds_resolver, INFO)
         << "  Adding filter=" << filter_config.name
         << " config=" << (config == nullptr ? "<null>" : config->ToString());
-    filter_impl->AddFilter(route_config_builder_.builder_, std::move(config));
-  }
-  if (route_config_builder_.add_last_filter_ != nullptr) {
-    route_config_builder_.add_last_filter_(route_config_builder_.builder_);
+    route_config_builder_.builder_.AddFilter(factory, std::move(config));
   }
   absl::StatusOr<RefCountedPtr<const FilterChain>> route_filter_chain =
       route_config_builder_.builder_.Build();
@@ -350,32 +394,35 @@ XdsRouting::RouteConfigFilterChainBuilder::VirtualHostFilterChainBuilder::
   }
   // Otherwise, build a new filter chain for the ClusterWeight.
   auto& route_config_builder = vhost_builder_.route_config_builder_;
-  for (size_t i = 0; i < route_config_builder.filter_impls_.size(); ++i) {
-    auto* filter_impl = route_config_builder.filter_impls_[i];
+  for (size_t i = 0; i < route_config_builder.factories_.size(); ++i) {
+    auto* factory = route_config_builder.factories_[i];
     const auto& filter_config = route_config_builder.hcm_filter_configs_[i];
+    if (IsFilterDisabled(factory, filter_config,
+                         &vhost_builder_.vhost_.typed_per_filter_config,
+                         &route_.typed_per_filter_config,
+                         &cluster_weight.typed_per_filter_config)) {
+      continue;
+    }
     RefCountedPtr<const FilterConfig> config;
     if (filter_config.filter_config != nullptr) {
       auto vhost_override_config = GetOverrideConfig(
-          filter_impl, vhost_builder_.vhost_.typed_per_filter_config,
+          factory, vhost_builder_.vhost_.typed_per_filter_config,
           filter_config.name);
       auto route_override_config = GetOverrideConfig(
-          filter_impl, route_.typed_per_filter_config, filter_config.name);
-      auto cluster_weight_override_config =
-          GetOverrideConfig(filter_impl, cluster_weight.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),
-          std::move(cluster_weight_override_config),
-          route_config_builder.blackboard_);
+          factory, route_.typed_per_filter_config, filter_config.name);
+      auto cluster_weight_override_config = GetOverrideConfig(
+          factory, cluster_weight.typed_per_filter_config, filter_config.name);
+      config = factory->MergeConfigs(filter_config.filter_config,
+                                     std::move(vhost_override_config),
+                                     std::move(route_override_config),
+                                     std::move(cluster_weight_override_config),
+                                     route_config_builder.transport_factory_,
+                                     route_config_builder.blackboard_);
     }
     GRPC_TRACE_LOG(xds_resolver, INFO)
         << "  Adding filter=" << filter_config.name
         << " config=" << (config == nullptr ? "<null>" : config->ToString());
-    filter_impl->AddFilter(route_config_builder.builder_, std::move(config));
-  }
-  if (route_config_builder.add_last_filter_ != nullptr) {
-    route_config_builder.add_last_filter_(route_config_builder.builder_);
+    route_config_builder.builder_.AddFilter(factory, std::move(config));
   }
   auto filter_chain = route_config_builder.builder_.Build();
   GRPC_TRACE_LOG(xds_resolver, INFO)
@@ -412,28 +459,28 @@ GeneratePerHTTPFilterConfigs(
     const std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>&
         http_filters,
     const ChannelArgs& args,
-    absl::FunctionRef<absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>(
-        const XdsHttpFilterImpl&,
-        const XdsListenerResource::HttpConnectionManager::HttpFilter&)>
+    absl::FunctionRef<
+        absl::StatusOr<XdsHttpFilterFactory::ServiceConfigJsonEntry>(
+            const XdsHttpFilterFactory&,
+            const XdsListenerResource::HttpConnectionManager::HttpFilter&)>
         generate_service_config) {
   XdsRouting::GeneratePerHttpFilterConfigsResult result;
   result.args = args;
   for (const auto& http_filter : http_filters) {
     // Find filter.  This is guaranteed to succeed, because it's checked
     // at config validation time in the listener parsing code.
-    const XdsHttpFilterImpl* filter_impl =
+    const XdsHttpFilterFactory* factory =
         http_filter_registry.GetFilterForTopLevelType(
             http_filter.config_proto_type);
-    GRPC_CHECK_NE(filter_impl, nullptr);
+    GRPC_CHECK_NE(factory, nullptr);
     // If there is not actually any C-core filter associated with this
     // xDS filter, then it won't need any config, so skip it.
-    if (filter_impl->channel_filter() == nullptr) continue;
+    if (factory->channel_filter() == nullptr) continue;
     // Allow filter to add channel args that may affect service config
     // parsing.
-    result.args = filter_impl->ModifyChannelArgs(result.args);
+    result.args = factory->ModifyChannelArgs(result.args);
     // Generate service config for filter.
-    auto service_config_field =
-        generate_service_config(*filter_impl, http_filter);
+    auto service_config_field = generate_service_config(*factory, http_filter);
     if (!service_config_field.ok()) {
       return absl::FailedPreconditionError(absl::StrCat(
           "failed to generate service config for HTTP filter ",
@@ -460,7 +507,7 @@ XdsRouting::GeneratePerHTTPFilterConfigsForMethodConfig(
     const ChannelArgs& args) {
   return GeneratePerHTTPFilterConfigs(
       http_filter_registry, http_filters, args,
-      [&](const XdsHttpFilterImpl& filter_impl,
+      [&](const XdsHttpFilterFactory& factory,
           const XdsListenerResource::HttpConnectionManager::HttpFilter&
               http_filter) {
         // Find override config, if any.
@@ -470,12 +517,12 @@ XdsRouting::GeneratePerHTTPFilterConfigsForMethodConfig(
         const Json* config_override = nullptr;
         if (filter_config_override != nullptr &&
             filter_config_override->config_proto_type ==
-                filter_impl.OverrideConfigProtoName()) {
+                factory.OverrideConfigProtoName()) {
           config_override = &filter_config_override->config;
         }
         // Generate service config for filter.
-        return filter_impl.GenerateMethodConfig(http_filter.config,
-                                                config_override);
+        return factory.GenerateMethodConfig(http_filter.config,
+                                            config_override);
       });
 }
 
@@ -487,10 +534,10 @@ XdsRouting::GeneratePerHTTPFilterConfigsForServiceConfig(
     const ChannelArgs& args) {
   return GeneratePerHTTPFilterConfigs(
       http_filter_registry, http_filters, args,
-      [&](const XdsHttpFilterImpl& filter_impl,
+      [&](const XdsHttpFilterFactory& factory,
           const XdsListenerResource::HttpConnectionManager::HttpFilter&
               http_filter) {
-        return filter_impl.GenerateServiceConfig(http_filter.config);
+        return factory.GenerateServiceConfig(http_filter.config);
       });
 }
 

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

@@ -19,7 +19,6 @@
 #ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_ROUTING_H
 #define GRPC_SRC_CORE_XDS_GRPC_XDS_ROUTING_H
 
-#include <grpc/support/port_platform.h>
 #include <stddef.h>
 
 #include <map>
@@ -32,6 +31,7 @@
 #include "src/core/xds/grpc/xds_http_filter_registry.h"
 #include "src/core/xds/grpc/xds_listener.h"
 #include "src/core/xds/grpc/xds_route_config.h"
+#include "absl/functional/any_invocable.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
@@ -90,6 +90,18 @@ class XdsRouting final {
   // can be used on both the client and server side.
   class RouteConfigFilterChainBuilder {
    public:
+    // A slightly different interface than the normal FilterChainBuilder
+    // that passes in the XdsHttpFilterFactory.
+    class XdsFilterChainBuilder {
+     public:
+      virtual ~XdsFilterChainBuilder() = default;
+
+      virtual void AddFilter(const XdsHttpFilterFactory* factory,
+                             RefCountedPtr<const FilterConfig> config) = 0;
+
+      virtual absl::StatusOr<RefCountedPtr<FilterChain>> Build() = 0;
+    };
+
     // Builds filter chains for each route within a VirtualHost.
     class VirtualHostFilterChainBuilder {
      public:
@@ -158,8 +170,7 @@ class XdsRouting final {
             XdsListenerResource::HttpConnectionManager::HttpFilter>&
             hcm_filter_configs,
         const XdsHttpFilterRegistry& http_filter_registry,
-        FilterChainBuilder& builder,
-        absl::AnyInvocable<void(FilterChainBuilder&)> add_last_filter,
+        XdsFilterChainBuilder& builder, XdsTransportFactory& transport_factory,
         Blackboard& blackboard);
 
     // Returns a filter chain builder for a given virtual host.
@@ -173,12 +184,12 @@ class XdsRouting final {
 
     const std::vector<XdsListenerResource::HttpConnectionManager::HttpFilter>&
         hcm_filter_configs_;
-    FilterChainBuilder& builder_;
-    absl::AnyInvocable<void(FilterChainBuilder&)> add_last_filter_;
+    XdsFilterChainBuilder& builder_;
     Blackboard& blackboard_;
+    XdsTransportFactory& transport_factory_;
 
     // Same size as hcm_filter_configs_.
-    std::vector<const XdsHttpFilterImpl*> filter_impls_;
+    std::vector<const XdsHttpFilterFactory*> factories_;
 
     // Cached default filter chain, to be used for any route that does
     // not have any filter config overrides.
@@ -186,12 +197,13 @@ class XdsRouting final {
         nullptr;
   };
 
+  // TODO(roth): Remove this struct and the following two methods when
+  // removing the xds_server_filter_chain_per_route experiment.
   struct GeneratePerHttpFilterConfigsResult {
     // Map of service config field name to list of elements for that field.
     std::map<std::string, std::vector<std::string>> per_filter_configs;
     ChannelArgs args;
   };
-
   // Generates per-HTTP filter configs for a method config.
   static absl::StatusOr<GeneratePerHttpFilterConfigsResult>
   GeneratePerHTTPFilterConfigsForMethodConfig(
@@ -203,7 +215,6 @@ class XdsRouting final {
       const XdsRouteConfigResource::Route::RouteAction::ClusterWeight*
           cluster_weight,
       const ChannelArgs& args);
-
   // Generates per-HTTP filter configs for the top-level service config.
   static absl::StatusOr<GeneratePerHttpFilterConfigsResult>
   GeneratePerHTTPFilterConfigsForServiceConfig(