grpc 1.42.0 → 1.45.0

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

@@ -32,10 +32,6 @@
 #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);
@@ -67,10 +63,6 @@ struct call_data {
 
   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;
@@ -104,18 +96,10 @@ struct channel_data {
 }  // namespace
 
 static grpc_error_handle hs_filter_outgoing_metadata(grpc_metadata_batch* b) {
-  if (b->legacy_index()->named.grpc_message != nullptr) {
-    grpc_slice pct_encoded_msg = grpc_core::PercentEncodeSlice(
-        GRPC_MDVALUE(b->legacy_index()->named.grpc_message->md),
-        grpc_core::PercentEncodingType::Compatible);
-    if (grpc_slice_is_equivalent(
-            pct_encoded_msg,
-            GRPC_MDVALUE(b->legacy_index()->named.grpc_message->md))) {
-      grpc_slice_unref_internal(pct_encoded_msg);
-    } else {
-      grpc_metadata_batch_set_value(b->legacy_index()->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;
 }
@@ -129,63 +113,37 @@ 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:
+        *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:
+        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(
@@ -206,19 +164,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(
@@ -226,40 +177,10 @@ 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"),
@@ -268,25 +189,18 @@ static grpc_error_handle hs_filter_incoming_metadata(grpc_call_element* elem,
              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);
+    static const char kQuerySeparator = '?';
     /* 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);
+    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) */
-      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);
+      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;
@@ -295,33 +209,24 @@ static grpc_error_handle hs_filter_incoming_metadata(grpc_call_element* elem,
       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));
+              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;
-      grpc_slice_unref_internal(query_slice);
     } else {
       gpr_log(GPR_ERROR, "GET request without QUERY");
     }
   }
 
-  if (b->legacy_index()->named.host != nullptr &&
-      b->legacy_index()->named.authority == nullptr) {
-    grpc_linked_mdelem* el = b->legacy_index()->named.host;
-    grpc_mdelem md = GRPC_MDELEM_REF(el->md);
-    b->Remove(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->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"),
@@ -329,9 +234,8 @@ static grpc_error_handle hs_filter_incoming_metadata(grpc_call_element* elem,
   }
 
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  if (!chand->surface_user_agent &&
-      b->legacy_index()->named.user_agent != nullptr) {
-    b->Remove(GRPC_BATCH_USER_AGENT);
+  if (!chand->surface_user_agent) {
+    b->Remove(grpc_core::UserAgentMetadata());
   }
 
   return error;
@@ -427,17 +331,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));
@@ -525,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,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);