grpc 1.44.0.pre2 → 1.46.3

data/src/core/ext/filters/http/client_authority_filter.cc

@@ -28,7 +28,7 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/channel/channel_args.h"
+#include "src/core/ext/filters/http/client_authority_filter.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gpr/string.h"
@@ -37,89 +37,40 @@
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 
-namespace {
-
-struct call_data {
-  grpc_core::CallCombiner* call_combiner;
-};
-
-struct channel_data {
-  grpc_core::Slice default_authority;
-};
+namespace grpc_core {
 
-void client_authority_start_transport_stream_op_batch(
-    grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
-  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  // Handle send_initial_metadata.
-  // If the initial metadata doesn't already contain :authority, add it.
-  if (batch->send_initial_metadata &&
-      batch->payload->send_initial_metadata.send_initial_metadata->get_pointer(
-          grpc_core::HttpAuthorityMetadata()) == nullptr) {
-    batch->payload->send_initial_metadata.send_initial_metadata->Set(
-        grpc_core::HttpAuthorityMetadata(), chand->default_authority.Ref());
+absl::StatusOr<ClientAuthorityFilter> ClientAuthorityFilter::Create(
+    ChannelArgs args, ChannelFilter::Args) {
+  absl::optional<absl::string_view> default_authority =
+      args.GetString(GRPC_ARG_DEFAULT_AUTHORITY);
+  if (!default_authority.has_value()) {
+    return absl::InvalidArgumentError(
+        "GRPC_ARG_DEFAULT_AUTHORITY string channel arg. not found. Note that "
+        "direct channels must explicitly specify a value for this argument.");
   }
-  // Pass control down the stack.
-  grpc_call_next_op(elem, batch);
-}
-
-/* Constructor for call_data */
-grpc_error_handle client_authority_init_call_elem(
-    grpc_call_element* elem, const grpc_call_element_args* args) {
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  calld->call_combiner = args->call_combiner;
-  return GRPC_ERROR_NONE;
+  return ClientAuthorityFilter(Slice::FromCopiedString(*default_authority));
 }
 
-/* Destructor for call_data */
-void client_authority_destroy_call_elem(
-    grpc_call_element* /*elem*/, const grpc_call_final_info* /*final_info*/,
-    grpc_closure* /*ignored*/) {}
-
-/* Constructor for channel_data */
-grpc_error_handle client_authority_init_channel_elem(
-    grpc_channel_element* elem, grpc_channel_element_args* args) {
-  channel_data* chand = new (elem->channel_data) channel_data;
-  const grpc_arg* default_authority_arg =
-      grpc_channel_args_find(args->channel_args, GRPC_ARG_DEFAULT_AUTHORITY);
-  if (default_authority_arg == nullptr) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "GRPC_ARG_DEFAULT_AUTHORITY channel arg. not found. Note that direct "
-        "channels must explicitly specify a value for this argument.");
+ArenaPromise<ServerMetadataHandle> ClientAuthorityFilter::MakeCallPromise(
+    CallArgs call_args, NextPromiseFactory next_promise_factory) {
+  // If no authority is set, set the default authority.
+  if (call_args.client_initial_metadata->get_pointer(HttpAuthorityMetadata()) ==
+      nullptr) {
+    call_args.client_initial_metadata->Set(HttpAuthorityMetadata(),
+                                           default_authority_.Ref());
   }
-  const char* default_authority_str =
-      grpc_channel_arg_get_string(default_authority_arg);
-  if (default_authority_str == nullptr) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "GRPC_ARG_DEFAULT_AUTHORITY channel arg. must be a string");
-  }
-  chand->default_authority =
-      grpc_core::Slice::FromCopiedString(default_authority_str);
-  GPR_ASSERT(!args->is_last);
-  return GRPC_ERROR_NONE;
-}
-
-/* Destructor for channel data */
-void client_authority_destroy_channel_elem(grpc_channel_element* elem) {
-  static_cast<channel_data*>(elem->channel_data)->~channel_data();
+  // We have no asynchronous work, so we can just ask the next promise to run,
+  // passing down initial_metadata.
+  return next_promise_factory(std::move(call_args));
 }
-}  // namespace
 
-const grpc_channel_filter grpc_client_authority_filter = {
-    client_authority_start_transport_stream_op_batch,
-    grpc_channel_next_op,
-    sizeof(call_data),
-    client_authority_init_call_elem,
-    grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    client_authority_destroy_call_elem,
-    sizeof(channel_data),
-    client_authority_init_channel_elem,
-    client_authority_destroy_channel_elem,
-    grpc_channel_next_get_info,
-    "authority"};
+const grpc_channel_filter ClientAuthorityFilter::kFilter =
+    MakePromiseBasedFilter<ClientAuthorityFilter, FilterEndpoint::kClient>(
+        "authority");
 
-static bool add_client_authority_filter(grpc_channel_stack_builder* builder) {
-  const grpc_channel_args* channel_args =
-      grpc_channel_stack_builder_get_channel_arguments(builder);
+namespace {
+bool add_client_authority_filter(ChannelStackBuilder* builder) {
+  const grpc_channel_args* channel_args = builder->channel_args();
   const grpc_arg* disable_client_authority_filter_arg = grpc_channel_args_find(
       channel_args, GRPC_ARG_DISABLE_CLIENT_AUTHORITY_FILTER);
   if (disable_client_authority_filter_arg != nullptr) {
@@ -129,15 +80,16 @@ static bool add_client_authority_filter(grpc_channel_stack_builder* builder) {
       return true;
     }
   }
-  return grpc_channel_stack_builder_prepend_filter(
-      builder, &grpc_client_authority_filter, nullptr, nullptr);
+  builder->PrependFilter(&ClientAuthorityFilter::kFilter, nullptr);
+  return true;
 }
+}  // namespace
 
-namespace grpc_core {
 void RegisterClientAuthorityFilter(CoreConfiguration::Builder* builder) {
   builder->channel_init()->RegisterStage(GRPC_CLIENT_SUBCHANNEL, INT_MAX,
                                          add_client_authority_filter);
   builder->channel_init()->RegisterStage(GRPC_CLIENT_DIRECT_CHANNEL, INT_MAX,
                                          add_client_authority_filter);
 }
+
 }  // namespace grpc_core

data/src/core/ext/filters/http/client_authority_filter.h

@@ -21,14 +21,33 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/status/statusor.h"
+
 #include <grpc/impl/codegen/compression_types.h>
 
-#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/promise_based_filter.h"
+#include "src/core/lib/slice/slice.h"
+
+namespace grpc_core {
+
+class ClientAuthorityFilter final : public ChannelFilter {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::StatusOr<ClientAuthorityFilter> Create(ChannelArgs args,
+                                                      ChannelFilter::Args);
+
+  // Construct a promise for one call.
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
 
-/// Filter responsible for setting the authority header, if not already set. It
-/// uses the value of the GRPC_ARG_DEFAULT_AUTHORITY channel arg if the initial
-/// metadata doesn't already contain an authority value.
+ private:
+  explicit ClientAuthorityFilter(Slice default_authority)
+      : default_authority_(std::move(default_authority)) {}
+  Slice default_authority_;
+};
 
-extern const grpc_channel_filter grpc_client_authority_filter;
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_FILTERS_HTTP_CLIENT_AUTHORITY_FILTER_H */

data/src/core/ext/filters/http/http_filters_plugin.cc

@@ -30,8 +30,8 @@
 #include "src/core/lib/transport/transport_impl.h"
 
 static bool is_building_http_like_transport(
-    grpc_channel_stack_builder* builder) {
-  grpc_transport* t = grpc_channel_stack_builder_get_transport(builder);
+    grpc_core::ChannelStackBuilder* builder) {
+  grpc_transport* t = builder->transport();
   return t != nullptr && strstr(t->vtable->name, "http");
 }
 
@@ -44,29 +44,31 @@ void RegisterHttpFilters(CoreConfiguration::Builder* builder) {
     builder->channel_init()->RegisterStage(
         channel_type, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
         [enable_in_minimal_stack, control_channel_arg,
-         filter](grpc_channel_stack_builder* builder) {
+         filter](ChannelStackBuilder* builder) {
           if (!is_building_http_like_transport(builder)) return true;
-          const grpc_channel_args* channel_args =
-              grpc_channel_stack_builder_get_channel_arguments(builder);
+          const grpc_channel_args* channel_args = builder->channel_args();
           bool enable = grpc_channel_arg_get_bool(
               grpc_channel_args_find(channel_args, control_channel_arg),
               enable_in_minimal_stack ||
                   !grpc_channel_args_want_minimal_stack(channel_args));
-          if (!enable) return true;
-          return grpc_channel_stack_builder_prepend_filter(builder, filter,
-                                                           nullptr, nullptr);
+          if (enable) builder->PrependFilter(filter, nullptr);
+          return true;
         });
   };
   auto required = [builder](grpc_channel_stack_type channel_type,
                             const grpc_channel_filter* filter) {
     builder->channel_init()->RegisterStage(
         channel_type, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-        [filter](grpc_channel_stack_builder* builder) {
-          if (!is_building_http_like_transport(builder)) return true;
-          return grpc_channel_stack_builder_prepend_filter(builder, filter,
-                                                           nullptr, nullptr);
+        [filter](ChannelStackBuilder* builder) {
+          if (is_building_http_like_transport(builder)) {
+            builder->PrependFilter(filter, nullptr);
+          }
+          return true;
         });
   };
+  // TODO(ctiller): return this flag to true once the promise conversion is
+  // complete.
+  static constexpr bool kMinimalStackHasDecompression = false;
   optional(GRPC_CLIENT_SUBCHANNEL, false,
            GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION,
            &grpc_message_compress_filter);
@@ -75,14 +77,14 @@ void RegisterHttpFilters(CoreConfiguration::Builder* builder) {
            &grpc_message_compress_filter);
   optional(GRPC_SERVER_CHANNEL, false, GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION,
            &grpc_message_compress_filter);
-  optional(GRPC_CLIENT_SUBCHANNEL, true,
+  optional(GRPC_CLIENT_SUBCHANNEL, kMinimalStackHasDecompression,
+           GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION, &MessageDecompressFilter);
+  optional(GRPC_CLIENT_DIRECT_CHANNEL, kMinimalStackHasDecompression,
            GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION, &MessageDecompressFilter);
-  optional(GRPC_CLIENT_DIRECT_CHANNEL, true,
+  optional(GRPC_SERVER_CHANNEL, kMinimalStackHasDecompression,
            GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION, &MessageDecompressFilter);
-  optional(GRPC_SERVER_CHANNEL, true, GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION,
-           &MessageDecompressFilter);
-  required(GRPC_CLIENT_SUBCHANNEL, &grpc_http_client_filter);
-  required(GRPC_CLIENT_DIRECT_CHANNEL, &grpc_http_client_filter);
+  required(GRPC_CLIENT_SUBCHANNEL, &HttpClientFilter::kFilter);
+  required(GRPC_CLIENT_DIRECT_CHANNEL, &HttpClientFilter::kFilter);
   required(GRPC_SERVER_CHANNEL, &grpc_http_server_filter);
 }
 }  // namespace grpc_core

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

@@ -443,6 +443,7 @@ void CompressDestroyChannelElem(grpc_channel_element* elem) {
 
 const grpc_channel_filter grpc_message_compress_filter = {
     CompressStartTransportStreamOpBatch,
+    nullptr,
     grpc_channel_next_op,
     sizeof(CallData),
     CompressInitCallElem,

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

@@ -45,12 +45,18 @@ namespace {
 class ChannelData {
  public:
   explicit ChannelData(const grpc_channel_element_args* args)
-      : max_recv_size_(GetMaxRecvSizeFromChannelArgs(args->channel_args)) {}
+      : max_recv_size_(GetMaxRecvSizeFromChannelArgs(args->channel_args)),
+        message_size_service_config_parser_index_(
+            MessageSizeParser::ParserIndex()) {}
 
   int max_recv_size() const { return max_recv_size_; }
+  size_t message_size_service_config_parser_index() const {
+    return message_size_service_config_parser_index_;
+  }
 
  private:
   int max_recv_size_;
+  const size_t message_size_service_config_parser_index_;
 };
 
 class CallData {
@@ -73,7 +79,8 @@ class CallData {
                       OnRecvTrailingMetadataReady, this,
                       grpc_schedule_on_exec_ctx);
     const MessageSizeParsedConfig* limits =
-        MessageSizeParsedConfig::GetFromCallContext(args.context);
+        MessageSizeParsedConfig::GetFromCallContext(
+            args.context, chand->message_size_service_config_parser_index());
     if (limits != nullptr && limits->limits().max_recv_size >= 0 &&
         (limits->limits().max_recv_size < max_recv_message_length_ ||
          max_recv_message_length_ < 0)) {
@@ -365,6 +372,7 @@ void DecompressDestroyChannelElem(grpc_channel_element* elem) {
 
 const grpc_channel_filter MessageDecompressFilter = {
     DecompressStartTransportStreamOpBatch,
+    nullptr,
     grpc_channel_next_op,
     sizeof(CallData),
     DecompressInitCallElem,

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

@@ -37,7 +37,6 @@ static void hs_recv_initial_metadata_ready(void* user_data,
                                            grpc_error_handle err);
 static void hs_recv_trailing_metadata_ready(void* user_data,
                                             grpc_error_handle err);
-static void hs_recv_message_ready(void* user_data, grpc_error_handle err);
 
 namespace {
 
@@ -47,27 +46,15 @@ struct call_data {
     GRPC_CLOSURE_INIT(&recv_initial_metadata_ready,
                       hs_recv_initial_metadata_ready, elem,
                       grpc_schedule_on_exec_ctx);
-    GRPC_CLOSURE_INIT(&recv_message_ready, hs_recv_message_ready, elem,
-                      grpc_schedule_on_exec_ctx);
     GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready,
                       hs_recv_trailing_metadata_ready, elem,
                       grpc_schedule_on_exec_ctx);
   }
 
-  ~call_data() {
-    GRPC_ERROR_UNREF(recv_initial_metadata_ready_error);
-    if (have_read_stream) {
-      read_stream->Orphan();
-    }
-  }
+  ~call_data() { GRPC_ERROR_UNREF(recv_initial_metadata_ready_error); }
 
   grpc_core::CallCombiner* call_combiner;
 
-  // If we see the recv_message contents in the GET query string, we
-  // store it here.
-  grpc_core::ManualConstructor<grpc_core::SliceBufferByteStream> read_stream;
-  bool have_read_stream = false;
-
   // State for intercepting recv_initial_metadata.
   grpc_closure recv_initial_metadata_ready;
   grpc_error_handle recv_initial_metadata_ready_error = GRPC_ERROR_NONE;
@@ -76,12 +63,6 @@ struct call_data {
   uint32_t* recv_initial_metadata_flags;
   bool seen_recv_initial_metadata_ready = false;
 
-  // State for intercepting recv_message.
-  grpc_closure* original_recv_message_ready;
-  grpc_closure recv_message_ready;
-  grpc_core::OrphanablePtr<grpc_core::ByteStream>* recv_message;
-  bool seen_recv_message_ready = false;
-
   // State for intercepting recv_trailing_metadata
   grpc_closure recv_trailing_metadata_ready;
   grpc_closure* original_recv_trailing_metadata_ready;
@@ -115,7 +96,6 @@ static void hs_add_error(const char* error_name, grpc_error_handle* cumulative,
 
 static grpc_error_handle hs_filter_incoming_metadata(grpc_call_element* elem,
                                                      grpc_metadata_batch* b) {
-  call_data* calld = static_cast<call_data*>(elem->call_data);
   grpc_error_handle error = GRPC_ERROR_NONE;
   static const char* error_name = "Failed processing incoming headers";
 
@@ -123,23 +103,9 @@ static grpc_error_handle hs_filter_incoming_metadata(grpc_call_element* elem,
   if (method.has_value()) {
     switch (*method) {
       case grpc_core::HttpMethodMetadata::kPost:
-        *calld->recv_initial_metadata_flags &=
-            ~(GRPC_INITIAL_METADATA_CACHEABLE_REQUEST |
-              GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST);
-        break;
-      case grpc_core::HttpMethodMetadata::kPut:
-        *calld->recv_initial_metadata_flags &=
-            ~GRPC_INITIAL_METADATA_CACHEABLE_REQUEST;
-        *calld->recv_initial_metadata_flags |=
-            GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST;
-        break;
-      case grpc_core::HttpMethodMetadata::kGet:
-        *calld->recv_initial_metadata_flags |=
-            GRPC_INITIAL_METADATA_CACHEABLE_REQUEST;
-        *calld->recv_initial_metadata_flags &=
-            ~GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST;
         break;
       case grpc_core::HttpMethodMetadata::kInvalid:
+      case grpc_core::HttpMethodMetadata::kGet:
         hs_add_error(error_name, &error,
                      GRPC_ERROR_CREATE_FROM_STATIC_STRING("Bad method header"));
         break;
@@ -185,38 +151,6 @@ static grpc_error_handle hs_filter_incoming_metadata(grpc_call_element* elem,
                  grpc_error_set_str(
                      GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
                      GRPC_ERROR_STR_KEY, ":path"));
-  } else if (*calld->recv_initial_metadata_flags &
-             GRPC_INITIAL_METADATA_CACHEABLE_REQUEST) {
-    /* We have a cacheable request made with GET verb. The path contains the
-     * query parameter which is base64 encoded request payload. */
-    static const char kQuerySeparator = '?';
-    /* offset of the character '?' */
-    auto it =
-        std::find(path_slice->begin(), path_slice->end(), kQuerySeparator);
-    if (it != path_slice->end()) {
-      const auto query_start = it - path_slice->begin() + 1;
-      auto query_slice = path_slice->RefSubSlice(
-          query_start, path_slice->size() - query_start);
-
-      /* substitute path metadata with just the path (not query) */
-      auto path_without_query = path_slice->TakeSubSlice(0, query_start - 1);
-      *path_slice = std::move(path_without_query);
-
-      /* decode payload from query and add to the slice buffer to be returned */
-      const int k_url_safe = 1;
-      grpc_slice_buffer read_slice_buffer;
-      grpc_slice_buffer_init(&read_slice_buffer);
-      grpc_slice_buffer_add(
-          &read_slice_buffer,
-          grpc_base64_decode_with_len(
-              reinterpret_cast<const char*>(query_slice.begin()),
-              query_slice.size(), k_url_safe));
-      calld->read_stream.Init(&read_slice_buffer, 0);
-      grpc_slice_buffer_destroy_internal(&read_slice_buffer);
-      calld->have_read_stream = true;
-    } else {
-      gpr_log(GPR_ERROR, "GET request without QUERY");
-    }
   }
 
   if (b->get_pointer(grpc_core::HttpAuthorityMetadata()) == nullptr) {
@@ -249,22 +183,6 @@ static void hs_recv_initial_metadata_ready(void* user_data,
   if (err == GRPC_ERROR_NONE) {
     err = hs_filter_incoming_metadata(elem, calld->recv_initial_metadata);
     calld->recv_initial_metadata_ready_error = GRPC_ERROR_REF(err);
-    if (calld->seen_recv_message_ready) {
-      // We've already seen the recv_message callback, but we previously
-      // deferred it, so we need to return it here.
-      // Replace the recv_message byte stream if needed.
-      if (calld->have_read_stream) {
-        calld->recv_message->reset(calld->read_stream.get());
-        calld->have_read_stream = false;
-      }
-      // Re-enter call combiner for original_recv_message_ready, since the
-      // surface code will release the call combiner for each callback it
-      // receives.
-      GRPC_CALL_COMBINER_START(
-          calld->call_combiner, calld->original_recv_message_ready,
-          GRPC_ERROR_REF(err),
-          "resuming recv_message_ready from recv_initial_metadata_ready");
-    }
   } else {
     (void)GRPC_ERROR_REF(err);
   }
@@ -279,31 +197,6 @@ static void hs_recv_initial_metadata_ready(void* user_data,
                           calld->original_recv_initial_metadata_ready, err);
 }
 
-static void hs_recv_message_ready(void* user_data, grpc_error_handle err) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  calld->seen_recv_message_ready = true;
-  if (calld->seen_recv_initial_metadata_ready) {
-    // We've already seen the recv_initial_metadata callback, so
-    // replace the recv_message byte stream if needed and invoke the
-    // original recv_message callback immediately.
-    if (calld->have_read_stream) {
-      calld->recv_message->reset(calld->read_stream.get());
-      calld->have_read_stream = false;
-    }
-    grpc_core::Closure::Run(DEBUG_LOCATION, calld->original_recv_message_ready,
-                            GRPC_ERROR_REF(err));
-  } else {
-    // We have not yet seen the recv_initial_metadata callback, so we
-    // need to wait to see if this is a GET request.
-    // Note that we release the call combiner here, so that other
-    // callbacks can run.
-    GRPC_CALL_COMBINER_STOP(
-        calld->call_combiner,
-        "pausing recv_message_ready until recv_initial_metadata_ready");
-  }
-}
-
 static void hs_recv_trailing_metadata_ready(void* user_data,
                                             grpc_error_handle err) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
@@ -355,13 +248,6 @@ static grpc_error_handle hs_mutate_op(grpc_call_element* elem,
         &calld->recv_initial_metadata_ready;
   }
 
-  if (op->recv_message) {
-    calld->recv_message = op->payload->recv_message.recv_message;
-    calld->original_recv_message_ready =
-        op->payload->recv_message.recv_message_ready;
-    op->payload->recv_message.recv_message_ready = &calld->recv_message_ready;
-  }
-
   if (op->recv_trailing_metadata) {
     calld->original_recv_trailing_metadata_ready =
         op->payload->recv_trailing_metadata.recv_trailing_metadata_ready;
@@ -423,6 +309,7 @@ static void hs_destroy_channel_elem(grpc_channel_element* /*elem*/) {}
 
 const grpc_channel_filter grpc_http_server_filter = {
     hs_start_transport_stream_op_batch,
+    nullptr,
     grpc_channel_next_op,
     sizeof(call_data),
     hs_init_call_elem,

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

@@ -27,6 +27,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/ext/filters/message_size/message_size_filter.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.h"
@@ -42,23 +43,19 @@ static void recv_trailing_metadata_ready(void* user_data,
 
 namespace grpc_core {
 
-namespace {
-size_t g_message_size_parser_index;
-}  // namespace
-
 //
 // MessageSizeParsedConfig
 //
 
 const MessageSizeParsedConfig* MessageSizeParsedConfig::GetFromCallContext(
-    const grpc_call_context_element* context) {
+    const grpc_call_context_element* context,
+    size_t service_config_parser_index) {
   if (context == nullptr) return nullptr;
   auto* svc_cfg_call_data = static_cast<ServiceConfigCallData*>(
       context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value);
   if (svc_cfg_call_data == nullptr) return nullptr;
   return static_cast<const MessageSizeParsedConfig*>(
-      svc_cfg_call_data->GetMethodParsedConfig(
-          MessageSizeParser::ParserIndex()));
+      svc_cfg_call_data->GetMethodParsedConfig(service_config_parser_index));
 }
 
 //
@@ -113,12 +110,15 @@ MessageSizeParser::ParsePerMethodParams(const grpc_channel_args* /*args*/,
                                                     max_response_message_bytes);
 }
 
-void MessageSizeParser::Register() {
-  g_message_size_parser_index = ServiceConfigParser::RegisterParser(
+void MessageSizeParser::Register(CoreConfiguration::Builder* builder) {
+  builder->service_config_parser()->RegisterParser(
       absl::make_unique<MessageSizeParser>());
 }
 
-size_t MessageSizeParser::ParserIndex() { return g_message_size_parser_index; }
+size_t MessageSizeParser::ParserIndex() {
+  return CoreConfiguration::Get().service_config_parser().GetParserIndex(
+      parser_name());
+}
 
 int GetMaxRecvSizeFromChannelArgs(const grpc_channel_args* args) {
   if (grpc_channel_args_want_minimal_stack(args)) return -1;
@@ -139,6 +139,8 @@ int GetMaxSendSizeFromChannelArgs(const grpc_channel_args* args) {
 namespace {
 struct channel_data {
   grpc_core::MessageSizeParsedConfig::message_size_limits limits;
+  const size_t service_config_parser_index{
+      grpc_core::MessageSizeParser::ParserIndex()};
 };
 
 struct call_data {
@@ -155,7 +157,8 @@ struct call_data {
     // apply the max request size to the send limit and the max response
     // size to the receive limit.
     const grpc_core::MessageSizeParsedConfig* limits =
-        grpc_core::MessageSizeParsedConfig::GetFromCallContext(args.context);
+        grpc_core::MessageSizeParsedConfig::GetFromCallContext(
+            args.context, chand.service_config_parser_index);
     if (limits != nullptr) {
       if (limits->limits().max_send_size >= 0 &&
           (limits->limits().max_send_size < this->limits.max_send_size ||
@@ -330,6 +333,7 @@ static void message_size_destroy_channel_elem(grpc_channel_element* elem) {
 
 const grpc_channel_filter grpc_message_size_filter = {
     message_size_start_transport_stream_op_batch,
+    nullptr,
     grpc_channel_next_op,
     sizeof(call_data),
     message_size_init_call_elem,
@@ -343,21 +347,20 @@ const grpc_channel_filter grpc_message_size_filter = {
 
 // Used for GRPC_CLIENT_SUBCHANNEL
 static bool maybe_add_message_size_filter_subchannel(
-    grpc_channel_stack_builder* builder) {
-  const grpc_channel_args* channel_args =
-      grpc_channel_stack_builder_get_channel_arguments(builder);
+    grpc_core::ChannelStackBuilder* builder) {
+  const grpc_channel_args* channel_args = builder->channel_args();
   if (grpc_channel_args_want_minimal_stack(channel_args)) {
     return true;
   }
-  return grpc_channel_stack_builder_prepend_filter(
-      builder, &grpc_message_size_filter, nullptr, nullptr);
+  builder->PrependFilter(&grpc_message_size_filter, nullptr);
+  return true;
 }
 
 // Used for GRPC_CLIENT_DIRECT_CHANNEL and GRPC_SERVER_CHANNEL. Adds the filter
 // only if message size limits or service config is specified.
-static bool maybe_add_message_size_filter(grpc_channel_stack_builder* builder) {
-  const grpc_channel_args* channel_args =
-      grpc_channel_stack_builder_get_channel_arguments(builder);
+static bool maybe_add_message_size_filter(
+    grpc_core::ChannelStackBuilder* builder) {
+  const grpc_channel_args* channel_args = builder->channel_args();
   if (grpc_channel_args_want_minimal_stack(channel_args)) {
     return true;
   }
@@ -370,25 +373,14 @@ static bool maybe_add_message_size_filter(grpc_channel_stack_builder* builder) {
   const grpc_arg* a =
       grpc_channel_args_find(channel_args, GRPC_ARG_SERVICE_CONFIG);
   const char* svc_cfg_str = grpc_channel_arg_get_string(a);
-  if (svc_cfg_str != nullptr) {
-    enable = true;
-  }
-  if (enable) {
-    return grpc_channel_stack_builder_prepend_filter(
-        builder, &grpc_message_size_filter, nullptr, nullptr);
-  } else {
-    return true;
-  }
+  if (svc_cfg_str != nullptr) enable = true;
+  if (enable) builder->PrependFilter(&grpc_message_size_filter, nullptr);
+  return true;
 }
 
-void grpc_message_size_filter_init(void) {
-  grpc_core::MessageSizeParser::Register();
-}
-
-void grpc_message_size_filter_shutdown(void) {}
-
 namespace grpc_core {
 void RegisterMessageSizeFilter(CoreConfiguration::Builder* builder) {
+  MessageSizeParser::Register(builder);
   builder->channel_init()->RegisterStage(
       GRPC_CLIENT_SUBCHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
       maybe_add_message_size_filter_subchannel);