grpc 1.44.0.pre2 → 1.45.0

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,45 @@
 #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;
-};
-
-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());
-  }
-  // 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;
-}
-
-/* Destructor for call_data */
-void client_authority_destroy_call_elem(
-    grpc_call_element* /*elem*/, const grpc_call_final_info* /*final_info*/,
-    grpc_closure* /*ignored*/) {}
+namespace grpc_core {
 
-/* 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;
+absl::StatusOr<ClientAuthorityFilter> ClientAuthorityFilter::Create(
+    const grpc_channel_args* args, ChannelFilter::Args) {
   const grpc_arg* default_authority_arg =
-      grpc_channel_args_find(args->channel_args, GRPC_ARG_DEFAULT_AUTHORITY);
+      grpc_channel_args_find(args, GRPC_ARG_DEFAULT_AUTHORITY);
   if (default_authority_arg == nullptr) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+    return absl::InvalidArgumentError(
         "GRPC_ARG_DEFAULT_AUTHORITY channel arg. not found. Note that direct "
         "channels must explicitly specify a value for this argument.");
   }
   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(
+    return absl::InvalidArgumentError(
         "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;
+  return ClientAuthorityFilter(Slice::FromCopiedString(default_authority_str));
 }
 
-/* Destructor for channel data */
-void client_authority_destroy_channel_elem(grpc_channel_element* elem) {
-  static_cast<channel_data*>(elem->channel_data)->~channel_data();
+ArenaPromise<TrailingMetadata> ClientAuthorityFilter::MakeCallPromise(
+    ClientInitialMetadata initial_metadata,
+    NextPromiseFactory next_promise_factory) {
+  // If no authority is set, set the default authority.
+  if (initial_metadata->get_pointer(HttpAuthorityMetadata()) == nullptr) {
+    initial_metadata->Set(HttpAuthorityMetadata(), default_authority_.Ref());
+  }
+  // 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(initial_metadata));
 }
-}  // 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"};
+namespace {
+const grpc_channel_filter grpc_client_authority_filter =
+    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);
+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 +85,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(&grpc_client_authority_filter, 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,32 @@
 
 #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 absl::StatusOr<ClientAuthorityFilter> Create(
+      const grpc_channel_args* args, ChannelFilter::Args);
+
+  // Construct a promise for one call.
+  ArenaPromise<TrailingMetadata> MakeCallPromise(
+      ClientInitialMetadata initial_metadata,
+      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,27 +44,26 @@ 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;
         });
   };
   optional(GRPC_CLIENT_SUBCHANNEL, false,

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

@@ -423,6 +423,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/max_age/max_age_filter.cc

@@ -68,11 +68,11 @@ struct channel_data {
      max_connection_idle */
   grpc_timer max_idle_timer;
   /* Allowed max time a channel may have no outstanding rpcs */
-  grpc_millis max_connection_idle;
+  grpc_core::Duration max_connection_idle;
   /* Allowed max time a channel may exist */
-  grpc_millis max_connection_age;
+  grpc_core::Duration max_connection_age;
   /* Allowed grace period after the channel reaches its max age */
-  grpc_millis max_connection_age_grace;
+  grpc_core::Duration max_connection_age_grace;
   /* Closure to run when the channel's idle duration reaches max_connection_idle
      and should be closed gracefully */
   grpc_closure max_idle_timer_cb;
@@ -142,7 +142,8 @@ struct channel_data {
      For 2, 7    :  See decrease_call_count() function
      For 4, 6    :  See increase_call_count() function */
   gpr_atm idle_state;
-  /* Time when the channel finished its last outstanding call, in grpc_millis */
+  /* Time when the channel finished its last outstanding call, in
+   * grpc_core::Timestamp */
   gpr_atm last_enter_idle_time_millis;
 };
 }  // namespace
@@ -179,7 +180,9 @@ static void decrease_call_count(channel_data* chand) {
   /* Enter idle */
   if (gpr_atm_full_fetch_add(&chand->call_count, -1) == 1) {
     gpr_atm_no_barrier_store(&chand->last_enter_idle_time_millis,
-                             (gpr_atm)grpc_core::ExecCtx::Get()->Now());
+                             (gpr_atm)grpc_core::ExecCtx::Get()
+                                 ->Now()
+                                 .milliseconds_after_process_epoch());
     while (true) {
       gpr_atm idle_state = gpr_atm_acq_load(&chand->idle_state);
       switch (idle_state) {
@@ -286,12 +289,10 @@ static void start_max_age_grace_timer_after_goaway_op(
     grpc_core::MutexLock lock(&chand->max_age_timer_mu);
     chand->max_age_grace_timer_pending = true;
     GRPC_CHANNEL_STACK_REF(chand->channel_stack, "max_age max_age_grace_timer");
-    grpc_timer_init(&chand->max_age_grace_timer,
-                    chand->max_connection_age_grace == GRPC_MILLIS_INF_FUTURE
-                        ? GRPC_MILLIS_INF_FUTURE
-                        : grpc_core::ExecCtx::Get()->Now() +
-                              chand->max_connection_age_grace,
-                    &chand->force_close_max_age_channel);
+    grpc_timer_init(
+        &chand->max_age_grace_timer,
+        grpc_core::ExecCtx::Get()->Now() + chand->max_connection_age_grace,
+        &chand->force_close_max_age_channel);
   }
   GRPC_CHANNEL_STACK_UNREF(chand->channel_stack,
                            "max_age start_max_age_grace_timer_after_goaway_op");
@@ -332,11 +333,13 @@ static void max_idle_timer_cb(void* arg, grpc_error_handle error) {
         case MAX_IDLE_STATE_SEEN_ENTER_IDLE:
           GRPC_CHANNEL_STACK_REF(chand->channel_stack,
                                  "max_age max_idle_timer");
-          grpc_timer_init(&chand->max_idle_timer,
-                          static_cast<grpc_millis>(gpr_atm_no_barrier_load(
-                              &chand->last_enter_idle_time_millis)) +
-                              chand->max_connection_idle,
-                          &chand->max_idle_timer_cb);
+          grpc_timer_init(
+              &chand->max_idle_timer,
+              grpc_core::Timestamp::FromMillisecondsAfterProcessEpoch(
+                  gpr_atm_no_barrier_load(
+                      &chand->last_enter_idle_time_millis)) +
+                  chand->max_connection_idle,
+              &chand->max_idle_timer_cb);
           /* idle_state may have already been set to
              MAX_IDLE_STATE_SEEN_EXIT_IDLE by increase_call_count(), in this
              case, we don't need to set it to MAX_IDLE_STATE_TIMER_SET */
@@ -399,8 +402,8 @@ static void force_close_max_age_channel(void* arg, grpc_error_handle error) {
    connection storms. Note that the MAX_CONNECTION_AGE option without jitter
    would not create connection storms by itself, but if there happened to be a
    connection storm it could cause it to repeat at a fixed period. */
-static grpc_millis
-add_random_max_connection_age_jitter_and_convert_to_grpc_millis(int value) {
+static grpc_core::Duration
+add_random_max_connection_age_jitter_and_convert_to_duration(int value) {
   /* generate a random number between 1 - MAX_CONNECTION_AGE_JITTER and
      1 + MAX_CONNECTION_AGE_JITTER */
   double multiplier = rand() * MAX_CONNECTION_AGE_JITTER * 2.0 / RAND_MAX +
@@ -408,9 +411,11 @@ add_random_max_connection_age_jitter_and_convert_to_grpc_millis(int value) {
   double result = multiplier * value;
   /* INT_MAX - 0.5 converts the value to float, so that result will not be
      cast to int implicitly before the comparison. */
-  return result > (static_cast<double>(GRPC_MILLIS_INF_FUTURE)) - 0.5
-             ? GRPC_MILLIS_INF_FUTURE
-             : static_cast<grpc_millis>(result);
+  return result > (static_cast<double>(
+                      grpc_core::Duration::Infinity().millis())) -
+                      0.5
+             ? grpc_core::Duration::Infinity()
+             : grpc_core::Duration::Milliseconds(result);
 }
 
 /* Constructor for call_data. */
@@ -436,15 +441,17 @@ static grpc_error_handle max_age_init_channel_elem(
   new (chand) channel_data();
   chand->channel_stack = args->channel_stack;
   chand->max_connection_age =
-      add_random_max_connection_age_jitter_and_convert_to_grpc_millis(
+      add_random_max_connection_age_jitter_and_convert_to_duration(
           DEFAULT_MAX_CONNECTION_AGE_MS);
   chand->max_connection_age_grace =
       DEFAULT_MAX_CONNECTION_AGE_GRACE_MS == INT_MAX
-          ? GRPC_MILLIS_INF_FUTURE
-          : DEFAULT_MAX_CONNECTION_AGE_GRACE_MS;
-  chand->max_connection_idle = DEFAULT_MAX_CONNECTION_IDLE_MS == INT_MAX
-                                   ? GRPC_MILLIS_INF_FUTURE
-                                   : DEFAULT_MAX_CONNECTION_IDLE_MS;
+          ? grpc_core::Duration::Infinity()
+          : grpc_core::Duration::Milliseconds(
+                DEFAULT_MAX_CONNECTION_AGE_GRACE_MS);
+  chand->max_connection_idle =
+      DEFAULT_MAX_CONNECTION_IDLE_MS == INT_MAX
+          ? grpc_core::Duration::Infinity()
+          : grpc_core::Duration::Milliseconds(DEFAULT_MAX_CONNECTION_IDLE_MS);
   chand->idle_state = MAX_IDLE_STATE_INIT;
   gpr_atm_no_barrier_store(&chand->last_enter_idle_time_millis, GPR_ATM_MIN);
   for (size_t i = 0; i < args->channel_args->num_args; ++i) {
@@ -453,21 +460,22 @@ static grpc_error_handle max_age_init_channel_elem(
       const int value = grpc_channel_arg_get_integer(
           &args->channel_args->args[i], MAX_CONNECTION_AGE_INTEGER_OPTIONS);
       chand->max_connection_age =
-          add_random_max_connection_age_jitter_and_convert_to_grpc_millis(
-              value);
+          add_random_max_connection_age_jitter_and_convert_to_duration(value);
     } else if (0 == strcmp(args->channel_args->args[i].key,
                            GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS)) {
       const int value = grpc_channel_arg_get_integer(
           &args->channel_args->args[i],
           {DEFAULT_MAX_CONNECTION_AGE_GRACE_MS, 0, INT_MAX});
       chand->max_connection_age_grace =
-          value == INT_MAX ? GRPC_MILLIS_INF_FUTURE : value;
+          value == INT_MAX ? grpc_core::Duration::Infinity()
+                           : grpc_core::Duration::Milliseconds(value);
     } else if (0 == strcmp(args->channel_args->args[i].key,
                            GRPC_ARG_MAX_CONNECTION_IDLE_MS)) {
       const int value = grpc_channel_arg_get_integer(
           &args->channel_args->args[i], MAX_CONNECTION_IDLE_INTEGER_OPTIONS);
       chand->max_connection_idle =
-          value == INT_MAX ? GRPC_MILLIS_INF_FUTURE : value;
+          value == INT_MAX ? grpc_core::Duration::Infinity()
+                           : grpc_core::Duration::Milliseconds(value);
     }
   }
   GRPC_CLOSURE_INIT(&chand->max_idle_timer_cb, max_idle_timer_cb, chand,
@@ -487,7 +495,7 @@ static grpc_error_handle max_age_init_channel_elem(
                     start_max_age_grace_timer_after_goaway_op, chand,
                     grpc_schedule_on_exec_ctx);
 
-  if (chand->max_connection_age != GRPC_MILLIS_INF_FUTURE) {
+  if (chand->max_connection_age != grpc_core::Duration::Infinity()) {
     /* When the channel reaches its max age, we send down an op with
        goaway_error set.  However, we can't send down any ops until after the
        channel stack is fully initialized.  If we start the timer here, we have
@@ -505,7 +513,7 @@ static grpc_error_handle max_age_init_channel_elem(
   /* Initialize the number of calls as 1, so that the max_idle_timer will not
      start until start_max_idle_timer_after_init is invoked. */
   gpr_atm_rel_store(&chand->call_count, 1);
-  if (chand->max_connection_idle != GRPC_MILLIS_INF_FUTURE) {
+  if (chand->max_connection_idle != grpc_core::Duration::Infinity()) {
     GRPC_CHANNEL_STACK_REF(chand->channel_stack,
                            "max_age start_max_idle_timer_after_init");
     grpc_core::ExecCtx::Run(DEBUG_LOCATION,
@@ -523,6 +531,7 @@ static void max_age_destroy_channel_elem(grpc_channel_element* elem) {
 
 const grpc_channel_filter grpc_max_age_filter = {
     grpc_call_next_op,
+    nullptr,
     grpc_channel_next_op,
     0, /* sizeof_call_data */
     max_age_init_call_elem,
@@ -538,9 +547,8 @@ namespace grpc_core {
 void RegisterMaxAgeFilter(CoreConfiguration::Builder* builder) {
   builder->channel_init()->RegisterStage(
       GRPC_SERVER_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      [](grpc_channel_stack_builder* builder) {
-        const grpc_channel_args* channel_args =
-            grpc_channel_stack_builder_get_channel_arguments(builder);
+      [](ChannelStackBuilder* builder) {
+        const grpc_channel_args* channel_args = builder->channel_args();
         bool enable = grpc_channel_arg_get_integer(
                           grpc_channel_args_find(
                               channel_args, GRPC_ARG_MAX_CONNECTION_AGE_MS),
@@ -550,11 +558,9 @@ void RegisterMaxAgeFilter(CoreConfiguration::Builder* builder) {
                               channel_args, GRPC_ARG_MAX_CONNECTION_IDLE_MS),
                           MAX_CONNECTION_IDLE_INTEGER_OPTIONS) != INT_MAX;
         if (enable) {
-          return grpc_channel_stack_builder_prepend_filter(
-              builder, &grpc_max_age_filter, nullptr, nullptr);
-        } else {
-          return true;
+          builder->PrependFilter(&grpc_max_age_filter, nullptr);
         }
+        return true;
       });
 }
 }  // namespace grpc_core

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);

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

@@ -20,6 +20,7 @@
 #include <grpc/support/port_platform.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);