grpc 1.41.1 → 1.44.0.pre2

data/src/core/ext/filters/http/client/http_client_filter.cc

@@ -39,7 +39,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"
 #include "src/core/lib/transport/status_conversion.h"
 #include "src/core/lib/transport/transport_impl.h"
 
@@ -75,13 +74,6 @@ struct call_data {
   ~call_data() { GRPC_ERROR_UNREF(recv_initial_metadata_error); }
 
   grpc_core::CallCombiner* call_combiner;
-  // State for handling send_initial_metadata ops.
-  grpc_linked_mdelem method;
-  grpc_linked_mdelem scheme;
-  grpc_linked_mdelem authority;
-  grpc_linked_mdelem te_trailers;
-  grpc_linked_mdelem content_type;
-  grpc_linked_mdelem user_agent;
   // State for handling recv_initial_metadata ops.
   grpc_metadata_batch* recv_initial_metadata;
   grpc_error_handle recv_initial_metadata_error = GRPC_ERROR_NONE;
@@ -105,83 +97,46 @@ struct call_data {
 };
 
 struct channel_data {
-  grpc_mdelem static_scheme;
-  grpc_mdelem user_agent;
+  grpc_core::HttpSchemeMetadata::ValueType static_scheme;
+  grpc_core::Slice user_agent;
   size_t max_payload_size_for_get;
 };
 }  // namespace
 
 static grpc_error_handle client_filter_incoming_metadata(
     grpc_metadata_batch* b) {
-  if (b->idx.named.status != nullptr) {
+  if (auto* status = b->get_pointer(grpc_core::HttpStatusMetadata())) {
     /* If both gRPC status and HTTP status are provided in the response, we
      * should prefer the gRPC status code, as mentioned in
      * https://github.com/grpc/grpc/blob/master/doc/http-grpc-status-mapping.md.
      */
-    if (b->idx.named.grpc_status != nullptr ||
-        grpc_mdelem_static_value_eq(b->idx.named.status->md,
-                                    GRPC_MDELEM_STATUS_200)) {
-      grpc_metadata_batch_remove(b, GRPC_BATCH_STATUS);
+    const grpc_status_code* grpc_status =
+        b->get_pointer(grpc_core::GrpcStatusMetadata());
+    if (grpc_status != nullptr || *status == 200) {
+      b->Remove(grpc_core::HttpStatusMetadata());
     } else {
-      char* val = grpc_dump_slice(GRPC_MDVALUE(b->idx.named.status->md),
-                                  GPR_DUMP_ASCII);
       std::string msg =
-          absl::StrCat("Received http2 header with status: ", val);
+          absl::StrCat("Received http2 header with status: ", *status);
       grpc_error_handle e = grpc_error_set_str(
           grpc_error_set_int(
               grpc_error_set_str(
                   GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                       "Received http2 :status header with non-200 OK status"),
-                  GRPC_ERROR_STR_VALUE, grpc_slice_from_copied_string(val)),
+                  GRPC_ERROR_STR_VALUE, std::to_string(*status)),
               GRPC_ERROR_INT_GRPC_STATUS,
-              grpc_http2_status_to_grpc_status(atoi(val))),
-          GRPC_ERROR_STR_GRPC_MESSAGE,
-          grpc_slice_from_cpp_string(std::move(msg)));
-      gpr_free(val);
+              grpc_http2_status_to_grpc_status(*status)),
+          GRPC_ERROR_STR_GRPC_MESSAGE, msg);
       return e;
     }
   }
 
-  if (b->idx.named.grpc_message != nullptr) {
-    grpc_slice pct_decoded_msg = grpc_core::PermissivePercentDecodeSlice(
-        GRPC_MDVALUE(b->idx.named.grpc_message->md));
-    if (grpc_slice_is_equivalent(pct_decoded_msg,
-                                 GRPC_MDVALUE(b->idx.named.grpc_message->md))) {
-      grpc_slice_unref_internal(pct_decoded_msg);
-    } else {
-      grpc_metadata_batch_set_value(b->idx.named.grpc_message, pct_decoded_msg);
-    }
+  if (grpc_core::Slice* grpc_message =
+          b->get_pointer(grpc_core::GrpcMessageMetadata())) {
+    *grpc_message =
+        grpc_core::PermissivePercentDecodeSlice(std::move(*grpc_message));
   }
 
-  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());
 
   return GRPC_ERROR_NONE;
 }
@@ -194,7 +149,7 @@ static void recv_initial_metadata_ready(void* user_data,
     error = client_filter_incoming_metadata(calld->recv_initial_metadata);
     calld->recv_initial_metadata_error = GRPC_ERROR_REF(error);
   } else {
-    GRPC_ERROR_REF(error);
+    (void)GRPC_ERROR_REF(error);
   }
   grpc_closure* closure = calld->original_recv_initial_metadata_ready;
   calld->original_recv_initial_metadata_ready = nullptr;
@@ -221,7 +176,7 @@ static void recv_trailing_metadata_ready(void* user_data,
   if (error == GRPC_ERROR_NONE) {
     error = client_filter_incoming_metadata(calld->recv_trailing_metadata);
   } else {
-    GRPC_ERROR_REF(error);
+    (void)GRPC_ERROR_REF(error);
   }
   error = grpc_error_add_child(
       error, GRPC_ERROR_REF(calld->recv_initial_metadata_error));
@@ -312,53 +267,41 @@ static char* slice_buffer_to_string(grpc_slice_buffer* slice_buffer) {
 
 // Modifies the path entry in the batch's send_initial_metadata to
 // append the base64-encoded query for a GET request.
-static grpc_error_handle update_path_for_get(
-    grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
+static void update_path_for_get(grpc_call_element* elem,
+                                grpc_transport_stream_op_batch* batch) {
+  grpc_metadata_batch* b =
+      batch->payload->send_initial_metadata.send_initial_metadata;
   call_data* calld = static_cast<call_data*>(elem->call_data);
-  grpc_slice path_slice =
-      GRPC_MDVALUE(batch->payload->send_initial_metadata.send_initial_metadata
-                       ->idx.named.path->md);
+  const grpc_core::Slice& path_slice =
+      *b->get_pointer(grpc_core::HttpPathMetadata());
   /* sum up individual component's lengths and allocate enough memory to
    * hold combined path+query */
-  size_t estimated_len = GRPC_SLICE_LENGTH(path_slice);
+  size_t estimated_len = path_slice.size();
   estimated_len++; /* for the '?' */
   estimated_len += grpc_base64_estimate_encoded_size(
       batch->payload->send_message.send_message->length(),
       false /* multi_line */);
-  grpc_core::UnmanagedMemorySlice path_with_query_slice(estimated_len);
+  grpc_core::MutableSlice path_with_query_slice =
+      grpc_core::MutableSlice::CreateUninitialized(estimated_len);
   /* memcopy individual pieces into this slice */
-  char* write_ptr =
-      reinterpret_cast<char*> GRPC_SLICE_START_PTR(path_with_query_slice);
-  char* original_path =
-      reinterpret_cast<char*> GRPC_SLICE_START_PTR(path_slice);
-  memcpy(write_ptr, original_path, GRPC_SLICE_LENGTH(path_slice));
-  write_ptr += GRPC_SLICE_LENGTH(path_slice);
+  uint8_t* write_ptr = path_with_query_slice.begin();
+  const uint8_t* original_path = path_slice.data();
+  memcpy(write_ptr, original_path, path_slice.size());
+  write_ptr += path_slice.size();
   *write_ptr++ = '?';
   char* payload_bytes =
       slice_buffer_to_string(calld->send_message_cache->cache_buffer());
-  grpc_base64_encode_core(write_ptr, payload_bytes,
+  grpc_base64_encode_core(reinterpret_cast<char*>(write_ptr), payload_bytes,
                           batch->payload->send_message.send_message->length(),
                           true /* url_safe */, false /* multi_line */);
   gpr_free(payload_bytes);
-  /* remove trailing unused memory and add trailing 0 to terminate string */
-  char* t = reinterpret_cast<char*> GRPC_SLICE_START_PTR(path_with_query_slice);
+  char* t = reinterpret_cast<char*>(path_with_query_slice.begin()) +
+            path_slice.size();
   /* safe to use strlen since base64_encode will always add '\0' */
-  path_with_query_slice =
-      grpc_slice_sub_no_ref(path_with_query_slice, 0, strlen(t));
   /* substitute previous path with the new path+query */
-  grpc_mdelem mdelem_path_and_query =
-      grpc_mdelem_from_slices(GRPC_MDSTR_PATH, path_with_query_slice);
-  grpc_metadata_batch* b =
-      batch->payload->send_initial_metadata.send_initial_metadata;
-  return grpc_metadata_batch_substitute(b, b->idx.named.path,
-                                        mdelem_path_and_query);
-}
-
-static void remove_if_present(grpc_metadata_batch* batch,
-                              grpc_metadata_batch_callouts_index idx) {
-  if (batch->idx.array[idx] != nullptr) {
-    grpc_metadata_batch_remove(batch, idx);
-  }
+  b->Set(grpc_core::HttpPathMetadata(),
+         grpc_core::Slice(path_with_query_slice.TakeSubSlice(
+             0, path_slice.size() + strlen(t))));
 }
 
 static void http_client_start_transport_stream_op_batch(
@@ -394,7 +337,8 @@ static void http_client_start_transport_stream_op_batch(
     // cacheable, and the operation contains both initial metadata and send
     // message, and the payload is below the size threshold, and all the data
     // for this request is immediately available.
-    grpc_mdelem method = GRPC_MDELEM_METHOD_POST;
+    grpc_core::HttpMethodMetadata::ValueType method =
+        grpc_core::HttpMethodMetadata::kPost;
     if (batch->send_message &&
         (batch->payload->send_initial_metadata.send_initial_metadata_flags &
          GRPC_INITIAL_METADATA_CACHEABLE_REQUEST) &&
@@ -414,9 +358,8 @@ static void http_client_start_transport_stream_op_batch(
       // If all the data has been read, then we can use GET.
       if (calld->send_message_bytes_read ==
           calld->send_message_caching_stream->length()) {
-        method = GRPC_MDELEM_METHOD_GET;
-        error = update_path_for_get(elem, batch);
-        if (error != GRPC_ERROR_NONE) goto done;
+        method = grpc_core::HttpMethodMetadata::kGet;
+        update_path_for_get(elem, batch);
         batch->send_message = false;
         calld->send_message_caching_stream->Orphan();
       } else {
@@ -431,49 +374,22 @@ static void http_client_start_transport_stream_op_batch(
     } else if (batch->payload->send_initial_metadata
                    .send_initial_metadata_flags &
                GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST) {
-      method = GRPC_MDELEM_METHOD_PUT;
+      method = grpc_core::HttpMethodMetadata::kPut;
     }
 
-    remove_if_present(
-        batch->payload->send_initial_metadata.send_initial_metadata,
-        GRPC_BATCH_METHOD);
-    remove_if_present(
-        batch->payload->send_initial_metadata.send_initial_metadata,
-        GRPC_BATCH_SCHEME);
-    remove_if_present(
-        batch->payload->send_initial_metadata.send_initial_metadata,
-        GRPC_BATCH_TE);
-    remove_if_present(
-        batch->payload->send_initial_metadata.send_initial_metadata,
-        GRPC_BATCH_CONTENT_TYPE);
-    remove_if_present(
-        batch->payload->send_initial_metadata.send_initial_metadata,
-        GRPC_BATCH_USER_AGENT);
-
     /* Send : prefixed headers, which have to be before any application
        layer headers. */
-    error = grpc_metadata_batch_add_head(
-        batch->payload->send_initial_metadata.send_initial_metadata,
-        &calld->method, method, GRPC_BATCH_METHOD);
-    if (error != GRPC_ERROR_NONE) goto done;
-    error = grpc_metadata_batch_add_head(
-        batch->payload->send_initial_metadata.send_initial_metadata,
-        &calld->scheme, channeld->static_scheme, GRPC_BATCH_SCHEME);
-    if (error != GRPC_ERROR_NONE) goto done;
-    error = grpc_metadata_batch_add_tail(
-        batch->payload->send_initial_metadata.send_initial_metadata,
-        &calld->te_trailers, GRPC_MDELEM_TE_TRAILERS, GRPC_BATCH_TE);
-    if (error != GRPC_ERROR_NONE) goto done;
-    error = grpc_metadata_batch_add_tail(
-        batch->payload->send_initial_metadata.send_initial_metadata,
-        &calld->content_type, GRPC_MDELEM_CONTENT_TYPE_APPLICATION_SLASH_GRPC,
-        GRPC_BATCH_CONTENT_TYPE);
-    if (error != GRPC_ERROR_NONE) goto done;
-    error = grpc_metadata_batch_add_tail(
-        batch->payload->send_initial_metadata.send_initial_metadata,
-        &calld->user_agent, GRPC_MDELEM_REF(channeld->user_agent),
-        GRPC_BATCH_USER_AGENT);
-    if (error != GRPC_ERROR_NONE) goto done;
+    batch->payload->send_initial_metadata.send_initial_metadata->Set(
+        grpc_core::HttpMethodMetadata(), method);
+    batch->payload->send_initial_metadata.send_initial_metadata->Set(
+        grpc_core::HttpSchemeMetadata(), channeld->static_scheme);
+    batch->payload->send_initial_metadata.send_initial_metadata->Set(
+        grpc_core::TeMetadata(), grpc_core::TeMetadata::kTrailers);
+    batch->payload->send_initial_metadata.send_initial_metadata->Set(
+        grpc_core::ContentTypeMetadata(),
+        grpc_core::ContentTypeMetadata::kApplicationGrpc);
+    batch->payload->send_initial_metadata.send_initial_metadata->Set(
+        grpc_core::UserAgentMetadata(), channeld->user_agent.Ref());
   }
 
 done:
@@ -500,25 +416,21 @@ static void http_client_destroy_call_elem(
   calld->~call_data();
 }
 
-static grpc_mdelem scheme_from_args(const grpc_channel_args* args) {
-  unsigned i;
-  size_t j;
-  grpc_mdelem valid_schemes[] = {GRPC_MDELEM_SCHEME_HTTP,
-                                 GRPC_MDELEM_SCHEME_HTTPS};
+static grpc_core::HttpSchemeMetadata::ValueType scheme_from_args(
+    const grpc_channel_args* args) {
   if (args != nullptr) {
-    for (i = 0; i < args->num_args; ++i) {
+    for (size_t i = 0; i < args->num_args; ++i) {
       if (args->args[i].type == GRPC_ARG_STRING &&
-          strcmp(args->args[i].key, GRPC_ARG_HTTP2_SCHEME) == 0) {
-        for (j = 0; j < GPR_ARRAY_SIZE(valid_schemes); j++) {
-          if (0 == grpc_slice_str_cmp(GRPC_MDVALUE(valid_schemes[j]),
-                                      args->args[i].value.string)) {
-            return valid_schemes[j];
-          }
-        }
+          0 == strcmp(args->args[i].key, GRPC_ARG_HTTP2_SCHEME)) {
+        grpc_core::HttpSchemeMetadata::ValueType scheme =
+            grpc_core::HttpSchemeMetadata::Parse(
+                args->args[i].value.string,
+                [](absl::string_view, const grpc_core::Slice&) {});
+        if (scheme != grpc_core::HttpSchemeMetadata::kInvalid) return scheme;
       }
     }
   }
-  return GRPC_MDELEM_SCHEME_HTTP;
+  return grpc_core::HttpSchemeMetadata::kHttp;
 }
 
 static size_t max_payload_size_from_args(const grpc_channel_args* args) {
@@ -537,8 +449,8 @@ static size_t max_payload_size_from_args(const grpc_channel_args* args) {
   return kMaxPayloadSizeForGet;
 }
 
-static grpc_core::ManagedMemorySlice user_agent_from_args(
-    const grpc_channel_args* args, const char* transport_name) {
+static grpc_core::Slice user_agent_from_args(const grpc_channel_args* args,
+                                             const char* transport_name) {
   std::vector<std::string> user_agent_fields;
 
   for (size_t i = 0; args && i < args->num_args; i++) {
@@ -568,29 +480,27 @@ static grpc_core::ManagedMemorySlice user_agent_from_args(
   }
 
   std::string user_agent_string = absl::StrJoin(user_agent_fields, " ");
-  return grpc_core::ManagedMemorySlice(user_agent_string.c_str());
+  return grpc_core::Slice::FromCopiedString(user_agent_string.c_str());
 }
 
 /* Constructor for channel_data */
 static grpc_error_handle http_client_init_channel_elem(
     grpc_channel_element* elem, grpc_channel_element_args* args) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
+  new (chand) channel_data();
   GPR_ASSERT(!args->is_last);
   GPR_ASSERT(args->optional_transport != nullptr);
   chand->static_scheme = scheme_from_args(args->channel_args);
   chand->max_payload_size_for_get =
       max_payload_size_from_args(args->channel_args);
-  chand->user_agent = grpc_mdelem_from_slices(
-      GRPC_MDSTR_USER_AGENT,
-      user_agent_from_args(args->channel_args,
-                           args->optional_transport->vtable->name));
+  chand->user_agent = grpc_core::Slice(user_agent_from_args(
+      args->channel_args, args->optional_transport->vtable->name));
   return GRPC_ERROR_NONE;
 }
 
 /* Destructor for channel data */
 static void http_client_destroy_channel_elem(grpc_channel_element* elem) {
-  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  GRPC_MDELEM_UNREF(chand->user_agent);
+  static_cast<channel_data*>(elem->channel_data)->~channel_data();
 }
 
 const grpc_channel_filter grpc_http_client_filter = {

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

@@ -29,44 +29,34 @@
 #include <grpc/support/string_util.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/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/surface/call.h"
-#include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/transport/static_metadata.h"
 
 namespace {
 
 struct call_data {
-  grpc_linked_mdelem authority_storage;
   grpc_core::CallCombiner* call_combiner;
 };
 
 struct channel_data {
-  grpc_core::ManagedMemorySlice default_authority;
-  grpc_mdelem default_authority_mdelem;
+  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);
-  call_data* calld = static_cast<call_data*>(elem->call_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->idx.named
-              .authority == nullptr) {
-    grpc_error_handle error = grpc_metadata_batch_add_head(
-        batch->payload->send_initial_metadata.send_initial_metadata,
-        &calld->authority_storage,
-        GRPC_MDELEM_REF(chand->default_authority_mdelem), GRPC_BATCH_AUTHORITY);
-    if (error != GRPC_ERROR_NONE) {
-      grpc_transport_stream_op_batch_finish_with_failure(batch, error,
-                                                         calld->call_combiner);
-      return;
-    }
+      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);
@@ -88,7 +78,7 @@ void client_authority_destroy_call_elem(
 /* Constructor for channel_data */
 grpc_error_handle client_authority_init_channel_elem(
     grpc_channel_element* elem, grpc_channel_element_args* args) {
-  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
+  channel_data* chand = new (elem->channel_data) channel_data;
   const grpc_arg* default_authority_arg =
       grpc_channel_args_find(args->channel_args, GRPC_ARG_DEFAULT_AUTHORITY);
   if (default_authority_arg == nullptr) {
@@ -103,18 +93,14 @@ grpc_error_handle client_authority_init_channel_elem(
         "GRPC_ARG_DEFAULT_AUTHORITY channel arg. must be a string");
   }
   chand->default_authority =
-      grpc_core::ManagedMemorySlice(default_authority_str);
-  chand->default_authority_mdelem = grpc_mdelem_create(
-      GRPC_MDSTR_AUTHORITY, chand->default_authority, nullptr);
+      grpc_core::Slice::FromCopiedString(default_authority_str);
   GPR_ASSERT(!args->is_last);
   return GRPC_ERROR_NONE;
 }
 
 /* Destructor for channel data */
 void client_authority_destroy_channel_elem(grpc_channel_element* elem) {
-  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  grpc_slice_unref_internal(chand->default_authority);
-  GRPC_MDELEM_UNREF(chand->default_authority_mdelem);
+  static_cast<channel_data*>(elem->channel_data)->~channel_data();
 }
 }  // namespace
 
@@ -131,8 +117,7 @@ const grpc_channel_filter grpc_client_authority_filter = {
     grpc_channel_next_get_info,
     "authority"};
 
-static bool add_client_authority_filter(grpc_channel_stack_builder* builder,
-                                        void* arg) {
+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);
   const grpc_arg* disable_client_authority_filter_arg = grpc_channel_args_find(
@@ -145,16 +130,14 @@ static bool add_client_authority_filter(grpc_channel_stack_builder* builder,
     }
   }
   return grpc_channel_stack_builder_prepend_filter(
-      builder, static_cast<const grpc_channel_filter*>(arg), nullptr, nullptr);
+      builder, &grpc_client_authority_filter, nullptr, nullptr);
 }
 
-void grpc_client_authority_filter_init(void) {
-  grpc_channel_init_register_stage(
-      GRPC_CLIENT_SUBCHANNEL, INT_MAX, add_client_authority_filter,
-      const_cast<grpc_channel_filter*>(&grpc_client_authority_filter));
-  grpc_channel_init_register_stage(
-      GRPC_CLIENT_DIRECT_CHANNEL, INT_MAX, add_client_authority_filter,
-      const_cast<grpc_channel_filter*>(&grpc_client_authority_filter));
+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);
 }
-
-void grpc_client_authority_filter_shutdown(void) {}
+}  // namespace grpc_core

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

@@ -25,84 +25,64 @@
 #include "src/core/ext/filters/http/message_compress/message_decompress_filter.h"
 #include "src/core/ext/filters/http/server/http_server_filter.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/surface/call.h"
-#include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/transport/transport_impl.h"
 
-struct optional_filter {
-  const grpc_channel_filter* filter;
-  const char* control_channel_arg;
-};
-
-static optional_filter compress_filter = {
-    &grpc_message_compress_filter, GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION};
-
-static optional_filter decompress_filter = {
-    &grpc_core::MessageDecompressFilter,
-    GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION};
-
 static bool is_building_http_like_transport(
     grpc_channel_stack_builder* builder) {
   grpc_transport* t = grpc_channel_stack_builder_get_transport(builder);
   return t != nullptr && strstr(t->vtable->name, "http");
 }
 
-template <bool enable_in_minimal_stack>
-static bool maybe_add_optional_filter(grpc_channel_stack_builder* builder,
-                                      void* arg) {
-  if (!is_building_http_like_transport(builder)) return true;
-  optional_filter* filtarg = static_cast<optional_filter*>(arg);
-  const grpc_channel_args* channel_args =
-      grpc_channel_stack_builder_get_channel_arguments(builder);
-  bool enable = grpc_channel_arg_get_bool(
-      grpc_channel_args_find(channel_args, filtarg->control_channel_arg),
-      enable_in_minimal_stack ||
-          !grpc_channel_args_want_minimal_stack(channel_args));
-  return enable ? grpc_channel_stack_builder_prepend_filter(
-                      builder, filtarg->filter, nullptr, nullptr)
-                : true;
-}
-
-static bool maybe_add_required_filter(grpc_channel_stack_builder* builder,
-                                      void* arg) {
-  return is_building_http_like_transport(builder)
-             ? grpc_channel_stack_builder_prepend_filter(
-                   builder, static_cast<const grpc_channel_filter*>(arg),
-                   nullptr, nullptr)
-             : true;
-}
-
-void grpc_http_filters_init(void) {
-  grpc_channel_init_register_stage(
-      GRPC_CLIENT_SUBCHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      maybe_add_optional_filter<false>, &compress_filter);
-  grpc_channel_init_register_stage(
-      GRPC_CLIENT_DIRECT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      maybe_add_optional_filter<false>, &compress_filter);
-  grpc_channel_init_register_stage(
-      GRPC_SERVER_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      maybe_add_optional_filter<false>, &compress_filter);
-  grpc_channel_init_register_stage(
-      GRPC_CLIENT_SUBCHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      maybe_add_optional_filter<true>, &decompress_filter);
-  grpc_channel_init_register_stage(
-      GRPC_CLIENT_DIRECT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      maybe_add_optional_filter<true>, &decompress_filter);
-  grpc_channel_init_register_stage(
-      GRPC_SERVER_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      maybe_add_optional_filter<true>, &decompress_filter);
-  grpc_channel_init_register_stage(
-      GRPC_CLIENT_SUBCHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      maybe_add_required_filter,
-      const_cast<grpc_channel_filter*>(&grpc_http_client_filter));
-  grpc_channel_init_register_stage(
-      GRPC_CLIENT_DIRECT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      maybe_add_required_filter,
-      const_cast<grpc_channel_filter*>(&grpc_http_client_filter));
-  grpc_channel_init_register_stage(
-      GRPC_SERVER_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      maybe_add_required_filter,
-      const_cast<grpc_channel_filter*>(&grpc_http_server_filter));
+namespace grpc_core {
+void RegisterHttpFilters(CoreConfiguration::Builder* builder) {
+  auto optional = [builder](grpc_channel_stack_type channel_type,
+                            bool enable_in_minimal_stack,
+                            const char* control_channel_arg,
+                            const grpc_channel_filter* filter) {
+    builder->channel_init()->RegisterStage(
+        channel_type, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
+        [enable_in_minimal_stack, control_channel_arg,
+         filter](grpc_channel_stack_builder* builder) {
+          if (!is_building_http_like_transport(builder)) return true;
+          const grpc_channel_args* channel_args =
+              grpc_channel_stack_builder_get_channel_arguments(builder);
+          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);
+        });
+  };
+  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);
+        });
+  };
+  optional(GRPC_CLIENT_SUBCHANNEL, false,
+           GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION,
+           &grpc_message_compress_filter);
+  optional(GRPC_CLIENT_DIRECT_CHANNEL, false,
+           GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION,
+           &grpc_message_compress_filter);
+  optional(GRPC_SERVER_CHANNEL, false, GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION,
+           &grpc_message_compress_filter);
+  optional(GRPC_CLIENT_SUBCHANNEL, true,
+           GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION, &MessageDecompressFilter);
+  optional(GRPC_CLIENT_DIRECT_CHANNEL, true,
+           GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION, &MessageDecompressFilter);
+  optional(GRPC_SERVER_CHANNEL, true, GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION,
+           &MessageDecompressFilter);
+  required(GRPC_CLIENT_SUBCHANNEL, &grpc_http_client_filter);
+  required(GRPC_CLIENT_DIRECT_CHANNEL, &grpc_http_client_filter);
+  required(GRPC_SERVER_CHANNEL, &grpc_http_server_filter);
 }
-
-void grpc_http_filters_shutdown(void) {}
+}  // namespace grpc_core