grpc 1.78.0 → 1.80.0.pre1

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

@@ -76,19 +76,18 @@ absl::string_view XdsHttpFaultFilter::ConfigProtoName() const {
 }
 
 absl::string_view XdsHttpFaultFilter::OverrideConfigProtoName() const {
-  return "";
+  return "envoy.extensions.filters.http.fault.v3.HTTPFault";
 }
 
 void XdsHttpFaultFilter::PopulateSymtab(upb_DefPool* symtab) const {
   envoy_extensions_filters_http_fault_v3_HTTPFault_getmsgdef(symtab);
 }
 
-std::optional<XdsHttpFilterImpl::FilterConfig>
-XdsHttpFaultFilter::GenerateFilterConfig(
+std::optional<Json> XdsHttpFaultFilter::GenerateFilterConfig(
     absl::string_view /*instance_name*/,
-    const XdsResourceType::DecodeContext& context, XdsExtension extension,
-    ValidationErrors* errors) const {
-  absl::string_view* serialized_filter_config =
+    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 fault injection filter config");
@@ -199,27 +198,26 @@ XdsHttpFaultFilter::GenerateFilterConfig(
     fault_injection_policy_json["maxFaults"] =
         Json::FromNumber(*max_fault_wrapper);
   }
-  return FilterConfig{ConfigProtoName(),
-                      Json::FromObject(std::move(fault_injection_policy_json))};
+  return Json::FromObject(std::move(fault_injection_policy_json));
 }
 
-std::optional<XdsHttpFilterImpl::FilterConfig>
-XdsHttpFaultFilter::GenerateFilterConfigOverride(
+std::optional<Json> XdsHttpFaultFilter::GenerateFilterConfigOverride(
     absl::string_view instance_name,
-    const XdsResourceType::DecodeContext& context, XdsExtension extension,
-    ValidationErrors* errors) const {
+    const XdsResourceType::DecodeContext& context,
+    const XdsExtension& extension, ValidationErrors* errors) const {
   // HTTPFault filter has the same message type in HTTP connection manager's
   // filter config and in overriding filter config field.
-  return GenerateFilterConfig(instance_name, context, std::move(extension),
-                              errors);
+  return GenerateFilterConfig(instance_name, context, extension, errors);
 }
 
-void XdsHttpFaultFilter::AddFilter(InterceptionChainBuilder& builder) const {
-  builder.Add<FaultInjectionFilter>(nullptr);
+const grpc_channel_filter* XdsHttpFaultFilter::channel_filter() const {
+  return &FaultInjectionFilter::kFilterVtable;
 }
 
-const grpc_channel_filter* XdsHttpFaultFilter::channel_filter() const {
-  return &FaultInjectionFilter::kFilter;
+void XdsHttpFaultFilter::AddFilter(
+    FilterChainBuilder& builder,
+    RefCountedPtr<const FilterConfig> config) const {
+  builder.AddFilter<FaultInjectionFilter>(std::move(config));
 }
 
 ChannelArgs XdsHttpFaultFilter::ModifyChannelArgs(
@@ -229,19 +227,125 @@ ChannelArgs XdsHttpFaultFilter::ModifyChannelArgs(
 
 absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
 XdsHttpFaultFilter::GenerateMethodConfig(
-    const FilterConfig& hcm_filter_config,
-    const FilterConfig* filter_config_override) const {
-  Json policy_json = filter_config_override != nullptr
-                         ? filter_config_override->config
-                         : hcm_filter_config.config;
+    const Json& hcm_filter_config, const Json* filter_config_override) const {
+  const Json& policy_json = filter_config_override != nullptr
+                                ? *filter_config_override
+                                : hcm_filter_config;
   // The policy JSON may be empty, that's allowed.
   return ServiceConfigJsonEntry{"faultInjectionPolicy", JsonDump(policy_json)};
 }
 
 absl::StatusOr<XdsHttpFilterImpl::ServiceConfigJsonEntry>
 XdsHttpFaultFilter::GenerateServiceConfig(
-    const FilterConfig& /*hcm_filter_config*/) const {
+    const Json& /*hcm_filter_config*/) const {
   return ServiceConfigJsonEntry{"", ""};
 }
 
+RefCountedPtr<const FilterConfig> XdsHttpFaultFilter::ParseTopLevelConfig(
+    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 fault injection filter config");
+    return nullptr;
+  }
+  auto* http_fault = envoy_extensions_filters_http_fault_v3_HTTPFault_parse(
+      serialized_filter_config->data(), serialized_filter_config->size(),
+      context.arena);
+  if (http_fault == nullptr) {
+    errors->AddError("could not parse fault injection filter config");
+    return nullptr;
+  }
+  auto config = MakeRefCounted<FaultInjectionFilter::Config>();
+  // Section 1: Parse the abort injection config
+  const auto* fault_abort =
+      envoy_extensions_filters_http_fault_v3_HTTPFault_abort(http_fault);
+  if (fault_abort != nullptr) {
+    ValidationErrors::ScopedField field(errors, ".abort");
+    // Try if gRPC status code is set first.  Otherwise, use HTTP status.
+    if (int abort_grpc_status_code_raw =
+            envoy_extensions_filters_http_fault_v3_FaultAbort_grpc_status(
+                fault_abort);
+        abort_grpc_status_code_raw != 0) {
+      if (!grpc_status_code_from_int(abort_grpc_status_code_raw,
+                                     &config->abort_code)) {
+        ValidationErrors::ScopedField field(errors, ".grpc_status");
+        errors->AddError(absl::StrCat("invalid gRPC status code: ",
+                                      abort_grpc_status_code_raw));
+      }
+    } else if (
+        int abort_http_status_code =
+            envoy_extensions_filters_http_fault_v3_FaultAbort_http_status(
+                fault_abort);
+        abort_http_status_code != 0 && abort_http_status_code != 200) {
+      config->abort_code =
+          grpc_http2_status_to_grpc_status(abort_http_status_code);
+    }
+    // Set the headers if we enabled header abort injection control
+    if (envoy_extensions_filters_http_fault_v3_FaultAbort_has_header_abort(
+            fault_abort)) {
+      config->abort_code_header = "x-envoy-fault-abort-grpc-request";
+      config->abort_percentage_header = "x-envoy-fault-abort-percentage";
+    }
+    // Set the fraction percent
+    auto* percent =
+        envoy_extensions_filters_http_fault_v3_FaultAbort_percentage(
+            fault_abort);
+    if (percent != nullptr) {
+      config->abort_percentage_numerator =
+          envoy_type_v3_FractionalPercent_numerator(percent);
+      config->abort_percentage_denominator = GetDenominator(percent);
+    }
+  }
+  // Section 2: Parse the delay injection config
+  const auto* fault_delay =
+      envoy_extensions_filters_http_fault_v3_HTTPFault_delay(http_fault);
+  if (fault_delay != nullptr) {
+    ValidationErrors::ScopedField field(errors, ".delay");
+    // Parse the delay duration
+    const auto* delay_duration =
+        envoy_extensions_filters_common_fault_v3_FaultDelay_fixed_delay(
+            fault_delay);
+    if (delay_duration != nullptr) {
+      ValidationErrors::ScopedField field(errors, ".fixed_delay");
+      config->delay = ParseDuration(delay_duration, errors);
+    }
+    // Set the headers if we enabled header delay injection control
+    if (envoy_extensions_filters_common_fault_v3_FaultDelay_has_header_delay(
+            fault_delay)) {
+      config->delay_header = "x-envoy-fault-delay-request";
+      config->delay_percentage_header =
+          "x-envoy-fault-delay-request-percentage";
+    }
+    // Set the fraction percent
+    auto* percent =
+        envoy_extensions_filters_common_fault_v3_FaultDelay_percentage(
+            fault_delay);
+    if (percent != nullptr) {
+      config->delay_percentage_numerator =
+          envoy_type_v3_FractionalPercent_numerator(percent);
+      config->delay_percentage_denominator = GetDenominator(percent);
+    }
+  }
+  // Section 3: Parse the maximum active faults
+  auto max_fault_wrapper = ParseUInt32Value(
+      envoy_extensions_filters_http_fault_v3_HTTPFault_max_active_faults(
+          http_fault));
+  if (max_fault_wrapper.has_value()) {
+    config->max_faults = *max_fault_wrapper;
+  }
+  return config;
+}
+
+RefCountedPtr<const FilterConfig> XdsHttpFaultFilter::ParseOverrideConfig(
+    absl::string_view instance_name,
+    const XdsResourceType::DecodeContext& context,
+    const XdsExtension& extension, ValidationErrors* errors) const {
+  // HTTPFault filter has the same message type in HTTP connection manager's
+  // filter config and in overriding filter config field.
+  return ParseTopLevelConfig(instance_name, context, extension, errors);
+}
+
 }  // namespace grpc_core

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

@@ -38,22 +38,31 @@ class XdsHttpFaultFilter final : public XdsHttpFilterImpl {
   absl::string_view ConfigProtoName() const override;
   absl::string_view OverrideConfigProtoName() const override;
   void PopulateSymtab(upb_DefPool* symtab) const override;
-  std::optional<FilterConfig> GenerateFilterConfig(
+  std::optional<Json> GenerateFilterConfig(
       absl::string_view /*instance_name*/,
-      const XdsResourceType::DecodeContext& context, XdsExtension extension,
-      ValidationErrors* errors) const override;
-  std::optional<FilterConfig> GenerateFilterConfigOverride(
+      const XdsResourceType::DecodeContext& context,
+      const XdsExtension& extension, ValidationErrors* errors) const override;
+  std::optional<Json> GenerateFilterConfigOverride(
       absl::string_view /*instance_name*/,
-      const XdsResourceType::DecodeContext& context, XdsExtension extension,
-      ValidationErrors* errors) const override;
-  void AddFilter(InterceptionChainBuilder& builder) const override;
+      const XdsResourceType::DecodeContext& context,
+      const XdsExtension& extension, ValidationErrors* errors) const override;
   const grpc_channel_filter* channel_filter() const override;
   ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const override;
   absl::StatusOr<ServiceConfigJsonEntry> GenerateMethodConfig(
-      const FilterConfig& hcm_filter_config,
-      const FilterConfig* filter_config_override) const override;
+      const Json& hcm_filter_config,
+      const Json* filter_config_override) const override;
   absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
-      const FilterConfig& hcm_filter_config) const override;
+      const Json& hcm_filter_config) const override;
+  void AddFilter(FilterChainBuilder& builder,
+                 RefCountedPtr<const FilterConfig> config) const override;
+  RefCountedPtr<const FilterConfig> ParseTopLevelConfig(
+      absl::string_view instance_name,
+      const XdsResourceType::DecodeContext& context,
+      const XdsExtension& extension, ValidationErrors* errors) const override;
+  RefCountedPtr<const FilterConfig> ParseOverrideConfig(
+      absl::string_view instance_name,
+      const XdsResourceType::DecodeContext& context,
+      const XdsExtension& extension, ValidationErrors* errors) const override;
   bool IsSupportedOnClients() const override { return true; }
   bool IsSupportedOnServers() const override { return false; }
 };

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

@@ -0,0 +1,38 @@
+//
+// Copyright 2025 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "src/core/xds/grpc/xds_http_filter.h"
+
+namespace grpc_core {
+
+RefCountedPtr<const FilterConfig> XdsHttpFilterImpl::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 {
+  if (cluster_weight_override_config != nullptr) {
+    return cluster_weight_override_config;
+  }
+  if (route_override_config != nullptr) {
+    return route_override_config;
+  }
+  if (virtual_host_override_config != nullptr) {
+    return virtual_host_override_config;
+  }
+  return top_level_config;
+}
+
+}  // namespace grpc_core

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

@@ -20,8 +20,8 @@
 #include <optional>
 #include <string>
 
-#include "src/core/call/interception_chain.h"
 #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"
@@ -38,19 +38,65 @@ namespace grpc_core {
 
 class XdsHttpFilterImpl {
  public:
-  struct FilterConfig {
-    absl::string_view config_proto_type_name;
-    Json config;
-
-    bool operator==(const FilterConfig& other) const {
-      return config_proto_type_name == other.config_proto_type_name &&
-             config == other.config;
-    }
-    std::string ToString() const {
-      return absl::StrCat("{config_proto_type_name=", config_proto_type_name,
-                          " config=", JsonDump(config), "}");
-    }
-  };
+  virtual ~XdsHttpFilterImpl() = default;
+
+  // Returns the top-level filter config proto message name.
+  virtual absl::string_view ConfigProtoName() const = 0;
+
+  // Returns the override filter config proto message name.
+  // If empty, no override type is supported.
+  virtual absl::string_view OverrideConfigProtoName() const = 0;
+
+  // Loads the proto message into the upb symtab.
+  virtual void PopulateSymtab(upb_DefPool* symtab) const = 0;
+
+  // Adds the filter to the builder.
+  virtual void AddFilter(FilterChainBuilder& builder,
+                         RefCountedPtr<const FilterConfig> config) const = 0;
+
+  // Parses the top-level filter config.
+  virtual RefCountedPtr<const FilterConfig> ParseTopLevelConfig(
+      absl::string_view instance_name,
+      const XdsResourceType::DecodeContext& context,
+      const XdsExtension& extension, ValidationErrors* errors) const = 0;
+
+  // Parses an override config.
+  virtual RefCountedPtr<const FilterConfig> ParseOverrideConfig(
+      absl::string_view instance_name,
+      const XdsResourceType::DecodeContext& context,
+      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.
+  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 {}
+
+  // Returns true if the filter is supported on clients; false otherwise
+  virtual bool IsSupportedOnClients() const = 0;
+
+  // Returns true if the filter is supported on servers; false otherwise
+  virtual bool IsSupportedOnServers() const = 0;
+
+  // Returns true if the filter must be the last filter in the chain.
+  virtual bool IsTerminalFilter() const { return false; }
+
+  /////////////////////////////////////////////////////////////////////////////
+  //
+  // ALL INTERFACES BELOW ARE DEPRECATED
+  //
+  /////////////////////////////////////////////////////////////////////////////
+  // TODO(roth): Remove these once the server side is migrated to the new
+  // approach for passing xDS HTTP filter configs.
 
   // Service config data for the filter, returned by GenerateServiceConfig().
   struct ServiceConfigJsonEntry {
@@ -66,34 +112,20 @@ class XdsHttpFilterImpl {
     std::string element;
   };
 
-  virtual ~XdsHttpFilterImpl() = default;
-
-  // Returns the top-level filter config proto message name.
-  virtual absl::string_view ConfigProtoName() const = 0;
-
-  // Returns the override filter config proto message name.
-  // If empty, no override type is supported.
-  virtual absl::string_view OverrideConfigProtoName() const = 0;
-
-  // Loads the proto message into the upb symtab.
-  virtual void PopulateSymtab(upb_DefPool* symtab) const = 0;
-
   // Generates a Config from the xDS filter config proto.
   // Used for the top-level config in the HCM HTTP filter list.
-  virtual std::optional<FilterConfig> GenerateFilterConfig(
+  virtual std::optional<Json> GenerateFilterConfig(
       absl::string_view instance_name,
-      const XdsResourceType::DecodeContext& context, XdsExtension extension,
-      ValidationErrors* errors) const = 0;
+      const XdsResourceType::DecodeContext& context,
+      const XdsExtension& extension, ValidationErrors* errors) const = 0;
 
   // Generates a Config from the xDS filter config proto.
   // Used for the typed_per_filter_config override in VirtualHost and Route.
-  virtual std::optional<FilterConfig> GenerateFilterConfigOverride(
+  virtual std::optional<Json> GenerateFilterConfigOverride(
       absl::string_view instance_name,
-      const XdsResourceType::DecodeContext& context, XdsExtension extension,
-      ValidationErrors* errors) const = 0;
+      const XdsResourceType::DecodeContext& context,
+      const XdsExtension& extension, ValidationErrors* errors) const = 0;
 
-  // C-core channel filter implementation.
-  virtual void AddFilter(InterceptionChainBuilder& builder) const = 0;
   // TODO(roth): Remove this once the legacy filter stack goes away.
   virtual const grpc_channel_filter* channel_filter() const = 0;
 
@@ -110,30 +142,21 @@ class XdsHttpFilterImpl {
   // Route, or VirtualHost entries that it is found in, or null if
   // there is no override in any of those locations.
   virtual absl::StatusOr<ServiceConfigJsonEntry> GenerateMethodConfig(
-      const FilterConfig& hcm_filter_config,
-      const FilterConfig* filter_config_override) const = 0;
+      const Json& hcm_filter_config,
+      const Json* filter_config_override) const = 0;
 
   // Function to convert the Configs into a JSON string to be added to the
   // top level of the service config.
   // The hcm_filter_config comes from the HttpConnectionManager config.
   // Currently used only on the client side.
   virtual absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
-      const FilterConfig& hcm_filter_config) const = 0;
+      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 FilterConfig& /*hcm_filter_config*/,
+  virtual void UpdateBlackboard(const Json& /*hcm_filter_config*/,
                                 const Blackboard* /*old_blackboard*/,
                                 Blackboard* /*new_blackboard*/) const {}
-
-  // Returns true if the filter is supported on clients; false otherwise
-  virtual bool IsSupportedOnClients() const = 0;
-
-  // Returns true if the filter is supported on servers; false otherwise
-  virtual bool IsSupportedOnServers() const = 0;
-
-  // Returns true if the filter must be the last filter in the chain.
-  virtual bool IsTerminalFilter() const { return false; }
 };
 
 }  // namespace grpc_core

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

@@ -51,12 +51,11 @@ void XdsHttpRouterFilter::PopulateSymtab(upb_DefPool* symtab) const {
   envoy_extensions_filters_http_router_v3_Router_getmsgdef(symtab);
 }
 
-std::optional<XdsHttpFilterImpl::FilterConfig>
-XdsHttpRouterFilter::GenerateFilterConfig(
+std::optional<Json> XdsHttpRouterFilter::GenerateFilterConfig(
     absl::string_view /*instance_name*/,
-    const XdsResourceType::DecodeContext& context, XdsExtension extension,
-    ValidationErrors* errors) const {
-  absl::string_view* serialized_filter_config =
+    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 router filter config");
@@ -68,18 +67,44 @@ XdsHttpRouterFilter::GenerateFilterConfig(
     errors->AddError("could not parse router filter config");
     return std::nullopt;
   }
-  return FilterConfig{ConfigProtoName(), Json()};
+  return Json();
 }
 
-std::optional<XdsHttpFilterImpl::FilterConfig>
-XdsHttpRouterFilter::GenerateFilterConfigOverride(
+std::optional<Json> XdsHttpRouterFilter::GenerateFilterConfigOverride(
     absl::string_view /*instance_name*/,
     const XdsResourceType::DecodeContext& /*context*/,
-    XdsExtension /*extension*/, ValidationErrors* errors) const {
+    const XdsExtension& /*extension*/, ValidationErrors* errors) const {
   errors->AddError("router filter does not support config override");
   return std::nullopt;
 }
 
+RefCountedPtr<const FilterConfig> XdsHttpRouterFilter::ParseTopLevelConfig(
+    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 router filter config");
+    return nullptr;
+  }
+  if (envoy_extensions_filters_http_router_v3_Router_parse(
+          serialized_filter_config->data(), serialized_filter_config->size(),
+          context.arena) == nullptr) {
+    errors->AddError("could not parse router filter config");
+    return nullptr;
+  }
+  return nullptr;
+}
+
+RefCountedPtr<const FilterConfig> XdsHttpRouterFilter::ParseOverrideConfig(
+    absl::string_view /*instance_name*/,
+    const XdsResourceType::DecodeContext& /*context*/,
+    const XdsExtension& /*extension*/, ValidationErrors* errors) const {
+  errors->AddError("router filter does not support config override");
+  return nullptr;
+}
+
 //
 // XdsHttpFilterRegistry
 //
@@ -97,18 +122,27 @@ XdsHttpFilterRegistry::XdsHttpFilterRegistry(bool register_builtins) {
 void XdsHttpFilterRegistry::RegisterFilter(
     std::unique_ptr<XdsHttpFilterImpl> filter) {
   GRPC_CHECK(
-      registry_map_.emplace(filter->ConfigProtoName(), filter.get()).second);
+      top_level_config_map_.emplace(filter->ConfigProtoName(), filter.get())
+          .second);
   auto override_proto_name = filter->OverrideConfigProtoName();
   if (!override_proto_name.empty()) {
-    GRPC_CHECK(registry_map_.emplace(override_proto_name, filter.get()).second);
+    GRPC_CHECK(
+        override_config_map_.emplace(override_proto_name, filter.get()).second);
   }
   owning_list_.push_back(std::move(filter));
 }
 
-const XdsHttpFilterImpl* XdsHttpFilterRegistry::GetFilterForType(
+const XdsHttpFilterImpl* XdsHttpFilterRegistry::GetFilterForTopLevelType(
+    absl::string_view proto_type_name) const {
+  auto it = top_level_config_map_.find(proto_type_name);
+  if (it == top_level_config_map_.end()) return nullptr;
+  return it->second;
+}
+
+const XdsHttpFilterImpl* XdsHttpFilterRegistry::GetFilterForOverrideType(
     absl::string_view proto_type_name) const {
-  auto it = registry_map_.find(proto_type_name);
-  if (it == registry_map_.end()) return nullptr;
+  auto it = override_config_map_.find(proto_type_name);
+  if (it == override_config_map_.end()) return nullptr;
   return it->second;
 }
 

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

@@ -24,7 +24,6 @@
 #include <utility>
 #include <vector>
 
-#include "src/core/call/interception_chain.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/util/validation_errors.h"
@@ -43,27 +42,36 @@ class XdsHttpRouterFilter final : public XdsHttpFilterImpl {
   absl::string_view ConfigProtoName() const override;
   absl::string_view OverrideConfigProtoName() const override;
   void PopulateSymtab(upb_DefPool* symtab) const override;
-  std::optional<FilterConfig> GenerateFilterConfig(
+  std::optional<Json> GenerateFilterConfig(
       absl::string_view /*instance_name*/,
-      const XdsResourceType::DecodeContext& context, XdsExtension extension,
-      ValidationErrors* errors) const override;
-  std::optional<FilterConfig> GenerateFilterConfigOverride(
+      const XdsResourceType::DecodeContext& context,
+      const XdsExtension& extension, ValidationErrors* errors) const override;
+  std::optional<Json> GenerateFilterConfigOverride(
       absl::string_view /*instance_name*/,
-      const XdsResourceType::DecodeContext& context, XdsExtension extension,
-      ValidationErrors* errors) const override;
-  void AddFilter(InterceptionChainBuilder& /*builder*/) const override {}
+      const XdsResourceType::DecodeContext& context,
+      const XdsExtension& extension, ValidationErrors* errors) const override;
   const grpc_channel_filter* channel_filter() const override { return nullptr; }
   absl::StatusOr<ServiceConfigJsonEntry> GenerateMethodConfig(
-      const FilterConfig& /*hcm_filter_config*/,
-      const FilterConfig* /*filter_config_override*/) const override {
+      const Json& /*hcm_filter_config*/,
+      const Json* /*filter_config_override*/) const override {
     // This will never be called, since channel_filter() returns null.
     return absl::UnimplementedError("router filter should never be called");
   }
   absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
-      const FilterConfig& /*hcm_filter_config*/) const override {
+      const Json& /*hcm_filter_config*/) const override {
     // This will never be called, since channel_filter() returns null.
     return absl::UnimplementedError("router filter should never be called");
   }
+  void AddFilter(FilterChainBuilder& /*builder*/,
+                 RefCountedPtr<const FilterConfig> /*config*/) const override {}
+  RefCountedPtr<const FilterConfig> ParseTopLevelConfig(
+      absl::string_view instance_name,
+      const XdsResourceType::DecodeContext& context,
+      const XdsExtension& extension, ValidationErrors* errors) const override;
+  RefCountedPtr<const FilterConfig> ParseOverrideConfig(
+      absl::string_view instance_name,
+      const XdsResourceType::DecodeContext& context,
+      const XdsExtension& extension, ValidationErrors* errors) const override;
   bool IsSupportedOnClients() const override { return true; }
   bool IsSupportedOnServers() const override { return true; }
   bool IsTerminalFilter() const override { return true; }
@@ -80,23 +88,29 @@ class XdsHttpFilterRegistry final {
   // Movable.
   XdsHttpFilterRegistry(XdsHttpFilterRegistry&& other) noexcept
       : owning_list_(std::move(other.owning_list_)),
-        registry_map_(std::move(other.registry_map_)) {}
+        top_level_config_map_(std::move(other.top_level_config_map_)),
+        override_config_map_(std::move(other.override_config_map_)) {}
   XdsHttpFilterRegistry& operator=(XdsHttpFilterRegistry&& other) noexcept {
     owning_list_ = std::move(other.owning_list_);
-    registry_map_ = std::move(other.registry_map_);
+    top_level_config_map_ = std::move(other.top_level_config_map_);
+    override_config_map_ = std::move(other.override_config_map_);
     return *this;
   }
 
   void RegisterFilter(std::unique_ptr<XdsHttpFilterImpl> filter);
 
-  const XdsHttpFilterImpl* GetFilterForType(
+  const XdsHttpFilterImpl* GetFilterForTopLevelType(
+      absl::string_view proto_type_name) const;
+
+  const XdsHttpFilterImpl* GetFilterForOverrideType(
       absl::string_view proto_type_name) const;
 
   void PopulateSymtab(upb_DefPool* symtab) const;
 
  private:
   std::vector<std::unique_ptr<XdsHttpFilterImpl>> owning_list_;
-  std::map<absl::string_view, XdsHttpFilterImpl*> registry_map_;
+  std::map<absl::string_view, XdsHttpFilterImpl*> top_level_config_map_;
+  std::map<absl::string_view, XdsHttpFilterImpl*> override_config_map_;
 };
 
 }  // namespace grpc_core