grpc 1.42.0 → 1.46.3

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

@@ -21,11 +21,28 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/promise_based_filter.h"
 
-/* Processes metadata on the client side for HTTP2 transports */
-extern const grpc_channel_filter grpc_http_client_filter;
+namespace grpc_core {
 
-/* Channel arg to determine maximum size of payload eligible for GET request */
-#define GRPC_ARG_MAX_PAYLOAD_SIZE_FOR_GET "grpc.max_payload_size_for_get"
+class HttpClientFilter : public ChannelFilter {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::StatusOr<HttpClientFilter> Create(
+      ChannelArgs args, ChannelFilter::Args filter_args);
+
+  // Construct a promise for one call.
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+
+ private:
+  HttpClientFilter(HttpSchemeMetadata::ValueType scheme, Slice user_agent);
+
+  HttpSchemeMetadata::ValueType scheme_;
+  Slice user_agent_;
+};
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_FILTERS_HTTP_CLIENT_HTTP_CLIENT_FILTER_H */

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

@@ -28,7 +28,7 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/channel/channel_args.h"
+#include "src/core/ext/filters/http/client_authority_filter.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gpr/string.h"
@@ -36,106 +36,41 @@
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/surface/call.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;
-};
+namespace grpc_core {
 
-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
-              ->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,
-                                                         calld->call_combiner);
-      return;
-    }
+absl::StatusOr<ClientAuthorityFilter> ClientAuthorityFilter::Create(
+    ChannelArgs args, ChannelFilter::Args) {
+  absl::optional<absl::string_view> default_authority =
+      args.GetString(GRPC_ARG_DEFAULT_AUTHORITY);
+  if (!default_authority.has_value()) {
+    return absl::InvalidArgumentError(
+        "GRPC_ARG_DEFAULT_AUTHORITY string channel arg. not found. Note that "
+        "direct channels must explicitly specify a value for this argument.");
   }
-  // Pass control down the stack.
-  grpc_call_next_op(elem, batch);
-}
-
-/* Constructor for call_data */
-grpc_error_handle client_authority_init_call_elem(
-    grpc_call_element* elem, const grpc_call_element_args* args) {
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  calld->call_combiner = args->call_combiner;
-  return GRPC_ERROR_NONE;
+  return ClientAuthorityFilter(Slice::FromCopiedString(*default_authority));
 }
 
-/* Destructor for call_data */
-void client_authority_destroy_call_elem(
-    grpc_call_element* /*elem*/, const grpc_call_final_info* /*final_info*/,
-    grpc_closure* /*ignored*/) {}
-
-/* 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);
-  const grpc_arg* default_authority_arg =
-      grpc_channel_args_find(args->channel_args, GRPC_ARG_DEFAULT_AUTHORITY);
-  if (default_authority_arg == nullptr) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "GRPC_ARG_DEFAULT_AUTHORITY channel arg. not found. Note that direct "
-        "channels must explicitly specify a value for this argument.");
+ArenaPromise<ServerMetadataHandle> ClientAuthorityFilter::MakeCallPromise(
+    CallArgs call_args, NextPromiseFactory next_promise_factory) {
+  // If no authority is set, set the default authority.
+  if (call_args.client_initial_metadata->get_pointer(HttpAuthorityMetadata()) ==
+      nullptr) {
+    call_args.client_initial_metadata->Set(HttpAuthorityMetadata(),
+                                           default_authority_.Ref());
   }
-  const char* default_authority_str =
-      grpc_channel_arg_get_string(default_authority_arg);
-  if (default_authority_str == nullptr) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "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);
-  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);
+  // We have no asynchronous work, so we can just ask the next promise to run,
+  // passing down initial_metadata.
+  return next_promise_factory(std::move(call_args));
 }
-}  // namespace
 
-const grpc_channel_filter grpc_client_authority_filter = {
-    client_authority_start_transport_stream_op_batch,
-    grpc_channel_next_op,
-    sizeof(call_data),
-    client_authority_init_call_elem,
-    grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    client_authority_destroy_call_elem,
-    sizeof(channel_data),
-    client_authority_init_channel_elem,
-    client_authority_destroy_channel_elem,
-    grpc_channel_next_get_info,
-    "authority"};
+const grpc_channel_filter ClientAuthorityFilter::kFilter =
+    MakePromiseBasedFilter<ClientAuthorityFilter, FilterEndpoint::kClient>(
+        "authority");
 
-static bool add_client_authority_filter(grpc_channel_stack_builder* builder) {
-  const grpc_channel_args* channel_args =
-      grpc_channel_stack_builder_get_channel_arguments(builder);
+namespace {
+bool add_client_authority_filter(ChannelStackBuilder* builder) {
+  const grpc_channel_args* channel_args = builder->channel_args();
   const grpc_arg* disable_client_authority_filter_arg = grpc_channel_args_find(
       channel_args, GRPC_ARG_DISABLE_CLIENT_AUTHORITY_FILTER);
   if (disable_client_authority_filter_arg != nullptr) {
@@ -145,15 +80,16 @@ static bool add_client_authority_filter(grpc_channel_stack_builder* builder) {
       return true;
     }
   }
-  return grpc_channel_stack_builder_prepend_filter(
-      builder, &grpc_client_authority_filter, nullptr, nullptr);
+  builder->PrependFilter(&ClientAuthorityFilter::kFilter, nullptr);
+  return true;
 }
+}  // namespace
 
-namespace grpc_core {
 void RegisterClientAuthorityFilter(CoreConfiguration::Builder* builder) {
   builder->channel_init()->RegisterStage(GRPC_CLIENT_SUBCHANNEL, INT_MAX,
                                          add_client_authority_filter);
   builder->channel_init()->RegisterStage(GRPC_CLIENT_DIRECT_CHANNEL, INT_MAX,
                                          add_client_authority_filter);
 }
+
 }  // namespace grpc_core

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

@@ -21,14 +21,33 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/status/statusor.h"
+
 #include <grpc/impl/codegen/compression_types.h>
 
-#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/promise_based_filter.h"
+#include "src/core/lib/slice/slice.h"
+
+namespace grpc_core {
+
+class ClientAuthorityFilter final : public ChannelFilter {
+ public:
+  static const grpc_channel_filter kFilter;
+
+  static absl::StatusOr<ClientAuthorityFilter> Create(ChannelArgs args,
+                                                      ChannelFilter::Args);
+
+  // Construct a promise for one call.
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
 
-/// Filter responsible for setting the authority header, if not already set. It
-/// uses the value of the GRPC_ARG_DEFAULT_AUTHORITY channel arg if the initial
-/// metadata doesn't already contain an authority value.
+ private:
+  explicit ClientAuthorityFilter(Slice default_authority)
+      : default_authority_(std::move(default_authority)) {}
+  Slice default_authority_;
+};
 
-extern const grpc_channel_filter grpc_client_authority_filter;
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_FILTERS_HTTP_CLIENT_AUTHORITY_FILTER_H */

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

@@ -30,8 +30,8 @@
 #include "src/core/lib/transport/transport_impl.h"
 
 static bool is_building_http_like_transport(
-    grpc_channel_stack_builder* builder) {
-  grpc_transport* t = grpc_channel_stack_builder_get_transport(builder);
+    grpc_core::ChannelStackBuilder* builder) {
+  grpc_transport* t = builder->transport();
   return t != nullptr && strstr(t->vtable->name, "http");
 }
 
@@ -44,29 +44,31 @@ void RegisterHttpFilters(CoreConfiguration::Builder* builder) {
     builder->channel_init()->RegisterStage(
         channel_type, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
         [enable_in_minimal_stack, control_channel_arg,
-         filter](grpc_channel_stack_builder* builder) {
+         filter](ChannelStackBuilder* builder) {
           if (!is_building_http_like_transport(builder)) return true;
-          const grpc_channel_args* channel_args =
-              grpc_channel_stack_builder_get_channel_arguments(builder);
+          const grpc_channel_args* channel_args = builder->channel_args();
           bool enable = grpc_channel_arg_get_bool(
               grpc_channel_args_find(channel_args, control_channel_arg),
               enable_in_minimal_stack ||
                   !grpc_channel_args_want_minimal_stack(channel_args));
-          if (!enable) return true;
-          return grpc_channel_stack_builder_prepend_filter(builder, filter,
-                                                           nullptr, nullptr);
+          if (enable) builder->PrependFilter(filter, nullptr);
+          return true;
         });
   };
   auto required = [builder](grpc_channel_stack_type channel_type,
                             const grpc_channel_filter* filter) {
     builder->channel_init()->RegisterStage(
         channel_type, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-        [filter](grpc_channel_stack_builder* builder) {
-          if (!is_building_http_like_transport(builder)) return true;
-          return grpc_channel_stack_builder_prepend_filter(builder, filter,
-                                                           nullptr, nullptr);
+        [filter](ChannelStackBuilder* builder) {
+          if (is_building_http_like_transport(builder)) {
+            builder->PrependFilter(filter, nullptr);
+          }
+          return true;
         });
   };
+  // TODO(ctiller): return this flag to true once the promise conversion is
+  // complete.
+  static constexpr bool kMinimalStackHasDecompression = false;
   optional(GRPC_CLIENT_SUBCHANNEL, false,
            GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION,
            &grpc_message_compress_filter);
@@ -75,16 +77,14 @@ void RegisterHttpFilters(CoreConfiguration::Builder* builder) {
            &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);
+  optional(GRPC_CLIENT_SUBCHANNEL, kMinimalStackHasDecompression,
+           GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION, &MessageDecompressFilter);
+  optional(GRPC_CLIENT_DIRECT_CHANNEL, kMinimalStackHasDecompression,
+           GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION, &MessageDecompressFilter);
+  optional(GRPC_SERVER_CHANNEL, kMinimalStackHasDecompression,
+           GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION, &MessageDecompressFilter);
+  required(GRPC_CLIENT_SUBCHANNEL, &HttpClientFilter::kFilter);
+  required(GRPC_CLIENT_DIRECT_CHANNEL, &HttpClientFilter::kFilter);
   required(GRPC_SERVER_CHANNEL, &grpc_http_server_filter);
 }
 }  // namespace grpc_core

data/src/core/ext/filters/http/message_compress/message_compress_filter.cc

@@ -31,8 +31,6 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/compression/algorithm_metadata.h"
-#include "src/core/lib/compression/compression_args.h"
 #include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/compression/message_compress.h"
 #include "src/core/lib/gpr/string.h"
@@ -41,7 +39,6 @@
 #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/transport/static_metadata.h"
 
 namespace {
 
@@ -49,15 +46,15 @@ class ChannelData {
  public:
   explicit ChannelData(grpc_channel_element_args* args) {
     // Get the enabled and the default algorithms from channel args.
-    enabled_compression_algorithms_bitset_ =
-        grpc_channel_args_compression_algorithm_get_states(args->channel_args);
+    enabled_compression_algorithms_ =
+        grpc_core::CompressionAlgorithmSet::FromChannelArgs(args->channel_args);
     default_compression_algorithm_ =
-        grpc_channel_args_get_channel_default_compression_algorithm(
-            args->channel_args);
+        grpc_core::DefaultCompressionAlgorithmFromChannelArgs(
+            args->channel_args)
+            .value_or(GRPC_COMPRESS_NONE);
     // Make sure the default is enabled.
-    if (size_t(default_compression_algorithm_) >= 32 ||
-        !grpc_core::GetBit(enabled_compression_algorithms_bitset_,
-                           default_compression_algorithm_)) {
+    if (!enabled_compression_algorithms_.IsSet(
+            default_compression_algorithm_)) {
       const char* name;
       if (!grpc_compression_algorithm_name(default_compression_algorithm_,
                                            &name)) {
@@ -68,12 +65,6 @@ class ChannelData {
               name);
       default_compression_algorithm_ = GRPC_COMPRESS_NONE;
     }
-    enabled_message_compression_algorithms_bitset_ =
-        grpc_compression_bitset_to_message_bitset(
-            enabled_compression_algorithms_bitset_);
-    enabled_stream_compression_algorithms_bitset_ =
-        grpc_compression_bitset_to_stream_bitset(
-            enabled_compression_algorithms_bitset_);
     GPR_ASSERT(!args->is_last);
   }
 
@@ -81,27 +72,15 @@ class ChannelData {
     return default_compression_algorithm_;
   }
 
-  uint32_t enabled_compression_algorithms_bitset() const {
-    return enabled_compression_algorithms_bitset_;
-  }
-
-  uint32_t enabled_message_compression_algorithms_bitset() const {
-    return enabled_message_compression_algorithms_bitset_;
-  }
-
-  uint32_t enabled_stream_compression_algorithms_bitset() const {
-    return enabled_stream_compression_algorithms_bitset_;
+  grpc_core::CompressionAlgorithmSet enabled_compression_algorithms() const {
+    return enabled_compression_algorithms_;
   }
 
  private:
   /** The default, channel-level, compression algorithm */
   grpc_compression_algorithm default_compression_algorithm_;
-  /** Bitset of enabled compression algorithms */
-  uint32_t enabled_compression_algorithms_bitset_;
-  /** Bitset of enabled message compression algorithms */
-  uint32_t enabled_message_compression_algorithms_bitset_;
-  /** Bitset of enabled stream compression algorithms */
-  uint32_t enabled_stream_compression_algorithms_bitset_;
+  /** Enabled compression algorithms */
+  grpc_core::CompressionAlgorithmSet enabled_compression_algorithms_;
 };
 
 class CallData {
@@ -111,12 +90,9 @@ class CallData {
     ChannelData* channeld = static_cast<ChannelData*>(elem->channel_data);
     // The call's message compression algorithm is set to channel's default
     // setting. It can be overridden later by initial metadata.
-    if (GPR_LIKELY(
-            grpc_core::GetBit(channeld->enabled_compression_algorithms_bitset(),
-                              channeld->default_compression_algorithm()))) {
-      message_compression_algorithm_ =
-          grpc_compression_algorithm_to_message_compression_algorithm(
-              channeld->default_compression_algorithm());
+    if (GPR_LIKELY(channeld->enabled_compression_algorithms().IsSet(
+            channeld->default_compression_algorithm()))) {
+      compression_algorithm_ = channeld->default_compression_algorithm();
     }
     GRPC_CLOSURE_INIT(&start_send_message_batch_in_call_combiner_,
                       StartSendMessageBatch, elem, grpc_schedule_on_exec_ctx);
@@ -136,8 +112,8 @@ class CallData {
   bool SkipMessageCompression();
   void InitializeState(grpc_call_element* elem);
 
-  grpc_error_handle ProcessSendInitialMetadata(
-      grpc_call_element* elem, grpc_metadata_batch* initial_metadata);
+  void ProcessSendInitialMetadata(grpc_call_element* elem,
+                                  grpc_metadata_batch* initial_metadata);
 
   // Methods for processing a send_message batch
   static void StartSendMessageBatch(void* elem_arg, grpc_error_handle unused);
@@ -152,8 +128,7 @@ class CallData {
   static void SendMessageOnComplete(void* calld_arg, grpc_error_handle error);
 
   grpc_core::CallCombiner* call_combiner_;
-  grpc_message_compression_algorithm message_compression_algorithm_ =
-      GRPC_MESSAGE_COMPRESS_NONE;
+  grpc_compression_algorithm compression_algorithm_ = GRPC_COMPRESS_NONE;
   grpc_error_handle cancel_error_ = GRPC_ERROR_NONE;
   grpc_transport_stream_op_batch* send_message_batch_ = nullptr;
   bool seen_initial_metadata_ = false;
@@ -163,10 +138,6 @@ class CallData {
   /* The fields below are only initialized when we compress the payload.
    * Keep them at the bottom of the struct, so they don't pollute the
    * cache-lines. */
-  grpc_linked_mdelem message_compression_algorithm_storage_;
-  grpc_linked_mdelem stream_compression_algorithm_storage_;
-  grpc_linked_mdelem accept_encoding_storage_;
-  grpc_linked_mdelem accept_stream_encoding_storage_;
   grpc_slice_buffer slices_; /**< Buffers up input slices to be compressed */
   // Allocate space for the replacement stream
   std::aligned_storage<sizeof(grpc_core::SliceBufferByteStream),
@@ -188,44 +159,7 @@ bool CallData::SkipMessageCompression() {
   }
   // If this call doesn't have any message compression algorithm set, skip
   // message compression.
-  return message_compression_algorithm_ == GRPC_MESSAGE_COMPRESS_NONE;
-}
-
-// Determines the compression algorithm from the initial metadata and the
-// channel's default setting.
-grpc_compression_algorithm FindCompressionAlgorithm(
-    grpc_metadata_batch* initial_metadata, ChannelData* channeld) {
-  if (initial_metadata->legacy_index()->named.grpc_internal_encoding_request ==
-      nullptr) {
-    return channeld->default_compression_algorithm();
-  }
-  grpc_compression_algorithm compression_algorithm;
-  // Parse the compression algorithm from the initial metadata.
-  grpc_mdelem md = initial_metadata->legacy_index()
-                       ->named.grpc_internal_encoding_request->md;
-  GPR_ASSERT(grpc_compression_algorithm_parse(GRPC_MDVALUE(md),
-                                              &compression_algorithm));
-  // Remove this metadata since it's an internal one (i.e., it won't be
-  // transmitted out).
-  initial_metadata->Remove(GRPC_BATCH_GRPC_INTERNAL_ENCODING_REQUEST);
-  // Check if that algorithm is enabled. Note that GRPC_COMPRESS_NONE is always
-  // enabled.
-  // TODO(juanlishen): Maybe use channel default or abort() if the algorithm
-  // from the initial metadata is disabled.
-  if (GPR_LIKELY(
-          grpc_core::GetBit(channeld->enabled_compression_algorithms_bitset(),
-                            compression_algorithm))) {
-    return compression_algorithm;
-  }
-  const char* algorithm_name;
-  GPR_ASSERT(
-      grpc_compression_algorithm_name(compression_algorithm, &algorithm_name));
-  gpr_log(GPR_ERROR,
-          "Invalid compression algorithm from initial metadata: '%s' "
-          "(previously disabled). "
-          "Will not compress.",
-          algorithm_name);
-  return GRPC_COMPRESS_NONE;
+  return compression_algorithm_ == GRPC_COMPRESS_NONE;
 }
 
 void CallData::InitializeState(grpc_call_element* elem) {
@@ -238,53 +172,28 @@ void CallData::InitializeState(grpc_call_element* elem) {
                     grpc_schedule_on_exec_ctx);
 }
 
-grpc_error_handle CallData::ProcessSendInitialMetadata(
+void CallData::ProcessSendInitialMetadata(
     grpc_call_element* elem, grpc_metadata_batch* initial_metadata) {
   ChannelData* channeld = static_cast<ChannelData*>(elem->channel_data);
   // Find the compression algorithm.
-  grpc_compression_algorithm compression_algorithm =
-      FindCompressionAlgorithm(initial_metadata, channeld);
-  // Note that at most one of the following algorithms can be set.
-  message_compression_algorithm_ =
-      grpc_compression_algorithm_to_message_compression_algorithm(
-          compression_algorithm);
-  grpc_stream_compression_algorithm stream_compression_algorithm =
-      grpc_compression_algorithm_to_stream_compression_algorithm(
-          compression_algorithm);
-  // Hint compression algorithm.
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  if (message_compression_algorithm_ != GRPC_MESSAGE_COMPRESS_NONE) {
-    InitializeState(elem);
-    error = grpc_metadata_batch_add_tail(
-        initial_metadata, &message_compression_algorithm_storage_,
-        grpc_message_compression_encoding_mdelem(
-            message_compression_algorithm_),
-        GRPC_BATCH_GRPC_ENCODING);
-  } else if (stream_compression_algorithm != GRPC_STREAM_COMPRESS_NONE) {
-    InitializeState(elem);
-    error = grpc_metadata_batch_add_tail(
-        initial_metadata, &stream_compression_algorithm_storage_,
-        grpc_stream_compression_encoding_mdelem(stream_compression_algorithm),
-        GRPC_BATCH_CONTENT_ENCODING);
+  compression_algorithm_ =
+      initial_metadata->Take(grpc_core::GrpcInternalEncodingRequest())
+          .value_or(channeld->default_compression_algorithm());
+  switch (compression_algorithm_) {
+    case GRPC_COMPRESS_NONE:
+      break;
+    case GRPC_COMPRESS_DEFLATE:
+    case GRPC_COMPRESS_GZIP:
+      InitializeState(elem);
+      initial_metadata->Set(grpc_core::GrpcEncodingMetadata(),
+                            compression_algorithm_);
+      break;
+    case GRPC_COMPRESS_ALGORITHMS_COUNT:
+      abort();
   }
-  if (error != GRPC_ERROR_NONE) return error;
   // Convey supported compression algorithms.
-  error = grpc_metadata_batch_add_tail(
-      initial_metadata, &accept_encoding_storage_,
-      GRPC_MDELEM_ACCEPT_ENCODING_FOR_ALGORITHMS(
-          channeld->enabled_message_compression_algorithms_bitset()),
-      GRPC_BATCH_GRPC_ACCEPT_ENCODING);
-  if (error != GRPC_ERROR_NONE) return error;
-  // Do not overwrite accept-encoding header if it already presents (e.g., added
-  // by some proxy).
-  if (!initial_metadata->legacy_index()->named.accept_encoding) {
-    error = grpc_metadata_batch_add_tail(
-        initial_metadata, &accept_stream_encoding_storage_,
-        GRPC_MDELEM_ACCEPT_STREAM_ENCODING_FOR_ALGORITHMS(
-            channeld->enabled_stream_compression_algorithms_bitset()),
-        GRPC_BATCH_ACCEPT_ENCODING);
-  }
-  return error;
+  initial_metadata->Set(grpc_core::GrpcAcceptEncodingMetadata(),
+                        channeld->enabled_compression_algorithms());
 }
 
 void CallData::SendMessageOnComplete(void* calld_arg, grpc_error_handle error) {
@@ -304,15 +213,13 @@ void CallData::SendMessageBatchContinue(grpc_call_element* elem) {
 }
 
 void CallData::FinishSendMessage(grpc_call_element* elem) {
-  GPR_DEBUG_ASSERT(message_compression_algorithm_ !=
-                   GRPC_MESSAGE_COMPRESS_NONE);
+  GPR_DEBUG_ASSERT(compression_algorithm_ != GRPC_COMPRESS_NONE);
   // Compress the data if appropriate.
   grpc_slice_buffer tmp;
   grpc_slice_buffer_init(&tmp);
   uint32_t send_flags =
       send_message_batch_->payload->send_message.send_message->flags();
-  bool did_compress =
-      grpc_msg_compress(message_compression_algorithm_, &slices_, &tmp);
+  bool did_compress = grpc_msg_compress(compression_algorithm_, &slices_, &tmp);
   if (did_compress) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_compression_trace)) {
       const char* algo_name;
@@ -320,8 +227,8 @@ void CallData::FinishSendMessage(grpc_call_element* elem) {
       const size_t after_size = tmp.length;
       const float savings_ratio = 1.0f - static_cast<float>(after_size) /
                                              static_cast<float>(before_size);
-      GPR_ASSERT(grpc_message_compression_algorithm_name(
-          message_compression_algorithm_, &algo_name));
+      GPR_ASSERT(
+          grpc_compression_algorithm_name(compression_algorithm_, &algo_name));
       gpr_log(GPR_INFO,
               "Compressed[%s] %" PRIuPTR " bytes vs. %" PRIuPTR
               " bytes (%.2f%% savings)",
@@ -332,8 +239,8 @@ void CallData::FinishSendMessage(grpc_call_element* elem) {
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_compression_trace)) {
       const char* algo_name;
-      GPR_ASSERT(grpc_message_compression_algorithm_name(
-          message_compression_algorithm_, &algo_name));
+      GPR_ASSERT(
+          grpc_compression_algorithm_name(compression_algorithm_, &algo_name));
       gpr_log(GPR_INFO,
               "Algorithm '%s' enabled but decided not to compress. Input size: "
               "%" PRIuPTR,
@@ -465,13 +372,8 @@ void CallData::CompressStartTransportStreamOpBatch(
   // Handle send_initial_metadata.
   if (batch->send_initial_metadata) {
     GPR_ASSERT(!seen_initial_metadata_);
-    grpc_error_handle error = ProcessSendInitialMetadata(
+    ProcessSendInitialMetadata(
         elem, batch->payload->send_initial_metadata.send_initial_metadata);
-    if (error != GRPC_ERROR_NONE) {
-      grpc_transport_stream_op_batch_finish_with_failure(batch, error,
-                                                         call_combiner_);
-      return;
-    }
     seen_initial_metadata_ = true;
     // If we had previously received a batch containing a send_message op,
     // handle it now.  Note that we need to re-enter the call combiner
@@ -541,6 +443,7 @@ void CompressDestroyChannelElem(grpc_channel_element* elem) {
 
 const grpc_channel_filter grpc_message_compress_filter = {
     CompressStartTransportStreamOpBatch,
+    nullptr,
     grpc_channel_next_op,
     sizeof(CallData),
     CompressInitCallElem,