grpc 1.28.0 → 1.42.0

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

@@ -17,12 +17,21 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
+#include "src/core/ext/filters/http/client/http_client_filter.h"
+
 #include <stdint.h>
 #include <string.h>
-#include "src/core/ext/filters/http/client/http_client_filter.h"
+
+#include <string>
+#include <vector>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/profiling/timers.h"
@@ -31,18 +40,21 @@
 #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"
 
 #define EXPECTED_CONTENT_TYPE "application/grpc"
-#define EXPECTED_CONTENT_TYPE_LENGTH sizeof(EXPECTED_CONTENT_TYPE) - 1
+#define EXPECTED_CONTENT_TYPE_LENGTH (sizeof(EXPECTED_CONTENT_TYPE) - 1)
 
 /* default maximum size of payload eligible for GET request */
 static constexpr size_t kMaxPayloadSizeForGet = 2048;
 
-static void recv_initial_metadata_ready(void* user_data, grpc_error* error);
-static void recv_trailing_metadata_ready(void* user_data, grpc_error* error);
-static void on_send_message_next_done(void* arg, grpc_error* error);
-static void send_message_on_complete(void* arg, grpc_error* error);
+static void recv_initial_metadata_ready(void* user_data,
+                                        grpc_error_handle error);
+static void recv_trailing_metadata_ready(void* user_data,
+                                         grpc_error_handle error);
+static void on_send_message_next_done(void* arg, grpc_error_handle error);
+static void send_message_on_complete(void* arg, grpc_error_handle error);
 
 namespace {
 struct call_data {
@@ -66,20 +78,18 @@ struct call_data {
   // 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* recv_initial_metadata_error = GRPC_ERROR_NONE;
+  grpc_error_handle recv_initial_metadata_error = GRPC_ERROR_NONE;
   grpc_closure* original_recv_initial_metadata_ready = nullptr;
   grpc_closure recv_initial_metadata_ready;
   // State for handling recv_trailing_metadata ops.
   grpc_metadata_batch* recv_trailing_metadata;
   grpc_closure* original_recv_trailing_metadata_ready;
   grpc_closure recv_trailing_metadata_ready;
-  grpc_error* recv_trailing_metadata_error = GRPC_ERROR_NONE;
+  grpc_error_handle recv_trailing_metadata_error = GRPC_ERROR_NONE;
   bool seen_recv_trailing_metadata_ready = false;
   // State for handling send_message ops.
   grpc_transport_stream_op_batch* send_message_batch;
@@ -99,58 +109,63 @@ struct channel_data {
 };
 }  // namespace
 
-static grpc_error* client_filter_incoming_metadata(grpc_metadata_batch* b) {
-  if (b->idx.named.status != nullptr) {
+static grpc_error_handle client_filter_incoming_metadata(
+    grpc_metadata_batch* b) {
+  if (b->legacy_index()->named.status != nullptr) {
     /* 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,
+    if (b->legacy_index()->named.grpc_status != nullptr ||
+        grpc_mdelem_static_value_eq(b->legacy_index()->named.status->md,
                                     GRPC_MDELEM_STATUS_200)) {
-      grpc_metadata_batch_remove(b, GRPC_BATCH_STATUS);
+      b->Remove(GRPC_BATCH_STATUS);
     } else {
-      char* val = grpc_dump_slice(GRPC_MDVALUE(b->idx.named.status->md),
-                                  GPR_DUMP_ASCII);
-      char* msg;
-      gpr_asprintf(&msg, "Received http2 header with status: %s", val);
-      grpc_error* e = grpc_error_set_str(
+      char* val = grpc_dump_slice(
+          GRPC_MDVALUE(b->legacy_index()->named.status->md), GPR_DUMP_ASCII);
+      std::string msg =
+          absl::StrCat("Received http2 header with status: ", val);
+      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_INT_GRPC_STATUS, GRPC_STATUS_CANCELLED),
-          GRPC_ERROR_STR_GRPC_MESSAGE, grpc_slice_from_copied_string(msg));
+                  GRPC_ERROR_STR_VALUE, val),
+              GRPC_ERROR_INT_GRPC_STATUS,
+              grpc_http2_status_to_grpc_status(atoi(val))),
+          GRPC_ERROR_STR_GRPC_MESSAGE, msg);
       gpr_free(val);
-      gpr_free(msg);
       return e;
     }
   }
 
-  if (b->idx.named.grpc_message != nullptr) {
-    grpc_slice pct_decoded_msg = grpc_permissive_percent_decode_slice(
-        GRPC_MDVALUE(b->idx.named.grpc_message->md));
-    if (grpc_slice_is_equivalent(pct_decoded_msg,
-                                 GRPC_MDVALUE(b->idx.named.grpc_message->md))) {
+  if (b->legacy_index()->named.grpc_message != nullptr) {
+    grpc_slice pct_decoded_msg = grpc_core::PermissivePercentDecodeSlice(
+        GRPC_MDVALUE(b->legacy_index()->named.grpc_message->md));
+    if (grpc_slice_is_equivalent(
+            pct_decoded_msg,
+            GRPC_MDVALUE(b->legacy_index()->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);
+      grpc_metadata_batch_set_value(b->legacy_index()->named.grpc_message,
+                                    pct_decoded_msg);
     }
   }
 
-  if (b->idx.named.content_type != nullptr) {
+  if (b->legacy_index()->named.content_type != nullptr) {
     if (!grpc_mdelem_static_value_eq(
-            b->idx.named.content_type->md,
+            b->legacy_index()->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) &&
+      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->idx.named.content_type->md))[EXPECTED_CONTENT_TYPE_LENGTH] ==
+               b->legacy_index()
+                   ->named.content_type->md))[EXPECTED_CONTENT_TYPE_LENGTH] ==
                '+' ||
            GRPC_SLICE_START_PTR(GRPC_MDVALUE(
-               b->idx.named.content_type->md))[EXPECTED_CONTENT_TYPE_LENGTH] ==
+               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. */
@@ -160,26 +175,28 @@ static grpc_error* client_filter_incoming_metadata(grpc_metadata_batch* b) {
       } 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);
+        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);
       }
     }
-    grpc_metadata_batch_remove(b, GRPC_BATCH_CONTENT_TYPE);
+    b->Remove(GRPC_BATCH_CONTENT_TYPE);
   }
 
   return GRPC_ERROR_NONE;
 }
 
-static void recv_initial_metadata_ready(void* user_data, grpc_error* error) {
+static void recv_initial_metadata_ready(void* user_data,
+                                        grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (error == GRPC_ERROR_NONE) {
     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;
@@ -191,7 +208,8 @@ static void recv_initial_metadata_ready(void* user_data, grpc_error* error) {
   grpc_core::Closure::Run(DEBUG_LOCATION, closure, error);
 }
 
-static void recv_trailing_metadata_ready(void* user_data, grpc_error* error) {
+static void recv_trailing_metadata_ready(void* user_data,
+                                         grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (calld->original_recv_initial_metadata_ready != nullptr) {
@@ -205,7 +223,7 @@ static void recv_trailing_metadata_ready(void* user_data, grpc_error* error) {
   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));
@@ -213,10 +231,13 @@ static void recv_trailing_metadata_ready(void* user_data, grpc_error* error) {
                           calld->original_recv_trailing_metadata_ready, error);
 }
 
-static void send_message_on_complete(void* arg, grpc_error* error) {
+static void send_message_on_complete(void* arg, grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->send_message_cache.Destroy();
+  // Set the batch's send_message bit back to true, so the retry code
+  // above knows what was in this batch.
+  calld->send_message_batch->send_message = true;
   grpc_core::Closure::Run(DEBUG_LOCATION,
                           calld->original_send_message_on_complete,
                           GRPC_ERROR_REF(error));
@@ -224,9 +245,10 @@ static void send_message_on_complete(void* arg, grpc_error* error) {
 
 // Pulls a slice from the send_message byte stream, updating
 // calld->send_message_bytes_read.
-static grpc_error* pull_slice_from_send_message(call_data* calld) {
+static grpc_error_handle pull_slice_from_send_message(call_data* calld) {
   grpc_slice incoming_slice;
-  grpc_error* error = calld->send_message_caching_stream->Pull(&incoming_slice);
+  grpc_error_handle error =
+      calld->send_message_caching_stream->Pull(&incoming_slice);
   if (error == GRPC_ERROR_NONE) {
     calld->send_message_bytes_read += GRPC_SLICE_LENGTH(incoming_slice);
     grpc_slice_unref_internal(incoming_slice);
@@ -239,10 +261,11 @@ static grpc_error* pull_slice_from_send_message(call_data* calld) {
 // calld->send_message_caching_stream->length(), then we have completed
 // reading from the byte stream; otherwise, an async read has been dispatched
 // and on_send_message_next_done() will be invoked when it is complete.
-static grpc_error* read_all_available_send_message_data(call_data* calld) {
+static grpc_error_handle read_all_available_send_message_data(
+    call_data* calld) {
   while (calld->send_message_caching_stream->Next(
       SIZE_MAX, &calld->on_send_message_next_done)) {
-    grpc_error* error = pull_slice_from_send_message(calld);
+    grpc_error_handle error = pull_slice_from_send_message(calld);
     if (error != GRPC_ERROR_NONE) return error;
     if (calld->send_message_bytes_read ==
         calld->send_message_caching_stream->length()) {
@@ -253,7 +276,7 @@ static grpc_error* read_all_available_send_message_data(call_data* calld) {
 }
 
 // Async callback for ByteStream::Next().
-static void on_send_message_next_done(void* arg, grpc_error* error) {
+static void on_send_message_next_done(void* arg, grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (error != GRPC_ERROR_NONE) {
@@ -291,12 +314,13 @@ 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* update_path_for_get(grpc_call_element* elem,
-                                       grpc_transport_stream_op_batch* batch) {
+static grpc_error_handle update_path_for_get(
+    grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
   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);
+                       ->legacy_index()
+                       ->named.path->md);
   /* sum up individual component's lengths and allocate enough memory to
    * hold combined path+query */
   size_t estimated_len = GRPC_SLICE_LENGTH(path_slice);
@@ -320,24 +344,23 @@ static grpc_error* update_path_for_get(grpc_call_element* elem,
                           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*> GRPC_SLICE_START_PTR(path_with_query_slice) +
+      GRPC_SLICE_LENGTH(path_slice);
   /* 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));
+  path_with_query_slice = grpc_slice_sub_no_ref(
+      path_with_query_slice, 0, GRPC_SLICE_LENGTH(path_slice) + 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);
+  return b->Substitute(b->legacy_index()->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);
-  }
+  batch->Remove(idx);
 }
 
 static void http_client_start_transport_stream_op_batch(
@@ -366,7 +389,7 @@ static void http_client_start_transport_stream_op_batch(
         &calld->recv_trailing_metadata_ready;
   }
 
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
   bool batch_will_be_handled_asynchronously = false;
   if (batch->send_initial_metadata) {
     // Decide which HTTP VERB to use. We use GET if the request is marked
@@ -419,9 +442,6 @@ static void http_client_start_transport_stream_op_batch(
     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);
@@ -439,10 +459,8 @@ static void http_client_start_transport_stream_op_batch(
         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;
+    batch->payload->send_initial_metadata.send_initial_metadata->Set(
+        grpc_core::TeMetadata(), grpc_core::TeMetadata::kTrailers);
     error = grpc_metadata_batch_add_tail(
         batch->payload->send_initial_metadata.send_initial_metadata,
         &calld->content_type, GRPC_MDELEM_CONTENT_TYPE_APPLICATION_SLASH_GRPC,
@@ -457,15 +475,15 @@ static void http_client_start_transport_stream_op_batch(
 
 done:
   if (error != GRPC_ERROR_NONE) {
-    grpc_transport_stream_op_batch_finish_with_failure(
-        calld->send_message_batch, error, calld->call_combiner);
+    grpc_transport_stream_op_batch_finish_with_failure(batch, error,
+                                                       calld->call_combiner);
   } else if (!batch_will_be_handled_asynchronously) {
     grpc_call_next_op(elem, batch);
   }
 }
 
 /* Constructor for call_data */
-static grpc_error* http_client_init_call_elem(
+static grpc_error_handle http_client_init_call_elem(
     grpc_call_element* elem, const grpc_call_element_args* args) {
   new (elem->call_data) call_data(elem, *args);
   return GRPC_ERROR_NONE;
@@ -518,55 +536,40 @@ static size_t max_payload_size_from_args(const grpc_channel_args* args) {
 
 static grpc_core::ManagedMemorySlice user_agent_from_args(
     const grpc_channel_args* args, const char* transport_name) {
-  gpr_strvec v;
-  size_t i;
-  int is_first = 1;
-  char* tmp;
+  std::vector<std::string> user_agent_fields;
 
-  gpr_strvec_init(&v);
-
-  for (i = 0; args && i < args->num_args; i++) {
+  for (size_t i = 0; args && i < args->num_args; i++) {
     if (0 == strcmp(args->args[i].key, GRPC_ARG_PRIMARY_USER_AGENT_STRING)) {
       if (args->args[i].type != GRPC_ARG_STRING) {
         gpr_log(GPR_ERROR, "Channel argument '%s' should be a string",
                 GRPC_ARG_PRIMARY_USER_AGENT_STRING);
       } else {
-        if (!is_first) gpr_strvec_add(&v, gpr_strdup(" "));
-        is_first = 0;
-        gpr_strvec_add(&v, gpr_strdup(args->args[i].value.string));
+        user_agent_fields.push_back(args->args[i].value.string);
       }
     }
   }
 
-  gpr_asprintf(&tmp, "%sgrpc-c/%s (%s; %s; %s)", is_first ? "" : " ",
-               grpc_version_string(), GPR_PLATFORM_STRING, transport_name,
-               grpc_g_stands_for());
-  is_first = 0;
-  gpr_strvec_add(&v, tmp);
+  user_agent_fields.push_back(
+      absl::StrFormat("grpc-c/%s (%s; %s)", grpc_version_string(),
+                      GPR_PLATFORM_STRING, transport_name));
 
-  for (i = 0; args && i < args->num_args; i++) {
+  for (size_t i = 0; args && i < args->num_args; i++) {
     if (0 == strcmp(args->args[i].key, GRPC_ARG_SECONDARY_USER_AGENT_STRING)) {
       if (args->args[i].type != GRPC_ARG_STRING) {
         gpr_log(GPR_ERROR, "Channel argument '%s' should be a string",
                 GRPC_ARG_SECONDARY_USER_AGENT_STRING);
       } else {
-        if (!is_first) gpr_strvec_add(&v, gpr_strdup(" "));
-        is_first = 0;
-        gpr_strvec_add(&v, gpr_strdup(args->args[i].value.string));
+        user_agent_fields.push_back(args->args[i].value.string);
       }
     }
   }
 
-  tmp = gpr_strvec_flatten(&v, nullptr);
-  gpr_strvec_destroy(&v);
-  grpc_core::ManagedMemorySlice result(tmp);
-  gpr_free(tmp);
-
-  return result;
+  std::string user_agent_string = absl::StrJoin(user_agent_fields, " ");
+  return grpc_core::ManagedMemorySlice(user_agent_string.c_str());
 }
 
 /* Constructor for channel_data */
-static grpc_error* http_client_init_channel_elem(
+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);
   GPR_ASSERT(!args->is_last);

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

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/ext/filters/http/client_authority_filter.h"
+
 #include <assert.h>
 #include <limits.h>
 #include <string.h>
@@ -26,13 +28,13 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/ext/filters/http/client_authority_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/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"
 
@@ -53,13 +55,14 @@ void client_authority_start_transport_stream_op_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.
-  auto* initial_metadata =
-      batch->payload->send_initial_metadata.send_initial_metadata;
   // If the initial metadata doesn't already contain :authority, add it.
   if (batch->send_initial_metadata &&
-      initial_metadata->idx.named.authority == nullptr) {
-    grpc_error* error = grpc_metadata_batch_add_head(
-        initial_metadata, &calld->authority_storage,
+      batch->payload->send_initial_metadata.send_initial_metadata
+              ->legacy_index()
+              ->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,
@@ -72,7 +75,7 @@ void client_authority_start_transport_stream_op_batch(
 }
 
 /* Constructor for call_data */
-grpc_error* client_authority_init_call_elem(
+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;
@@ -85,7 +88,7 @@ void client_authority_destroy_call_elem(
     grpc_closure* /*ignored*/) {}
 
 /* Constructor for channel_data */
-grpc_error* client_authority_init_channel_elem(
+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);
   const grpc_arg* default_authority_arg =
@@ -130,8 +133,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(
@@ -144,16 +146,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,
-                                   (void*)&grpc_client_authority_filter);
-  grpc_channel_init_register_stage(GRPC_CLIENT_DIRECT_CHANNEL, INT_MAX,
-                                   add_client_authority_filter,
-                                   (void*)&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

@@ -22,68 +22,69 @@
 
 #include "src/core/ext/filters/http/client/http_client_filter.h"
 #include "src/core/ext/filters/http/message_compress/message_compress_filter.h"
+#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"
 
-typedef struct {
-  const grpc_channel_filter* filter;
-  const char* control_channel_arg;
-} optional_filter;
-
-static optional_filter compress_filter = {
-    &grpc_message_compress_filter, GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION};
-
 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");
 }
 
-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),
-      !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;
+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,
+           &grpc_core::MessageDecompressFilter);
+  optional(GRPC_CLIENT_DIRECT_CHANNEL, true,
+           GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION,
+           &grpc_core::MessageDecompressFilter);
+  optional(GRPC_SERVER_CHANNEL, true, GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION,
+           &grpc_core::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_init(void) {
-  grpc_channel_init_register_stage(GRPC_CLIENT_SUBCHANNEL,
-                                   GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-                                   maybe_add_optional_filter, &compress_filter);
-  grpc_channel_init_register_stage(GRPC_CLIENT_DIRECT_CHANNEL,
-                                   GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-                                   maybe_add_optional_filter, &compress_filter);
-  grpc_channel_init_register_stage(GRPC_SERVER_CHANNEL,
-                                   GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-                                   maybe_add_optional_filter, &compress_filter);
-  grpc_channel_init_register_stage(
-      GRPC_CLIENT_SUBCHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      maybe_add_required_filter, (void*)&grpc_http_client_filter);
-  grpc_channel_init_register_stage(
-      GRPC_CLIENT_DIRECT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      maybe_add_required_filter, (void*)&grpc_http_client_filter);
-  grpc_channel_init_register_stage(
-      GRPC_SERVER_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      maybe_add_required_filter, (void*)&grpc_http_server_filter);
-}
-
-void grpc_http_filters_shutdown(void) {}
+}  // namespace grpc_core