grpc 1.40.0 → 1.46.3

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

@@ -20,9 +20,11 @@
 
 #include "src/core/ext/filters/http/server/http_server_filter.h"
 
+#include <string.h>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <string.h>
+
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/profiling/timers.h"
@@ -30,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 {
 
@@ -49,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;
@@ -82,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;
@@ -102,16 +77,10 @@ struct channel_data {
 }  // namespace
 
 static grpc_error_handle hs_filter_outgoing_metadata(grpc_metadata_batch* b) {
-  if (b->idx.named.grpc_message != nullptr) {
-    grpc_slice pct_encoded_msg = grpc_percent_encode_slice(
-        GRPC_MDVALUE(b->idx.named.grpc_message->md),
-        grpc_compatible_percent_encoding_unreserved_bytes);
-    if (grpc_slice_is_equivalent(pct_encoded_msg,
-                                 GRPC_MDVALUE(b->idx.named.grpc_message->md))) {
-      grpc_slice_unref_internal(pct_encoded_msg);
-    } else {
-      grpc_metadata_batch_set_value(b->idx.named.grpc_message, pct_encoded_msg);
-    }
+  if (grpc_core::Slice* grpc_message =
+          b->get_pointer(grpc_core::GrpcMessageMetadata())) {
+    *grpc_message = grpc_core::PercentEncodeSlice(
+        std::move(*grpc_message), grpc_core::PercentEncodingType::Compatible);
   }
   return GRPC_ERROR_NONE;
 }
@@ -125,208 +94,82 @@ 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->idx.named.method != nullptr) {
-    if (md_strict_equal(b->idx.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->idx.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->idx.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->idx.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;
     }
-    grpc_metadata_batch_remove(b, GRPC_BATCH_METHOD);
   } else {
-    hs_add_error(
-        error_name, &error,
-        grpc_error_set_str(
-            GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
-            GRPC_ERROR_STR_KEY, grpc_slice_from_static_string(":method")));
+    hs_add_error(error_name, &error,
+                 grpc_error_set_str(
+                     GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
+                     GRPC_ERROR_STR_KEY, ":method"));
   }
 
-  if (b->idx.named.te != nullptr) {
-    if (!grpc_mdelem_static_value_eq(b->idx.named.te->md,
-                                     GRPC_MDELEM_TE_TRAILERS)) {
-      hs_add_error(error_name, &error,
-                   grpc_attach_md_to_error(
-                       GRPC_ERROR_CREATE_FROM_STATIC_STRING("Bad header"),
-                       b->idx.named.te->md));
-    }
-    grpc_metadata_batch_remove(b, GRPC_BATCH_TE);
-  } else {
+  auto te = b->Take(grpc_core::TeMetadata());
+  if (te == grpc_core::TeMetadata::kTrailers) {
+    // Do nothing, ok.
+  } else if (!te.has_value()) {
     hs_add_error(error_name, &error,
                  grpc_error_set_str(
                      GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
-                     GRPC_ERROR_STR_KEY, grpc_slice_from_static_string("te")));
+                     GRPC_ERROR_STR_KEY, "te"));
+  } else {
+    hs_add_error(error_name, &error,
+                 GRPC_ERROR_CREATE_FROM_STATIC_STRING("Bad te header"));
   }
 
-  if (b->idx.named.scheme != nullptr) {
-    if (!md_strict_equal(b->idx.named.scheme->md, GRPC_MDELEM_SCHEME_HTTP) &&
-        !md_strict_equal(b->idx.named.scheme->md, GRPC_MDELEM_SCHEME_HTTPS) &&
-        !grpc_mdelem_static_value_eq(b->idx.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->idx.named.scheme->md));
+                   GRPC_ERROR_CREATE_FROM_STATIC_STRING("Bad :scheme header"));
     }
-    grpc_metadata_batch_remove(b, GRPC_BATCH_SCHEME);
   } else {
-    hs_add_error(
-        error_name, &error,
-        grpc_error_set_str(
-            GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
-            GRPC_ERROR_STR_KEY, grpc_slice_from_static_string(":scheme")));
+    hs_add_error(error_name, &error,
+                 grpc_error_set_str(
+                     GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
+                     GRPC_ERROR_STR_KEY, ":scheme"));
   }
 
-  if (b->idx.named.content_type != nullptr) {
-    if (!grpc_mdelem_static_value_eq(
-            b->idx.named.content_type->md,
-            GRPC_MDELEM_CONTENT_TYPE_APPLICATION_SLASH_GRPC)) {
-      if (grpc_slice_buf_start_eq(GRPC_MDVALUE(b->idx.named.content_type->md),
-                                  EXPECTED_CONTENT_TYPE,
-                                  EXPECTED_CONTENT_TYPE_LENGTH) &&
-          (GRPC_SLICE_START_PTR(GRPC_MDVALUE(
-               b->idx.named.content_type->md))[EXPECTED_CONTENT_TYPE_LENGTH] ==
-               '+' ||
-           GRPC_SLICE_START_PTR(GRPC_MDVALUE(
-               b->idx.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->idx.named.content_type->md),
-                                    GPR_DUMP_ASCII);
-        gpr_log(GPR_INFO, "Unexpected content-type '%s'", val);
-        gpr_free(val);
-      }
-    }
-    grpc_metadata_batch_remove(b, GRPC_BATCH_CONTENT_TYPE);
-  }
+  b->Remove(grpc_core::ContentTypeMetadata());
 
-  if (b->idx.named.path == nullptr) {
-    hs_add_error(
-        error_name, &error,
-        grpc_error_set_str(
-            GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
-            GRPC_ERROR_STR_KEY, grpc_slice_from_static_string(":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->idx.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));
-
-      grpc_metadata_batch_substitute(b, b->idx.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");
-    }
+  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"));
   }
 
-  if (b->idx.named.host != nullptr && b->idx.named.authority == nullptr) {
-    grpc_linked_mdelem* el = b->idx.named.host;
-    grpc_mdelem md = GRPC_MDELEM_REF(el->md);
-    grpc_metadata_batch_remove(b, el);
-    hs_add_error(
-        error_name, &error,
-        grpc_metadata_batch_add_head(
-            b, el,
-            grpc_mdelem_from_slices(GRPC_MDSTR_AUTHORITY,
-                                    grpc_slice_ref_internal(GRPC_MDVALUE(md))),
-            GRPC_BATCH_AUTHORITY));
-    GRPC_MDELEM_UNREF(md);
+  if (b->get_pointer(grpc_core::HttpAuthorityMetadata()) == nullptr) {
+    absl::optional<grpc_core::Slice> host = b->Take(grpc_core::HostMetadata());
+    if (host.has_value()) {
+      b->Set(grpc_core::HttpAuthorityMetadata(), std::move(*host));
+    }
   }
 
-  if (b->idx.named.authority == nullptr) {
-    hs_add_error(
-        error_name, &error,
-        grpc_error_set_str(
-            GRPC_ERROR_CREATE_FROM_STATIC_STRING("Missing header"),
-            GRPC_ERROR_STR_KEY, grpc_slice_from_static_string(":authority")));
+  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"),
+                     GRPC_ERROR_STR_KEY, ":authority"));
   }
 
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  if (!chand->surface_user_agent && b->idx.named.user_agent != nullptr) {
-    grpc_metadata_batch_remove(b, GRPC_BATCH_USER_AGENT);
+  if (!chand->surface_user_agent) {
+    b->Remove(grpc_core::UserAgentMetadata());
   }
 
   return error;
@@ -340,24 +183,8 @@ 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 {
-    GRPC_ERROR_REF(err);
+    (void)GRPC_ERROR_REF(err);
   }
   if (calld->seen_recv_trailing_metadata_ready) {
     GRPC_CALL_COMBINER_START(calld->call_combiner,
@@ -370,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);
@@ -422,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));
@@ -452,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;
@@ -520,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,15 +27,15 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/filters/client_channel/service_config.h"
-#include "src/core/ext/filters/client_channel/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"
-#include "src/core/lib/surface/channel_init.h"
 
 static void recv_message_ready(void* user_data, grpc_error_handle error);
 static void recv_trailing_metadata_ready(void* user_data,
@@ -43,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));
 }
 
 //
@@ -114,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;
@@ -140,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 {
@@ -156,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 ||
@@ -203,17 +205,15 @@ static void recv_message_ready(void* user_data, grpc_error_handle error) {
       (*calld->recv_message)->length() >
           static_cast<size_t>(calld->limits.max_recv_size)) {
     grpc_error_handle new_error = grpc_error_set_int(
-        GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-            absl::StrFormat("Received message larger than max (%u vs. %d)",
-                            (*calld->recv_message)->length(),
-                            calld->limits.max_recv_size)
-                .c_str()),
+        GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+            "Received message larger than max (%u vs. %d)",
+            (*calld->recv_message)->length(), calld->limits.max_recv_size)),
         GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED);
     error = grpc_error_add_child(GRPC_ERROR_REF(error), new_error);
     GRPC_ERROR_UNREF(calld->error);
     calld->error = GRPC_ERROR_REF(error);
   } else {
-    GRPC_ERROR_REF(error);
+    (void)GRPC_ERROR_REF(error);
   }
   // Invoke the next callback.
   grpc_closure* closure = calld->next_recv_message_ready;
@@ -264,14 +264,12 @@ static void message_size_start_transport_stream_op_batch(
           static_cast<size_t>(calld->limits.max_send_size)) {
     grpc_transport_stream_op_batch_finish_with_failure(
         op,
-        grpc_error_set_int(
-            GRPC_ERROR_CREATE_FROM_COPIED_STRING(
-                absl::StrFormat(
-                    "Sent message larger than max (%u vs. %d)",
-                    op->payload->send_message.send_message->length(),
-                    calld->limits.max_send_size)
-                    .c_str()),
-            GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED),
+        grpc_error_set_int(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+                               "Sent message larger than max (%u vs. %d)",
+                               op->payload->send_message.send_message->length(),
+                               calld->limits.max_send_size)),
+                           GRPC_ERROR_INT_GRPC_STATUS,
+                           GRPC_STATUS_RESOURCE_EXHAUSTED),
         calld->call_combiner);
     return;
   }
@@ -335,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,
@@ -348,22 +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, void* /*arg*/) {
-  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,
-                                          void* /*arg*/) {
-  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;
   }
@@ -376,28 +373,22 @@ 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_channel_init_register_stage(
+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, nullptr);
-  grpc_channel_init_register_stage(GRPC_CLIENT_DIRECT_CHANNEL,
-                                   GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-                                   maybe_add_message_size_filter, nullptr);
-  grpc_channel_init_register_stage(GRPC_SERVER_CHANNEL,
-                                   GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-                                   maybe_add_message_size_filter, nullptr);
-  grpc_core::MessageSizeParser::Register();
+      maybe_add_message_size_filter_subchannel);
+  builder->channel_init()->RegisterStage(GRPC_CLIENT_DIRECT_CHANNEL,
+                                         GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
+                                         maybe_add_message_size_filter);
+  builder->channel_init()->RegisterStage(GRPC_SERVER_CHANNEL,
+                                         GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
+                                         maybe_add_message_size_filter);
 }
-
-void grpc_message_size_filter_shutdown(void) {}
+}  // namespace grpc_core