grpc 1.37.0 → 1.45.0

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

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/ext/filters/http/message_compress/message_compress_filter.h"
+
 #include <assert.h>
 #include <string.h>
 
@@ -28,10 +30,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/filters/http/message_compress/message_compress_filter.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"
@@ -40,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 {
 
@@ -48,28 +46,25 @@ 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 (!GPR_BITGET(enabled_compression_algorithms_bitset_,
-                    default_compression_algorithm_)) {
+    if (!enabled_compression_algorithms_.IsSet(
+            default_compression_algorithm_)) {
       const char* name;
-      GPR_ASSERT(grpc_compression_algorithm_name(default_compression_algorithm_,
-                                                 &name) == 1);
+      if (!grpc_compression_algorithm_name(default_compression_algorithm_,
+                                           &name)) {
+        name = "<unknown>";
+      }
       gpr_log(GPR_ERROR,
               "default compression algorithm %s not enabled: switching to none",
               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);
   }
 
@@ -77,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 {
@@ -107,11 +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(GPR_BITGET(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);
@@ -131,25 +112,24 @@ class CallData {
   bool SkipMessageCompression();
   void InitializeState(grpc_call_element* elem);
 
-  grpc_error* 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* unused);
-  static void OnSendMessageNextDone(void* elem_arg, grpc_error* error);
-  grpc_error* PullSliceFromSendMessage();
+  static void StartSendMessageBatch(void* elem_arg, grpc_error_handle unused);
+  static void OnSendMessageNextDone(void* elem_arg, grpc_error_handle error);
+  grpc_error_handle PullSliceFromSendMessage();
   void ContinueReadingSendMessage(grpc_call_element* elem);
   void FinishSendMessage(grpc_call_element* elem);
   void SendMessageBatchContinue(grpc_call_element* elem);
   static void FailSendMessageBatchInCallCombiner(void* calld_arg,
-                                                 grpc_error* error);
+                                                 grpc_error_handle error);
 
-  static void SendMessageOnComplete(void* calld_arg, grpc_error* error);
+  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_error* cancel_error_ = GRPC_ERROR_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;
   /* Set to true, if the fields below are initialized. */
@@ -158,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),
@@ -183,43 +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->idx.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->idx.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).
-  grpc_metadata_batch_remove(initial_metadata,
-                             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(GPR_BITGET(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) {
@@ -232,56 +172,31 @@ void CallData::InitializeState(grpc_call_element* elem) {
                     grpc_schedule_on_exec_ctx);
 }
 
-grpc_error* 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* 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->idx.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* error) {
+void CallData::SendMessageOnComplete(void* calld_arg, grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(calld_arg);
   grpc_slice_buffer_reset_and_unref_internal(&calld->slices_);
   grpc_core::Closure::Run(DEBUG_LOCATION,
@@ -298,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;
@@ -314,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)",
@@ -326,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,
@@ -348,7 +261,7 @@ void CallData::FinishSendMessage(grpc_call_element* elem) {
 }
 
 void CallData::FailSendMessageBatchInCallCombiner(void* calld_arg,
-                                                  grpc_error* error) {
+                                                  grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(calld_arg);
   if (calld->send_message_batch_ != nullptr) {
     grpc_transport_stream_op_batch_finish_with_failure(
@@ -359,9 +272,9 @@ void CallData::FailSendMessageBatchInCallCombiner(void* calld_arg,
 }
 
 // Pulls a slice from the send_message byte stream and adds it to slices_.
-grpc_error* CallData::PullSliceFromSendMessage() {
+grpc_error_handle CallData::PullSliceFromSendMessage() {
   grpc_slice incoming_slice;
-  grpc_error* error =
+  grpc_error_handle error =
       send_message_batch_->payload->send_message.send_message->Pull(
           &incoming_slice);
   if (error == GRPC_ERROR_NONE) {
@@ -382,7 +295,7 @@ void CallData::ContinueReadingSendMessage(grpc_call_element* elem) {
   }
   while (send_message_batch_->payload->send_message.send_message->Next(
       ~static_cast<size_t>(0), &on_send_message_next_done_)) {
-    grpc_error* error = PullSliceFromSendMessage();
+    grpc_error_handle error = PullSliceFromSendMessage();
     if (error != GRPC_ERROR_NONE) {
       // Closure callback; does not take ownership of error.
       FailSendMessageBatchInCallCombiner(this, error);
@@ -398,7 +311,7 @@ void CallData::ContinueReadingSendMessage(grpc_call_element* elem) {
 }
 
 // Async callback for ByteStream::Next().
-void CallData::OnSendMessageNextDone(void* elem_arg, grpc_error* error) {
+void CallData::OnSendMessageNextDone(void* elem_arg, grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(elem_arg);
   CallData* calld = static_cast<CallData*>(elem->call_data);
   if (error != GRPC_ERROR_NONE) {
@@ -421,7 +334,8 @@ void CallData::OnSendMessageNextDone(void* elem_arg, grpc_error* error) {
   }
 }
 
-void CallData::StartSendMessageBatch(void* elem_arg, grpc_error* /*unused*/) {
+void CallData::StartSendMessageBatch(void* elem_arg,
+                                     grpc_error_handle /*unused*/) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(elem_arg);
   CallData* calld = static_cast<CallData*>(elem->call_data);
   if (calld->SkipMessageCompression()) {
@@ -458,13 +372,8 @@ void CallData::CompressStartTransportStreamOpBatch(
   // Handle send_initial_metadata.
   if (batch->send_initial_metadata) {
     GPR_ASSERT(!seen_initial_metadata_);
-    grpc_error* 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
@@ -503,8 +412,8 @@ void CompressStartTransportStreamOpBatch(
 }
 
 /* Constructor for call_data */
-grpc_error* CompressInitCallElem(grpc_call_element* elem,
-                                 const grpc_call_element_args* args) {
+grpc_error_handle CompressInitCallElem(grpc_call_element* elem,
+                                       const grpc_call_element_args* args) {
   new (elem->call_data) CallData(elem, *args);
   return GRPC_ERROR_NONE;
 }
@@ -518,8 +427,8 @@ void CompressDestroyCallElem(grpc_call_element* elem,
 }
 
 /* Constructor for ChannelData */
-grpc_error* CompressInitChannelElem(grpc_channel_element* elem,
-                                    grpc_channel_element_args* args) {
+grpc_error_handle CompressInitChannelElem(grpc_channel_element* elem,
+                                          grpc_channel_element_args* args) {
   new (elem->channel_data) ChannelData(args);
   return GRPC_ERROR_NONE;
 }
@@ -534,6 +443,7 @@ void CompressDestroyChannelElem(grpc_channel_element* elem) {
 
 const grpc_channel_filter grpc_message_compress_filter = {
     CompressStartTransportStreamOpBatch,
+    nullptr,
     grpc_channel_next_op,
     sizeof(CallData),
     CompressInitCallElem,

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

@@ -24,17 +24,15 @@
 #include <string.h>
 
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 
 #include <grpc/compression.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "absl/strings/str_format.h"
 #include "src/core/ext/filters/message_size/message_size_filter.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"
@@ -47,12 +45,18 @@ namespace {
 class ChannelData {
  public:
   explicit ChannelData(const grpc_channel_element_args* args)
-      : max_recv_size_(GetMaxRecvSizeFromChannelArgs(args->channel_args)) {}
+      : max_recv_size_(GetMaxRecvSizeFromChannelArgs(args->channel_args)),
+        message_size_service_config_parser_index_(
+            MessageSizeParser::ParserIndex()) {}
 
   int max_recv_size() const { return max_recv_size_; }
+  size_t message_size_service_config_parser_index() const {
+    return message_size_service_config_parser_index_;
+  }
 
  private:
   int max_recv_size_;
+  const size_t message_size_service_config_parser_index_;
 };
 
 class CallData {
@@ -75,7 +79,8 @@ class CallData {
                       OnRecvTrailingMetadataReady, this,
                       grpc_schedule_on_exec_ctx);
     const MessageSizeParsedConfig* limits =
-        MessageSizeParsedConfig::GetFromCallContext(args.context);
+        MessageSizeParsedConfig::GetFromCallContext(
+            args.context, chand->message_size_service_config_parser_index());
     if (limits != nullptr && limits->limits().max_recv_size >= 0 &&
         (limits->limits().max_recv_size < max_recv_message_length_ ||
          max_recv_message_length_ < 0)) {
@@ -89,24 +94,24 @@ class CallData {
       grpc_call_element* elem, grpc_transport_stream_op_batch* batch);
 
  private:
-  static void OnRecvInitialMetadataReady(void* arg, grpc_error* error);
+  static void OnRecvInitialMetadataReady(void* arg, grpc_error_handle error);
 
   // Methods for processing a receive message event
   void MaybeResumeOnRecvMessageReady();
-  static void OnRecvMessageReady(void* arg, grpc_error* error);
-  static void OnRecvMessageNextDone(void* arg, grpc_error* error);
-  grpc_error* PullSliceFromRecvMessage();
+  static void OnRecvMessageReady(void* arg, grpc_error_handle error);
+  static void OnRecvMessageNextDone(void* arg, grpc_error_handle error);
+  grpc_error_handle PullSliceFromRecvMessage();
   void ContinueReadingRecvMessage();
   void FinishRecvMessage();
-  void ContinueRecvMessageReadyCallback(grpc_error* error);
+  void ContinueRecvMessageReadyCallback(grpc_error_handle error);
 
   // Methods for processing a recv_trailing_metadata event
   void MaybeResumeOnRecvTrailingMetadataReady();
-  static void OnRecvTrailingMetadataReady(void* arg, grpc_error* error);
+  static void OnRecvTrailingMetadataReady(void* arg, grpc_error_handle error);
 
   CallCombiner* call_combiner_;
   // Overall error for the call
-  grpc_error* error_ = GRPC_ERROR_NONE;
+  grpc_error_handle error_ = GRPC_ERROR_NONE;
   // Fields for handling recv_initial_metadata_ready callback
   grpc_closure on_recv_initial_metadata_ready_;
   grpc_closure* original_recv_initial_metadata_ready_ = nullptr;
@@ -114,7 +119,7 @@ class CallData {
   // Fields for handling recv_message_ready callback
   bool seen_recv_message_ready_ = false;
   int max_recv_message_length_;
-  grpc_message_compression_algorithm algorithm_ = GRPC_MESSAGE_COMPRESS_NONE;
+  grpc_compression_algorithm algorithm_ = GRPC_COMPRESS_NONE;
   grpc_closure on_recv_message_ready_;
   grpc_closure* original_recv_message_ready_ = nullptr;
   grpc_closure on_recv_message_next_done_;
@@ -130,33 +135,15 @@ class CallData {
   bool seen_recv_trailing_metadata_ready_ = false;
   grpc_closure on_recv_trailing_metadata_ready_;
   grpc_closure* original_recv_trailing_metadata_ready_ = nullptr;
-  grpc_error* on_recv_trailing_metadata_ready_error_ = GRPC_ERROR_NONE;
+  grpc_error_handle on_recv_trailing_metadata_ready_error_ = GRPC_ERROR_NONE;
 };
 
-grpc_message_compression_algorithm DecodeMessageCompressionAlgorithm(
-    grpc_mdelem md) {
-  grpc_message_compression_algorithm algorithm =
-      grpc_message_compression_algorithm_from_slice(GRPC_MDVALUE(md));
-  if (algorithm == GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT) {
-    char* md_c_str = grpc_slice_to_c_string(GRPC_MDVALUE(md));
-    gpr_log(GPR_ERROR,
-            "Invalid incoming message compression algorithm: '%s'. "
-            "Interpreting incoming data as uncompressed.",
-            md_c_str);
-    gpr_free(md_c_str);
-    return GRPC_MESSAGE_COMPRESS_NONE;
-  }
-  return algorithm;
-}
-
-void CallData::OnRecvInitialMetadataReady(void* arg, grpc_error* error) {
+void CallData::OnRecvInitialMetadataReady(void* arg, grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(arg);
   if (error == GRPC_ERROR_NONE) {
-    grpc_linked_mdelem* grpc_encoding =
-        calld->recv_initial_metadata_->idx.named.grpc_encoding;
-    if (grpc_encoding != nullptr) {
-      calld->algorithm_ = DecodeMessageCompressionAlgorithm(grpc_encoding->md);
-    }
+    calld->algorithm_ =
+        calld->recv_initial_metadata_->get(GrpcEncodingMetadata())
+            .value_or(GRPC_COMPRESS_NONE);
   }
   calld->MaybeResumeOnRecvMessageReady();
   calld->MaybeResumeOnRecvTrailingMetadataReady();
@@ -174,7 +161,7 @@ void CallData::MaybeResumeOnRecvMessageReady() {
   }
 }
 
-void CallData::OnRecvMessageReady(void* arg, grpc_error* error) {
+void CallData::OnRecvMessageReady(void* arg, grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(arg);
   if (error == GRPC_ERROR_NONE) {
     if (calld->original_recv_initial_metadata_ready_ != nullptr) {
@@ -184,7 +171,7 @@ void CallData::OnRecvMessageReady(void* arg, grpc_error* error) {
                               "OnRecvInitialMetadataReady");
       return;
     }
-    if (calld->algorithm_ != GRPC_MESSAGE_COMPRESS_NONE) {
+    if (calld->algorithm_ != GRPC_COMPRESS_NONE) {
       // recv_message can be NULL if trailing metadata is received instead of
       // message, or it's possible that the message was not compressed.
       if (*calld->recv_message_ == nullptr ||
@@ -196,12 +183,12 @@ void CallData::OnRecvMessageReady(void* arg, grpc_error* error) {
       if (calld->max_recv_message_length_ >= 0 &&
           (*calld->recv_message_)->length() >
               static_cast<uint32_t>(calld->max_recv_message_length_)) {
-        std::string message_string = absl::StrFormat(
-            "Received message larger than max (%u vs. %d)",
-            (*calld->recv_message_)->length(), calld->max_recv_message_length_);
         GPR_DEBUG_ASSERT(calld->error_ == GRPC_ERROR_NONE);
         calld->error_ = grpc_error_set_int(
-            GRPC_ERROR_CREATE_FROM_COPIED_STRING(message_string.c_str()),
+            GRPC_ERROR_CREATE_FROM_CPP_STRING(
+                absl::StrFormat("Received message larger than max (%u vs. %d)",
+                                (*calld->recv_message_)->length(),
+                                calld->max_recv_message_length_)),
             GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED);
         return calld->ContinueRecvMessageReadyCallback(
             GRPC_ERROR_REF(calld->error_));
@@ -218,7 +205,7 @@ void CallData::ContinueReadingRecvMessage() {
   while ((*recv_message_)
              ->Next((*recv_message_)->length() - recv_slices_.length,
                     &on_recv_message_next_done_)) {
-    grpc_error* error = PullSliceFromRecvMessage();
+    grpc_error_handle error = PullSliceFromRecvMessage();
     if (error != GRPC_ERROR_NONE) {
       return ContinueRecvMessageReadyCallback(error);
     }
@@ -229,16 +216,16 @@ void CallData::ContinueReadingRecvMessage() {
   }
 }
 
-grpc_error* CallData::PullSliceFromRecvMessage() {
+grpc_error_handle CallData::PullSliceFromRecvMessage() {
   grpc_slice incoming_slice;
-  grpc_error* error = (*recv_message_)->Pull(&incoming_slice);
+  grpc_error_handle error = (*recv_message_)->Pull(&incoming_slice);
   if (error == GRPC_ERROR_NONE) {
     grpc_slice_buffer_add(&recv_slices_, incoming_slice);
   }
   return error;
 }
 
-void CallData::OnRecvMessageNextDone(void* arg, grpc_error* error) {
+void CallData::OnRecvMessageNextDone(void* arg, grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(arg);
   if (error != GRPC_ERROR_NONE) {
     return calld->ContinueRecvMessageReadyCallback(GRPC_ERROR_REF(error));
@@ -260,11 +247,10 @@ void CallData::FinishRecvMessage() {
   if (grpc_msg_decompress(algorithm_, &recv_slices_, &decompressed_slices) ==
       0) {
     GPR_DEBUG_ASSERT(error_ == GRPC_ERROR_NONE);
-    error_ = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+    error_ = GRPC_ERROR_CREATE_FROM_CPP_STRING(
         absl::StrCat("Unexpected error decompressing data for algorithm with "
                      "enum value ",
-                     algorithm_)
-            .c_str());
+                     algorithm_));
     grpc_slice_buffer_destroy_internal(&decompressed_slices);
   } else {
     uint32_t recv_flags =
@@ -283,7 +269,7 @@ void CallData::FinishRecvMessage() {
   ContinueRecvMessageReadyCallback(GRPC_ERROR_REF(error_));
 }
 
-void CallData::ContinueRecvMessageReadyCallback(grpc_error* error) {
+void CallData::ContinueRecvMessageReadyCallback(grpc_error_handle error) {
   MaybeResumeOnRecvTrailingMetadataReady();
   // The surface will clean up the receiving stream if there is an error.
   grpc_closure* closure = original_recv_message_ready_;
@@ -294,14 +280,14 @@ void CallData::ContinueRecvMessageReadyCallback(grpc_error* error) {
 void CallData::MaybeResumeOnRecvTrailingMetadataReady() {
   if (seen_recv_trailing_metadata_ready_) {
     seen_recv_trailing_metadata_ready_ = false;
-    grpc_error* error = on_recv_trailing_metadata_ready_error_;
+    grpc_error_handle error = on_recv_trailing_metadata_ready_error_;
     on_recv_trailing_metadata_ready_error_ = GRPC_ERROR_NONE;
     GRPC_CALL_COMBINER_START(call_combiner_, &on_recv_trailing_metadata_ready_,
                              error, "Continuing OnRecvTrailingMetadataReady");
   }
 }
 
-void CallData::OnRecvTrailingMetadataReady(void* arg, grpc_error* error) {
+void CallData::OnRecvTrailingMetadataReady(void* arg, grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(arg);
   if (calld->original_recv_initial_metadata_ready_ != nullptr ||
       calld->original_recv_message_ready_ != nullptr) {
@@ -356,8 +342,8 @@ void DecompressStartTransportStreamOpBatch(
   calld->DecompressStartTransportStreamOpBatch(elem, batch);
 }
 
-grpc_error* DecompressInitCallElem(grpc_call_element* elem,
-                                   const grpc_call_element_args* args) {
+grpc_error_handle DecompressInitCallElem(grpc_call_element* elem,
+                                         const grpc_call_element_args* args) {
   ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
   new (elem->call_data) CallData(*args, chand);
   return GRPC_ERROR_NONE;
@@ -370,8 +356,8 @@ void DecompressDestroyCallElem(grpc_call_element* elem,
   calld->~CallData();
 }
 
-grpc_error* DecompressInitChannelElem(grpc_channel_element* elem,
-                                      grpc_channel_element_args* args) {
+grpc_error_handle DecompressInitChannelElem(grpc_channel_element* elem,
+                                            grpc_channel_element_args* args) {
   ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
   new (chand) ChannelData(args);
   return GRPC_ERROR_NONE;
@@ -386,6 +372,7 @@ void DecompressDestroyChannelElem(grpc_channel_element* elem) {
 
 const grpc_channel_filter MessageDecompressFilter = {
     DecompressStartTransportStreamOpBatch,
+    nullptr,
     grpc_channel_next_op,
     sizeof(CallData),
     DecompressInitCallElem,