grpc 1.43.1 → 1.46.2

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

@@ -33,8 +33,6 @@
 
 #include "src/core/ext/filters/message_size/message_size_filter.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/compression/algorithm_metadata.h"
-#include "src/core/lib/compression/compression_args.h"
 #include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/compression/message_compress.h"
 #include "src/core/lib/gpr/string.h"
@@ -47,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 {
@@ -75,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)) {
@@ -114,7 +119,7 @@ class CallData {
   // Fields for handling recv_message_ready callback
   bool seen_recv_message_ready_ = false;
   int max_recv_message_length_;
-  grpc_message_compression_algorithm algorithm_ = GRPC_MESSAGE_COMPRESS_NONE;
+  grpc_compression_algorithm algorithm_ = GRPC_COMPRESS_NONE;
   grpc_closure on_recv_message_ready_;
   grpc_closure* original_recv_message_ready_ = nullptr;
   grpc_closure on_recv_message_next_done_;
@@ -133,30 +138,12 @@ class CallData {
   grpc_error_handle on_recv_trailing_metadata_ready_error_ = GRPC_ERROR_NONE;
 };
 
-grpc_message_compression_algorithm DecodeMessageCompressionAlgorithm(
-    grpc_mdelem md) {
-  grpc_message_compression_algorithm algorithm =
-      grpc_message_compression_algorithm_from_slice(GRPC_MDVALUE(md));
-  if (algorithm == GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT) {
-    char* md_c_str = grpc_slice_to_c_string(GRPC_MDVALUE(md));
-    gpr_log(GPR_ERROR,
-            "Invalid incoming message compression algorithm: '%s'. "
-            "Interpreting incoming data as uncompressed.",
-            md_c_str);
-    gpr_free(md_c_str);
-    return GRPC_MESSAGE_COMPRESS_NONE;
-  }
-  return algorithm;
-}
-
 void CallData::OnRecvInitialMetadataReady(void* arg, grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(arg);
   if (error == GRPC_ERROR_NONE) {
-    grpc_linked_mdelem* grpc_encoding =
-        calld->recv_initial_metadata_->legacy_index()->named.grpc_encoding;
-    if (grpc_encoding != nullptr) {
-      calld->algorithm_ = DecodeMessageCompressionAlgorithm(grpc_encoding->md);
-    }
+    calld->algorithm_ =
+        calld->recv_initial_metadata_->get(GrpcEncodingMetadata())
+            .value_or(GRPC_COMPRESS_NONE);
   }
   calld->MaybeResumeOnRecvMessageReady();
   calld->MaybeResumeOnRecvTrailingMetadataReady();
@@ -184,7 +171,7 @@ void CallData::OnRecvMessageReady(void* arg, grpc_error_handle error) {
                               "OnRecvInitialMetadataReady");
       return;
     }
-    if (calld->algorithm_ != GRPC_MESSAGE_COMPRESS_NONE) {
+    if (calld->algorithm_ != GRPC_COMPRESS_NONE) {
       // recv_message can be NULL if trailing metadata is received instead of
       // message, or it's possible that the message was not compressed.
       if (*calld->recv_message_ == nullptr ||
@@ -385,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

@@ -32,16 +32,11 @@
 #include "src/core/lib/slice/percent_encoding.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
-#include "src/core/lib/transport/static_metadata.h"
-
-#define EXPECTED_CONTENT_TYPE "application/grpc"
-#define EXPECTED_CONTENT_TYPE_LENGTH (sizeof(EXPECTED_CONTENT_TYPE) - 1)
 
 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 {
 
@@ -51,31 +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;
 
-  // Outgoing headers to add to send_initial_metadata.
-  grpc_linked_mdelem status;
-  grpc_linked_mdelem content_type;
-
-  // 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;
@@ -84,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;
@@ -121,63 +94,22 @@ static void hs_add_error(const char* error_name, grpc_error_handle* cumulative,
   *cumulative = grpc_error_add_child(*cumulative, new_err);
 }
 
-// Metadata equality within this filter leverages the fact that the sender was
-// likely using the gRPC chttp2 transport, in which case the encoder would emit
-// indexed values, in which case the local hpack parser would intern the
-// relevant metadata, allowing a simple pointer comparison.
-//
-// That said, if the header was transmitted sans indexing/encoding, we still
-// need to do the right thing.
-//
-// Assumptions:
-// 1) The keys for a and b_static must match
-// 2) b_static must be a statically allocated metadata object.
-// 3) It is assumed that the remote end is indexing, but not necessary.
-// TODO(arjunroy): Revisit this method when grpc_mdelem is strongly typed.
-static bool md_strict_equal(grpc_mdelem a, grpc_mdelem b_static) {
-  // Hpack encoder on the remote side should emit indexed values, in which case
-  // hpack parser on this end should pick up interned values, in which case the
-  // pointer comparison alone is enough.
-  //
-  if (GPR_LIKELY(GRPC_MDELEM_IS_INTERNED(a))) {
-    return a.payload == b_static.payload;
-  } else {
-    return grpc_slice_eq_static_interned(GRPC_MDVALUE(a),
-                                         GRPC_MDVALUE(b_static));
-  }
-}
-
 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";
 
-  if (b->legacy_index()->named.method != nullptr) {
-    if (md_strict_equal(b->legacy_index()->named.method->md,
-                        GRPC_MDELEM_METHOD_POST)) {
-      *calld->recv_initial_metadata_flags &=
-          ~(GRPC_INITIAL_METADATA_CACHEABLE_REQUEST |
-            GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST);
-    } else if (md_strict_equal(b->legacy_index()->named.method->md,
-                               GRPC_MDELEM_METHOD_PUT)) {
-      *calld->recv_initial_metadata_flags &=
-          ~GRPC_INITIAL_METADATA_CACHEABLE_REQUEST;
-      *calld->recv_initial_metadata_flags |=
-          GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST;
-    } else if (md_strict_equal(b->legacy_index()->named.method->md,
-                               GRPC_MDELEM_METHOD_GET)) {
-      *calld->recv_initial_metadata_flags |=
-          GRPC_INITIAL_METADATA_CACHEABLE_REQUEST;
-      *calld->recv_initial_metadata_flags &=
-          ~GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST;
-    } else {
-      hs_add_error(error_name, &error,
-                   grpc_attach_md_to_error(
-                       GRPC_ERROR_CREATE_FROM_STATIC_STRING("Bad header"),
-                       b->legacy_index()->named.method->md));
+  auto method = b->get(grpc_core::HttpMethodMetadata());
+  if (method.has_value()) {
+    switch (*method) {
+      case grpc_core::HttpMethodMetadata::kPost:
+        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;
     }
-    b->Remove(GRPC_BATCH_METHOD);
   } else {
     hs_add_error(error_name, &error,
                  grpc_error_set_str(
@@ -198,19 +130,12 @@ static grpc_error_handle hs_filter_incoming_metadata(grpc_call_element* elem,
                  GRPC_ERROR_CREATE_FROM_STATIC_STRING("Bad te header"));
   }
 
-  if (b->legacy_index()->named.scheme != nullptr) {
-    if (!md_strict_equal(b->legacy_index()->named.scheme->md,
-                         GRPC_MDELEM_SCHEME_HTTP) &&
-        !md_strict_equal(b->legacy_index()->named.scheme->md,
-                         GRPC_MDELEM_SCHEME_HTTPS) &&
-        !grpc_mdelem_static_value_eq(b->legacy_index()->named.scheme->md,
-                                     GRPC_MDELEM_SCHEME_GRPC)) {
+  auto scheme = b->Take(grpc_core::HttpSchemeMetadata());
+  if (scheme.has_value()) {
+    if (*scheme == grpc_core::HttpSchemeMetadata::kInvalid) {
       hs_add_error(error_name, &error,
-                   grpc_attach_md_to_error(
-                       GRPC_ERROR_CREATE_FROM_STATIC_STRING("Bad header"),
-                       b->legacy_index()->named.scheme->md));
+                   GRPC_ERROR_CREATE_FROM_STATIC_STRING("Bad :scheme header"));
     }
-    b->Remove(GRPC_BATCH_SCHEME);
   } else {
     hs_add_error(error_name, &error,
                  grpc_error_set_str(
@@ -218,94 +143,24 @@ static grpc_error_handle hs_filter_incoming_metadata(grpc_call_element* elem,
                      GRPC_ERROR_STR_KEY, ":scheme"));
   }
 
-  if (b->legacy_index()->named.content_type != nullptr) {
-    if (!grpc_mdelem_static_value_eq(
-            b->legacy_index()->named.content_type->md,
-            GRPC_MDELEM_CONTENT_TYPE_APPLICATION_SLASH_GRPC)) {
-      if (grpc_slice_buf_start_eq(
-              GRPC_MDVALUE(b->legacy_index()->named.content_type->md),
-              EXPECTED_CONTENT_TYPE, EXPECTED_CONTENT_TYPE_LENGTH) &&
-          (GRPC_SLICE_START_PTR(GRPC_MDVALUE(
-               b->legacy_index()
-                   ->named.content_type->md))[EXPECTED_CONTENT_TYPE_LENGTH] ==
-               '+' ||
-           GRPC_SLICE_START_PTR(GRPC_MDVALUE(
-               b->legacy_index()
-                   ->named.content_type->md))[EXPECTED_CONTENT_TYPE_LENGTH] ==
-               ';')) {
-        /* Although the C implementation doesn't (currently) generate them,
-           any custom +-suffix is explicitly valid. */
-        /* TODO(klempner): We should consider preallocating common values such
-           as +proto or +json, or at least stashing them if we see them. */
-        /* TODO(klempner): Should we be surfacing this to application code? */
-      } else {
-        /* TODO(klempner): We're currently allowing this, but we shouldn't
-           see it without a proxy so log for now. */
-        char* val = grpc_dump_slice(
-            GRPC_MDVALUE(b->legacy_index()->named.content_type->md),
-            GPR_DUMP_ASCII);
-        gpr_log(GPR_INFO, "Unexpected content-type '%s'", val);
-        gpr_free(val);
-      }
-    }
-    b->Remove(GRPC_BATCH_CONTENT_TYPE);
-  }
+  b->Remove(grpc_core::ContentTypeMetadata());
 
-  if (b->legacy_index()->named.path == nullptr) {
+  grpc_core::Slice* path_slice = b->get_pointer(grpc_core::HttpPathMetadata());
+  if (path_slice == nullptr) {
     hs_add_error(error_name, &error,
                  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. */
-    const char k_query_separator = '?';
-    grpc_slice path_slice = GRPC_MDVALUE(b->legacy_index()->named.path->md);
-    uint8_t* path_ptr = GRPC_SLICE_START_PTR(path_slice);
-    size_t path_length = GRPC_SLICE_LENGTH(path_slice);
-    /* offset of the character '?' */
-    size_t offset = 0;
-    for (offset = 0; offset < path_length && *path_ptr != k_query_separator;
-         path_ptr++, offset++) {
-    }
-    if (offset < path_length) {
-      grpc_slice query_slice =
-          grpc_slice_sub(path_slice, offset + 1, path_length);
-
-      /* substitute path metadata with just the path (not query) */
-      grpc_mdelem mdelem_path_without_query = grpc_mdelem_from_slices(
-          GRPC_MDSTR_PATH, grpc_slice_sub(path_slice, 0, offset));
-
-      (void)b->Substitute(b->legacy_index()->named.path,
-                          mdelem_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*> GRPC_SLICE_START_PTR(query_slice),
-              GRPC_SLICE_LENGTH(query_slice), k_url_safe));
-      calld->read_stream.Init(&read_slice_buffer, 0);
-      grpc_slice_buffer_destroy_internal(&read_slice_buffer);
-      calld->have_read_stream = true;
-      grpc_slice_unref_internal(query_slice);
-    } else {
-      gpr_log(GPR_ERROR, "GET request without QUERY");
-    }
   }
 
-  if (b->legacy_index()->named.authority == nullptr) {
+  if (b->get_pointer(grpc_core::HttpAuthorityMetadata()) == nullptr) {
     absl::optional<grpc_core::Slice> host = b->Take(grpc_core::HostMetadata());
     if (host.has_value()) {
-      b->Append(":authority", std::move(*host));
+      b->Set(grpc_core::HttpAuthorityMetadata(), std::move(*host));
     }
   }
 
-  if (b->legacy_index()->named.authority == nullptr) {
+  if (b->get_pointer(grpc_core::HttpAuthorityMetadata()) == nullptr) {
     hs_add_error(error_name, &error,
                  grpc_error_set_str(
                      GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
@@ -328,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);
   }
@@ -358,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);
@@ -410,17 +224,11 @@ static grpc_error_handle hs_mutate_op(grpc_call_element* elem,
   if (op->send_initial_metadata) {
     grpc_error_handle error = GRPC_ERROR_NONE;
     static const char* error_name = "Failed sending initial metadata";
-    hs_add_error(
-        error_name, &error,
-        grpc_metadata_batch_add_head(
-            op->payload->send_initial_metadata.send_initial_metadata,
-            &calld->status, GRPC_MDELEM_STATUS_200, GRPC_BATCH_STATUS));
-    hs_add_error(error_name, &error,
-                 grpc_metadata_batch_add_tail(
-                     op->payload->send_initial_metadata.send_initial_metadata,
-                     &calld->content_type,
-                     GRPC_MDELEM_CONTENT_TYPE_APPLICATION_SLASH_GRPC,
-                     GRPC_BATCH_CONTENT_TYPE));
+    op->payload->send_initial_metadata.send_initial_metadata->Set(
+        grpc_core::HttpStatusMetadata(), 200);
+    op->payload->send_initial_metadata.send_initial_metadata->Set(
+        grpc_core::ContentTypeMetadata(),
+        grpc_core::ContentTypeMetadata::kApplicationGrpc);
     hs_add_error(error_name, &error,
                  hs_filter_outgoing_metadata(
                      op->payload->send_initial_metadata.send_initial_metadata));
@@ -440,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;
@@ -508,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,13 +27,14 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/service_config/service_config_call_data.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"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/service_config/service_config_call_data.h"
 #include "src/core/lib/surface/call.h"
 
 static void recv_message_ready(void* user_data, grpc_error_handle error);
@@ -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);

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

@@ -19,8 +19,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/service_config/service_config_parser.h"
 #include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/service_config/service_config_parser.h"
 
 extern const grpc_channel_filter grpc_message_size_filter;
 
@@ -41,7 +42,8 @@ class MessageSizeParsedConfig : public ServiceConfigParser::ParsedConfig {
   const message_size_limits& limits() const { return limits_; }
 
   static const MessageSizeParsedConfig* GetFromCallContext(
-      const grpc_call_context_element* context);
+      const grpc_call_context_element* context,
+      size_t service_config_parser_index);
 
  private:
   message_size_limits limits_;
@@ -49,13 +51,18 @@ class MessageSizeParsedConfig : public ServiceConfigParser::ParsedConfig {
 
 class MessageSizeParser : public ServiceConfigParser::Parser {
  public:
+  absl::string_view name() const override { return parser_name(); }
+
   std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
       const grpc_channel_args* /*args*/, const Json& json,
       grpc_error_handle* error) override;
 
-  static void Register();
+  static void Register(CoreConfiguration::Builder* builder);
 
   static size_t ParserIndex();
+
+ private:
+  static absl::string_view parser_name() { return "message_size"; }
 };
 
 int GetMaxRecvSizeFromChannelArgs(const grpc_channel_args* args);