grpc 1.60.0 → 1.61.0

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

@@ -0,0 +1,139 @@
+//
+//
+// Copyright 2020 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.
+//
+//
+
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_HTTP_MESSAGE_COMPRESS_LEGACY_COMPRESSION_FILTER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_HTTP_MESSAGE_COMPRESS_LEGACY_COMPRESSION_FILTER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "absl/status/statusor.h"
+#include "absl/types/optional.h"
+
+#include <grpc/impl/compression_types.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/compression/compression_internal.h"
+#include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
+
+namespace grpc_core {
+
+/// Compression filter for messages.
+///
+/// See <grpc/compression.h> for the available compression settings.
+///
+/// Compression settings may come from:
+/// - Channel configuration, as established at channel creation time.
+/// - The metadata accompanying the outgoing data to be compressed. This is
+///   taken as a request only. We may choose not to honor it. The metadata key
+///   is given by \a GRPC_COMPRESSION_REQUEST_ALGORITHM_MD_KEY.
+///
+/// Compression can be disabled for concrete messages (for instance in order to
+/// prevent CRIME/BEAST type attacks) by having the GRPC_WRITE_NO_COMPRESS set
+/// in the MessageHandle flags.
+///
+/// The attempted compression mechanism is added to the resulting initial
+/// metadata under the 'grpc-encoding' key.
+///
+/// If compression is actually performed, the MessageHandle's flag is modified
+/// to incorporate GRPC_WRITE_INTERNAL_COMPRESS. Otherwise, and regardless of
+/// the aforementioned 'grpc-encoding' metadata value, data will pass through
+/// uncompressed.
+
+class LegacyCompressionFilter : public ChannelFilter {
+ protected:
+  struct DecompressArgs {
+    grpc_compression_algorithm algorithm;
+    absl::optional<uint32_t> max_recv_message_length;
+  };
+
+  explicit LegacyCompressionFilter(const ChannelArgs& args);
+
+  grpc_compression_algorithm default_compression_algorithm() const {
+    return default_compression_algorithm_;
+  }
+
+  CompressionAlgorithmSet enabled_compression_algorithms() const {
+    return enabled_compression_algorithms_;
+  }
+
+  grpc_compression_algorithm HandleOutgoingMetadata(
+      grpc_metadata_batch& outgoing_metadata);
+  DecompressArgs HandleIncomingMetadata(
+      const grpc_metadata_batch& incoming_metadata);
+
+  // Compress one message synchronously.
+  MessageHandle CompressMessage(MessageHandle message,
+                                grpc_compression_algorithm algorithm) const;
+  // Decompress one message synchronously.
+  absl::StatusOr<MessageHandle> DecompressMessage(MessageHandle message,
+                                                  DecompressArgs args) const;
+
+ private:
+  // Max receive message length, if set.
+  absl::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.
+  CompressionAlgorithmSet enabled_compression_algorithms_;
+  // Is compression enabled?
+  bool enable_compression_;
+  // Is decompression enabled?
+  bool enable_decompression_;
+};
+
+class LegacyClientCompressionFilter final : public LegacyCompressionFilter {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::StatusOr<LegacyClientCompressionFilter> Create(
+      const ChannelArgs& args, ChannelFilter::Args filter_args);
+
+  // Construct a promise for one call.
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+
+ private:
+  using LegacyCompressionFilter::LegacyCompressionFilter;
+};
+
+class LegacyServerCompressionFilter final : public LegacyCompressionFilter {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::StatusOr<LegacyServerCompressionFilter> Create(
+      const ChannelArgs& args, ChannelFilter::Args filter_args);
+
+  // Construct a promise for one call.
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+
+ private:
+  using LegacyCompressionFilter::LegacyCompressionFilter;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_HTTP_MESSAGE_COMPRESS_LEGACY_COMPRESSION_FILTER_H

data/src/core/ext/filters/http/server/http_server_filter.cc

@@ -49,6 +49,10 @@
 
 namespace grpc_core {
 
+const NoInterceptor HttpServerFilter::Call::OnClientToServerMessage;
+const NoInterceptor HttpServerFilter::Call::OnServerToClientMessage;
+const NoInterceptor HttpServerFilter::Call::OnFinalize;
+
 const grpc_channel_filter HttpServerFilter::kFilter =
     MakePromiseBasedFilter<HttpServerFilter, FilterEndpoint::kServer,
                            kFilterExaminesServerInitialMetadata>("http-server");
@@ -71,85 +75,81 @@ ServerMetadataHandle MalformedRequest(absl::string_view explanation) {
 }
 }  // namespace
 
-ArenaPromise<ServerMetadataHandle> HttpServerFilter::MakeCallPromise(
-    CallArgs call_args, NextPromiseFactory next_promise_factory) {
-  const auto& md = call_args.client_initial_metadata;
-
-  auto method = md->get(HttpMethodMetadata());
+ServerMetadataHandle HttpServerFilter::Call::OnClientInitialMetadata(
+    ClientMetadata& md, HttpServerFilter* filter) {
+  auto method = md.get(HttpMethodMetadata());
   if (method.has_value()) {
     switch (*method) {
       case HttpMethodMetadata::kPost:
         break;
       case HttpMethodMetadata::kPut:
-        if (allow_put_requests_) {
+        if (filter->allow_put_requests_) {
           break;
         }
         ABSL_FALLTHROUGH_INTENDED;
       case HttpMethodMetadata::kInvalid:
       case HttpMethodMetadata::kGet:
-        return Immediate(MalformedRequest("Bad method header"));
+        return MalformedRequest("Bad method header");
     }
   } else {
-    return Immediate(MalformedRequest("Missing :method header"));
+    return MalformedRequest("Missing :method header");
   }
 
-  auto te = md->Take(TeMetadata());
+  auto te = md.Take(TeMetadata());
   if (te == TeMetadata::kTrailers) {
     // Do nothing, ok.
   } else if (!te.has_value()) {
-    return Immediate(MalformedRequest("Missing :te header"));
+    return MalformedRequest("Missing :te header");
   } else {
-    return Immediate(MalformedRequest("Bad :te header"));
+    return MalformedRequest("Bad :te header");
   }
 
-  auto scheme = md->Take(HttpSchemeMetadata());
+  auto scheme = md.Take(HttpSchemeMetadata());
   if (scheme.has_value()) {
     if (*scheme == HttpSchemeMetadata::kInvalid) {
-      return Immediate(MalformedRequest("Bad :scheme header"));
+      return MalformedRequest("Bad :scheme header");
     }
   } else {
-    return Immediate(MalformedRequest("Missing :scheme header"));
+    return MalformedRequest("Missing :scheme header");
   }
 
-  md->Remove(ContentTypeMetadata());
+  md.Remove(ContentTypeMetadata());
 
-  Slice* path_slice = md->get_pointer(HttpPathMetadata());
+  Slice* path_slice = md.get_pointer(HttpPathMetadata());
   if (path_slice == nullptr) {
-    return Immediate(MalformedRequest("Missing :path header"));
+    return MalformedRequest("Missing :path header");
   }
 
-  if (md->get_pointer(HttpAuthorityMetadata()) == nullptr) {
-    absl::optional<Slice> host = md->Take(HostMetadata());
+  if (md.get_pointer(HttpAuthorityMetadata()) == nullptr) {
+    absl::optional<Slice> host = md.Take(HostMetadata());
     if (host.has_value()) {
-      md->Set(HttpAuthorityMetadata(), std::move(*host));
+      md.Set(HttpAuthorityMetadata(), std::move(*host));
     }
   }
 
-  if (md->get_pointer(HttpAuthorityMetadata()) == nullptr) {
-    return Immediate(MalformedRequest("Missing :authority header"));
+  if (md.get_pointer(HttpAuthorityMetadata()) == nullptr) {
+    return MalformedRequest("Missing :authority header");
   }
 
-  if (!surface_user_agent_) {
-    md->Remove(UserAgentMetadata());
+  if (!filter->surface_user_agent_) {
+    md.Remove(UserAgentMetadata());
   }
 
-  call_args.server_initial_metadata->InterceptAndMap(
-      [](ServerMetadataHandle md) {
-        if (grpc_call_trace.enabled()) {
-          gpr_log(GPR_INFO, "%s[http-server] Write metadata",
-                  Activity::current()->DebugTag().c_str());
-        }
-        FilterOutgoingMetadata(md.get());
-        md->Set(HttpStatusMetadata(), 200);
-        md->Set(ContentTypeMetadata(), ContentTypeMetadata::kApplicationGrpc);
-        return md;
-      });
-
-  return Map(next_promise_factory(std::move(call_args)),
-             [](ServerMetadataHandle md) -> ServerMetadataHandle {
-               FilterOutgoingMetadata(md.get());
-               return md;
-             });
+  return nullptr;
+}
+
+void HttpServerFilter::Call::OnServerInitialMetadata(ServerMetadata& md) {
+  if (grpc_call_trace.enabled()) {
+    gpr_log(GPR_INFO, "%s[http-server] Write metadata",
+            Activity::current()->DebugTag().c_str());
+  }
+  FilterOutgoingMetadata(&md);
+  md.Set(HttpStatusMetadata(), 200);
+  md.Set(ContentTypeMetadata(), ContentTypeMetadata::kApplicationGrpc);
+}
+
+void HttpServerFilter::Call::OnServerTrailingMetadata(ServerMetadata& md) {
+  FilterOutgoingMetadata(&md);
 }
 
 absl::StatusOr<HttpServerFilter> HttpServerFilter::Create(

data/src/core/ext/filters/http/server/http_server_filter.h

@@ -32,16 +32,23 @@
 namespace grpc_core {
 
 // Processes metadata on the server side for HTTP2 transports
-class HttpServerFilter : public ChannelFilter {
+class HttpServerFilter : public ImplementChannelFilter<HttpServerFilter> {
  public:
   static const grpc_channel_filter kFilter;
 
   static absl::StatusOr<HttpServerFilter> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
-  // Construct a promise for one call.
-  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
-      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+  class Call {
+   public:
+    ServerMetadataHandle OnClientInitialMetadata(ClientMetadata& md,
+                                                 HttpServerFilter* filter);
+    void OnServerInitialMetadata(ServerMetadata& md);
+    void OnServerTrailingMetadata(ServerMetadata& md);
+    static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnServerToClientMessage;
+    static const NoInterceptor OnFinalize;
+  };
 
  private:
   HttpServerFilter(bool surface_user_agent, bool allow_put_requests)

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

@@ -50,6 +50,15 @@
 
 namespace grpc_core {
 
+const NoInterceptor ClientMessageSizeFilter::Call::OnClientInitialMetadata;
+const NoInterceptor ClientMessageSizeFilter::Call::OnServerInitialMetadata;
+const NoInterceptor ClientMessageSizeFilter::Call::OnServerTrailingMetadata;
+const NoInterceptor ClientMessageSizeFilter::Call::OnFinalize;
+const NoInterceptor ServerMessageSizeFilter::Call::OnClientInitialMetadata;
+const NoInterceptor ServerMessageSizeFilter::Call::OnServerInitialMetadata;
+const NoInterceptor ServerMessageSizeFilter::Call::OnServerTrailingMetadata;
+const NoInterceptor ServerMessageSizeFilter::Call::OnFinalize;
+
 //
 // MessageSizeParsedConfig
 //
@@ -138,60 +147,6 @@ const grpc_channel_filter ServerMessageSizeFilter::kFilter =
                            kFilterExaminesOutboundMessages |
                                kFilterExaminesInboundMessages>("message_size");
 
-class MessageSizeFilter::CallBuilder {
- private:
-  auto Interceptor(uint32_t max_length, bool is_send) {
-    return [max_length, is_send,
-            err = err_](MessageHandle msg) -> absl::optional<MessageHandle> {
-      if (grpc_call_trace.enabled()) {
-        gpr_log(GPR_INFO, "%s[message_size] %s len:%" PRIdPTR " max:%d",
-                Activity::current()->DebugTag().c_str(),
-                is_send ? "send" : "recv", msg->payload()->Length(),
-                max_length);
-      }
-      if (msg->payload()->Length() > max_length) {
-        if (err->is_set()) return std::move(msg);
-        auto r = GetContext<Arena>()->MakePooled<ServerMetadata>(
-            GetContext<Arena>());
-        r->Set(GrpcStatusMetadata(), GRPC_STATUS_RESOURCE_EXHAUSTED);
-        r->Set(GrpcMessageMetadata(),
-               Slice::FromCopiedString(
-                   absl::StrFormat("%s message larger than max (%u vs. %d)",
-                                   is_send ? "Sent" : "Received",
-                                   msg->payload()->Length(), max_length)));
-        err->Set(std::move(r));
-        return absl::nullopt;
-      }
-      return std::move(msg);
-    };
-  }
-
- public:
-  explicit CallBuilder(const MessageSizeParsedConfig& limits)
-      : limits_(limits) {}
-
-  template <typename T>
-  void AddSend(T* pipe_end) {
-    if (!limits_.max_send_size().has_value()) return;
-    pipe_end->InterceptAndMap(Interceptor(*limits_.max_send_size(), true));
-  }
-  template <typename T>
-  void AddRecv(T* pipe_end) {
-    if (!limits_.max_recv_size().has_value()) return;
-    pipe_end->InterceptAndMap(Interceptor(*limits_.max_recv_size(), false));
-  }
-
-  ArenaPromise<ServerMetadataHandle> Run(
-      CallArgs call_args, NextPromiseFactory next_promise_factory) {
-    return Race(err_->Wait(), next_promise_factory(std::move(call_args)));
-  }
-
- private:
-  Latch<ServerMetadataHandle>* const err_ =
-      GetContext<Arena>()->ManagedNew<Latch<ServerMetadataHandle>>();
-  MessageSizeParsedConfig limits_;
-};
-
 absl::StatusOr<ClientMessageSizeFilter> ClientMessageSizeFilter::Create(
     const ChannelArgs& args, ChannelFilter::Args) {
   return ClientMessageSizeFilter(args);
@@ -202,20 +157,40 @@ absl::StatusOr<ServerMessageSizeFilter> ServerMessageSizeFilter::Create(
   return ServerMessageSizeFilter(args);
 }
 
-ArenaPromise<ServerMetadataHandle> ClientMessageSizeFilter::MakeCallPromise(
-    CallArgs call_args, NextPromiseFactory next_promise_factory) {
+namespace {
+ServerMetadataHandle CheckPayload(const Message& msg,
+                                  absl::optional<uint32_t> max_length,
+                                  bool is_send) {
+  if (!max_length.has_value()) return nullptr;
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_call_trace)) {
+    gpr_log(GPR_INFO, "%s[message_size] %s len:%" PRIdPTR " max:%d",
+            Activity::current()->DebugTag().c_str(), is_send ? "send" : "recv",
+            msg.payload()->Length(), *max_length);
+  }
+  if (msg.payload()->Length() <= *max_length) return nullptr;
+  auto r = GetContext<Arena>()->MakePooled<ServerMetadata>(GetContext<Arena>());
+  r->Set(GrpcStatusMetadata(), GRPC_STATUS_RESOURCE_EXHAUSTED);
+  r->Set(GrpcMessageMetadata(), Slice::FromCopiedString(absl::StrFormat(
+                                    "%s message larger than max (%u vs. %d)",
+                                    is_send ? "Sent" : "Received",
+                                    msg.payload()->Length(), *max_length)));
+  return r;
+}
+}  // namespace
+
+ClientMessageSizeFilter::Call::Call(ClientMessageSizeFilter* filter)
+    : limits_(filter->parsed_config_) {
   // Get max sizes from channel data, then merge in per-method config values.
   // Note: Per-method config is only available on the client, so we
   // apply the max request size to the send limit and the max response
   // size to the receive limit.
-  MessageSizeParsedConfig limits = this->limits();
   const MessageSizeParsedConfig* config_from_call_context =
       MessageSizeParsedConfig::GetFromCallContext(
           GetContext<grpc_call_context_element>(),
-          service_config_parser_index_);
+          filter->service_config_parser_index_);
   if (config_from_call_context != nullptr) {
-    absl::optional<uint32_t> max_send_size = limits.max_send_size();
-    absl::optional<uint32_t> max_recv_size = limits.max_recv_size();
+    absl::optional<uint32_t> max_send_size = limits_.max_send_size();
+    absl::optional<uint32_t> max_recv_size = limits_.max_recv_size();
     if (config_from_call_context->max_send_size().has_value() &&
         (!max_send_size.has_value() ||
          *config_from_call_context->max_send_size() < *max_send_size)) {
@@ -226,21 +201,28 @@ ArenaPromise<ServerMetadataHandle> ClientMessageSizeFilter::MakeCallPromise(
          *config_from_call_context->max_recv_size() < *max_recv_size)) {
       max_recv_size = *config_from_call_context->max_recv_size();
     }
-    limits = MessageSizeParsedConfig(max_send_size, max_recv_size);
+    limits_ = MessageSizeParsedConfig(max_send_size, max_recv_size);
   }
+}
+
+ServerMetadataHandle ServerMessageSizeFilter::Call::OnClientToServerMessage(
+    const Message& message, ServerMessageSizeFilter* filter) {
+  return CheckPayload(message, filter->parsed_config_.max_recv_size(), false);
+}
+
+ServerMetadataHandle ServerMessageSizeFilter::Call::OnServerToClientMessage(
+    const Message& message, ServerMessageSizeFilter* filter) {
+  return CheckPayload(message, filter->parsed_config_.max_send_size(), true);
+}
 
-  CallBuilder b(limits);
-  b.AddSend(call_args.client_to_server_messages);
-  b.AddRecv(call_args.server_to_client_messages);
-  return b.Run(std::move(call_args), std::move(next_promise_factory));
+ServerMetadataHandle ClientMessageSizeFilter::Call::OnClientToServerMessage(
+    const Message& message) {
+  return CheckPayload(message, limits_.max_send_size(), true);
 }
 
-ArenaPromise<ServerMetadataHandle> ServerMessageSizeFilter::MakeCallPromise(
-    CallArgs call_args, NextPromiseFactory next_promise_factory) {
-  CallBuilder b(limits());
-  b.AddSend(call_args.server_to_client_messages);
-  b.AddRecv(call_args.client_to_server_messages);
-  return b.Run(std::move(call_args), std::move(next_promise_factory));
+ServerMetadataHandle ClientMessageSizeFilter::Call::OnServerToClientMessage(
+    const Message& message) {
+  return CheckPayload(message, limits_.max_recv_size(), false);
 }
 
 namespace {
@@ -258,12 +240,10 @@ bool HasMessageSizeLimits(const ChannelArgs& channel_args) {
 void RegisterMessageSizeFilter(CoreConfiguration::Builder* builder) {
   MessageSizeParser::Register(builder);
   builder->channel_init()
-      ->RegisterFilter(GRPC_CLIENT_SUBCHANNEL,
-                       &ClientMessageSizeFilter::kFilter)
+      ->RegisterFilter<ClientMessageSizeFilter>(GRPC_CLIENT_SUBCHANNEL)
       .ExcludeFromMinimalStack();
   builder->channel_init()
-      ->RegisterFilter(GRPC_CLIENT_DIRECT_CHANNEL,
-                       &ClientMessageSizeFilter::kFilter)
+      ->RegisterFilter<ClientMessageSizeFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
       .ExcludeFromMinimalStack()
       .If(HasMessageSizeLimits)
       // TODO(ctiller): ordering constraint is here to match the ordering that
@@ -271,7 +251,7 @@ void RegisterMessageSizeFilter(CoreConfiguration::Builder* builder) {
       // filters from first principles.
       .Before({&grpc_client_deadline_filter});
   builder->channel_init()
-      ->RegisterFilter(GRPC_SERVER_CHANNEL, &ServerMessageSizeFilter::kFilter)
+      ->RegisterFilter<ServerMessageSizeFilter>(GRPC_SERVER_CHANNEL)
       .ExcludeFromMinimalStack()
       .If(HasMessageSizeLimits)
       // TODO(ctiller): ordering constraint is here to match the ordering that

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

@@ -86,48 +86,60 @@ class MessageSizeParser : public ServiceConfigParser::Parser {
 absl::optional<uint32_t> GetMaxRecvSizeFromChannelArgs(const ChannelArgs& args);
 absl::optional<uint32_t> GetMaxSendSizeFromChannelArgs(const ChannelArgs& args);
 
-class MessageSizeFilter : public ChannelFilter {
- protected:
-  explicit MessageSizeFilter(const ChannelArgs& args)
-      : limits_(MessageSizeParsedConfig::GetFromChannelArgs(args)) {}
-
-  class CallBuilder;
-
-  const MessageSizeParsedConfig& limits() const { return limits_; }
-
- private:
-  MessageSizeParsedConfig limits_;
-};
-
-class ServerMessageSizeFilter final : public MessageSizeFilter {
+class ServerMessageSizeFilter final
+    : public ImplementChannelFilter<ServerMessageSizeFilter> {
  public:
   static const grpc_channel_filter kFilter;
 
   static absl::StatusOr<ServerMessageSizeFilter> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
-  // Construct a promise for one call.
-  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
-      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+  class Call {
+   public:
+    static const NoInterceptor OnClientInitialMetadata;
+    static const NoInterceptor OnServerInitialMetadata;
+    static const NoInterceptor OnServerTrailingMetadata;
+    static const NoInterceptor OnFinalize;
+    ServerMetadataHandle OnClientToServerMessage(
+        const Message& message, ServerMessageSizeFilter* filter);
+    ServerMetadataHandle OnServerToClientMessage(
+        const Message& message, ServerMessageSizeFilter* filter);
+  };
 
  private:
-  using MessageSizeFilter::MessageSizeFilter;
+  explicit ServerMessageSizeFilter(const ChannelArgs& args)
+      : parsed_config_(MessageSizeParsedConfig::GetFromChannelArgs(args)) {}
+  const MessageSizeParsedConfig parsed_config_;
 };
 
-class ClientMessageSizeFilter final : public MessageSizeFilter {
+class ClientMessageSizeFilter final
+    : public ImplementChannelFilter<ClientMessageSizeFilter> {
  public:
   static const grpc_channel_filter kFilter;
 
   static absl::StatusOr<ClientMessageSizeFilter> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
-  // Construct a promise for one call.
-  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
-      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+  class Call {
+   public:
+    explicit Call(ClientMessageSizeFilter* filter);
+
+    static const NoInterceptor OnClientInitialMetadata;
+    static const NoInterceptor OnServerInitialMetadata;
+    static const NoInterceptor OnServerTrailingMetadata;
+    static const NoInterceptor OnFinalize;
+    ServerMetadataHandle OnClientToServerMessage(const Message& message);
+    ServerMetadataHandle OnServerToClientMessage(const Message& message);
+
+   private:
+    MessageSizeParsedConfig limits_;
+  };
 
  private:
+  explicit ClientMessageSizeFilter(const ChannelArgs& args)
+      : parsed_config_(MessageSizeParsedConfig::GetFromChannelArgs(args)) {}
   const size_t service_config_parser_index_{MessageSizeParser::ParserIndex()};
-  using MessageSizeFilter::MessageSizeFilter;
+  const MessageSizeParsedConfig parsed_config_;
 };
 
 }  // namespace grpc_core

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

@@ -43,8 +43,14 @@
 
 namespace grpc_core {
 
-ArenaPromise<ServerMetadataHandle> RbacFilter::MakeCallPromise(
-    CallArgs call_args, NextPromiseFactory next_promise_factory) {
+const NoInterceptor RbacFilter::Call::OnServerInitialMetadata;
+const NoInterceptor RbacFilter::Call::OnServerTrailingMetadata;
+const NoInterceptor RbacFilter::Call::OnClientToServerMessage;
+const NoInterceptor RbacFilter::Call::OnServerToClientMessage;
+const NoInterceptor RbacFilter::Call::OnFinalize;
+
+absl::Status RbacFilter::Call::OnClientInitialMetadata(ClientMetadata& md,
+                                                       RbacFilter* filter) {
   // Fetch and apply the rbac policy from the service config.
   auto* service_config_call_data = static_cast<ServiceConfigCallData*>(
       GetContext<
@@ -52,21 +58,19 @@ ArenaPromise<ServerMetadataHandle> RbacFilter::MakeCallPromise(
           .value);
   auto* method_params = static_cast<RbacMethodParsedConfig*>(
       service_config_call_data->GetMethodParsedConfig(
-          service_config_parser_index_));
+          filter->service_config_parser_index_));
   if (method_params == nullptr) {
-    return Immediate(ServerMetadataFromStatus(
-        absl::PermissionDeniedError("No RBAC policy found.")));
+    return absl::PermissionDeniedError("No RBAC policy found.");
   } else {
-    auto* authorization_engine = method_params->authorization_engine(index_);
+    auto* authorization_engine =
+        method_params->authorization_engine(filter->index_);
     if (authorization_engine
-            ->Evaluate(EvaluateArgs(call_args.client_initial_metadata.get(),
-                                    &per_channel_evaluate_args_))
+            ->Evaluate(EvaluateArgs(&md, &filter->per_channel_evaluate_args_))
             .type == AuthorizationEngine::Decision::Type::kDeny) {
-      return Immediate(ServerMetadataFromStatus(
-          absl::PermissionDeniedError("Unauthorized RPC rejected")));
+      return absl::PermissionDeniedError("Unauthorized RPC rejected");
     }
   }
-  return next_promise_factory(std::move(call_args));
+  return absl::OkStatus();
 }
 
 const grpc_channel_filter RbacFilter::kFilterVtable =

data/src/core/ext/filters/rbac/rbac_filter.h

@@ -34,7 +34,7 @@ namespace grpc_core {
 
 // Filter used when xDS server config fetcher provides a configuration with an
 // HTTP RBAC filter. Also serves as the type for channel data for the filter.
-class RbacFilter : public ChannelFilter {
+class RbacFilter : public ImplementChannelFilter<RbacFilter> {
  public:
   // This channel filter is intended to be used by connections on xDS enabled
   // servers configured with RBAC. The RBAC filter fetches the RBAC policy from
@@ -45,9 +45,16 @@ class RbacFilter : public ChannelFilter {
   static absl::StatusOr<RbacFilter> Create(const ChannelArgs& args,
                                            ChannelFilter::Args filter_args);
 
-  // Construct a promise for one call.
-  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
-      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+  class Call {
+   public:
+    absl::Status OnClientInitialMetadata(ClientMetadata& md,
+                                         RbacFilter* filter);
+    static const NoInterceptor OnServerInitialMetadata;
+    static const NoInterceptor OnServerTrailingMetadata;
+    static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnServerToClientMessage;
+    static const NoInterceptor OnFinalize;
+  };
 
  private:
   RbacFilter(size_t index,