grpc 1.81.1 → 1.83.1

data/src/core/ext/filters/gcp_authentication/gcp_authentication_filter.cc

@@ -23,16 +23,15 @@
 #include "src/core/call/security_context.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/credentials/call/gcp_service_account_identity/gcp_service_account_identity_credentials.h"
-#include "src/core/ext/filters/gcp_authentication/gcp_authentication_service_config_parser.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/resolver/xds/xds_resolver_attributes.h"
-#include "src/core/service_config/service_config.h"
 #include "src/core/service_config/service_config_call_data.h"
 #include "src/core/util/grpc_check.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 
 namespace grpc_core {
 
@@ -42,12 +41,13 @@ namespace grpc_core {
 
 bool GcpAuthenticationFilter::Config::Equals(const FilterConfig& other) const {
   const auto& o = DownCast<const Config&>(other);
-  return instance_name == o.instance_name && cache_size == o.cache_size;
+  return instance_name == o.instance_name && cache_size == o.cache_size &&
+         cache == o.cache;
 }
 
 std::string GcpAuthenticationFilter::Config::ToString() const {
-  return absl::StrCat("{instance_name=\"", instance_name,
-                      "\", cache_size=", cache_size, "}");
+  return absl::StrFormat("{instance_name=\"%s\", cache_size=%u, cache=%p}",
+                         instance_name, cache_size, cache.get());
 }
 
 //
@@ -108,7 +108,7 @@ absl::Status GcpAuthenticationFilter::Call::OnClientInitialMetadata(
         cluster_name));
   }
   // Get the call creds instance.
-  auto creds = filter->cache_->Get(
+  auto creds = filter->filter_config_->cache->Get(
       DownCast<const XdsGcpAuthnAudienceMetadataValue*>(metadata_value)->url());
   // Add the call creds instance to the call.
   auto* arena = GetContext<Arena>();
@@ -158,40 +158,20 @@ const grpc_channel_filter GcpAuthenticationFilter::kFilterVtable =
 absl::StatusOr<std::unique_ptr<GcpAuthenticationFilter>>
 GcpAuthenticationFilter::Create(const ChannelArgs& args,
                                 ChannelFilter::Args filter_args) {
-  RefCountedPtr<const Config> config;
-  if (!IsXdsChannelFilterChainPerRouteEnabled()) {
-    // Construct new-style filter config from legacy service config.
-    auto service_config = args.GetObjectRef<ServiceConfig>();
-    if (service_config == nullptr) {
-      return absl::InvalidArgumentError(
-          "gcp_auth: no service config in channel args");
-    }
-    auto* global_config = static_cast<const GcpAuthenticationParsedConfig*>(
-        service_config->GetGlobalParsedConfig(
-            GcpAuthenticationServiceConfigParser::ParserIndex()));
-    if (global_config == nullptr) {
-      return absl::InvalidArgumentError("gcp_auth: parsed config not found");
-    }
-    auto* filter_config = global_config->GetConfig(filter_args.instance_id());
-    if (filter_config == nullptr) {
-      return absl::InvalidArgumentError(
-          "gcp_auth: filter instance ID not found in filter config");
-    }
-    auto new_config = MakeRefCounted<Config>();
-    new_config->instance_name = filter_config->filter_instance_name;
-    new_config->cache_size = filter_config->cache_size;
-    config = std::move(new_config);
-  } else {
-    // Get filter config.
-    if (filter_args.config() == nullptr) {
-      return absl::InternalError("gcp_auth: filter config not set");
-    }
-    if (filter_args.config()->type() != Config::Type()) {
-      return absl::InternalError(
-          absl::StrCat("wrong config type passed to GCP authn filter: ",
-                       filter_args.config()->type().name()));
-    }
-    config = filter_args.config().TakeAsSubclass<const Config>();
+  // Get filter config.
+  if (filter_args.config() == nullptr) {
+    return absl::InternalError("gcp_auth: filter config not set");
+  }
+  if (filter_args.config()->type() != Config::Type()) {
+    return absl::InternalError(
+        absl::StrCat("wrong config type passed to GCP authn filter: ",
+                     filter_args.config()->type().name()));
+  }
+  auto config = filter_args.config().TakeAsSubclass<const Config>();
+  // Make sure cache is present in config.
+  if (config->cache == nullptr) {
+    return absl::InternalError(
+        "gcp_auth: cache object not found in filter config");
   }
   // Get XdsConfig so that we can look up CDS resources.
   auto xds_config = args.GetObjectRef<XdsConfig>();
@@ -199,29 +179,15 @@ GcpAuthenticationFilter::Create(const ChannelArgs& args,
     return absl::InternalError(
         "gcp_auth: xds config not found in channel args");
   }
-  // Get cache from blackboard.  This must have been populated
-  // previously by the XdsConfigSelector.
-  auto cache =
-      filter_args.GetState<CallCredentialsCache>(config->instance_name);
-  if (cache == nullptr) {
-    return absl::InternalError(
-        "gcp_auth: cache object not found in filter state");
-  }
   // Instantiate filter.
-  return std::unique_ptr<GcpAuthenticationFilter>(new GcpAuthenticationFilter(
-      std::move(config), std::move(xds_config), std::move(cache)));
+  return std::unique_ptr<GcpAuthenticationFilter>(
+      new GcpAuthenticationFilter(std::move(config), std::move(xds_config)));
 }
 
 GcpAuthenticationFilter::GcpAuthenticationFilter(
     RefCountedPtr<const Config> filter_config,
-    RefCountedPtr<const XdsConfig> xds_config,
-    RefCountedPtr<CallCredentialsCache> cache)
+    RefCountedPtr<const XdsConfig> xds_config)
     : filter_config_(std::move(filter_config)),
-      xds_config_(std::move(xds_config)),
-      cache_(std::move(cache)) {}
-
-void GcpAuthenticationFilterRegister(CoreConfiguration::Builder* builder) {
-  GcpAuthenticationServiceConfigParser::Register(builder);
-}
+      xds_config_(std::move(xds_config)) {}
 
 }  // namespace grpc_core

data/src/core/ext/filters/gcp_authentication/gcp_authentication_filter.h

@@ -21,8 +21,6 @@
 #include <string>
 
 #include "src/core/credentials/call/call_credentials.h"
-#include "src/core/ext/filters/gcp_authentication/gcp_authentication_service_config_parser.h"
-#include "src/core/filter/blackboard.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/promise_based_filter.h"
@@ -31,6 +29,7 @@
 #include "src/core/util/lru_cache.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
+#include "src/core/xds/grpc/blackboard.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
@@ -42,19 +41,6 @@ namespace grpc_core {
 class GcpAuthenticationFilter
     : public ImplementChannelFilter<GcpAuthenticationFilter> {
  public:
-  struct Config : public FilterConfig {
-    static UniqueTypeName Type() {
-      return GRPC_UNIQUE_TYPE_NAME_HERE("gcp_authentication_filter_config");
-    }
-    UniqueTypeName type() const override { return Type(); }
-
-    bool Equals(const FilterConfig& other) const override;
-    std::string ToString() const override;
-
-    std::string instance_name;
-    uint64_t cache_size = 10;
-  };
-
   class CallCredentialsCache : public Blackboard::Entry {
    public:
     explicit CallCredentialsCache(size_t max_size) : cache_(max_size) {}
@@ -63,14 +49,35 @@ class GcpAuthenticationFilter
 
     void SetMaxSize(size_t max_size);
 
+    size_t max_size() const {
+      MutexLock lock(&mu_);
+      return cache_.max_size();
+    }
+
     RefCountedPtr<grpc_call_credentials> Get(const std::string& audience);
 
    private:
-    Mutex mu_;
+    mutable Mutex mu_;
     LruCache<std::string /*audience*/, RefCountedPtr<grpc_call_credentials>>
         cache_ ABSL_GUARDED_BY(&mu_);
   };
 
+  struct Config : public FilterConfig {
+    static UniqueTypeName Type() {
+      return GRPC_UNIQUE_TYPE_NAME_HERE("gcp_authentication_filter_config");
+    }
+    UniqueTypeName type() const override { return Type(); }
+
+    bool Equals(const FilterConfig& other) const override;
+    std::string ToString() const override;
+
+    std::string instance_name;
+    uint64_t cache_size = 10;
+
+    // Populated from the blackboard.
+    RefCountedPtr<CallCredentialsCache> cache;
+  };
+
   static const grpc_channel_filter kFilterVtable;
 
   static absl::string_view TypeName() { return "gcp_authentication_filter"; }
@@ -95,12 +102,10 @@ class GcpAuthenticationFilter
 
  private:
   GcpAuthenticationFilter(RefCountedPtr<const Config> filter_config,
-                          RefCountedPtr<const XdsConfig> xds_config,
-                          RefCountedPtr<CallCredentialsCache> cache);
+                          RefCountedPtr<const XdsConfig> xds_config);
 
   const RefCountedPtr<const Config> filter_config_;
   const RefCountedPtr<const XdsConfig> xds_config_;
-  const RefCountedPtr<CallCredentialsCache> cache_;
 };
 
 }  // namespace grpc_core

data/src/core/ext/filters/http/message_compress/compression_filter.cc

@@ -21,6 +21,7 @@
 #include <grpc/support/port_platform.h>
 #include <inttypes.h>
 
+#include <cstdint>
 #include <functional>
 #include <memory>
 #include <optional>
@@ -44,6 +45,7 @@
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/telemetry/call_tracer.h"
+#include "src/core/transport/message_size_service_config.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/latent_see.h"
 #include "absl/status/status.h"
@@ -75,8 +77,6 @@ ServerCompressionFilter::Create(const ChannelArgs& args, ChannelFilter::Args) {
 
 ChannelCompression::ChannelCompression(const ChannelArgs& args)
     : max_recv_size_(GetMaxRecvSizeFromChannelArgs(args)),
-      message_size_service_config_parser_index_(
-          MessageSizeParser::ParserIndex()),
       default_compression_algorithm_(
           DefaultCompressionAlgorithmFromChannelArgs(args).value_or(
               GRPC_COMPRESS_NONE)),
@@ -118,26 +118,25 @@ MessageHandle ChannelCompression::CompressMessage(
     return message;
   }
   // Try to compress the payload.
-  SliceBuffer tmp;
-  SliceBuffer* payload = message->payload();
-  bool did_compress = grpc_msg_compress(algorithm, payload->c_slice_buffer(),
-                                        tmp.c_slice_buffer());
+  std::optional<SliceBuffer> compressed =
+      MessageCompress(algorithm, *message->payload());
+
   // If we achieved compression send it as compressed, otherwise send it as (to
   // avoid spending cycles on the receiver decompressing).
-  if (did_compress) {
+  if (compressed.has_value()) {
     if (GRPC_TRACE_FLAG_ENABLED(compression)) {
       const char* algo_name;
-      const size_t before_size = payload->Length();
-      const size_t after_size = tmp.Length();
+      GRPC_CHECK(grpc_compression_algorithm_name(algorithm, &algo_name));
+      const size_t before_size = message->payload()->Length();
+      const size_t after_size = compressed->Length();
       const float savings_ratio = 1.0f - (static_cast<float>(after_size) /
                                           static_cast<float>(before_size));
-      GRPC_CHECK(grpc_compression_algorithm_name(algorithm, &algo_name));
       LOG(INFO) << absl::StrFormat(
           "Compressed[%s] %" PRIuPTR " bytes vs. %" PRIuPTR
           " bytes (%.2f%% savings)",
           algo_name, before_size, after_size, 100 * savings_ratio);
     }
-    tmp.Swap(payload);
+    *message->payload() = std::move(*compressed);
     flags |= GRPC_WRITE_INTERNAL_COMPRESS;
     if (call_tracer != nullptr) {
       call_tracer->RecordSendCompressedMessage(*message);
@@ -148,7 +147,7 @@ MessageHandle ChannelCompression::CompressMessage(
       GRPC_CHECK(grpc_compression_algorithm_name(algorithm, &algo_name));
       LOG(INFO) << "Algorithm '" << algo_name
                 << "' enabled but decided not to compress. Input size: "
-                << payload->Length();
+                << message->payload()->Length();
     }
   }
   return message;
@@ -180,15 +179,17 @@ absl::StatusOr<MessageHandle> ChannelCompression::DecompressMessage(
     return std::move(message);
   }
   // Try to decompress the payload.
-  SliceBuffer decompressed_slices;
-  if (grpc_msg_decompress(args.algorithm, message->payload()->c_slice_buffer(),
-                          decompressed_slices.c_slice_buffer()) == 0) {
-    return absl::InternalError(
-        absl::StrCat("Unexpected error decompressing data for algorithm ",
-                     CompressionAlgorithmAsString(args.algorithm)));
+  std::optional<uint32_t> max_output_size = IsMessageSizeRefactoringEnabled()
+                                                ? args.max_recv_message_length
+                                                : std::nullopt;
+  absl::StatusOr<SliceBuffer> decompressed_slices =
+      MessageDecompress(args.algorithm, *message->payload(), max_output_size);
+  if (!decompressed_slices.ok()) {
+    return decompressed_slices.status();
   }
-  // Swap the decompressed slices into the message.
-  message->payload()->Swap(&decompressed_slices);
+
+  // Move the decompressed slices into the message.
+  *message->payload() = std::move(*decompressed_slices);
   message->mutable_flags() &= ~GRPC_WRITE_INTERNAL_COMPRESS;
   message->mutable_flags() |= GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED;
   if (call_tracer != nullptr) {
@@ -213,18 +214,10 @@ grpc_compression_algorithm ChannelCompression::HandleOutgoingMetadata(
 ChannelCompression::DecompressArgs ChannelCompression::HandleIncomingMetadata(
     const grpc_metadata_batch& incoming_metadata) {
   // Configure max receive size.
-  auto max_recv_message_length = max_recv_size_;
-  const MessageSizeParsedConfig* limits =
-      MessageSizeParsedConfig::GetFromCallContext(
-          GetContext<Arena>(), message_size_service_config_parser_index_);
-  if (limits != nullptr && limits->max_recv_size().has_value() &&
-      (!max_recv_message_length.has_value() ||
-       *limits->max_recv_size() < *max_recv_message_length)) {
-    max_recv_message_length = limits->max_recv_size();
-  }
-  return DecompressArgs{incoming_metadata.get(GrpcEncodingMetadata())
-                            .value_or(GRPC_COMPRESS_NONE),
-                        max_recv_message_length};
+  return DecompressArgs{
+      incoming_metadata.get(GrpcEncodingMetadata())
+          .value_or(GRPC_COMPRESS_NONE),
+      GetMaxRecvSizeFromCallContext(GetContext<Arena>(), max_recv_size_)};
 }
 
 void ClientCompressionFilter::Call::OnClientInitialMetadata(

data/src/core/ext/filters/http/message_compress/compression_filter.h

@@ -107,7 +107,6 @@ class ChannelCompression {
  private:
   // Max receive message length, if set.
   std::optional<uint32_t> max_recv_size_;
-  size_t message_size_service_config_parser_index_;
   // The default, channel-level, compression algorithm.
   grpc_compression_algorithm default_compression_algorithm_;
   // Enabled compression algorithms.

data/src/core/ext/filters/message_size/message_size_filter.cc

@@ -19,102 +19,22 @@
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/status.h>
 #include <grpc/support/port_platform.h>
-#include <inttypes.h>
 
-#include <functional>
-#include <utility>
-
-#include "src/core/call/metadata_batch.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/activity.h"
 #include "src/core/lib/promise/context.h"
-#include "src/core/lib/promise/latch.h"
-#include "src/core/lib/promise/race.h"
 #include "src/core/lib/resource_quota/arena.h"
-#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/transport/transport.h"
-#include "src/core/service_config/service_config_call_data.h"
+#include "src/core/transport/message_size_service_config.h"
 #include "src/core/util/latent_see.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_format.h"
 
 namespace grpc_core {
 
-//
-// MessageSizeParsedConfig
-//
-
-const MessageSizeParsedConfig* MessageSizeParsedConfig::GetFromCallContext(
-    Arena* arena, size_t service_config_parser_index) {
-  auto* svc_cfg_call_data = arena->GetContext<ServiceConfigCallData>();
-  if (svc_cfg_call_data == nullptr) return nullptr;
-  return static_cast<const MessageSizeParsedConfig*>(
-      svc_cfg_call_data->GetMethodParsedConfig(service_config_parser_index));
-}
-
-MessageSizeParsedConfig MessageSizeParsedConfig::GetFromChannelArgs(
-    const ChannelArgs& channel_args) {
-  MessageSizeParsedConfig limits;
-  limits.max_send_size_ = GetMaxSendSizeFromChannelArgs(channel_args);
-  limits.max_recv_size_ = GetMaxRecvSizeFromChannelArgs(channel_args);
-  return limits;
-}
-
-std::optional<uint32_t> GetMaxRecvSizeFromChannelArgs(const ChannelArgs& args) {
-  if (args.WantMinimalStack()) return std::nullopt;
-  int size = args.GetInt(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH)
-                 .value_or(GRPC_DEFAULT_MAX_RECV_MESSAGE_LENGTH);
-  if (size < 0) return std::nullopt;
-  return static_cast<uint32_t>(size);
-}
-
-std::optional<uint32_t> GetMaxSendSizeFromChannelArgs(const ChannelArgs& args) {
-  if (args.WantMinimalStack()) return std::nullopt;
-  int size = args.GetInt(GRPC_ARG_MAX_SEND_MESSAGE_LENGTH)
-                 .value_or(GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH);
-  if (size < 0) return std::nullopt;
-  return static_cast<uint32_t>(size);
-}
-
-const JsonLoaderInterface* MessageSizeParsedConfig::JsonLoader(
-    const JsonArgs&) {
-  static const auto* loader =
-      JsonObjectLoader<MessageSizeParsedConfig>()
-          .OptionalField("maxRequestMessageBytes",
-                         &MessageSizeParsedConfig::max_send_size_)
-          .OptionalField("maxResponseMessageBytes",
-                         &MessageSizeParsedConfig::max_recv_size_)
-          .Finish();
-  return loader;
-}
-
-//
-// MessageSizeParser
-//
-
-std::unique_ptr<ServiceConfigParser::ParsedConfig>
-MessageSizeParser::ParsePerMethodParams(const ChannelArgs& /*args*/,
-                                        const Json& json,
-                                        ValidationErrors* errors) {
-  return LoadFromJson<std::unique_ptr<MessageSizeParsedConfig>>(
-      json, JsonArgs(), errors);
-}
-
-void MessageSizeParser::Register(CoreConfiguration::Builder* builder) {
-  builder->service_config_parser()->RegisterParser(
-      std::make_unique<MessageSizeParser>());
-}
-
-size_t MessageSizeParser::ParserIndex() {
-  return CoreConfiguration::Get().service_config_parser().GetParserIndex(
-      parser_name());
-}
-
 //
 // MessageSizeFilter
 //

data/src/core/ext/filters/message_size/message_size_filter.h

@@ -24,64 +24,15 @@
 #include <memory>
 #include <optional>
 
-#include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/promise_based_filter.h"
-#include "src/core/lib/promise/arena_promise.h"
-#include "src/core/lib/transport/transport.h"
-#include "src/core/service_config/service_config_parser.h"
-#include "src/core/util/json/json.h"
-#include "src/core/util/json/json_args.h"
-#include "src/core/util/json/json_object_loader.h"
-#include "src/core/util/validation_errors.h"
+#include "src/core/transport/message_size_service_config.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
-class MessageSizeParsedConfig : public ServiceConfigParser::ParsedConfig {
- public:
-  std::optional<uint32_t> max_send_size() const { return max_send_size_; }
-  std::optional<uint32_t> max_recv_size() const { return max_recv_size_; }
-
-  MessageSizeParsedConfig() = default;
-
-  MessageSizeParsedConfig(std::optional<uint32_t> max_send_size,
-                          std::optional<uint32_t> max_recv_size)
-      : max_send_size_(max_send_size), max_recv_size_(max_recv_size) {}
-
-  static const MessageSizeParsedConfig* GetFromCallContext(
-      Arena* arena, size_t service_config_parser_index);
-
-  static MessageSizeParsedConfig GetFromChannelArgs(const ChannelArgs& args);
-
-  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
-
- private:
-  std::optional<uint32_t> max_send_size_;
-  std::optional<uint32_t> max_recv_size_;
-};
-
-class MessageSizeParser : public ServiceConfigParser::Parser {
- public:
-  absl::string_view name() const override { return parser_name(); }
-
-  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
-      const ChannelArgs& /*args*/, const Json& json,
-      ValidationErrors* errors) override;
-
-  static void Register(CoreConfiguration::Builder* builder);
-
-  static size_t ParserIndex();
-
- private:
-  static absl::string_view parser_name() { return "message_size"; }
-};
-
-std::optional<uint32_t> GetMaxRecvSizeFromChannelArgs(const ChannelArgs& args);
-std::optional<uint32_t> GetMaxSendSizeFromChannelArgs(const ChannelArgs& args);
-
 class ServerMessageSizeFilter final
     : public ImplementChannelFilter<ServerMessageSizeFilter> {
  public:

data/src/core/ext/filters/rbac/rbac_service_config_parser.cc

@@ -205,7 +205,8 @@ struct RbacConfig {
       std::map<std::string, Policy> policies;
       // Defaults to kNone since its json field is optional.
       Rbac::AuditCondition audit_condition = Rbac::AuditCondition::kNone;
-      std::vector<std::unique_ptr<AuditLoggerFactory::Config>> logger_configs;
+      std::vector<std::shared_ptr<const AuditLoggerFactory::Config>>
+          logger_configs;
 
       Rules() {}
       Rules(const Rules&) = delete;

data/src/core/ext/filters/stateful_session/stateful_session_filter.cc

@@ -29,7 +29,6 @@
 
 #include "src/core/call/metadata_batch.h"
 #include "src/core/config/core_configuration.h"
-#include "src/core/ext/filters/stateful_session/stateful_session_service_config_parser.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/promise/context.h"
@@ -85,24 +84,19 @@ const grpc_channel_filter StatefulSessionFilter::kFilterVtable =
 absl::StatusOr<std::unique_ptr<StatefulSessionFilter>>
 StatefulSessionFilter::Create(const ChannelArgs&,
                               ChannelFilter::Args filter_args) {
-  if (IsXdsChannelFilterChainPerRouteEnabled()) {
-    if (filter_args.config() == nullptr) {
-      return absl::InternalError("no config in stateful session filter");
-    }
-    if (filter_args.config()->type() != Config::Type()) {
-      return absl::InternalError(
-          absl::StrCat("wrong config type in stateful session filter: ",
-                       filter_args.config()->type().name()));
-    }
+  if (filter_args.config() == nullptr) {
+    return absl::InternalError("no config in stateful session filter");
+  }
+  if (filter_args.config()->type() != Config::Type()) {
+    return absl::InternalError(
+        absl::StrCat("wrong config type in stateful session filter: ",
+                     filter_args.config()->type().name()));
   }
   return std::make_unique<StatefulSessionFilter>(filter_args);
 }
 
 StatefulSessionFilter::StatefulSessionFilter(ChannelFilter::Args filter_args)
-    : index_(filter_args.instance_id()),
-      service_config_parser_index_(
-          StatefulSessionServiceConfigParser::ParserIndex()),
-      config_(filter_args.config().TakeAsSubclass<const Config>()) {}
+    : config_(filter_args.config().TakeAsSubclass<const Config>()) {}
 
 namespace {
 
@@ -121,12 +115,9 @@ absl::string_view AllocateStringOnArena(
 }
 
 // Adds the set-cookie header to the server initial metadata if needed.
-// TODO(roth): Un-templatize this when we remove the
-// xds_channel_filter_chain_per_route experiment.
-template <typename T>
 void MaybeUpdateServerInitialMetadata(
-    const T& config, bool cluster_changed, absl::string_view actual_cluster,
-    absl::string_view cookie_address_list,
+    const StatefulSessionFilter::Config& config, bool cluster_changed,
+    absl::string_view actual_cluster, absl::string_view cookie_address_list,
     XdsOverrideHostAttribute* override_host_attribute,
     ServerMetadata& server_initial_metadata) {
   // If cookie doesn't need to change, do nothing.
@@ -246,30 +237,12 @@ bool IsConfiguredPath(absl::string_view configured_path,
 void StatefulSessionFilter::Call::OnClientInitialMetadata(
     ClientMetadata& md, StatefulSessionFilter* filter) {
   GRPC_LATENT_SEE_SCOPE("StatefulSessionFilter::Call::OnClientInitialMetadata");
-  if (!IsXdsChannelFilterChainPerRouteEnabled()) {
-    // Get config.
-    auto* service_config_call_data = GetContext<ServiceConfigCallData>();
-    GRPC_CHECK_NE(service_config_call_data, nullptr);
-    auto* method_params = static_cast<StatefulSessionMethodParsedConfig*>(
-        service_config_call_data->GetMethodParsedConfig(
-            filter->service_config_parser_index_));
-    GRPC_CHECK_NE(method_params, nullptr);
-    cookie_config_ = method_params->GetConfig(filter->index_);
-    GRPC_CHECK_NE(cookie_config_, nullptr);
-    OnClientInitialMetadataImpl(md, *cookie_config_);
-    return;
-  }
-  OnClientInitialMetadataImpl(md, *filter->config_);
-}
-
-template <typename T>
-void StatefulSessionFilter::Call::OnClientInitialMetadataImpl(
-    ClientMetadata& md, const T& config) {
-  if (config.cookie_name.empty() || !IsConfiguredPath(config.path, md)) {
+  if (filter->config_->cookie_name.empty() ||
+      !IsConfiguredPath(filter->config_->path, md)) {
     return;
   }
   // Base64-decode cookie value.
-  std::string cookie_value = GetCookieValue(md, config.cookie_name);
+  std::string cookie_value = GetCookieValue(md, filter->config_->cookie_name);
   // Cookie format is "host;cluster"
   std::pair<absl::string_view, absl::string_view> host_cluster =
       absl::StrSplit(cookie_value, absl::MaxSplits(';', 1));
@@ -300,12 +273,6 @@ void StatefulSessionFilter::Call::OnServerInitialMetadata(
   GRPC_LATENT_SEE_SCOPE("StatefulSessionFilter::Call::OnServerInitialMetadata");
   if (!perform_filtering_) return;
   // Add cookie to server initial metadata if needed.
-  if (!IsXdsChannelFilterChainPerRouteEnabled()) {
-    MaybeUpdateServerInitialMetadata(*cookie_config_, cluster_changed_,
-                                     cluster_name_, cookie_address_list_,
-                                     override_host_attribute_, md);
-    return;
-  }
   MaybeUpdateServerInitialMetadata(*filter->config_, cluster_changed_,
                                    cluster_name_, cookie_address_list_,
                                    override_host_attribute_, md);
@@ -320,20 +287,10 @@ void StatefulSessionFilter::Call::OnServerTrailingMetadata(
   // cookie to the trailing metadata instead of the
   // initial metadata.
   if (md.get(GrpcTrailersOnly()).value_or(false)) {
-    if (!IsXdsChannelFilterChainPerRouteEnabled()) {
-      MaybeUpdateServerInitialMetadata(*cookie_config_, cluster_changed_,
-                                       cluster_name_, cookie_address_list_,
-                                       override_host_attribute_, md);
-      return;
-    }
     MaybeUpdateServerInitialMetadata(*filter->config_, cluster_changed_,
                                      cluster_name_, cookie_address_list_,
                                      override_host_attribute_, md);
   }
 }
 
-void StatefulSessionFilterRegister(CoreConfiguration::Builder* builder) {
-  StatefulSessionServiceConfigParser::Register(builder);
-}
-
 }  // namespace grpc_core