Change C core surface API

BUILD

@@ -572,6 +572,7 @@ grpc_cc_library(
         "src/core/lib/channel/handshaker_factory.c",
         "src/core/lib/channel/handshaker_registry.c",
         "src/core/lib/compression/compression.c",
+        "src/core/lib/compression/compression_internal.c",
         "src/core/lib/compression/message_compress.c",
         "src/core/lib/compression/stream_compression.c",
         "src/core/lib/http/format_request.c",
@@ -703,6 +704,7 @@ grpc_cc_library(
         "src/core/lib/channel/handshaker_factory.h",
         "src/core/lib/channel/handshaker_registry.h",
         "src/core/lib/compression/algorithm_metadata.h",
+        "src/core/lib/compression/compression_internal.h",
         "src/core/lib/compression/message_compress.h",
         "src/core/lib/compression/stream_compression.h",
         "src/core/lib/http/format_request.h",

build.yaml

@@ -193,6 +193,7 @@ filegroups:
   - src/core/lib/channel/handshaker_factory.c
   - src/core/lib/channel/handshaker_registry.c
   - src/core/lib/compression/compression.c
+  - src/core/lib/compression/compression_internal.c
   - src/core/lib/compression/message_compress.c
   - src/core/lib/compression/stream_compression.c
   - src/core/lib/debug/stats.c
@@ -344,6 +345,7 @@ filegroups:
   - src/core/lib/channel/handshaker_factory.h
   - src/core/lib/channel/handshaker_registry.h
   - src/core/lib/compression/algorithm_metadata.h
+  - src/core/lib/compression/compression_internal.h
   - src/core/lib/compression/message_compress.h
   - src/core/lib/compression/stream_compression.h
   - src/core/lib/debug/stats.h

include/grpc/compression.h

@@ -30,28 +30,25 @@
 extern "C" {
 #endif
 
+/** Return if an algorithm is message compression algorithm. */
+GRPCAPI int grpc_compression_algorithm_is_message(
+    grpc_compression_algorithm algorithm);
+
+/** Return if an algorithm is stream compression algorithm. */
+GRPCAPI int grpc_compression_algorithm_is_stream(
+    grpc_compression_algorithm algorithm);
+
 /** Parses the \a slice as a grpc_compression_algorithm instance and updating \a
  * algorithm. Returns 1 upon success, 0 otherwise. */
 GRPCAPI int grpc_compression_algorithm_parse(
     grpc_slice value, grpc_compression_algorithm *algorithm);
 
-/** Parses the \a slice as a grpc_stream_compression_algorithm instance and
- * updating \a algorithm. Returns 1 upon success, 0 otherwise. */
-int grpc_stream_compression_algorithm_parse(
-    grpc_slice name, grpc_stream_compression_algorithm *algorithm);
-
 /** Updates \a name with the encoding name corresponding to a valid \a
  * algorithm. Note that \a name is statically allocated and must *not* be freed.
  * Returns 1 upon success, 0 otherwise. */
 GRPCAPI int grpc_compression_algorithm_name(
     grpc_compression_algorithm algorithm, char **name);
 
-/** Updates \a name with the encoding name corresponding to a valid \a
- * algorithm. Note that \a name is statically allocated and must *not* be freed.
- * Returns 1 upon success, 0 otherwise. */
-GRPCAPI int grpc_stream_compression_algorithm_name(
-    grpc_stream_compression_algorithm algorithm, char **name);
-
 /** Returns the compression algorithm corresponding to \a level for the
  * compression algorithms encoded in the \a accepted_encodings bitset.
  *
@@ -59,13 +56,6 @@ GRPCAPI int grpc_stream_compression_algorithm_name(
 GRPCAPI grpc_compression_algorithm grpc_compression_algorithm_for_level(
     grpc_compression_level level, uint32_t accepted_encodings);
 
-/** Returns the stream compression algorithm corresponding to \a level for the
- * compression algorithms encoded in the \a accepted_stream_encodings bitset.
- * It abort()s for unknown levels. */
-GRPCAPI grpc_stream_compression_algorithm
-grpc_stream_compression_algorithm_for_level(grpc_stream_compression_level level,
-                                            uint32_t accepted_stream_encodings);
-
 GRPCAPI void grpc_compression_options_init(grpc_compression_options *opts);
 
 /** Mark \a algorithm as enabled in \a opts. */
@@ -80,11 +70,6 @@ GRPCAPI void grpc_compression_options_disable_algorithm(
 GRPCAPI int grpc_compression_options_is_algorithm_enabled(
     const grpc_compression_options *opts, grpc_compression_algorithm algorithm);
 
-/** Returns true if \a algorithm is marked as enabled in \a opts. */
-GRPCAPI int grpc_compression_options_is_stream_compression_algorithm_enabled(
-    const grpc_compression_options *opts,
-    grpc_stream_compression_algorithm algorithm);
-
 #ifdef __cplusplus
 }
 #endif

include/grpc/impl/codegen/compression_types.h

@@ -29,11 +29,6 @@ extern "C" {
  * algorithm */
 #define GRPC_COMPRESSION_REQUEST_ALGORITHM_MD_KEY \
   "grpc-internal-encoding-request"
-/** To be used as initial metadata key for the request of a concrete stream
- * compression
- * algorithm */
-#define GRPC_STREAM_COMPRESSION_REQUEST_ALGORITHM_MD_KEY \
-  "grpc-internal-stream-encoding-request"
 
 /** To be used in channel arguments.
  *
@@ -43,17 +38,9 @@ extern "C" {
  * Its value is an int from the \a grpc_compression_algorithm enum. */
 #define GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM \
   "grpc.default_compression_algorithm"
-/** Default stream compression algorithm for the channel.
- * Its value is an int from the \a grpc_stream_compression_algorithm enum. */
-#define GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM \
-  "grpc.default_stream_compression_algorithm"
 /** Default compression level for the channel.
  * Its value is an int from the \a grpc_compression_level enum. */
 #define GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL "grpc.default_compression_level"
-/** Default stream compression level for the channel.
- * Its value is an int from the \a grpc_stream_compression_level enum. */
-#define GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_LEVEL \
-  "grpc.default_stream_compression_level"
 /** Compression algorithms supported by the channel.
  * Its value is a bitset (an int). Bits correspond to algorithms in \a
  * grpc_compression_algorithm. For example, its LSB corresponds to
@@ -63,80 +50,49 @@ extern "C" {
  * be ignored). */
 #define GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET \
   "grpc.compression_enabled_algorithms_bitset"
-/** Stream compression algorithms supported by the channel.
- * Its value is a bitset (an int). Bits correspond to algorithms in \a
- * grpc_stream_compression_algorithm. For example, its LSB corresponds to
- * GRPC_STREAM_COMPRESS_NONE, the next bit to GRPC_STREAM_COMPRESS_DEFLATE, etc.
- * Unset bits disable support for the algorithm. By default all algorithms are
- * supported. It's not possible to disable GRPC_STREAM_COMPRESS_NONE (the
- * attempt will be ignored). */
-#define GRPC_STREAM_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET \
-  "grpc.stream_compression_enabled_algorithms_bitset"
 /** \} */
 
 /** The various compression algorithms supported by gRPC */
 typedef enum {
   GRPC_COMPRESS_NONE = 0,
-  GRPC_COMPRESS_DEFLATE,
+  GRPC_COMPRESS_MESSAGE_DEFLATE,
-  GRPC_COMPRESS_GZIP,
+  GRPC_COMPRESS_MESSAGE_GZIP,
+  GRPC_COMPRESS_STREAM_GZIP,
   /* TODO(ctiller): snappy */
   GRPC_COMPRESS_ALGORITHMS_COUNT
 } grpc_compression_algorithm;
 
-/** Stream compresssion algorithms supported by gRPC */
-typedef enum {
-  GRPC_STREAM_COMPRESS_NONE = 0,
-  GRPC_STREAM_COMPRESS_GZIP,
-  GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT
-} grpc_stream_compression_algorithm;
-
 /** Compression levels allow a party with knowledge of its peer's accepted
  * encodings to request compression in an abstract way. The level-algorithm
  * mapping is performed internally and depends on the peer's supported
  * compression algorithms. */
 typedef enum {
   GRPC_COMPRESS_LEVEL_NONE = 0,
-  GRPC_COMPRESS_LEVEL_LOW,
+  GRPC_COMPRESS_LEVEL_MESSAGE_LOW,
-  GRPC_COMPRESS_LEVEL_MED,
+  GRPC_COMPRESS_LEVEL_MESSAGE_MED,
-  GRPC_COMPRESS_LEVEL_HIGH,
+  GRPC_COMPRESS_LEVEL_MESSAGE_HIGH,
+  GRPC_COMPRESS_LEVEL_STREAM_LOW,
+  GRPC_COMPRESS_LEVEL_STREAM_MED,
+  GRPC_COMPRESS_LEVEL_STREAM_HIGH,
   GRPC_COMPRESS_LEVEL_COUNT
 } grpc_compression_level;
 
-/** Compression levels for stream compression algorithms */
-typedef enum {
-  GRPC_STREAM_COMPRESS_LEVEL_NONE = 0,
-  GRPC_STREAM_COMPRESS_LEVEL_LOW,
-  GRPC_STREAM_COMPRESS_LEVEL_MED,
-  GRPC_STREAM_COMPRESS_LEVEL_HIGH,
-  GRPC_STREAM_COMPRESS_LEVEL_COUNT
-} grpc_stream_compression_level;
-
 typedef struct grpc_compression_options {
   /** All algs are enabled by default. This option corresponds to the channel
    * argument key behind \a GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET
    */
   uint32_t enabled_algorithms_bitset;
-  uint32_t enabled_stream_compression_algorithms_bitset;
 
-  /** The default message-wise compression level. It'll be used in the absence
+  /** The default compression level. It'll be used in the absence of call
-   * of * call specific settings. This option corresponds to the channel
+   * specific settings. This option corresponds to the channel
    * argument key behind \a GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL. If present,
-   * takes precedence over \a default_algorithm and \a
+   * takes precedence over \a default_algorithm.
-   * default_stream_compression_algorithm.
    * TODO(dgq): currently only available for server channels. */
   struct grpc_compression_options_default_level {
     int is_set;
     grpc_compression_level level;
   } default_level;
 
-  /** The default stream compression level. It'll be used in the absence of call
-   * specefic settings. If present, takes precedence over \a default_level,
-   * \a default_algorithm and \a default_stream_compression_algorithm. */
-  struct grpc_stream_compression_options_default_level {
-    int is_set;
-    grpc_stream_compression_level level;
-  } default_stream_compression_level;
-
   /** The default message compression algorithm. It'll be used in the absence of
    * call specific settings. This option corresponds to the channel argument key
    * behind \a GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM. */
@@ -144,17 +100,6 @@ typedef struct grpc_compression_options {
     int is_set;
     grpc_compression_algorithm algorithm;
   } default_algorithm;
-
-  /** The default stream compression algorithm. It'll be used in the absence of
-   * call specific settings. If present, takes precedence over \a
-   * default_algorithm. This option corresponds to the channel
-   * argument key behind \a GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM.
-   */
-  struct grpc_stream_compression_options_default_algorithm {
-    int is_set;
-    grpc_stream_compression_algorithm algorithm;
-  } default_stream_compression_algorithm;
-
 } grpc_compression_options;
 
 #ifdef __cplusplus

include/grpc/impl/codegen/grpc_types.h

@@ -508,10 +508,6 @@ typedef struct grpc_op {
         uint8_t is_set;
         grpc_compression_level level;
       } maybe_compression_level;
-      struct grpc_op_send_initial_metadata_maybe_stream_compression_level {
-        uint8_t is_set;
-        grpc_stream_compression_level level;
-      } maybe_stream_compression_level;
     } send_initial_metadata;
     struct grpc_op_send_message {
       /** This op takes ownership of the slices in send_message.  After

src/core/ext/filters/http/message_compress/message_compress_filter.c

@@ -27,6 +27,7 @@
 #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_internal.h"
 #include "src/core/lib/compression/message_compress.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -52,7 +53,7 @@ typedef struct call_data {
   grpc_linked_mdelem accept_stream_encoding_storage;
   /** Compression algorithm we'll try to use. It may be given by incoming
    * metadata, or by the channel's default compression settings. */
-  grpc_compression_algorithm compression_algorithm;
+  grpc_message_compression_algorithm message_compression_algorithm;
   initial_metadata_state send_initial_metadata_state;
   grpc_error *cancel_error;
   grpc_closure start_send_message_batch_in_call_combiner;
@@ -67,15 +68,10 @@ typedef struct call_data {
 typedef struct channel_data {
   /** The default, channel-level, compression algorithm */
   grpc_compression_algorithm default_compression_algorithm;
-  /** Bitset of enabled algorithms */
+  /** Bitset of enabled compression algorithms */
   uint32_t enabled_algorithms_bitset;
   /** Supported compression algorithms */
-  uint32_t supported_compression_algorithms;
+  uint32_t supported_message_compression_algorithms;
-
-  /** The default, channel-level, stream compression algorithm */
-  grpc_stream_compression_algorithm default_stream_compression_algorithm;
-  /** Bitset of enabled stream compression algorithms */
-  uint32_t enabled_stream_compression_algorithms_bitset;
   /** Supported stream compression algorithms */
   uint32_t supported_stream_compression_algorithms;
 } channel_data;
@@ -89,7 +85,7 @@ static bool skip_compression(grpc_call_element *elem, uint32_t flags,
     return true;
   }
   if (has_compression_algorithm) {
-    if (calld->compression_algorithm == GRPC_COMPRESS_NONE) {
+    if (calld->message_compression_algorithm == GRPC_MESSAGE_COMPRESS_NONE) {
       return true;
     }
     return false; /* we have an actual call-specific algorithm */
@@ -109,70 +105,53 @@ static grpc_error *process_send_initial_metadata(
   call_data *calld = (call_data *)elem->call_data;
   channel_data *channeld = (channel_data *)elem->channel_data;
   *has_compression_algorithm = false;
+  grpc_compression_algorithm compression_algorithm;
   grpc_stream_compression_algorithm stream_compression_algorithm =
       GRPC_STREAM_COMPRESS_NONE;
-  if (initial_metadata->idx.named.grpc_internal_stream_encoding_request !=
+  if (initial_metadata->idx.named.grpc_internal_encoding_request != NULL) {
-      NULL) {
     grpc_mdelem md =
-        initial_metadata->idx.named.grpc_internal_stream_encoding_request->md;
+        initial_metadata->idx.named.grpc_internal_encoding_request->md;
-    if (!grpc_stream_compression_algorithm_parse(
+    if (!grpc_compression_algorithm_parse(GRPC_MDVALUE(md),
-            GRPC_MDVALUE(md), &stream_compression_algorithm)) {
+                                          &compression_algorithm)) {
       char *val = grpc_slice_to_c_string(GRPC_MDVALUE(md));
       gpr_log(GPR_ERROR,
-              "Invalid stream compression algorithm: '%s' (unknown). Ignoring.",
+              "Invalid compression algorithm: '%s' (unknown). Ignoring.", val);
-              val);
-      gpr_free(val);
-      stream_compression_algorithm = GRPC_STREAM_COMPRESS_NONE;
-    }
-    if (!GPR_BITGET(channeld->enabled_stream_compression_algorithms_bitset,
-                    stream_compression_algorithm)) {
-      char *val = grpc_slice_to_c_string(GRPC_MDVALUE(md));
-      gpr_log(
-          GPR_ERROR,
-          "Invalid stream compression algorithm: '%s' (previously disabled). "
-          "Ignoring.",
-          val);
       gpr_free(val);
+      calld->message_compression_algorithm = GRPC_MESSAGE_COMPRESS_NONE;
       stream_compression_algorithm = GRPC_STREAM_COMPRESS_NONE;
     }
-    *has_compression_algorithm = true;
+    if (!GPR_BITGET(channeld->enabled_algorithms_bitset,
-    grpc_metadata_batch_remove(
+                    compression_algorithm)) {
-        exec_ctx, initial_metadata,
-        initial_metadata->idx.named.grpc_internal_stream_encoding_request);
-    /* Disable message-wise compression */
-    calld->compression_algorithm = GRPC_COMPRESS_NONE;
-    if (initial_metadata->idx.named.grpc_internal_encoding_request != NULL) {
-      grpc_metadata_batch_remove(
-          exec_ctx, initial_metadata,
-          initial_metadata->idx.named.grpc_internal_encoding_request);
-    }
-  } else if (initial_metadata->idx.named.grpc_internal_encoding_request !=
-             NULL) {
-    grpc_mdelem md =
-        initial_metadata->idx.named.grpc_internal_encoding_request->md;
-    if (!grpc_compression_algorithm_parse(GRPC_MDVALUE(md),
-                                          &calld->compression_algorithm)) {
       char *val = grpc_slice_to_c_string(GRPC_MDVALUE(md));
       gpr_log(GPR_ERROR,
-              "Invalid compression algorithm: '%s' (unknown). Ignoring.", val);
+              "Invalid compression algorithm: '%s' (previously disabled). "
+              "Ignoring.",
+              val);
       gpr_free(val);
-      calld->compression_algorithm = GRPC_COMPRESS_NONE;
+      calld->message_compression_algorithm = GRPC_MESSAGE_COMPRESS_NONE;
+      stream_compression_algorithm = GRPC_STREAM_COMPRESS_NONE;
     }
     *has_compression_algorithm = true;
     grpc_metadata_batch_remove(
         exec_ctx, initial_metadata,
         initial_metadata->idx.named.grpc_internal_encoding_request);
+    calld->message_compression_algorithm =
+        grpc_compression_algorithm_to_message_compression_algorithm(
+            compression_algorithm);
+    stream_compression_algorithm =
+        grpc_compression_algorithm_to_stream_compression_algorithm(
+            compression_algorithm);
   } else {
     /* If no algorithm was found in the metadata and we aren't
      * exceptionally skipping compression, fall back to the channel
      * default */
-    if (channeld->default_stream_compression_algorithm !=
+    if (channeld->default_compression_algorithm != GRPC_COMPRESS_NONE) {
-        GRPC_STREAM_COMPRESS_NONE) {
+      calld->message_compression_algorithm =
+          grpc_compression_algorithm_to_message_compression_algorithm(
+              channeld->default_compression_algorithm);
       stream_compression_algorithm =
-          channeld->default_stream_compression_algorithm;
+          grpc_compression_algorithm_to_stream_compression_algorithm(
-      calld->compression_algorithm = GRPC_COMPRESS_NONE;
+              channeld->default_compression_algorithm);
-    } else {
-      calld->compression_algorithm = channeld->default_compression_algorithm;
     }
     *has_compression_algorithm = true;
   }
@@ -184,10 +163,11 @@ static grpc_error *process_send_initial_metadata(
         exec_ctx, initial_metadata,
         &calld->stream_compression_algorithm_storage,
         grpc_stream_compression_encoding_mdelem(stream_compression_algorithm));
-  } else if (calld->compression_algorithm != GRPC_COMPRESS_NONE) {
+  } else if (calld->message_compression_algorithm !=
+             GRPC_MESSAGE_COMPRESS_NONE) {
     error = grpc_metadata_batch_add_tail(
         exec_ctx, initial_metadata, &calld->compression_algorithm_storage,
-        grpc_compression_encoding_mdelem(calld->compression_algorithm));
+        grpc_message_compression_encoding_mdelem(calld->message_compression_algorithm));
   }
 
   if (error != GRPC_ERROR_NONE) return error;
@@ -196,11 +176,12 @@ static grpc_error *process_send_initial_metadata(
   error = grpc_metadata_batch_add_tail(
       exec_ctx, initial_metadata, &calld->accept_encoding_storage,
       GRPC_MDELEM_ACCEPT_ENCODING_FOR_ALGORITHMS(
-          channeld->supported_compression_algorithms));
+          channeld->supported_message_compression_algorithms));
 
   if (error != GRPC_ERROR_NONE) return error;
 
-  /* Do not overwrite accept-encoding header if it already presents. */
+  /* 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(
         exec_ctx, initial_metadata, &calld->accept_stream_encoding_storage,
@@ -240,16 +221,16 @@ static void finish_send_message(grpc_exec_ctx *exec_ctx,
   grpc_slice_buffer_init(&tmp);
   uint32_t send_flags =
       calld->send_message_batch->payload->send_message.send_message->flags;
-  bool did_compress = grpc_msg_compress(exec_ctx, calld->compression_algorithm,
+  bool did_compress = grpc_msg_compress(
-                                        &calld->slices, &tmp);
+      exec_ctx, calld->message_compression_algorithm, &calld->slices, &tmp);
   if (did_compress) {
     if (GRPC_TRACER_ON(grpc_compression_trace)) {
       char *algo_name;
       const size_t before_size = calld->slices.length;
       const size_t after_size = tmp.length;
       const float savings_ratio = 1.0f - (float)after_size / (float)before_size;
-      GPR_ASSERT(grpc_compression_algorithm_name(calld->compression_algorithm,
+      GPR_ASSERT(grpc_message_compression_algorithm_name(
-                                                 &algo_name));
+          calld->message_compression_algorithm, &algo_name));
       gpr_log(GPR_DEBUG, "Compressed[%s] %" PRIuPTR " bytes vs. %" PRIuPTR
                          " bytes (%.2f%% savings)",
               algo_name, before_size, after_size, 100 * savings_ratio);
@@ -259,8 +240,8 @@ static void finish_send_message(grpc_exec_ctx *exec_ctx,
   } else {
     if (GRPC_TRACER_ON(grpc_compression_trace)) {
       char *algo_name;
-      GPR_ASSERT(grpc_compression_algorithm_name(calld->compression_algorithm,
+      GPR_ASSERT(grpc_message_compression_algorithm_name(
-                                                 &algo_name));
+          calld->message_compression_algorithm, &algo_name));
       gpr_log(GPR_DEBUG,
               "Algorithm '%s' enabled but decided not to compress. Input size: "
               "%" PRIuPTR,
@@ -484,12 +465,11 @@ static grpc_error *init_channel_elem(grpc_exec_ctx *exec_ctx,
                                      grpc_channel_element_args *args) {
   channel_data *channeld = (channel_data *)elem->channel_data;
 
-  /* Configuration for message compression */
   channeld->enabled_algorithms_bitset =
       grpc_channel_args_compression_algorithm_get_states(args->channel_args);
-
   channeld->default_compression_algorithm =
       grpc_channel_args_get_compression_algorithm(args->channel_args);
+
   /* Make sure the default isn't disabled. */
   if (!GPR_BITGET(channeld->enabled_algorithms_bitset,
                   channeld->default_compression_algorithm)) {
@@ -499,31 +479,18 @@ static grpc_error *init_channel_elem(grpc_exec_ctx *exec_ctx,
     channeld->default_compression_algorithm = GRPC_COMPRESS_NONE;
   }
 
-  channeld->supported_compression_algorithms =
+  uint32_t supported_compression_algorithms =
       (((1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1) &
        channeld->enabled_algorithms_bitset) |
       1u;
 
-  /* Configuration for stream compression */
+  channeld->supported_message_compression_algorithms =
-  channeld->enabled_stream_compression_algorithms_bitset =
+      grpc_compression_bitset_to_message_bitset(
-      grpc_channel_args_stream_compression_algorithm_get_states(
+          supported_compression_algorithms);
-          args->channel_args);
-
-  channeld->default_stream_compression_algorithm =
-      grpc_channel_args_get_stream_compression_algorithm(args->channel_args);
-
-  if (!GPR_BITGET(channeld->enabled_stream_compression_algorithms_bitset,
-                  channeld->default_stream_compression_algorithm)) {
-    gpr_log(GPR_DEBUG,
-            "stream compression algorithm %d not enabled: switching to none",
-            channeld->default_stream_compression_algorithm);
-    channeld->default_stream_compression_algorithm = GRPC_STREAM_COMPRESS_NONE;
-  }
 
   channeld->supported_stream_compression_algorithms =
-      (((1u << GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) - 1) &
+      grpc_compression_bitset_to_stream_bitset(
-       channeld->enabled_stream_compression_algorithms_bitset) |
+          supported_compression_algorithms);
-      1u;
 
   GPR_ASSERT(!args->is_last);
   return GRPC_ERROR_NONE;

src/core/lib/channel/channel_args.c

@@ -223,21 +223,6 @@ grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
   return GRPC_COMPRESS_NONE;
 }
 
-grpc_stream_compression_algorithm
-grpc_channel_args_get_stream_compression_algorithm(const grpc_channel_args *a) {
-  size_t i;
-  if (a == NULL) return 0;
-  for (i = 0; i < a->num_args; ++i) {
-    if (a->args[i].type == GRPC_ARG_INTEGER &&
-        !strcmp(GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM,
-                a->args[i].key)) {
-      return (grpc_stream_compression_algorithm)a->args[i].value.integer;
-      break;
-    }
-  }
-  return GRPC_STREAM_COMPRESS_NONE;
-}
-
 grpc_channel_args *grpc_channel_args_set_compression_algorithm(
     grpc_channel_args *a, grpc_compression_algorithm algorithm) {
   GPR_ASSERT(algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT);
@@ -248,16 +233,6 @@ grpc_channel_args *grpc_channel_args_set_compression_algorithm(
   return grpc_channel_args_copy_and_add(a, &tmp, 1);
 }
 
-grpc_channel_args *grpc_channel_args_set_stream_compression_algorithm(
-    grpc_channel_args *a, grpc_stream_compression_algorithm algorithm) {
-  GPR_ASSERT(algorithm < GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT);
-  grpc_arg tmp;
-  tmp.type = GRPC_ARG_INTEGER;
-  tmp.key = GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM;
-  tmp.value.integer = algorithm;
-  return grpc_channel_args_copy_and_add(a, &tmp, 1);
-}
-
 /** Returns 1 if the argument for compression algorithm's enabled states bitset
  * was found in \a a, returning the arg's value in \a states. Otherwise, returns
  * 0. */
@@ -278,26 +253,6 @@ static int find_compression_algorithm_states_bitset(const grpc_channel_args *a,
   return 0; /* GPR_FALSE */
 }
 
-/** Returns 1 if the argument for compression algorithm's enabled states bitset
- * was found in \a a, returning the arg's value in \a states. Otherwise, returns
- * 0. */
-static int find_stream_compression_algorithm_states_bitset(
-    const grpc_channel_args *a, int **states_arg) {
-  if (a != NULL) {
-    size_t i;
-    for (i = 0; i < a->num_args; ++i) {
-      if (a->args[i].type == GRPC_ARG_INTEGER &&
-          !strcmp(GRPC_STREAM_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET,
-                  a->args[i].key)) {
-        *states_arg = &a->args[i].value.integer;
-        **states_arg |= 0x1; /* forcefully enable support for no compression */
-        return 1;
-      }
-    }
-  }
-  return 0; /* GPR_FALSE */
-}
-
 grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(
     grpc_exec_ctx *exec_ctx, grpc_channel_args **a,
     grpc_compression_algorithm algorithm, int state) {
@@ -339,48 +294,6 @@ grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(
   return result;
 }
 
-grpc_channel_args *grpc_channel_args_stream_compression_algorithm_set_state(
-    grpc_exec_ctx *exec_ctx, grpc_channel_args **a,
-    grpc_stream_compression_algorithm algorithm, int state) {
-  int *states_arg = NULL;
-  grpc_channel_args *result = *a;
-  const int states_arg_found =
-      find_stream_compression_algorithm_states_bitset(*a, &states_arg);
-
-  if (grpc_channel_args_get_stream_compression_algorithm(*a) == algorithm &&
-      state == 0) {
-    char *algo_name = NULL;
-    GPR_ASSERT(grpc_stream_compression_algorithm_name(algorithm, &algo_name) !=
-               0);
-    gpr_log(GPR_ERROR,
-            "Tried to disable default stream compression algorithm '%s'. The "
-            "operation has been ignored.",
-            algo_name);
-  } else if (states_arg_found) {
-    if (state != 0) {
-      GPR_BITSET((unsigned *)states_arg, algorithm);
-    } else if (algorithm != GRPC_STREAM_COMPRESS_NONE) {
-      GPR_BITCLEAR((unsigned *)states_arg, algorithm);
-    }
-  } else {
-    /* create a new arg */
-    grpc_arg tmp;
-    tmp.type = GRPC_ARG_INTEGER;
-    tmp.key = GRPC_STREAM_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET;
-    /* all enabled by default */
-    tmp.value.integer = (1u << GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) - 1;
-    if (state != 0) {
-      GPR_BITSET((unsigned *)&tmp.value.integer, algorithm);
-    } else if (algorithm != GRPC_STREAM_COMPRESS_NONE) {
-      GPR_BITCLEAR((unsigned *)&tmp.value.integer, algorithm);
-    }
-    result = grpc_channel_args_copy_and_add(*a, &tmp, 1);
-    grpc_channel_args_destroy(exec_ctx, *a);
-    *a = result;
-  }
-  return result;
-}
-
 uint32_t grpc_channel_args_compression_algorithm_get_states(
     const grpc_channel_args *a) {
   int *states_arg;
@@ -391,17 +304,6 @@ uint32_t grpc_channel_args_compression_algorithm_get_states(
   }
 }
 
-uint32_t grpc_channel_args_stream_compression_algorithm_get_states(
-    const grpc_channel_args *a) {
-  int *states_arg;
-  if (find_stream_compression_algorithm_states_bitset(a, &states_arg)) {
-    return (uint32_t)*states_arg;
-  } else {
-    return (1u << GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) -
-           1; /* All algs. enabled */
-  }
-}
-
 grpc_channel_args *grpc_channel_args_set_socket_mutator(
     grpc_channel_args *a, grpc_socket_mutator *mutator) {
   grpc_arg tmp = grpc_socket_mutator_to_arg(mutator);

src/core/lib/channel/channel_args.h

@@ -59,24 +59,12 @@ void grpc_channel_args_destroy(grpc_exec_ctx *exec_ctx, grpc_channel_args *a);
 grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
     const grpc_channel_args *a);
 
-/** Returns the stream compression algorithm set in \a a. */
-grpc_stream_compression_algorithm
-grpc_channel_args_get_stream_compression_algorithm(const grpc_channel_args *a);
-
 /** Returns a channel arg instance with compression enabled. If \a a is
  * non-NULL, its args are copied. N.B. GRPC_COMPRESS_NONE disables compression
  * for the channel. */
 grpc_channel_args *grpc_channel_args_set_compression_algorithm(
     grpc_channel_args *a, grpc_compression_algorithm algorithm);
 
-/** Returns a channel arg instance with stream compression enabled. If \a a is
- * non-NULL, its args are copied. N.B. GRPC_STREAM_COMPRESS_NONE disables
- * stream compression for the channel. If a value other than
- * GRPC_STREAM_COMPRESS_NONE is set, it takes precedence over message-wise
- * compression algorithms. */
-grpc_channel_args *grpc_channel_args_set_stream_compression_algorithm(
-    grpc_channel_args *a, grpc_stream_compression_algorithm algorithm);
-
 /** Sets the support for the given compression algorithm. By default, all
  * compression algorithms are enabled. It's an error to disable an algorithm set
  * by grpc_channel_args_set_compression_algorithm.
@@ -88,17 +76,6 @@ grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(
     grpc_exec_ctx *exec_ctx, grpc_channel_args **a,
     grpc_compression_algorithm algorithm, int enabled);
 
-/** Sets the support for the given stream compression algorithm. By default, all
- * stream compression algorithms are enabled. It's an error to disable an
- * algorithm set by grpc_channel_args_set_stream_compression_algorithm.
- *
- * Returns an instance with the updated algorithm states. The \a a pointer is
- * modified to point to the returned instance (which may be different from the
- * input value of \a a). */
-grpc_channel_args *grpc_channel_args_stream_compression_algorithm_set_state(
-    grpc_exec_ctx *exec_ctx, grpc_channel_args **a,
-    grpc_stream_compression_algorithm algorithm, int enabled);
-
 /** Returns the bitset representing the support state (true for enabled, false
  * for disabled) for compression algorithms.
  *
@@ -107,14 +84,6 @@ grpc_channel_args *grpc_channel_args_stream_compression_algorithm_set_state(
 uint32_t grpc_channel_args_compression_algorithm_get_states(
     const grpc_channel_args *a);
 
-/** Returns the bitset representing the support state (true for enabled, false
- * for disabled) for stream compression algorithms.
- *
- * The i-th bit of the returned bitset corresponds to the i-th entry in the
- * grpc_stream_compression_algorithm enum. */
-uint32_t grpc_channel_args_stream_compression_algorithm_get_states(
-    const grpc_channel_args *a);
-
 int grpc_channel_args_compare(const grpc_channel_args *a,
                               const grpc_channel_args *b);
 

src/core/lib/compression/algorithm_metadata.h

@@ -20,20 +20,26 @@
 #define GRPC_CORE_LIB_COMPRESSION_ALGORITHM_METADATA_H
 
 #include <grpc/compression.h>
+#include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/transport/metadata.h"
 
 /** Return compression algorithm based metadata value */
 grpc_slice grpc_compression_algorithm_slice(
     grpc_compression_algorithm algorithm);
 
-/** Return stream compression algorithm based metadata value */
+/** Find compression algorithm based on passed in mdstr - returns
-grpc_slice grpc_stream_compression_algorithm_slice(
+ *  GRPC_COMPRESS_ALGORITHM_COUNT on failure */
-    grpc_stream_compression_algorithm algorithm);
+grpc_compression_algorithm grpc_compression_algorithm_from_slice(
+        grpc_slice str);
 
-/** Return compression algorithm based metadata element (grpc-encoding: xxx) */
+/** Return compression algorithm based metadata element */
 grpc_mdelem grpc_compression_encoding_mdelem(
     grpc_compression_algorithm algorithm);
 
+/** Return message compression algorithm based metadata element (grpc-encoding: xxx) */
+grpc_mdelem grpc_message_compression_encoding_mdelem(
+    grpc_message_compression_algorithm algorithm);
+
 /** Return stream compression algorithm based metadata element
  * (content-encoding: xxx) */
 grpc_mdelem grpc_stream_compression_encoding_mdelem(
@@ -41,8 +47,8 @@ grpc_mdelem grpc_stream_compression_encoding_mdelem(
 
 /** Find compression algorithm based on passed in mdstr - returns
  * GRPC_COMPRESS_ALGORITHM_COUNT on failure */
-grpc_compression_algorithm grpc_compression_algorithm_from_slice(
+grpc_message_compression_algorithm
-    grpc_slice str);
+grpc_message_compression_algorithm_from_slice(grpc_slice str);
 
 /** Find stream compression algorithm based on passed in mdstr - returns
  * GRPC_STREAM_COMPRESS_ALGORITHM_COUNT on failure */

src/core/lib/compression/compression.c

@@ -23,40 +23,39 @@
 #include <grpc/support/useful.h>
 
 #include "src/core/lib/compression/algorithm_metadata.h"
+#include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/transport/static_metadata.h"
 
+int grpc_compression_algorithm_is_message(
+    grpc_compression_algorithm algorithm) {
+  return (algorithm >= GRPC_COMPRESS_MESSAGE_DEFLATE &&
+          algorithm <= GRPC_COMPRESS_MESSAGE_GZIP) ? 1 : 0;
+}
+
+int grpc_compression_algorithm_is_stream(
+    grpc_compression_algorithm algorithm) {
+  return (algorithm == GRPC_COMPRESS_STREAM_GZIP) ? 1 : 0;
+}
+
 int grpc_compression_algorithm_parse(grpc_slice name,
                                      grpc_compression_algorithm *algorithm) {
-  /* we use strncmp not only because it's safer (even though in this case it
-   * doesn't matter, given that we are comparing against string literals, but
-   * because this way we needn't have "name" nil-terminated (useful for slice
-   * data, for example) */
   if (grpc_slice_eq(name, GRPC_MDSTR_IDENTITY)) {
     *algorithm = GRPC_COMPRESS_NONE;
     return 1;
-  } else if (grpc_slice_eq(name, GRPC_MDSTR_GZIP)) {
+  } else if (grpc_slice_eq(name, GRPC_MDSTR_MESSAGE_SLASH_DEFLATE)) {
-    *algorithm = GRPC_COMPRESS_GZIP;
+    *algorithm = GRPC_COMPRESS_MESSAGE_DEFLATE;
-    return 1;
-  } else if (grpc_slice_eq(name, GRPC_MDSTR_DEFLATE)) {
-    *algorithm = GRPC_COMPRESS_DEFLATE;
     return 1;
-  } else {
+  } else if (grpc_slice_eq(name, GRPC_MDSTR_MESSAGE_SLASH_GZIP)) {
-    return 0;
+    *algorithm = GRPC_COMPRESS_MESSAGE_GZIP;
-  }
-}
-
-int grpc_stream_compression_algorithm_parse(
-    grpc_slice name, grpc_stream_compression_algorithm *algorithm) {
-  if (grpc_slice_eq(name, GRPC_MDSTR_IDENTITY)) {
-    *algorithm = GRPC_STREAM_COMPRESS_NONE;
     return 1;
-  } else if (grpc_slice_eq(name, GRPC_MDSTR_GZIP)) {
+  } else if (grpc_slice_eq(name, GRPC_MDSTR_STREAM_SLASH_GZIP)) {
-    *algorithm = GRPC_STREAM_COMPRESS_GZIP;
+    *algorithm = GRPC_COMPRESS_STREAM_GZIP;
     return 1;
   } else {
     return 0;
   }
+  return 0;
 }
 
 int grpc_compression_algorithm_name(grpc_compression_algorithm algorithm,
@@ -67,11 +66,14 @@ int grpc_compression_algorithm_name(grpc_compression_algorithm algorithm,
     case GRPC_COMPRESS_NONE:
       *name = "identity";
       return 1;
-    case GRPC_COMPRESS_DEFLATE:
+    case GRPC_COMPRESS_MESSAGE_DEFLATE:
-      *name = "deflate";
+      *name = "message/deflate";
       return 1;
-    case GRPC_COMPRESS_GZIP:
+    case GRPC_COMPRESS_MESSAGE_GZIP:
-      *name = "gzip";
+      *name = "message/gzip";
+      return 1;
+    case GRPC_COMPRESS_STREAM_GZIP:
+      *name = "stream/gzip";
       return 1;
     case GRPC_COMPRESS_ALGORITHMS_COUNT:
       return 0;
@@ -79,37 +81,56 @@ int grpc_compression_algorithm_name(grpc_compression_algorithm algorithm,
   return 0;
 }
 
-int grpc_stream_compression_algorithm_name(
+grpc_compression_algorithm grpc_compression_algorithm_for_level(
-    grpc_stream_compression_algorithm algorithm, char **name) {
+    grpc_compression_level level, uint32_t accepted_encodings) {
-  GRPC_API_TRACE(
+  grpc_compression_algorithm algo;
-      "grpc_stream_compression_algorithm_parse(algorithm=%d, name=%p)", 2,
+  if (level == GRPC_COMPRESS_LEVEL_NONE) {
-      ((int)algorithm, name));
+    return GRPC_COMPRESS_NONE;
-  switch (algorithm) {
+  } else if (level <= GRPC_COMPRESS_LEVEL_MESSAGE_HIGH) {
-    case GRPC_STREAM_COMPRESS_NONE:
+    GPR_ASSERT(
-      *name = "identity";
+        grpc_compression_algorithm_from_message_stream_compression_algorithm(
-      return 1;
+            &algo,
-    case GRPC_STREAM_COMPRESS_GZIP:
+            grpc_message_compression_algorithm_for_level(
-      *name = "gzip";
+                grpc_compression_level_to_message_compression_level(level),
-      return 1;
+                grpc_compression_bitset_to_message_bitset(
-    case GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT:
+                    accepted_encodings)),
-      return 0;
+            0));
+    return algo;
+  } else if (level <= GRPC_COMPRESS_LEVEL_STREAM_HIGH) {
+    GPR_ASSERT(
+        grpc_compression_algorithm_from_message_stream_compression_algorithm(
+            &algo, 0,
+            grpc_stream_compression_algorithm_for_level(
+                grpc_compression_level_to_stream_compression_level(level),
+                grpc_compression_bitset_to_stream_bitset(
+                    accepted_encodings))));
+    return algo;
+  } else {
+    gpr_log(GPR_ERROR, "Unknown compression level: %d", level);
+    return GRPC_COMPRESS_NONE;
   }
-  return 0;
 }
 
-grpc_compression_algorithm grpc_compression_algorithm_from_slice(
+void grpc_compression_options_init(grpc_compression_options *opts) {
-    grpc_slice str) {
+  memset(opts, 0, sizeof(*opts));
-  if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY)) return GRPC_COMPRESS_NONE;
+  /* all enabled by default */
-  if (grpc_slice_eq(str, GRPC_MDSTR_DEFLATE)) return GRPC_COMPRESS_DEFLATE;
+  opts->enabled_algorithms_bitset = (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
-  if (grpc_slice_eq(str, GRPC_MDSTR_GZIP)) return GRPC_COMPRESS_GZIP;
+}
-  return GRPC_COMPRESS_ALGORITHMS_COUNT;
+
+void grpc_compression_options_enable_algorithm(
+    grpc_compression_options *opts, grpc_compression_algorithm algorithm) {
+  GPR_BITSET(&opts->enabled_algorithms_bitset, algorithm);
 }
 
-grpc_stream_compression_algorithm grpc_stream_compression_algorithm_from_slice(
+void grpc_compression_options_disable_algorithm(
-    grpc_slice str) {
+    grpc_compression_options *opts, grpc_compression_algorithm algorithm) {
-  if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY)) return GRPC_STREAM_COMPRESS_NONE;
+  GPR_BITCLEAR(&opts->enabled_algorithms_bitset, algorithm);
-  if (grpc_slice_eq(str, GRPC_MDSTR_GZIP)) return GRPC_STREAM_COMPRESS_GZIP;
+}
-  return GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT;
+
+int grpc_compression_options_is_algorithm_enabled(
+    const grpc_compression_options *opts,
+    grpc_compression_algorithm algorithm) {
+  return GPR_BITGET(opts->enabled_algorithms_bitset, algorithm);
 }
 
 grpc_slice grpc_compression_algorithm_slice(
@@ -117,27 +138,25 @@ grpc_slice grpc_compression_algorithm_slice(
   switch (algorithm) {
     case GRPC_COMPRESS_NONE:
       return GRPC_MDSTR_IDENTITY;
-    case GRPC_COMPRESS_DEFLATE:
+    case GRPC_COMPRESS_MESSAGE_DEFLATE:
-      return GRPC_MDSTR_DEFLATE;
+      return GRPC_MDSTR_MESSAGE_SLASH_DEFLATE;
-    case GRPC_COMPRESS_GZIP:
+    case GRPC_COMPRESS_MESSAGE_GZIP:
-      return GRPC_MDSTR_GZIP;
+      return GRPC_MDSTR_MESSAGE_SLASH_GZIP;
+    case GRPC_COMPRESS_STREAM_GZIP:
+      return GRPC_MDSTR_STREAM_SLASH_GZIP;
     case GRPC_COMPRESS_ALGORITHMS_COUNT:
       return grpc_empty_slice();
   }
   return grpc_empty_slice();
 }
 
-grpc_slice grpc_stream_compression_algorithm_slice(
+grpc_compression_algorithm grpc_compression_algorithm_from_slice(
-    grpc_stream_compression_algorithm algorithm) {
+        grpc_slice str) {
-  switch (algorithm) {
+  if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY)) return GRPC_COMPRESS_NONE;
-    case GRPC_STREAM_COMPRESS_NONE:
+  if (grpc_slice_eq(str, GRPC_MDSTR_MESSAGE_SLASH_DEFLATE)) return GRPC_COMPRESS_MESSAGE_DEFLATE;
-      return GRPC_MDSTR_IDENTITY;
+  if (grpc_slice_eq(str, GRPC_MDSTR_MESSAGE_SLASH_GZIP)) return GRPC_COMPRESS_MESSAGE_GZIP;
-    case GRPC_STREAM_COMPRESS_GZIP:
+  if (grpc_slice_eq(str, GRPC_MDSTR_STREAM_SLASH_GZIP)) return GRPC_COMPRESS_STREAM_GZIP;
-      return GRPC_MDSTR_GZIP;
+  return GRPC_COMPRESS_ALGORITHMS_COUNT;
-    case GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT:
-      return grpc_empty_slice();
-  }
-  return grpc_empty_slice();
 }
 
 grpc_mdelem grpc_compression_encoding_mdelem(
@@ -145,9 +164,11 @@ grpc_mdelem grpc_compression_encoding_mdelem(
   switch (algorithm) {
     case GRPC_COMPRESS_NONE:
       return GRPC_MDELEM_GRPC_ENCODING_IDENTITY;
-    case GRPC_COMPRESS_DEFLATE:
+    case GRPC_COMPRESS_MESSAGE_DEFLATE:
       return GRPC_MDELEM_GRPC_ENCODING_DEFLATE;
-    case GRPC_COMPRESS_GZIP:
+    case GRPC_COMPRESS_MESSAGE_GZIP:
+      return GRPC_MDELEM_GRPC_ENCODING_GZIP;
+    case GRPC_COMPRESS_STREAM_GZIP:
       return GRPC_MDELEM_GRPC_ENCODING_GZIP;
     default:
       break;
@@ -155,129 +176,3 @@ grpc_mdelem grpc_compression_encoding_mdelem(
   return GRPC_MDNULL;
 }
 
-grpc_mdelem grpc_stream_compression_encoding_mdelem(
-    grpc_stream_compression_algorithm algorithm) {
-  switch (algorithm) {
-    case GRPC_STREAM_COMPRESS_NONE:
-      return GRPC_MDELEM_CONTENT_ENCODING_IDENTITY;
-    case GRPC_STREAM_COMPRESS_GZIP:
-      return GRPC_MDELEM_CONTENT_ENCODING_GZIP;
-    default:
-      break;
-  }
-  return GRPC_MDNULL;
-}
-
-void grpc_compression_options_init(grpc_compression_options *opts) {
-  memset(opts, 0, sizeof(*opts));
-  /* all enabled by default */
-  opts->enabled_algorithms_bitset = (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
-  opts->enabled_stream_compression_algorithms_bitset =
-      (1u << GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) - 1;
-}
-
-void grpc_compression_options_enable_algorithm(
-    grpc_compression_options *opts, grpc_compression_algorithm algorithm) {
-  GPR_BITSET(&opts->enabled_algorithms_bitset, algorithm);
-}
-
-void grpc_compression_options_disable_algorithm(
-    grpc_compression_options *opts, grpc_compression_algorithm algorithm) {
-  GPR_BITCLEAR(&opts->enabled_algorithms_bitset, algorithm);
-}
-
-int grpc_compression_options_is_algorithm_enabled(
-    const grpc_compression_options *opts,
-    grpc_compression_algorithm algorithm) {
-  return GPR_BITGET(opts->enabled_algorithms_bitset, algorithm);
-}
-
-int grpc_compression_options_is_stream_compression_algorithm_enabled(
-    const grpc_compression_options *opts,
-    grpc_stream_compression_algorithm algorithm) {
-  return GPR_BITGET(opts->enabled_stream_compression_algorithms_bitset,
-                    algorithm);
-}
-
-/* TODO(dgq): Add the ability to specify parameters to the individual
- * compression algorithms */
-grpc_compression_algorithm grpc_compression_algorithm_for_level(
-    grpc_compression_level level, uint32_t accepted_encodings) {
-  GRPC_API_TRACE("grpc_compression_algorithm_for_level(level=%d)", 1,
-                 ((int)level));
-  if (level > GRPC_COMPRESS_LEVEL_HIGH) {
-    gpr_log(GPR_ERROR, "Unknown compression level %d.", (int)level);
-    abort();
-  }
-
-  const size_t num_supported =
-      GPR_BITCOUNT(accepted_encodings) - 1; /* discard NONE */
-  if (level == GRPC_COMPRESS_LEVEL_NONE || num_supported == 0) {
-    return GRPC_COMPRESS_NONE;
-  }
-
-  GPR_ASSERT(level > 0);
-
-  /* Establish a "ranking" or compression algorithms in increasing order of
-   * compression.
-   * This is simplistic and we will probably want to introduce other dimensions
-   * in the future (cpu/memory cost, etc). */
-  const grpc_compression_algorithm algos_ranking[] = {GRPC_COMPRESS_GZIP,
-                                                      GRPC_COMPRESS_DEFLATE};
-
-  /* intersect algos_ranking with the supported ones keeping the ranked order */
-  grpc_compression_algorithm
-      sorted_supported_algos[GRPC_COMPRESS_ALGORITHMS_COUNT];
-  size_t algos_supported_idx = 0;
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(algos_ranking); i++) {
-    const grpc_compression_algorithm alg = algos_ranking[i];
-    for (size_t j = 0; j < num_supported; j++) {
-      if (GPR_BITGET(accepted_encodings, alg) == 1) {
-        /* if \a alg in supported */
-        sorted_supported_algos[algos_supported_idx++] = alg;
-        break;
-      }
-    }
-    if (algos_supported_idx == num_supported) break;
-  }
-
-  switch (level) {
-    case GRPC_COMPRESS_LEVEL_NONE:
-      abort(); /* should have been handled already */
-    case GRPC_COMPRESS_LEVEL_LOW:
-      return sorted_supported_algos[0];
-    case GRPC_COMPRESS_LEVEL_MED:
-      return sorted_supported_algos[num_supported / 2];
-    case GRPC_COMPRESS_LEVEL_HIGH:
-      return sorted_supported_algos[num_supported - 1];
-    default:
-      abort();
-  };
-}
-
-GRPCAPI grpc_stream_compression_algorithm
-grpc_stream_compression_algorithm_for_level(
-    grpc_stream_compression_level level, uint32_t accepted_stream_encodings) {
-  GRPC_API_TRACE("grpc_stream_compression_algorithm_for_level(level=%d)", 1,
-                 ((int)level));
-  if (level > GRPC_STREAM_COMPRESS_LEVEL_HIGH) {
-    gpr_log(GPR_ERROR, "Unknown compression level %d.", (int)level);
-    abort();
-  }
-
-  switch (level) {
-    case GRPC_STREAM_COMPRESS_LEVEL_NONE:
-      return GRPC_STREAM_COMPRESS_NONE;
-    case GRPC_STREAM_COMPRESS_LEVEL_LOW:
-    case GRPC_STREAM_COMPRESS_LEVEL_MED:
-    case GRPC_STREAM_COMPRESS_LEVEL_HIGH:
-      if (GPR_BITGET(accepted_stream_encodings, GRPC_STREAM_COMPRESS_GZIP) ==
-          1) {
-        return GRPC_STREAM_COMPRESS_GZIP;
-      } else {
-        return GRPC_STREAM_COMPRESS_NONE;
-      }
-    default:
-      abort();
-  }
-}

src/core/lib/compression/compression_internal.c

@@ -0,0 +1,310 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <grpc/compression.h>
+#include <grpc/support/useful.h>
+
+#include "src/core/lib/compression/algorithm_metadata.h"
+#include "src/core/lib/compression/compression_internal.h"
+#include "src/core/lib/surface/api_trace.h"
+#include "src/core/lib/transport/static_metadata.h"
+
+/* Interfaces related to MD */
+
+grpc_message_compression_algorithm
+grpc_message_compression_algorithm_from_slice(grpc_slice str) {
+  if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY))
+    return GRPC_MESSAGE_COMPRESS_NONE;
+  if (grpc_slice_eq(str, GRPC_MDSTR_DEFLATE))
+    return GRPC_MESSAGE_COMPRESS_DEFLATE;
+  if (grpc_slice_eq(str, GRPC_MDSTR_GZIP)) return GRPC_MESSAGE_COMPRESS_GZIP;
+  return GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT;
+}
+
+grpc_stream_compression_algorithm grpc_stream_compression_algorithm_from_slice(
+    grpc_slice str) {
+  if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY)) return GRPC_STREAM_COMPRESS_NONE;
+  if (grpc_slice_eq(str, GRPC_MDSTR_GZIP)) return GRPC_STREAM_COMPRESS_GZIP;
+  return GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT;
+}
+
+grpc_mdelem grpc_message_compression_encoding_mdelem(
+    grpc_message_compression_algorithm algorithm) {
+  switch (algorithm) {
+    case GRPC_MESSAGE_COMPRESS_NONE:
+      return GRPC_MDELEM_GRPC_ENCODING_IDENTITY;
+    case GRPC_MESSAGE_COMPRESS_DEFLATE:
+      return GRPC_MDELEM_GRPC_ENCODING_DEFLATE;
+    case GRPC_MESSAGE_COMPRESS_GZIP:
+      return GRPC_MDELEM_GRPC_ENCODING_GZIP;
+    default:
+      break;
+  }
+  return GRPC_MDNULL;
+}
+
+grpc_mdelem grpc_stream_compression_encoding_mdelem(
+    grpc_stream_compression_algorithm algorithm) {
+  switch (algorithm) {
+    case GRPC_STREAM_COMPRESS_NONE:
+      return GRPC_MDELEM_CONTENT_ENCODING_IDENTITY;
+    case GRPC_STREAM_COMPRESS_GZIP:
+      return GRPC_MDELEM_CONTENT_ENCODING_GZIP;
+    default:
+      break;
+  }
+  return GRPC_MDNULL;
+}
+
+/* Interfaces performing transformation between compression algorithms and
+ * levels. */
+grpc_message_compression_level
+grpc_compression_level_to_message_compression_level(
+    grpc_compression_level level) {
+  if (level >= GRPC_COMPRESS_LEVEL_COUNT) {
+    return GRPC_MESSAGE_COMPRESS_LEVEL_NONE;
+  }
+  return (grpc_message_compression_level)(
+      (uint32_t)(level - GRPC_COMPRESS_LEVEL_NONE) +
+      (uint32_t)GRPC_MESSAGE_COMPRESS_LEVEL_NONE);
+}
+
+grpc_stream_compression_level
+grpc_compression_level_to_stream_compression_level(
+    grpc_compression_level level) {
+  if (level >= GRPC_COMPRESS_LEVEL_COUNT) {
+    return GRPC_STREAM_COMPRESS_LEVEL_NONE;
+  }
+  return (grpc_stream_compression_level)(
+      (uint32_t)(level - (GRPC_MESSAGE_COMPRESS_LEVEL_COUNT - 1) - GRPC_COMPRESS_LEVEL_NONE) +
+      (uint32_t)GRPC_STREAM_COMPRESS_LEVEL_NONE);
+}
+
+grpc_message_compression_algorithm
+grpc_compression_algorithm_to_message_compression_algorithm(
+    grpc_compression_algorithm algo) {
+  switch (algo) {
+    case GRPC_COMPRESS_MESSAGE_DEFLATE:
+      return GRPC_MESSAGE_COMPRESS_DEFLATE;
+    case GRPC_COMPRESS_MESSAGE_GZIP:
+      return GRPC_MESSAGE_COMPRESS_GZIP;
+    default:
+      return GRPC_MESSAGE_COMPRESS_NONE;
+  }
+}
+
+grpc_stream_compression_algorithm
+grpc_compression_algorithm_to_stream_compression_algorithm(
+    grpc_compression_algorithm algo) {
+  switch (algo) {
+    case GRPC_COMPRESS_STREAM_GZIP:
+      return GRPC_STREAM_COMPRESS_GZIP;
+    default:
+      return GRPC_STREAM_COMPRESS_NONE;
+  }
+}
+
+uint32_t grpc_compression_bitset_to_message_bitset(uint32_t bitset) {
+  return bitset & ((1u << GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT) - 1);
+}
+
+uint32_t grpc_compression_bitset_to_stream_bitset(uint32_t bitset) {
+  uint32_t identity = (bitset & 1u);
+  uint32_t other_bits =
+      (bitset >> (GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT - 1)) &
+      ((1u << GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) - 2);
+  return identity | other_bits;
+}
+
+uint32_t grpc_compression_bitset_from_message_stream_compression_bitset(
+    uint32_t message_bitset, uint32_t stream_bitset) {
+  uint32_t offset_stream_bitset = (stream_bitset & 1u) | ((stream_bitset & (~1u)) << (GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT - 1));
+  return message_bitset | offset_stream_bitset;
+}
+
+int grpc_compression_algorithm_from_message_stream_compression_algorithm(
+    grpc_compression_algorithm *algorithm,
+    grpc_message_compression_algorithm message_algorithm,
+    grpc_stream_compression_algorithm stream_algorithm) {
+  if (message_algorithm != GRPC_MESSAGE_COMPRESS_NONE &&
+      stream_algorithm != GRPC_STREAM_COMPRESS_NONE) {
+    *algorithm = GRPC_COMPRESS_NONE;
+    return 0;
+  }
+  if (message_algorithm == GRPC_MESSAGE_COMPRESS_NONE) {
+    switch (stream_algorithm) {
+      case GRPC_STREAM_COMPRESS_NONE:
+        *algorithm = GRPC_COMPRESS_NONE;
+        return 1;
+      case GRPC_STREAM_COMPRESS_GZIP:
+        *algorithm = GRPC_COMPRESS_STREAM_GZIP;
+        return 1;
+      default:
+        *algorithm = GRPC_COMPRESS_NONE;
+        return 0;
+    }
+  } else {
+    switch (message_algorithm) {
+      case GRPC_MESSAGE_COMPRESS_NONE:
+        *algorithm = GRPC_COMPRESS_NONE;
+        return 1;
+      case GRPC_MESSAGE_COMPRESS_DEFLATE:
+        *algorithm = GRPC_COMPRESS_MESSAGE_DEFLATE;
+        return 1;
+      case GRPC_MESSAGE_COMPRESS_GZIP:
+        *algorithm = GRPC_COMPRESS_MESSAGE_GZIP;
+        return 1;
+      default:
+        *algorithm = GRPC_COMPRESS_NONE;
+        return 0;
+    }
+  }
+  return 0;
+}
+
+/* Interfaces for message compression. */
+
+int grpc_message_compression_algorithm_name(
+    grpc_message_compression_algorithm algorithm, char **name) {
+  GRPC_API_TRACE("grpc_message_compression_algorithm_parse(algorithm=%d, name=%p)", 2,
+                 ((int)algorithm, name));
+  switch (algorithm) {
+    case GRPC_MESSAGE_COMPRESS_NONE:
+      *name = "identity";
+      return 1;
+    case GRPC_MESSAGE_COMPRESS_DEFLATE:
+      *name = "deflate";
+      return 1;
+    case GRPC_MESSAGE_COMPRESS_GZIP:
+      *name = "gzip";
+      return 1;
+    case GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT:
+      return 0;
+  }
+  return 0;
+}
+
+/* TODO(dgq): Add the ability to specify parameters to the individual
+ * compression algorithms */
+grpc_message_compression_algorithm grpc_message_compression_algorithm_for_level(
+    grpc_message_compression_level level, uint32_t accepted_encodings) {
+  GRPC_API_TRACE("grpc_message_compression_algorithm_for_level(level=%d)", 1,
+                 ((int)level));
+  if (level > GRPC_MESSAGE_COMPRESS_LEVEL_HIGH) {
+    gpr_log(GPR_ERROR, "Unknown message compression level %d.", (int)level);
+    abort();
+  }
+
+  const size_t num_supported =
+      GPR_BITCOUNT(accepted_encodings) - 1; /* discard NONE */
+  if (level == GRPC_MESSAGE_COMPRESS_LEVEL_NONE || num_supported == 0) {
+    return GRPC_MESSAGE_COMPRESS_NONE;
+  }
+
+  GPR_ASSERT(level > 0);
+
+  /* Establish a "ranking" or compression algorithms in increasing order of
+   * compression.
+   * This is simplistic and we will probably want to introduce other dimensions
+   * in the future (cpu/memory cost, etc). */
+  const grpc_message_compression_algorithm algos_ranking[] = {
+      GRPC_MESSAGE_COMPRESS_GZIP, GRPC_MESSAGE_COMPRESS_DEFLATE};
+
+  /* intersect algos_ranking with the supported ones keeping the ranked order */
+  grpc_message_compression_algorithm
+      sorted_supported_algos[GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT];
+  size_t algos_supported_idx = 0;
+  for (size_t i = 0; i < GPR_ARRAY_SIZE(algos_ranking); i++) {
+    const grpc_message_compression_algorithm alg = algos_ranking[i];
+    for (size_t j = 0; j < num_supported; j++) {
+      if (GPR_BITGET(accepted_encodings, alg) == 1) {
+        /* if \a alg in supported */
+        sorted_supported_algos[algos_supported_idx++] = alg;
+        break;
+      }
+    }
+    if (algos_supported_idx == num_supported) break;
+  }
+
+  switch (level) {
+    case GRPC_MESSAGE_COMPRESS_LEVEL_NONE:
+      abort(); /* should have been handled already */
+    case GRPC_MESSAGE_COMPRESS_LEVEL_LOW:
+      return sorted_supported_algos[0];
+    case GRPC_MESSAGE_COMPRESS_LEVEL_MED:
+      return sorted_supported_algos[num_supported / 2];
+    case GRPC_MESSAGE_COMPRESS_LEVEL_HIGH:
+      return sorted_supported_algos[num_supported - 1];
+    default:
+      abort();
+  };
+}
+
+int grpc_message_compression_algorithm_parse(
+    grpc_slice value, grpc_message_compression_algorithm *algorithm) {
+  if (grpc_slice_eq(value, GRPC_MDSTR_IDENTITY)) {
+    *algorithm = GRPC_MESSAGE_COMPRESS_NONE;
+    return 1;
+  } else if (grpc_slice_eq(value, GRPC_MDSTR_DEFLATE)) {
+    *algorithm = GRPC_MESSAGE_COMPRESS_DEFLATE;
+    return 1;
+  } else if (grpc_slice_eq(value, GRPC_MDSTR_GZIP)) {
+    *algorithm = GRPC_MESSAGE_COMPRESS_GZIP;
+    return 1;
+  } else {
+    return 0;
+  }
+  return 0;
+}
+
+/* Interfaces for stream compression. */
+
+grpc_stream_compression_algorithm grpc_stream_compression_algorithm_for_level(
+    grpc_stream_compression_level level, uint32_t accepted_encodings) {
+  GRPC_API_TRACE("grpc_stream_compression_algorithm_for_level(level=%d)", 1,
+                 ((int)level));
+  if (level > GRPC_STREAM_COMPRESS_LEVEL_HIGH) {
+    gpr_log(GPR_ERROR, "Unknown stream compression level %d.", (int)level);
+    abort();
+  }
+
+  /* TODO(mxyan): Use more sophisticated scheme when more algorithms added. */
+  if (level != GRPC_STREAM_COMPRESS_LEVEL_NONE &&
+      GPR_BITGET(accepted_encodings, GRPC_STREAM_COMPRESS_GZIP)) {
+    return GRPC_STREAM_COMPRESS_GZIP;
+  }
+  return GRPC_STREAM_COMPRESS_NONE;
+}
+
+int grpc_stream_compression_algorithm_parse(
+    grpc_slice value, grpc_stream_compression_algorithm *algorithm) {
+  if (grpc_slice_eq(value, GRPC_MDSTR_IDENTITY)) {
+    *algorithm = GRPC_STREAM_COMPRESS_NONE;
+    return 1;
+  } else if (grpc_slice_eq(value, GRPC_MDSTR_GZIP)) {
+    *algorithm = GRPC_STREAM_COMPRESS_GZIP;
+    return 1;
+  } else {
+    return 0;
+  }
+  return 0;
+}
+

src/core/lib/compression/compression_internal.h

@@ -0,0 +1,110 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef GRPC_CORE_LIB_COMPRESSION_COMPRESSION_INTERNAL_H
+#define GRPC_CORE_LIB_COMPRESSION_COMPRESSION_INTERNAL_H
+
+#include <grpc/impl/codegen/compression_types.h>
+
+typedef enum {
+  GRPC_MESSAGE_COMPRESS_NONE = 0,
+  GRPC_MESSAGE_COMPRESS_DEFLATE,
+  GRPC_MESSAGE_COMPRESS_GZIP,
+  /* TODO(ctiller): snappy */
+  GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT
+} grpc_message_compression_algorithm;
+
+/** Stream compresssion algorithms supported by gRPC */
+typedef enum {
+  GRPC_STREAM_COMPRESS_NONE = 0,
+  GRPC_STREAM_COMPRESS_GZIP,
+  GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT
+} grpc_stream_compression_algorithm;
+
+/** Compression levels allow a party with knowledge of its peer's accepted
+ * encodings to request compression in an abstract way. The level-algorithm
+ * mapping is performed internally and depends on the peer's supported
+ * compression algorithms. */
+typedef enum {
+  GRPC_MESSAGE_COMPRESS_LEVEL_NONE = 0,
+  GRPC_MESSAGE_COMPRESS_LEVEL_LOW,
+  GRPC_MESSAGE_COMPRESS_LEVEL_MED,
+  GRPC_MESSAGE_COMPRESS_LEVEL_HIGH,
+  GRPC_MESSAGE_COMPRESS_LEVEL_COUNT
+} grpc_message_compression_level;
+
+/** Compression levels for stream compression algorithms */
+typedef enum {
+  GRPC_STREAM_COMPRESS_LEVEL_NONE = 0,
+  GRPC_STREAM_COMPRESS_LEVEL_LOW,
+  GRPC_STREAM_COMPRESS_LEVEL_MED,
+  GRPC_STREAM_COMPRESS_LEVEL_HIGH,
+  GRPC_STREAM_COMPRESS_LEVEL_COUNT
+} grpc_stream_compression_level;
+
+/* Interfaces performing transformation between compression algorithms and
+ * levels. */
+
+grpc_message_compression_level
+grpc_compression_level_to_message_compression_level(
+    grpc_compression_level level);
+
+grpc_stream_compression_level
+grpc_compression_level_to_stream_compression_level(
+    grpc_compression_level level);
+
+grpc_message_compression_algorithm
+grpc_compression_algorithm_to_message_compression_algorithm(
+    grpc_compression_algorithm algo);
+
+grpc_stream_compression_algorithm
+grpc_compression_algorithm_to_stream_compression_algorithm(
+    grpc_compression_algorithm algo);
+
+uint32_t grpc_compression_bitset_to_message_bitset(uint32_t bitset);
+
+uint32_t grpc_compression_bitset_to_stream_bitset(uint32_t bitset);
+
+uint32_t grpc_compression_bitset_from_message_stream_compression_bitset(
+    uint32_t message_bitset, uint32_t stream_bitset);
+
+int grpc_compression_algorithm_from_message_stream_compression_algorithm(
+    grpc_compression_algorithm *algorithm,
+    grpc_message_compression_algorithm message_algorithm,
+    grpc_stream_compression_algorithm stream_algorithm);
+
+/* Interfaces for message compression. */
+
+int grpc_message_compression_algorithm_name(
+    grpc_message_compression_algorithm algorithm, char **name);
+
+grpc_message_compression_algorithm grpc_message_compression_algorithm_for_level(
+    grpc_message_compression_level level, uint32_t accepted_encodings);
+
+int grpc_message_compression_algorithm_parse(
+    grpc_slice value, grpc_message_compression_algorithm *algorithm);
+
+/* Interfaces for stream compression. */
+
+grpc_stream_compression_algorithm grpc_stream_compression_algorithm_for_level(
+    grpc_stream_compression_level level, uint32_t accepted_encodings);
+
+int grpc_stream_compression_algorithm_parse(
+    grpc_slice value, grpc_stream_compression_algorithm *algorithm);
+
+#endif /* GRPC_CORE_LIB_COMPRESSION_COMPRESSION_INTERNAL_H */

src/core/lib/compression/message_compress.c

@@ -143,18 +143,18 @@ static int copy(grpc_slice_buffer* input, grpc_slice_buffer* output) {
 }
 
 static int compress_inner(grpc_exec_ctx* exec_ctx,
-                          grpc_compression_algorithm algorithm,
+                          grpc_message_compression_algorithm algorithm,
                           grpc_slice_buffer* input, grpc_slice_buffer* output) {
   switch (algorithm) {
-    case GRPC_COMPRESS_NONE:
+    case GRPC_MESSAGE_COMPRESS_NONE:
       /* the fallback path always needs to be send uncompressed: we simply
          rely on that here */
       return 0;
-    case GRPC_COMPRESS_DEFLATE:
+    case GRPC_MESSAGE_COMPRESS_DEFLATE:
       return zlib_compress(exec_ctx, input, output, 0);
-    case GRPC_COMPRESS_GZIP:
+    case GRPC_MESSAGE_COMPRESS_GZIP:
       return zlib_compress(exec_ctx, input, output, 1);
-    case GRPC_COMPRESS_ALGORITHMS_COUNT:
+    case GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT:
       break;
   }
   gpr_log(GPR_ERROR, "invalid compression algorithm %d", algorithm);
@@ -162,7 +162,7 @@ static int compress_inner(grpc_exec_ctx* exec_ctx,
 }
 
 int grpc_msg_compress(grpc_exec_ctx* exec_ctx,
-                      grpc_compression_algorithm algorithm,
+                      grpc_message_compression_algorithm algorithm,
                       grpc_slice_buffer* input, grpc_slice_buffer* output) {
   if (!compress_inner(exec_ctx, algorithm, input, output)) {
     copy(input, output);
@@ -172,16 +172,16 @@ int grpc_msg_compress(grpc_exec_ctx* exec_ctx,
 }
 
 int grpc_msg_decompress(grpc_exec_ctx* exec_ctx,
-                        grpc_compression_algorithm algorithm,
+                        grpc_message_compression_algorithm algorithm,
                         grpc_slice_buffer* input, grpc_slice_buffer* output) {
   switch (algorithm) {
-    case GRPC_COMPRESS_NONE:
+    case GRPC_MESSAGE_COMPRESS_NONE:
       return copy(input, output);
-    case GRPC_COMPRESS_DEFLATE:
+    case GRPC_MESSAGE_COMPRESS_DEFLATE:
       return zlib_decompress(exec_ctx, input, output, 0);
-    case GRPC_COMPRESS_GZIP:
+    case GRPC_MESSAGE_COMPRESS_GZIP:
       return zlib_decompress(exec_ctx, input, output, 1);
-    case GRPC_COMPRESS_ALGORITHMS_COUNT:
+    case GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT:
       break;
   }
   gpr_log(GPR_ERROR, "invalid compression algorithm %d", algorithm);

src/core/lib/compression/message_compress.h

@@ -19,21 +19,22 @@
 #ifndef GRPC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H
 #define GRPC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H
 
-#include <grpc/compression.h>
 #include <grpc/slice_buffer.h>
 
+#include "src/core/lib/compression/compression_internal.h"
+
 /* compress 'input' to 'output' using 'algorithm'.
    On success, appends compressed slices to output and returns 1.
    On failure, appends uncompressed slices to output and returns 0. */
 int grpc_msg_compress(grpc_exec_ctx* exec_ctx,
-                      grpc_compression_algorithm algorithm,
+                      grpc_message_compression_algorithm algorithm,
                       grpc_slice_buffer* input, grpc_slice_buffer* output);
 
 /* decompress 'input' to 'output' using 'algorithm'.
    On success, appends slices to output and returns 1.
    On failure, output is unchanged, and returns 0. */
 int grpc_msg_decompress(grpc_exec_ctx* exec_ctx,
-                        grpc_compression_algorithm algorithm,
+                        grpc_message_compression_algorithm algorithm,
                         grpc_slice_buffer* input, grpc_slice_buffer* output);
 
 #endif /* GRPC_CORE_LIB_COMPRESSION_MESSAGE_COMPRESS_H */

src/core/lib/surface/byte_buffer_reader.c

@@ -50,7 +50,7 @@ int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader *reader,
       grpc_slice_buffer_init(&decompressed_slices_buffer);
       if (is_compressed(reader->buffer_in)) {
         if (grpc_msg_decompress(&exec_ctx,
-                                reader->buffer_in->data.raw.compression,
+                                grpc_compression_algorithm_to_message_compression_algorithm(reader->buffer_in->data.raw.compression),
                                 &reader->buffer_in->data.raw.slice_buffer,
                                 &decompressed_slices_buffer) == 0) {
           gpr_log(GPR_ERROR,

src/core/lib/surface/call.c

@@ -199,7 +199,7 @@ struct grpc_call {
   grpc_call_final_info final_info;
 
   /* Compression algorithm for *incoming* data */
-  grpc_compression_algorithm incoming_compression_algorithm;
+  grpc_message_compression_algorithm incoming_message_compression_algorithm;
   /* Stream compression algorithm for *incoming* data */
   grpc_stream_compression_algorithm incoming_stream_compression_algorithm;
   /* Supported encodings (compression algorithms), a bitset */
@@ -342,7 +342,7 @@ grpc_error *grpc_call_create(grpc_exec_ctx *exec_ctx,
   call->cq = args->cq;
   call->start_time = gpr_now(GPR_CLOCK_MONOTONIC);
   /* Always support no compression */
-  GPR_BITSET(&call->encodings_accepted_by_peer, GRPC_COMPRESS_NONE);
+  GPR_BITSET(&call->encodings_accepted_by_peer, GRPC_MESSAGE_COMPRESS_NONE);
   call->is_client = args->server_transport_data == NULL;
   if (call->is_client) {
     GRPC_STATS_INC_CLIENT_CALLS_CREATED(exec_ctx);
@@ -818,10 +818,10 @@ static void set_status_from_error(grpc_exec_ctx *exec_ctx, grpc_call *call,
  * COMPRESSION
  */
 
-static void set_incoming_compression_algorithm(
+static void set_incoming_message_compression_algorithm(
-    grpc_call *call, grpc_compression_algorithm algo) {
+    grpc_call *call, grpc_message_compression_algorithm algo) {
-  GPR_ASSERT(algo < GRPC_COMPRESS_ALGORITHMS_COUNT);
+  GPR_ASSERT(algo < GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT);
-  call->incoming_compression_algorithm = algo;
+  call->incoming_message_compression_algorithm = algo;
 }
 
 static void set_incoming_stream_compression_algorithm(
@@ -830,10 +830,12 @@ static void set_incoming_stream_compression_algorithm(
   call->incoming_stream_compression_algorithm = algo;
 }
 
-grpc_compression_algorithm grpc_call_test_only_get_compression_algorithm(
+grpc_compression_algorithm
-    grpc_call *call) {
+grpc_call_test_only_get_compression_algorithm(grpc_call *call) {
-  grpc_compression_algorithm algorithm;
+  grpc_compression_algorithm algorithm = GRPC_COMPRESS_NONE;
-  algorithm = call->incoming_compression_algorithm;
+  grpc_compression_algorithm_from_message_stream_compression_algorithm(
+      &algorithm, call->incoming_message_compression_algorithm,
+      call->incoming_stream_compression_algorithm);
   return algorithm;
 }
 
@@ -843,13 +845,6 @@ static grpc_compression_algorithm compression_algorithm_for_level_locked(
                                               call->encodings_accepted_by_peer);
 }
 
-static grpc_stream_compression_algorithm
-stream_compression_algorithm_for_level_locked(
-    grpc_call *call, grpc_stream_compression_level level) {
-  return grpc_stream_compression_algorithm_for_level(
-      level, call->stream_encodings_accepted_by_peer);
-}
-
 uint32_t grpc_call_test_only_get_message_flags(grpc_call *call) {
   uint32_t flags;
   flags = call->test_only_last_message_flags;
@@ -859,9 +854,11 @@ uint32_t grpc_call_test_only_get_message_flags(grpc_call *call) {
 static void destroy_encodings_accepted_by_peer(void *p) { return; }
 
 static void set_encodings_accepted_by_peer(grpc_exec_ctx *exec_ctx,
-                                           grpc_call *call, grpc_mdelem mdel) {
+                                           grpc_call *call, grpc_mdelem mdel,
+                                           uint32_t *encodings_accepted_by_peer,
+                                           bool stream_encoding) {
   size_t i;
-  grpc_compression_algorithm algorithm;
+  uint32_t algorithm;
   grpc_slice_buffer accept_encoding_parts;
   grpc_slice accept_encoding_slice;
   void *accepted_user_data;
@@ -869,70 +866,32 @@ static void set_encodings_accepted_by_peer(grpc_exec_ctx *exec_ctx,
   accepted_user_data =
       grpc_mdelem_get_user_data(mdel, destroy_encodings_accepted_by_peer);
   if (accepted_user_data != NULL) {
-    call->encodings_accepted_by_peer =
+    *encodings_accepted_by_peer =
         (uint32_t)(((uintptr_t)accepted_user_data) - 1);
     return;
   }
 
+  *encodings_accepted_by_peer = 0;
+
   accept_encoding_slice = GRPC_MDVALUE(mdel);
   grpc_slice_buffer_init(&accept_encoding_parts);
   grpc_slice_split(accept_encoding_slice, ",", &accept_encoding_parts);
 
-  /* No need to zero call->encodings_accepted_by_peer: grpc_call_create already
+  GPR_BITSET(encodings_accepted_by_peer, GRPC_COMPRESS_NONE);
-   * zeroes the whole grpc_call */
-  /* Always support no compression */
-  GPR_BITSET(&call->encodings_accepted_by_peer, GRPC_COMPRESS_NONE);
   for (i = 0; i < accept_encoding_parts.count; i++) {
+    int r;
     grpc_slice accept_encoding_entry_slice = accept_encoding_parts.slices[i];
-    if (grpc_compression_algorithm_parse(accept_encoding_entry_slice,
+    if (!stream_encoding) {
-                                         &algorithm)) {
+      r = grpc_message_compression_algorithm_parse(
-      GPR_BITSET(&call->encodings_accepted_by_peer, algorithm);
+          accept_encoding_entry_slice,
+          (grpc_message_compression_algorithm *)&algorithm);
     } else {
-      char *accept_encoding_entry_str =
+      r = grpc_stream_compression_algorithm_parse(
-          grpc_slice_to_c_string(accept_encoding_entry_slice);
+          accept_encoding_entry_slice,
-      gpr_log(GPR_ERROR,
+          (grpc_stream_compression_algorithm *)&algorithm);
-              "Invalid entry in accept encoding metadata: '%s'. Ignoring.",
-              accept_encoding_entry_str);
-      gpr_free(accept_encoding_entry_str);
     }
-  }
+    if (r) {
-
+      GPR_BITSET(encodings_accepted_by_peer, algorithm);
-  grpc_slice_buffer_destroy_internal(exec_ctx, &accept_encoding_parts);
-
-  grpc_mdelem_set_user_data(
-      mdel, destroy_encodings_accepted_by_peer,
-      (void *)(((uintptr_t)call->encodings_accepted_by_peer) + 1));
-}
-
-static void set_stream_encodings_accepted_by_peer(grpc_exec_ctx *exec_ctx,
-                                                  grpc_call *call,
-                                                  grpc_mdelem mdel) {
-  size_t i;
-  grpc_stream_compression_algorithm algorithm;
-  grpc_slice_buffer accept_encoding_parts;
-  grpc_slice accept_encoding_slice;
-  void *accepted_user_data;
-
-  accepted_user_data =
-      grpc_mdelem_get_user_data(mdel, destroy_encodings_accepted_by_peer);
-  if (accepted_user_data != NULL) {
-    call->stream_encodings_accepted_by_peer =
-        (uint32_t)(((uintptr_t)accepted_user_data) - 1);
-    return;
-  }
-
-  accept_encoding_slice = GRPC_MDVALUE(mdel);
-  grpc_slice_buffer_init(&accept_encoding_parts);
-  grpc_slice_split(accept_encoding_slice, ",", &accept_encoding_parts);
-
-  /* Always support no compression */
-  GPR_BITSET(&call->stream_encodings_accepted_by_peer,
-             GRPC_STREAM_COMPRESS_NONE);
-  for (i = 0; i < accept_encoding_parts.count; i++) {
-    grpc_slice accept_encoding_entry_slice = accept_encoding_parts.slices[i];
-    if (grpc_stream_compression_algorithm_parse(accept_encoding_entry_slice,
-                                                &algorithm)) {
-      GPR_BITSET(&call->stream_encodings_accepted_by_peer, algorithm);
     } else {
       char *accept_encoding_entry_str =
           grpc_slice_to_c_string(accept_encoding_entry_slice);
@@ -947,7 +906,7 @@ static void set_stream_encodings_accepted_by_peer(grpc_exec_ctx *exec_ctx,
 
   grpc_mdelem_set_user_data(
       mdel, destroy_encodings_accepted_by_peer,
-      (void *)(((uintptr_t)call->stream_encodings_accepted_by_peer) + 1));
+      (void *)(((uintptr_t)(*encodings_accepted_by_peer)) + 1));
 }
 
 uint32_t grpc_call_test_only_get_encodings_accepted_by_peer(grpc_call *call) {
@@ -956,13 +915,6 @@ uint32_t grpc_call_test_only_get_encodings_accepted_by_peer(grpc_call *call) {
   return encodings_accepted_by_peer;
 }
 
-uint32_t grpc_call_test_only_get_stream_encodings_accepted_by_peer(
-    grpc_call *call) {
-  uint32_t stream_encodings_accepted_by_peer;
-  stream_encodings_accepted_by_peer = call->stream_encodings_accepted_by_peer;
-  return stream_encodings_accepted_by_peer;
-}
-
 grpc_stream_compression_algorithm
 grpc_call_test_only_get_incoming_stream_encodings(grpc_call *call) {
   return call->incoming_stream_compression_algorithm;
@@ -1064,17 +1016,17 @@ static uint32_t decode_status(grpc_mdelem md) {
   return status;
 }
 
-static grpc_compression_algorithm decode_compression(grpc_mdelem md) {
+static grpc_message_compression_algorithm decode_message_compression(grpc_mdelem md) {
-  grpc_compression_algorithm algorithm =
+  grpc_message_compression_algorithm algorithm =
-      grpc_compression_algorithm_from_slice(GRPC_MDVALUE(md));
+      grpc_message_compression_algorithm_from_slice(GRPC_MDVALUE(md));
-  if (algorithm == GRPC_COMPRESS_ALGORITHMS_COUNT) {
+  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 compression algorithm: '%s'. Interpreting "
+            "Invalid incoming message compression algorithm: '%s'. "
-            "incoming data as uncompressed.",
+            "Interpreting incoming data as uncompressed.",
             md_c_str);
     gpr_free(md_c_str);
-    return GRPC_COMPRESS_NONE;
+    return GRPC_MESSAGE_COMPRESS_NONE;
   }
   return algorithm;
 }
@@ -1120,38 +1072,41 @@ static void publish_app_metadata(grpc_call *call, grpc_metadata_batch *b,
 static void recv_initial_filter(grpc_exec_ctx *exec_ctx, grpc_call *call,
                                 grpc_metadata_batch *b) {
   if (b->idx.named.content_encoding != NULL) {
-    if (b->idx.named.grpc_encoding != NULL) {
-      gpr_log(GPR_ERROR,
-              "Received both content-encoding and grpc-encoding header. "
-              "Ignoring grpc-encoding.");
-      grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.grpc_encoding);
-    }
     GPR_TIMER_BEGIN("incoming_stream_compression_algorithm", 0);
     set_incoming_stream_compression_algorithm(
         call, decode_stream_compression(b->idx.named.content_encoding->md));
     GPR_TIMER_END("incoming_stream_compression_algorithm", 0);
     grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.content_encoding);
-  } else if (b->idx.named.grpc_encoding != NULL) {
+  }
-    GPR_TIMER_BEGIN("incoming_compression_algorithm", 0);
+  if (b->idx.named.grpc_encoding != NULL) {
-    set_incoming_compression_algorithm(
+    GPR_TIMER_BEGIN("incoming_message_compression_algorithm", 0);
-        call, decode_compression(b->idx.named.grpc_encoding->md));
+    set_incoming_message_compression_algorithm(
-    GPR_TIMER_END("incoming_compression_algorithm", 0);
+        call, decode_message_compression(b->idx.named.grpc_encoding->md));
+    GPR_TIMER_END("incoming_message_compression_algorithm", 0);
     grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.grpc_encoding);
   }
+  uint32_t message_encodings_accepted_by_peer = 1u;
+  uint32_t stream_encodings_accepted_by_peer = 1u;
   if (b->idx.named.grpc_accept_encoding != NULL) {
     GPR_TIMER_BEGIN("encodings_accepted_by_peer", 0);
     set_encodings_accepted_by_peer(exec_ctx, call,
-                                   b->idx.named.grpc_accept_encoding->md);
+                                   b->idx.named.grpc_accept_encoding->md,
+                                   &message_encodings_accepted_by_peer, false);
     grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.grpc_accept_encoding);
     GPR_TIMER_END("encodings_accepted_by_peer", 0);
   }
   if (b->idx.named.accept_encoding != NULL) {
     GPR_TIMER_BEGIN("stream_encodings_accepted_by_peer", 0);
-    set_stream_encodings_accepted_by_peer(exec_ctx, call,
+    set_encodings_accepted_by_peer(exec_ctx, call,
-                                          b->idx.named.accept_encoding->md);
+                                   b->idx.named.accept_encoding->md,
+                                   &stream_encodings_accepted_by_peer, true);
     grpc_metadata_batch_remove(exec_ctx, b, b->idx.named.accept_encoding);
     GPR_TIMER_END("stream_encodings_accepted_by_peer", 0);
   }
+  call->encodings_accepted_by_peer =
+      grpc_compression_bitset_from_message_stream_compression_bitset(
+          message_encodings_accepted_by_peer,
+          stream_encodings_accepted_by_peer);
   publish_app_metadata(call, b, false);
 }
 
@@ -1444,9 +1399,12 @@ static void process_data_after_md(grpc_exec_ctx *exec_ctx,
   } else {
     call->test_only_last_message_flags = call->receiving_stream->flags;
     if ((call->receiving_stream->flags & GRPC_WRITE_INTERNAL_COMPRESS) &&
-        (call->incoming_compression_algorithm > GRPC_COMPRESS_NONE)) {
+        (call->incoming_message_compression_algorithm > GRPC_MESSAGE_COMPRESS_NONE)) {
+      grpc_compression_algorithm algo;
+      GPR_ASSERT(grpc_compression_algorithm_from_message_stream_compression_algorithm(
+          &algo, call->incoming_message_compression_algorithm, 0));
       *call->receiving_buffer = grpc_raw_compressed_byte_buffer_create(
-          NULL, 0, call->incoming_compression_algorithm);
+          NULL, 0, algo);
     } else {
       *call->receiving_buffer = grpc_raw_byte_buffer_create(NULL, 0);
     }
@@ -1492,88 +1450,65 @@ static void receiving_stream_ready_in_call_combiner(grpc_exec_ctx *exec_ctx,
 
 static void validate_filtered_metadata(grpc_exec_ctx *exec_ctx,
                                        batch_control *bctl) {
+  grpc_compression_algorithm compression_algorithm;
   grpc_call *call = bctl->call;
-  /* validate compression algorithms */
   if (call->incoming_stream_compression_algorithm !=
-      GRPC_STREAM_COMPRESS_NONE) {
+          GRPC_STREAM_COMPRESS_NONE &&
-    const grpc_stream_compression_algorithm algo =
+      call->incoming_message_compression_algorithm != GRPC_MESSAGE_COMPRESS_NONE) {
-        call->incoming_stream_compression_algorithm;
     char *error_msg = NULL;
-    const grpc_compression_options compression_options =
+    gpr_asprintf(&error_msg,
-        grpc_channel_compression_options(call->channel);
+                 "Incoming stream has both stream compression (%d) and message "
-    if (algo >= GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) {
+                 "compression (%d).",
-      gpr_asprintf(&error_msg,
+                 call->incoming_stream_compression_algorithm,
-                   "Invalid stream compression algorithm value '%d'.", algo);
+                 call->incoming_message_compression_algorithm);
-      gpr_log(GPR_ERROR, "%s", error_msg);
+    gpr_log(GPR_ERROR, "%s", error_msg);
-      cancel_with_status(exec_ctx, call, STATUS_FROM_SURFACE,
+    cancel_with_status(exec_ctx, call, STATUS_FROM_SURFACE,
-                         GRPC_STATUS_UNIMPLEMENTED, error_msg);
+                       GRPC_STATUS_INTERNAL, error_msg);
-    } else if (grpc_compression_options_is_stream_compression_algorithm_enabled(
-                   &compression_options, algo) == 0) {
-      /* check if algorithm is supported by current channel config */
-      char *algo_name = NULL;
-      grpc_stream_compression_algorithm_name(algo, &algo_name);
-      gpr_asprintf(&error_msg, "Stream compression algorithm '%s' is disabled.",
-                   algo_name);
-      gpr_log(GPR_ERROR, "%s", error_msg);
-      cancel_with_status(exec_ctx, call, STATUS_FROM_SURFACE,
-                         GRPC_STATUS_UNIMPLEMENTED, error_msg);
-    }
     gpr_free(error_msg);
-
+  } else if (
-    GPR_ASSERT(call->stream_encodings_accepted_by_peer != 0);
+      grpc_compression_algorithm_from_message_stream_compression_algorithm(
-    if (!GPR_BITGET(call->stream_encodings_accepted_by_peer,
+          &compression_algorithm, call->incoming_message_compression_algorithm,
-                    call->incoming_stream_compression_algorithm)) {
+          call->incoming_stream_compression_algorithm) == 0) {
-      if (GRPC_TRACER_ON(grpc_compression_trace)) {
+    char *error_msg = NULL;
-        char *algo_name = NULL;
+    gpr_asprintf(&error_msg,
-        grpc_stream_compression_algorithm_name(
+                 "Error in incoming message compression (%d) or stream "
-            call->incoming_stream_compression_algorithm, &algo_name);
+                 "compression (%d).",
-        gpr_log(
+                 call->incoming_stream_compression_algorithm,
-            GPR_ERROR,
+                 call->incoming_message_compression_algorithm);
-            "Stream compression algorithm (content-encoding = '%s') not "
+    cancel_with_status(exec_ctx, call, STATUS_FROM_SURFACE,
-            "present in the bitset of accepted encodings (accept-encodings: "
+                       GRPC_STATUS_INTERNAL, error_msg);
-            "'0x%x')",
+    gpr_free(error_msg);
-            algo_name, call->stream_encodings_accepted_by_peer);
+  } else {
-      }
-    }
-  } else if (call->incoming_compression_algorithm != GRPC_COMPRESS_NONE) {
-    const grpc_compression_algorithm algo =
-        call->incoming_compression_algorithm;
     char *error_msg = NULL;
     const grpc_compression_options compression_options =
         grpc_channel_compression_options(call->channel);
-    /* check if algorithm is known */
+    if (compression_algorithm >= GRPC_COMPRESS_ALGORITHMS_COUNT) {
-    if (algo >= GRPC_COMPRESS_ALGORITHMS_COUNT) {
       gpr_asprintf(&error_msg, "Invalid compression algorithm value '%d'.",
-                   algo);
+                   compression_algorithm);
       gpr_log(GPR_ERROR, "%s", error_msg);
       cancel_with_status(exec_ctx, call, STATUS_FROM_SURFACE,
                          GRPC_STATUS_UNIMPLEMENTED, error_msg);
     } else if (grpc_compression_options_is_algorithm_enabled(
-                   &compression_options, algo) == 0) {
+                   &compression_options, compression_algorithm) == 0) {
       /* check if algorithm is supported by current channel config */
       char *algo_name = NULL;
-      grpc_compression_algorithm_name(algo, &algo_name);
+      grpc_compression_algorithm_name(compression_algorithm, &algo_name);
       gpr_asprintf(&error_msg, "Compression algorithm '%s' is disabled.",
                    algo_name);
       gpr_log(GPR_ERROR, "%s", error_msg);
       cancel_with_status(exec_ctx, call, STATUS_FROM_SURFACE,
                          GRPC_STATUS_UNIMPLEMENTED, error_msg);
-    } else {
-      call->incoming_compression_algorithm = algo;
     }
     gpr_free(error_msg);
 
     GPR_ASSERT(call->encodings_accepted_by_peer != 0);
-    if (!GPR_BITGET(call->encodings_accepted_by_peer,
+    if (!GPR_BITGET(call->encodings_accepted_by_peer, compression_algorithm)) {
-                    call->incoming_compression_algorithm)) {
       if (GRPC_TRACER_ON(grpc_compression_trace)) {
         char *algo_name = NULL;
-        grpc_compression_algorithm_name(call->incoming_compression_algorithm,
+        grpc_compression_algorithm_name(compression_algorithm, &algo_name);
-                                        &algo_name);
         gpr_log(GPR_ERROR,
-                "Compression algorithm (grpc-encoding = '%s') not present in "
+                "Compression algorithm ('%s') not present in the bitset of "
-                "the bitset of accepted encodings (grpc-accept-encodings: "
+                "accepted encodings ('0x%x')",
-                "'0x%x')",
                 algo_name, call->encodings_accepted_by_peer);
       }
     }
@@ -1724,56 +1659,28 @@ static grpc_call_error call_start_batch(grpc_exec_ctx *exec_ctx,
         size_t additional_metadata_count = 0;
         grpc_compression_level effective_compression_level =
             GRPC_COMPRESS_LEVEL_NONE;
-        grpc_stream_compression_level effective_stream_compression_level =
-            GRPC_STREAM_COMPRESS_LEVEL_NONE;
         bool level_set = false;
-        bool stream_compression = false;
+        if (op->data.send_initial_metadata.maybe_compression_level.is_set) {
-        if (op->data.send_initial_metadata.maybe_stream_compression_level
-                .is_set) {
-          effective_stream_compression_level =
-              op->data.send_initial_metadata.maybe_stream_compression_level
-                  .level;
-          level_set = true;
-          stream_compression = true;
-        } else if (op->data.send_initial_metadata.maybe_compression_level
-                       .is_set) {
           effective_compression_level =
               op->data.send_initial_metadata.maybe_compression_level.level;
           level_set = true;
         } else {
           const grpc_compression_options copts =
               grpc_channel_compression_options(call->channel);
-          if (copts.default_stream_compression_level.is_set) {
+          if (copts.default_level.is_set) {
-            level_set = true;
-            effective_stream_compression_level =
-                copts.default_stream_compression_level.level;
-            stream_compression = true;
-          } else if (copts.default_level.is_set) {
             level_set = true;
             effective_compression_level = copts.default_level.level;
           }
         }
         if (level_set && !call->is_client) {
-          if (stream_compression) {
+          const grpc_compression_algorithm calgo =
-            const grpc_stream_compression_algorithm calgo =
+              compression_algorithm_for_level_locked(
-                stream_compression_algorithm_for_level_locked(
+                  call, effective_compression_level);
-                    call, effective_stream_compression_level);
+          /* the following will be picked up by the compress filter and used
-            call->compression_md.key =
+           * as the call's compression algorithm. */
-                GRPC_MDSTR_GRPC_INTERNAL_STREAM_ENCODING_REQUEST;
+          call->compression_md.key = GRPC_MDSTR_GRPC_INTERNAL_ENCODING_REQUEST;
-            call->compression_md.value =
+          call->compression_md.value = grpc_compression_algorithm_slice(calgo);
-                grpc_stream_compression_algorithm_slice(calgo);
+          additional_metadata_count++;
-          } else {
-            const grpc_compression_algorithm calgo =
-                compression_algorithm_for_level_locked(
-                    call, effective_compression_level);
-            /* the following will be picked up by the compress filter and used
-             * as the call's compression algorithm. */
-            call->compression_md.key =
-                GRPC_MDSTR_GRPC_INTERNAL_ENCODING_REQUEST;
-            call->compression_md.value =
-                grpc_compression_algorithm_slice(calgo);
-            additional_metadata_count++;
-          }
         }
 
         if (op->data.send_initial_metadata.count + additional_metadata_count >

src/core/lib/surface/call_test_only.h

@@ -25,7 +25,7 @@
 extern "C" {
 #endif
 
-/** Return the compression algorithm from \a call.
+/** Return the message compression algorithm from \a call.
  *
  * \warning This function should \b only be used in test code. */
 grpc_compression_algorithm grpc_call_test_only_get_compression_algorithm(
@@ -42,18 +42,6 @@ uint32_t grpc_call_test_only_get_message_flags(grpc_call *call);
  * To be indexed by grpc_compression_algorithm enum values. */
 uint32_t grpc_call_test_only_get_encodings_accepted_by_peer(grpc_call *call);
 
-/** Returns a bitset for the stream encodings (stream compression algorithms)
- * supported by \a call's peer.
- *
- * To be indexed by grpc_stream_compression_algorithm enum values. */
-uint32_t grpc_call_test_only_get_stream_encodings_accepted_by_peer(
-    grpc_call *call);
-
-/** Returns the incoming stream compression algorithm (content-encoding header)
- * received by a call. */
-grpc_stream_compression_algorithm
-grpc_call_test_only_get_incoming_stream_encodings(grpc_call *call);
-
 #ifdef __cplusplus
 }
 #endif

src/core/lib/surface/channel.c

@@ -141,16 +141,6 @@ grpc_channel *grpc_channel_create_with_builder(
               (grpc_integer_options){GRPC_COMPRESS_LEVEL_NONE,
                                      GRPC_COMPRESS_LEVEL_NONE,
                                      GRPC_COMPRESS_LEVEL_COUNT - 1});
-    } else if (0 == strcmp(args->args[i].key,
-                           GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_LEVEL)) {
-      channel->compression_options.default_stream_compression_level.is_set =
-          true;
-      channel->compression_options.default_stream_compression_level.level =
-          (grpc_stream_compression_level)grpc_channel_arg_get_integer(
-              &args->args[i],
-              (grpc_integer_options){GRPC_STREAM_COMPRESS_LEVEL_NONE,
-                                     GRPC_STREAM_COMPRESS_LEVEL_NONE,
-                                     GRPC_STREAM_COMPRESS_LEVEL_COUNT - 1});
     } else if (0 == strcmp(args->args[i].key,
                            GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM)) {
       channel->compression_options.default_algorithm.is_set = true;
@@ -159,31 +149,12 @@ grpc_channel *grpc_channel_create_with_builder(
               &args->args[i],
               (grpc_integer_options){GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
                                      GRPC_COMPRESS_ALGORITHMS_COUNT - 1});
-    } else if (0 == strcmp(args->args[i].key,
-                           GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM)) {
-      channel->compression_options.default_stream_compression_algorithm.is_set =
-          true;
-      channel->compression_options.default_stream_compression_algorithm
-          .algorithm =
-          (grpc_stream_compression_algorithm)grpc_channel_arg_get_integer(
-              &args->args[i],
-              (grpc_integer_options){
-                  GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_NONE,
-                  GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT - 1});
     } else if (0 ==
                strcmp(args->args[i].key,
                       GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET)) {
       channel->compression_options.enabled_algorithms_bitset =
           (uint32_t)args->args[i].value.integer |
           0x1; /* always support no compression */
-    } else if (0 ==
-               strcmp(
-                   args->args[i].key,
-                   GRPC_STREAM_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET)) {
-      channel->compression_options
-          .enabled_stream_compression_algorithms_bitset =
-          (uint32_t)args->args[i].value.integer |
-          0x1; /* always support no compression */
     }
   }
 

src/core/lib/transport/static_metadata.c

@@ -57,51 +57,53 @@ static uint8_t g_bytes[] = {
     112, 111, 110, 115, 101, 95,  109, 101, 115, 115, 97,  103, 101, 95,  98,
     121, 116, 101, 115, 47,  103, 114, 112, 99,  46,  108, 98,  46,  118, 49,
     46,  76,  111, 97,  100, 66,  97,  108, 97,  110, 99,  101, 114, 47,  66,
-    97,  108, 97,  110, 99,  101, 76,  111, 97,  100, 48,  49,  50,  105, 100,
+    97,  108, 97,  110, 99,  101, 76,  111, 97,  100, 109, 101, 115, 115, 97,
-    101, 110, 116, 105, 116, 121, 103, 122, 105, 112, 100, 101, 102, 108, 97,
+    103, 101, 47,  100, 101, 102, 108, 97,  116, 101, 109, 101, 115, 115, 97,
-    116, 101, 116, 114, 97,  105, 108, 101, 114, 115, 97,  112, 112, 108, 105,
+    103, 101, 47,  103, 122, 105, 112, 115, 116, 114, 101, 97,  109, 47,  103,
-    99,  97,  116, 105, 111, 110, 47,  103, 114, 112, 99,  80,  79,  83,  84,
+    122, 105, 112, 48,  49,  50,  105, 100, 101, 110, 116, 105, 116, 121, 103,
-    50,  48,  48,  52,  48,  52,  104, 116, 116, 112, 104, 116, 116, 112, 115,
+    122, 105, 112, 100, 101, 102, 108, 97,  116, 101, 116, 114, 97,  105, 108,
-    103, 114, 112, 99,  71,  69,  84,  80,  85,  84,  47,  47,  105, 110, 100,
+    101, 114, 115, 97,  112, 112, 108, 105, 99,  97,  116, 105, 111, 110, 47,
-    101, 120, 46,  104, 116, 109, 108, 50,  48,  52,  50,  48,  54,  51,  48,
+    103, 114, 112, 99,  80,  79,  83,  84,  50,  48,  48,  52,  48,  52,  104,
-    52,  52,  48,  48,  53,  48,  48,  97,  99,  99,  101, 112, 116, 45,  99,
+    116, 116, 112, 104, 116, 116, 112, 115, 103, 114, 112, 99,  71,  69,  84,
-    104, 97,  114, 115, 101, 116, 103, 122, 105, 112, 44,  32,  100, 101, 102,
+    80,  85,  84,  47,  47,  105, 110, 100, 101, 120, 46,  104, 116, 109, 108,
-    108, 97,  116, 101, 97,  99,  99,  101, 112, 116, 45,  108, 97,  110, 103,
+    50,  48,  52,  50,  48,  54,  51,  48,  52,  52,  48,  48,  53,  48,  48,
-    117, 97,  103, 101, 97,  99,  99,  101, 112, 116, 45,  114, 97,  110, 103,
+    97,  99,  99,  101, 112, 116, 45,  99,  104, 97,  114, 115, 101, 116, 103,
-    101, 115, 97,  99,  99,  101, 112, 116, 97,  99,  99,  101, 115, 115, 45,
+    122, 105, 112, 44,  32,  100, 101, 102, 108, 97,  116, 101, 97,  99,  99,
-    99,  111, 110, 116, 114, 111, 108, 45,  97,  108, 108, 111, 119, 45,  111,
+    101, 112, 116, 45,  108, 97,  110, 103, 117, 97,  103, 101, 97,  99,  99,
-    114, 105, 103, 105, 110, 97,  103, 101, 97,  108, 108, 111, 119, 97,  117,
+    101, 112, 116, 45,  114, 97,  110, 103, 101, 115, 97,  99,  99,  101, 112,
-    116, 104, 111, 114, 105, 122, 97,  116, 105, 111, 110, 99,  97,  99,  104,
+    116, 97,  99,  99,  101, 115, 115, 45,  99,  111, 110, 116, 114, 111, 108,
-    101, 45,  99,  111, 110, 116, 114, 111, 108, 99,  111, 110, 116, 101, 110,
+    45,  97,  108, 108, 111, 119, 45,  111, 114, 105, 103, 105, 110, 97,  103,
-    116, 45,  100, 105, 115, 112, 111, 115, 105, 116, 105, 111, 110, 99,  111,
+    101, 97,  108, 108, 111, 119, 97,  117, 116, 104, 111, 114, 105, 122, 97,
-    110, 116, 101, 110, 116, 45,  108, 97,  110, 103, 117, 97,  103, 101, 99,
+    116, 105, 111, 110, 99,  97,  99,  104, 101, 45,  99,  111, 110, 116, 114,
-    111, 110, 116, 101, 110, 116, 45,  108, 101, 110, 103, 116, 104, 99,  111,
+    111, 108, 99,  111, 110, 116, 101, 110, 116, 45,  100, 105, 115, 112, 111,
-    110, 116, 101, 110, 116, 45,  108, 111, 99,  97,  116, 105, 111, 110, 99,
+    115, 105, 116, 105, 111, 110, 99,  111, 110, 116, 101, 110, 116, 45,  108,
-    111, 110, 116, 101, 110, 116, 45,  114, 97,  110, 103, 101, 99,  111, 111,
+    97,  110, 103, 117, 97,  103, 101, 99,  111, 110, 116, 101, 110, 116, 45,
-    107, 105, 101, 100, 97,  116, 101, 101, 116, 97,  103, 101, 120, 112, 101,
+    108, 101, 110, 103, 116, 104, 99,  111, 110, 116, 101, 110, 116, 45,  108,
-    99,  116, 101, 120, 112, 105, 114, 101, 115, 102, 114, 111, 109, 105, 102,
+    111, 99,  97,  116, 105, 111, 110, 99,  111, 110, 116, 101, 110, 116, 45,
-    45,  109, 97,  116, 99,  104, 105, 102, 45,  109, 111, 100, 105, 102, 105,
+    114, 97,  110, 103, 101, 99,  111, 111, 107, 105, 101, 100, 97,  116, 101,
-    101, 100, 45,  115, 105, 110, 99,  101, 105, 102, 45,  110, 111, 110, 101,
+    101, 116, 97,  103, 101, 120, 112, 101, 99,  116, 101, 120, 112, 105, 114,
-    45,  109, 97,  116, 99,  104, 105, 102, 45,  114, 97,  110, 103, 101, 105,
+    101, 115, 102, 114, 111, 109, 105, 102, 45,  109, 97,  116, 99,  104, 105,
-    102, 45,  117, 110, 109, 111, 100, 105, 102, 105, 101, 100, 45,  115, 105,
+    102, 45,  109, 111, 100, 105, 102, 105, 101, 100, 45,  115, 105, 110, 99,
-    110, 99,  101, 108, 97,  115, 116, 45,  109, 111, 100, 105, 102, 105, 101,
+    101, 105, 102, 45,  110, 111, 110, 101, 45,  109, 97,  116, 99,  104, 105,
-    100, 108, 98,  45,  99,  111, 115, 116, 45,  98,  105, 110, 108, 105, 110,
+    102, 45,  114, 97,  110, 103, 101, 105, 102, 45,  117, 110, 109, 111, 100,
-    107, 108, 111, 99,  97,  116, 105, 111, 110, 109, 97,  120, 45,  102, 111,
+    105, 102, 105, 101, 100, 45,  115, 105, 110, 99,  101, 108, 97,  115, 116,
-    114, 119, 97,  114, 100, 115, 112, 114, 111, 120, 121, 45,  97,  117, 116,
+    45,  109, 111, 100, 105, 102, 105, 101, 100, 108, 98,  45,  99,  111, 115,
-    104, 101, 110, 116, 105, 99,  97,  116, 101, 112, 114, 111, 120, 121, 45,
+    116, 45,  98,  105, 110, 108, 105, 110, 107, 108, 111, 99,  97,  116, 105,
-    97,  117, 116, 104, 111, 114, 105, 122, 97,  116, 105, 111, 110, 114, 97,
+    111, 110, 109, 97,  120, 45,  102, 111, 114, 119, 97,  114, 100, 115, 112,
-    110, 103, 101, 114, 101, 102, 101, 114, 101, 114, 114, 101, 102, 114, 101,
+    114, 111, 120, 121, 45,  97,  117, 116, 104, 101, 110, 116, 105, 99,  97,
-    115, 104, 114, 101, 116, 114, 121, 45,  97,  102, 116, 101, 114, 115, 101,
+    116, 101, 112, 114, 111, 120, 121, 45,  97,  117, 116, 104, 111, 114, 105,
-    114, 118, 101, 114, 115, 101, 116, 45,  99,  111, 111, 107, 105, 101, 115,
+    122, 97,  116, 105, 111, 110, 114, 97,  110, 103, 101, 114, 101, 102, 101,
-    116, 114, 105, 99,  116, 45,  116, 114, 97,  110, 115, 112, 111, 114, 116,
+    114, 101, 114, 114, 101, 102, 114, 101, 115, 104, 114, 101, 116, 114, 121,
-    45,  115, 101, 99,  117, 114, 105, 116, 121, 116, 114, 97,  110, 115, 102,
+    45,  97,  102, 116, 101, 114, 115, 101, 114, 118, 101, 114, 115, 101, 116,
-    101, 114, 45,  101, 110, 99,  111, 100, 105, 110, 103, 118, 97,  114, 121,
+    45,  99,  111, 111, 107, 105, 101, 115, 116, 114, 105, 99,  116, 45,  116,
-    118, 105, 97,  119, 119, 119, 45,  97,  117, 116, 104, 101, 110, 116, 105,
+    114, 97,  110, 115, 112, 111, 114, 116, 45,  115, 101, 99,  117, 114, 105,
-    99,  97,  116, 101, 105, 100, 101, 110, 116, 105, 116, 121, 44,  100, 101,
+    116, 121, 116, 114, 97,  110, 115, 102, 101, 114, 45,  101, 110, 99,  111,
-    102, 108, 97,  116, 101, 105, 100, 101, 110, 116, 105, 116, 121, 44,  103,
+    100, 105, 110, 103, 118, 97,  114, 121, 118, 105, 97,  119, 119, 119, 45,
-    122, 105, 112, 100, 101, 102, 108, 97,  116, 101, 44,  103, 122, 105, 112,
+    97,  117, 116, 104, 101, 110, 116, 105, 99,  97,  116, 101, 105, 100, 101,
-    105, 100, 101, 110, 116, 105, 116, 121, 44,  100, 101, 102, 108, 97,  116,
+    110, 116, 105, 116, 121, 44,  100, 101, 102, 108, 97,  116, 101, 105, 100,
-    101, 44,  103, 122, 105, 112};
+    101, 110, 116, 105, 116, 121, 44,  103, 122, 105, 112, 100, 101, 102, 108,
+    97,  116, 101, 44,  103, 122, 105, 112, 105, 100, 101, 110, 116, 105, 116,
+    121, 44,  100, 101, 102, 108, 97,  116, 101, 44,  103, 122, 105, 112};
 
 static void static_ref(void *unused) {}
 static void static_unref(grpc_exec_ctx *exec_ctx, void *unused) {}
@@ -213,6 +215,9 @@ grpc_slice_refcount grpc_static_metadata_refcounts[GRPC_STATIC_MDSTR_COUNT] = {
     {&grpc_static_metadata_vtable, &static_sub_refcnt},
     {&grpc_static_metadata_vtable, &static_sub_refcnt},
     {&grpc_static_metadata_vtable, &static_sub_refcnt},
+    {&grpc_static_metadata_vtable, &static_sub_refcnt},
+    {&grpc_static_metadata_vtable, &static_sub_refcnt},
+    {&grpc_static_metadata_vtable, &static_sub_refcnt},
 };
 
 const grpc_slice grpc_static_slice_table[GRPC_STATIC_MDSTR_COUNT] = {
@@ -275,147 +280,153 @@ const grpc_slice grpc_static_slice_table[GRPC_STATIC_MDSTR_COUNT] = {
     {.refcount = &grpc_static_metadata_refcounts[28],
      .data.refcounted = {g_bytes + 394, 36}},
     {.refcount = &grpc_static_metadata_refcounts[29],
-     .data.refcounted = {g_bytes + 430, 1}},
+     .data.refcounted = {g_bytes + 430, 15}},
     {.refcount = &grpc_static_metadata_refcounts[30],
-     .data.refcounted = {g_bytes + 431, 1}},
+     .data.refcounted = {g_bytes + 445, 12}},
     {.refcount = &grpc_static_metadata_refcounts[31],
-     .data.refcounted = {g_bytes + 432, 1}},
+     .data.refcounted = {g_bytes + 457, 11}},
     {.refcount = &grpc_static_metadata_refcounts[32],
-     .data.refcounted = {g_bytes + 433, 8}},
+     .data.refcounted = {g_bytes + 468, 1}},
     {.refcount = &grpc_static_metadata_refcounts[33],
-     .data.refcounted = {g_bytes + 441, 4}},
+     .data.refcounted = {g_bytes + 469, 1}},
     {.refcount = &grpc_static_metadata_refcounts[34],
-     .data.refcounted = {g_bytes + 445, 7}},
+     .data.refcounted = {g_bytes + 470, 1}},
     {.refcount = &grpc_static_metadata_refcounts[35],
-     .data.refcounted = {g_bytes + 452, 8}},
+     .data.refcounted = {g_bytes + 471, 8}},
     {.refcount = &grpc_static_metadata_refcounts[36],
-     .data.refcounted = {g_bytes + 460, 16}},
+     .data.refcounted = {g_bytes + 479, 4}},
     {.refcount = &grpc_static_metadata_refcounts[37],
-     .data.refcounted = {g_bytes + 476, 4}},
+     .data.refcounted = {g_bytes + 483, 7}},
     {.refcount = &grpc_static_metadata_refcounts[38],
-     .data.refcounted = {g_bytes + 480, 3}},
+     .data.refcounted = {g_bytes + 490, 8}},
     {.refcount = &grpc_static_metadata_refcounts[39],
-     .data.refcounted = {g_bytes + 483, 3}},
+     .data.refcounted = {g_bytes + 498, 16}},
     {.refcount = &grpc_static_metadata_refcounts[40],
-     .data.refcounted = {g_bytes + 486, 4}},
+     .data.refcounted = {g_bytes + 514, 4}},
     {.refcount = &grpc_static_metadata_refcounts[41],
-     .data.refcounted = {g_bytes + 490, 5}},
+     .data.refcounted = {g_bytes + 518, 3}},
     {.refcount = &grpc_static_metadata_refcounts[42],
-     .data.refcounted = {g_bytes + 495, 4}},
+     .data.refcounted = {g_bytes + 521, 3}},
     {.refcount = &grpc_static_metadata_refcounts[43],
-     .data.refcounted = {g_bytes + 499, 3}},
+     .data.refcounted = {g_bytes + 524, 4}},
     {.refcount = &grpc_static_metadata_refcounts[44],
-     .data.refcounted = {g_bytes + 502, 3}},
+     .data.refcounted = {g_bytes + 528, 5}},
     {.refcount = &grpc_static_metadata_refcounts[45],
-     .data.refcounted = {g_bytes + 505, 1}},
+     .data.refcounted = {g_bytes + 533, 4}},
     {.refcount = &grpc_static_metadata_refcounts[46],
-     .data.refcounted = {g_bytes + 506, 11}},
+     .data.refcounted = {g_bytes + 537, 3}},
     {.refcount = &grpc_static_metadata_refcounts[47],
-     .data.refcounted = {g_bytes + 517, 3}},
+     .data.refcounted = {g_bytes + 540, 3}},
     {.refcount = &grpc_static_metadata_refcounts[48],
-     .data.refcounted = {g_bytes + 520, 3}},
+     .data.refcounted = {g_bytes + 543, 1}},
     {.refcount = &grpc_static_metadata_refcounts[49],
-     .data.refcounted = {g_bytes + 523, 3}},
+     .data.refcounted = {g_bytes + 544, 11}},
     {.refcount = &grpc_static_metadata_refcounts[50],
-     .data.refcounted = {g_bytes + 526, 3}},
+     .data.refcounted = {g_bytes + 555, 3}},
     {.refcount = &grpc_static_metadata_refcounts[51],
-     .data.refcounted = {g_bytes + 529, 3}},
+     .data.refcounted = {g_bytes + 558, 3}},
     {.refcount = &grpc_static_metadata_refcounts[52],
-     .data.refcounted = {g_bytes + 532, 14}},
+     .data.refcounted = {g_bytes + 561, 3}},
     {.refcount = &grpc_static_metadata_refcounts[53],
-     .data.refcounted = {g_bytes + 546, 13}},
+     .data.refcounted = {g_bytes + 564, 3}},
     {.refcount = &grpc_static_metadata_refcounts[54],
-     .data.refcounted = {g_bytes + 559, 15}},
+     .data.refcounted = {g_bytes + 567, 3}},
     {.refcount = &grpc_static_metadata_refcounts[55],
-     .data.refcounted = {g_bytes + 574, 13}},
+     .data.refcounted = {g_bytes + 570, 14}},
     {.refcount = &grpc_static_metadata_refcounts[56],
-     .data.refcounted = {g_bytes + 587, 6}},
+     .data.refcounted = {g_bytes + 584, 13}},
     {.refcount = &grpc_static_metadata_refcounts[57],
-     .data.refcounted = {g_bytes + 593, 27}},
+     .data.refcounted = {g_bytes + 597, 15}},
     {.refcount = &grpc_static_metadata_refcounts[58],
-     .data.refcounted = {g_bytes + 620, 3}},
+     .data.refcounted = {g_bytes + 612, 13}},
     {.refcount = &grpc_static_metadata_refcounts[59],
-     .data.refcounted = {g_bytes + 623, 5}},
+     .data.refcounted = {g_bytes + 625, 6}},
     {.refcount = &grpc_static_metadata_refcounts[60],
-     .data.refcounted = {g_bytes + 628, 13}},
+     .data.refcounted = {g_bytes + 631, 27}},
     {.refcount = &grpc_static_metadata_refcounts[61],
-     .data.refcounted = {g_bytes + 641, 13}},
+     .data.refcounted = {g_bytes + 658, 3}},
     {.refcount = &grpc_static_metadata_refcounts[62],
-     .data.refcounted = {g_bytes + 654, 19}},
+     .data.refcounted = {g_bytes + 661, 5}},
     {.refcount = &grpc_static_metadata_refcounts[63],
-     .data.refcounted = {g_bytes + 673, 16}},
+     .data.refcounted = {g_bytes + 666, 13}},
     {.refcount = &grpc_static_metadata_refcounts[64],
-     .data.refcounted = {g_bytes + 689, 14}},
+     .data.refcounted = {g_bytes + 679, 13}},
     {.refcount = &grpc_static_metadata_refcounts[65],
-     .data.refcounted = {g_bytes + 703, 16}},
+     .data.refcounted = {g_bytes + 692, 19}},
     {.refcount = &grpc_static_metadata_refcounts[66],
-     .data.refcounted = {g_bytes + 719, 13}},
+     .data.refcounted = {g_bytes + 711, 16}},
     {.refcount = &grpc_static_metadata_refcounts[67],
-     .data.refcounted = {g_bytes + 732, 6}},
+     .data.refcounted = {g_bytes + 727, 14}},
     {.refcount = &grpc_static_metadata_refcounts[68],
-     .data.refcounted = {g_bytes + 738, 4}},
+     .data.refcounted = {g_bytes + 741, 16}},
     {.refcount = &grpc_static_metadata_refcounts[69],
-     .data.refcounted = {g_bytes + 742, 4}},
+     .data.refcounted = {g_bytes + 757, 13}},
     {.refcount = &grpc_static_metadata_refcounts[70],
-     .data.refcounted = {g_bytes + 746, 6}},
+     .data.refcounted = {g_bytes + 770, 6}},
     {.refcount = &grpc_static_metadata_refcounts[71],
-     .data.refcounted = {g_bytes + 752, 7}},
+     .data.refcounted = {g_bytes + 776, 4}},
     {.refcount = &grpc_static_metadata_refcounts[72],
-     .data.refcounted = {g_bytes + 759, 4}},
+     .data.refcounted = {g_bytes + 780, 4}},
     {.refcount = &grpc_static_metadata_refcounts[73],
-     .data.refcounted = {g_bytes + 763, 8}},
+     .data.refcounted = {g_bytes + 784, 6}},
     {.refcount = &grpc_static_metadata_refcounts[74],
-     .data.refcounted = {g_bytes + 771, 17}},
+     .data.refcounted = {g_bytes + 790, 7}},
     {.refcount = &grpc_static_metadata_refcounts[75],
-     .data.refcounted = {g_bytes + 788, 13}},
+     .data.refcounted = {g_bytes + 797, 4}},
     {.refcount = &grpc_static_metadata_refcounts[76],
      .data.refcounted = {g_bytes + 801, 8}},
     {.refcount = &grpc_static_metadata_refcounts[77],
-     .data.refcounted = {g_bytes + 809, 19}},
+     .data.refcounted = {g_bytes + 809, 17}},
     {.refcount = &grpc_static_metadata_refcounts[78],
-     .data.refcounted = {g_bytes + 828, 13}},
+     .data.refcounted = {g_bytes + 826, 13}},
     {.refcount = &grpc_static_metadata_refcounts[79],
-     .data.refcounted = {g_bytes + 841, 11}},
+     .data.refcounted = {g_bytes + 839, 8}},
     {.refcount = &grpc_static_metadata_refcounts[80],
-     .data.refcounted = {g_bytes + 852, 4}},
+     .data.refcounted = {g_bytes + 847, 19}},
     {.refcount = &grpc_static_metadata_refcounts[81],
-     .data.refcounted = {g_bytes + 856, 8}},
+     .data.refcounted = {g_bytes + 866, 13}},
     {.refcount = &grpc_static_metadata_refcounts[82],
-     .data.refcounted = {g_bytes + 864, 12}},
+     .data.refcounted = {g_bytes + 879, 11}},
     {.refcount = &grpc_static_metadata_refcounts[83],
-     .data.refcounted = {g_bytes + 876, 18}},
+     .data.refcounted = {g_bytes + 890, 4}},
     {.refcount = &grpc_static_metadata_refcounts[84],
-     .data.refcounted = {g_bytes + 894, 19}},
+     .data.refcounted = {g_bytes + 894, 8}},
     {.refcount = &grpc_static_metadata_refcounts[85],
-     .data.refcounted = {g_bytes + 913, 5}},
+     .data.refcounted = {g_bytes + 902, 12}},
     {.refcount = &grpc_static_metadata_refcounts[86],
-     .data.refcounted = {g_bytes + 918, 7}},
+     .data.refcounted = {g_bytes + 914, 18}},
     {.refcount = &grpc_static_metadata_refcounts[87],
-     .data.refcounted = {g_bytes + 925, 7}},
+     .data.refcounted = {g_bytes + 932, 19}},
     {.refcount = &grpc_static_metadata_refcounts[88],
-     .data.refcounted = {g_bytes + 932, 11}},
+     .data.refcounted = {g_bytes + 951, 5}},
     {.refcount = &grpc_static_metadata_refcounts[89],
-     .data.refcounted = {g_bytes + 943, 6}},
+     .data.refcounted = {g_bytes + 956, 7}},
     {.refcount = &grpc_static_metadata_refcounts[90],
-     .data.refcounted = {g_bytes + 949, 10}},
+     .data.refcounted = {g_bytes + 963, 7}},
     {.refcount = &grpc_static_metadata_refcounts[91],
-     .data.refcounted = {g_bytes + 959, 25}},
+     .data.refcounted = {g_bytes + 970, 11}},
     {.refcount = &grpc_static_metadata_refcounts[92],
-     .data.refcounted = {g_bytes + 984, 17}},
+     .data.refcounted = {g_bytes + 981, 6}},
     {.refcount = &grpc_static_metadata_refcounts[93],
-     .data.refcounted = {g_bytes + 1001, 4}},
+     .data.refcounted = {g_bytes + 987, 10}},
     {.refcount = &grpc_static_metadata_refcounts[94],
-     .data.refcounted = {g_bytes + 1005, 3}},
+     .data.refcounted = {g_bytes + 997, 25}},
     {.refcount = &grpc_static_metadata_refcounts[95],
-     .data.refcounted = {g_bytes + 1008, 16}},
+     .data.refcounted = {g_bytes + 1022, 17}},
     {.refcount = &grpc_static_metadata_refcounts[96],
-     .data.refcounted = {g_bytes + 1024, 16}},
+     .data.refcounted = {g_bytes + 1039, 4}},
     {.refcount = &grpc_static_metadata_refcounts[97],
-     .data.refcounted = {g_bytes + 1040, 13}},
+     .data.refcounted = {g_bytes + 1043, 3}},
     {.refcount = &grpc_static_metadata_refcounts[98],
-     .data.refcounted = {g_bytes + 1053, 12}},
+     .data.refcounted = {g_bytes + 1046, 16}},
     {.refcount = &grpc_static_metadata_refcounts[99],
-     .data.refcounted = {g_bytes + 1065, 21}},
+     .data.refcounted = {g_bytes + 1062, 16}},
+    {.refcount = &grpc_static_metadata_refcounts[100],
+     .data.refcounted = {g_bytes + 1078, 13}},
+    {.refcount = &grpc_static_metadata_refcounts[101],
+     .data.refcounted = {g_bytes + 1091, 12}},
+    {.refcount = &grpc_static_metadata_refcounts[102],
+     .data.refcounted = {g_bytes + 1103, 21}},
 };
 
 uintptr_t grpc_static_mdelem_user_data[GRPC_STATIC_MDELEM_COUNT] = {
@@ -425,16 +436,16 @@ uintptr_t grpc_static_mdelem_user_data[GRPC_STATIC_MDELEM_COUNT] = {
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 4, 6, 6, 8, 8, 2, 4, 4};
 
 static const int8_t elems_r[] = {
-    11, 9,   -3, 0,   10,  27,  -74, 28,  0,   14, -7, 0,  0,  0,  18, 8,  -2,
+    11, 9,  -3, 0,  10,  25, -77, 26,  0,   11,  -7,  0,   0,  0,  21, 14, 1,
-    0,  0,   13, 12,  11,  0,   0,   0,   0,   0,  0,  0,  0,  0,  0,  0,  0,
+    0,  0,  33, 12, 11,  0,  0,   0,   0,   0,   0,   0,   0,  0,  0,  0,  0,
-    0,  0,   0,  0,   0,   0,   0,   0,   0,   0,  0,  0,  0,  0,  0,  0,  0,
+    0,  0,  0,  0,  0,   0,  0,   0,   0,   0,   0,   0,   0,  0,  0,  0,  0,
-    0,  -50, 0,  -33, -55, -56, -57, -58, -57, 0,  40, 39, 38, 37, 36, 35, 34,
+    0,  0,  0,  0,  -56, 0,  -36, -61, -60, -39, -63, -64, 0,  36, 35, 34, 33,
-    33, 32,  31, 30,  29,  28,  28,  27,  26,  25, 24, 23, 22, 21, 20, 19, 22,
+    34, 33, 32, 31, 31,  30, 29,  28,  27,  26,  26,  25,  25, 24, 23, 22, 21,
-    21, 20,  19, 18,  17,  16,  15,  14,  13,  12, 12, 11, 0};
+    20, 19, 22, 21, 20,  19, 18,  17,  16,  15,  14,  13,  12, 12, 11, 0};
 static uint32_t elems_phash(uint32_t i) {
-  i -= 45;
+  i -= 48;
-  uint32_t x = i % 98;
+  uint32_t x = i % 101;
-  uint32_t y = i / 98;
+  uint32_t y = i / 101;
   uint32_t h = x;
   if (y < GPR_ARRAY_SIZE(elems_r)) {
     uint32_t delta = (uint32_t)elems_r[y];
@@ -444,31 +455,31 @@ static uint32_t elems_phash(uint32_t i) {
 }
 
 static const uint16_t elem_keys[] = {
-    1032, 1033, 1034, 247,  248,  249,  250,  251,  1623, 143,  144,  45,
+    1065, 1066, 1067, 256,  257,  258,  259,  260,  1671,  149,   150,  48,
-    46,   440,  441,  442,  1523, 1632, 1633, 932,  933,  934,  729,  730,
+    49,   455,  456,  457,  962,  963,  964,  1568, 1683,  1684,  753,  754,
-    1423, 1532, 1533, 535,  731,  1923, 2023, 2123, 5223, 5523, 5623, 5723,
+    1465, 553,  755,  2083, 2186, 5688, 5997, 1580, 1581,  6100,  6306, 6409,
-    5823, 1436, 1653, 5923, 6023, 6123, 6223, 6323, 6423, 6523, 6623, 6723,
+    6512, 6615, 6718, 6821, 1481, 1704, 6924, 7027, 7130,  7233,  1980, 7336,
-    6823, 6923, 7023, 7123, 7223, 5423, 7323, 7423, 7523, 7623, 7723, 7823,
+    7439, 7542, 7645, 7748, 7851, 5894, 7954, 8057, 6203,  8160,  8263, 8366,
-    7923, 8023, 8123, 8223, 1096, 1097, 1098, 1099, 8323, 8423, 8523, 8623,
+    8469, 8572, 8675, 8778, 1129, 1130, 1131, 1132, 8881,  8984,  9087, 9190,
-    8723, 8823, 8923, 9023, 9123, 9223, 9323, 323,  9423, 9523, 1697, 0,
+    9293, 9396, 9499, 9602, 9705, 9808, 9911, 332,  10014, 10117, 0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    1748, 0,    0,    0,    0,    0,    0,    0,     0,     0,    0,
-    0,    0,    0,    0,    0,    0,    0,    137,  238,  239,  0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,     0,     143,  247,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    248,  0,    0,    0,    0,    0,    0,    0,    0,     0,     0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,     0,     0,    0,
-    0,    0,    0,    0,    0};
+    0,    0,    0,    0};
 static const uint8_t elem_idxs[] = {
     76,  79,  77,  19,  20,  21,  22,  23,  25,  15,  16,  17,  18,  11,
-    12,  13,  38,  83,  84,  3,   4,   5,   0,   1,   43,  36,  37,  6,
+    12,  13,  3,   4,   5,   38,  83,  84,  0,   1,   43,  6,   2,   50,
-    2,   72,  50,  57,  24,  28,  29,  30,  31,  7,   26,  32,  33,  34,
+    57,  24,  28,  36,  37,  29,  31,  32,  33,  34,  35,  39,  7,   26,
-    35,  39,  40,  41,  42,  44,  45,  46,  47,  48,  49,  27,  51,  52,
+    40,  41,  42,  44,  72,  45,  46,  47,  48,  49,  51,  27,  52,  53,
-    53,  54,  55,  56,  58,  59,  60,  61,  78,  80,  81,  82,  62,  63,
+    30,  54,  55,  56,  58,  59,  60,  61,  78,  80,  81,  82,  62,  63,
-    64,  65,  66,  67,  68,  69,  70,  71,  73,  14,  74,  75,  85,  255,
+    64,  65,  66,  67,  68,  69,  70,  71,  73,  14,  74,  75,  255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 85,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 8,   9,   10};
+    255, 255, 255, 255, 255, 255, 255, 255, 8,   9,   10};
 
 grpc_mdelem grpc_static_mdelem_for_static_strings(int a, int b) {
   if (a == -1 || b == -1) return GRPC_MDNULL;
-  uint32_t k = (uint32_t)(a * 100 + b);
+  uint32_t k = (uint32_t)(a * 103 + b);
   uint32_t h = elems_phash(k);
   return h < GPR_ARRAY_SIZE(elem_keys) && elem_keys[h] == k &&
                  elem_idxs[h] != 255
@@ -480,102 +491,102 @@ grpc_mdelem grpc_static_mdelem_for_static_strings(int a, int b) {
 grpc_mdelem_data grpc_static_mdelem_table[GRPC_STATIC_MDELEM_COUNT] = {
     {{.refcount = &grpc_static_metadata_refcounts[7],
       .data.refcounted = {g_bytes + 50, 11}},
-     {.refcount = &grpc_static_metadata_refcounts[29],
+     {.refcount = &grpc_static_metadata_refcounts[32],
-      .data.refcounted = {g_bytes + 430, 1}}},
+      .data.refcounted = {g_bytes + 468, 1}}},
     {{.refcount = &grpc_static_metadata_refcounts[7],
       .data.refcounted = {g_bytes + 50, 11}},
-     {.refcount = &grpc_static_metadata_refcounts[30],
+     {.refcount = &grpc_static_metadata_refcounts[33],
-      .data.refcounted = {g_bytes + 431, 1}}},
+      .data.refcounted = {g_bytes + 469, 1}}},
     {{.refcount = &grpc_static_metadata_refcounts[7],
       .data.refcounted = {g_bytes + 50, 11}},
-     {.refcount = &grpc_static_metadata_refcounts[31],
+     {.refcount = &grpc_static_metadata_refcounts[34],
-      .data.refcounted = {g_bytes + 432, 1}}},
+      .data.refcounted = {g_bytes + 470, 1}}},
     {{.refcount = &grpc_static_metadata_refcounts[9],
       .data.refcounted = {g_bytes + 77, 13}},
-     {.refcount = &grpc_static_metadata_refcounts[32],
+     {.refcount = &grpc_static_metadata_refcounts[35],
-      .data.refcounted = {g_bytes + 433, 8}}},
+      .data.refcounted = {g_bytes + 471, 8}}},
     {{.refcount = &grpc_static_metadata_refcounts[9],
       .data.refcounted = {g_bytes + 77, 13}},
-     {.refcount = &grpc_static_metadata_refcounts[33],
+     {.refcount = &grpc_static_metadata_refcounts[36],
-      .data.refcounted = {g_bytes + 441, 4}}},
+      .data.refcounted = {g_bytes + 479, 4}}},
     {{.refcount = &grpc_static_metadata_refcounts[9],
       .data.refcounted = {g_bytes + 77, 13}},
-     {.refcount = &grpc_static_metadata_refcounts[34],
+     {.refcount = &grpc_static_metadata_refcounts[37],
-      .data.refcounted = {g_bytes + 445, 7}}},
+      .data.refcounted = {g_bytes + 483, 7}}},
     {{.refcount = &grpc_static_metadata_refcounts[5],
       .data.refcounted = {g_bytes + 36, 2}},
-     {.refcount = &grpc_static_metadata_refcounts[35],
+     {.refcount = &grpc_static_metadata_refcounts[38],
-      .data.refcounted = {g_bytes + 452, 8}}},
+      .data.refcounted = {g_bytes + 490, 8}}},
     {{.refcount = &grpc_static_metadata_refcounts[14],
       .data.refcounted = {g_bytes + 158, 12}},
-     {.refcount = &grpc_static_metadata_refcounts[36],
+     {.refcount = &grpc_static_metadata_refcounts[39],
-      .data.refcounted = {g_bytes + 460, 16}}},
+      .data.refcounted = {g_bytes + 498, 16}}},
     {{.refcount = &grpc_static_metadata_refcounts[1],
       .data.refcounted = {g_bytes + 5, 7}},
-     {.refcount = &grpc_static_metadata_refcounts[37],
+     {.refcount = &grpc_static_metadata_refcounts[40],
-      .data.refcounted = {g_bytes + 476, 4}}},
+      .data.refcounted = {g_bytes + 514, 4}}},
     {{.refcount = &grpc_static_metadata_refcounts[2],
       .data.refcounted = {g_bytes + 12, 7}},
-     {.refcount = &grpc_static_metadata_refcounts[38],
+     {.refcount = &grpc_static_metadata_refcounts[41],
-      .data.refcounted = {g_bytes + 480, 3}}},
+      .data.refcounted = {g_bytes + 518, 3}}},
     {{.refcount = &grpc_static_metadata_refcounts[2],
       .data.refcounted = {g_bytes + 12, 7}},
-     {.refcount = &grpc_static_metadata_refcounts[39],
+     {.refcount = &grpc_static_metadata_refcounts[42],
-      .data.refcounted = {g_bytes + 483, 3}}},
+      .data.refcounted = {g_bytes + 521, 3}}},
     {{.refcount = &grpc_static_metadata_refcounts[4],
       .data.refcounted = {g_bytes + 29, 7}},
-     {.refcount = &grpc_static_metadata_refcounts[40],
+     {.refcount = &grpc_static_metadata_refcounts[43],
-      .data.refcounted = {g_bytes + 486, 4}}},
+      .data.refcounted = {g_bytes + 524, 4}}},
     {{.refcount = &grpc_static_metadata_refcounts[4],
       .data.refcounted = {g_bytes + 29, 7}},
-     {.refcount = &grpc_static_metadata_refcounts[41],
+     {.refcount = &grpc_static_metadata_refcounts[44],
-      .data.refcounted = {g_bytes + 490, 5}}},
+      .data.refcounted = {g_bytes + 528, 5}}},
     {{.refcount = &grpc_static_metadata_refcounts[4],
       .data.refcounted = {g_bytes + 29, 7}},
-     {.refcount = &grpc_static_metadata_refcounts[42],
+     {.refcount = &grpc_static_metadata_refcounts[45],
-      .data.refcounted = {g_bytes + 495, 4}}},
+      .data.refcounted = {g_bytes + 533, 4}}},
     {{.refcount = &grpc_static_metadata_refcounts[3],
       .data.refcounted = {g_bytes + 19, 10}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[1],
       .data.refcounted = {g_bytes + 5, 7}},
-     {.refcount = &grpc_static_metadata_refcounts[43],
+     {.refcount = &grpc_static_metadata_refcounts[46],
-      .data.refcounted = {g_bytes + 499, 3}}},
+      .data.refcounted = {g_bytes + 537, 3}}},
     {{.refcount = &grpc_static_metadata_refcounts[1],
       .data.refcounted = {g_bytes + 5, 7}},
-     {.refcount = &grpc_static_metadata_refcounts[44],
+     {.refcount = &grpc_static_metadata_refcounts[47],
-      .data.refcounted = {g_bytes + 502, 3}}},
+      .data.refcounted = {g_bytes + 540, 3}}},
     {{.refcount = &grpc_static_metadata_refcounts[0],
       .data.refcounted = {g_bytes + 0, 5}},
-     {.refcount = &grpc_static_metadata_refcounts[45],
+     {.refcount = &grpc_static_metadata_refcounts[48],
-      .data.refcounted = {g_bytes + 505, 1}}},
+      .data.refcounted = {g_bytes + 543, 1}}},
     {{.refcount = &grpc_static_metadata_refcounts[0],
       .data.refcounted = {g_bytes + 0, 5}},
-     {.refcount = &grpc_static_metadata_refcounts[46],
+     {.refcount = &grpc_static_metadata_refcounts[49],
-      .data.refcounted = {g_bytes + 506, 11}}},
+      .data.refcounted = {g_bytes + 544, 11}}},
     {{.refcount = &grpc_static_metadata_refcounts[2],
       .data.refcounted = {g_bytes + 12, 7}},
-     {.refcount = &grpc_static_metadata_refcounts[47],
+     {.refcount = &grpc_static_metadata_refcounts[50],
-      .data.refcounted = {g_bytes + 517, 3}}},
+      .data.refcounted = {g_bytes + 555, 3}}},
     {{.refcount = &grpc_static_metadata_refcounts[2],
       .data.refcounted = {g_bytes + 12, 7}},
-     {.refcount = &grpc_static_metadata_refcounts[48],
+     {.refcount = &grpc_static_metadata_refcounts[51],
-      .data.refcounted = {g_bytes + 520, 3}}},
+      .data.refcounted = {g_bytes + 558, 3}}},
     {{.refcount = &grpc_static_metadata_refcounts[2],
       .data.refcounted = {g_bytes + 12, 7}},
-     {.refcount = &grpc_static_metadata_refcounts[49],
+     {.refcount = &grpc_static_metadata_refcounts[52],
-      .data.refcounted = {g_bytes + 523, 3}}},
+      .data.refcounted = {g_bytes + 561, 3}}},
     {{.refcount = &grpc_static_metadata_refcounts[2],
       .data.refcounted = {g_bytes + 12, 7}},
-     {.refcount = &grpc_static_metadata_refcounts[50],
+     {.refcount = &grpc_static_metadata_refcounts[53],
-      .data.refcounted = {g_bytes + 526, 3}}},
+      .data.refcounted = {g_bytes + 564, 3}}},
     {{.refcount = &grpc_static_metadata_refcounts[2],
       .data.refcounted = {g_bytes + 12, 7}},
-     {.refcount = &grpc_static_metadata_refcounts[51],
+     {.refcount = &grpc_static_metadata_refcounts[54],
-      .data.refcounted = {g_bytes + 529, 3}}},
+      .data.refcounted = {g_bytes + 567, 3}}},
-    {{.refcount = &grpc_static_metadata_refcounts[52],
+    {{.refcount = &grpc_static_metadata_refcounts[55],
-      .data.refcounted = {g_bytes + 532, 14}},
+      .data.refcounted = {g_bytes + 570, 14}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[16],
@@ -584,114 +595,102 @@ grpc_mdelem_data grpc_static_mdelem_table[GRPC_STATIC_MDELEM_COUNT] = {
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[16],
       .data.refcounted = {g_bytes + 186, 15}},
-     {.refcount = &grpc_static_metadata_refcounts[53],
+     {.refcount = &grpc_static_metadata_refcounts[56],
-      .data.refcounted = {g_bytes + 546, 13}}},
+      .data.refcounted = {g_bytes + 584, 13}}},
-    {{.refcount = &grpc_static_metadata_refcounts[54],
-      .data.refcounted = {g_bytes + 559, 15}},
-     {.refcount = &grpc_static_metadata_refcounts[23],
-      .data.refcounted = {g_bytes + 302, 0}}},
-    {{.refcount = &grpc_static_metadata_refcounts[55],
-      .data.refcounted = {g_bytes + 574, 13}},
-     {.refcount = &grpc_static_metadata_refcounts[23],
-      .data.refcounted = {g_bytes + 302, 0}}},
-    {{.refcount = &grpc_static_metadata_refcounts[56],
-      .data.refcounted = {g_bytes + 587, 6}},
-     {.refcount = &grpc_static_metadata_refcounts[23],
-      .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[57],
-      .data.refcounted = {g_bytes + 593, 27}},
+      .data.refcounted = {g_bytes + 597, 15}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[58],
-      .data.refcounted = {g_bytes + 620, 3}},
+      .data.refcounted = {g_bytes + 612, 13}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[59],
-      .data.refcounted = {g_bytes + 623, 5}},
+      .data.refcounted = {g_bytes + 625, 6}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[60],
-      .data.refcounted = {g_bytes + 628, 13}},
+      .data.refcounted = {g_bytes + 631, 27}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[61],
-      .data.refcounted = {g_bytes + 641, 13}},
+      .data.refcounted = {g_bytes + 658, 3}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[62],
-      .data.refcounted = {g_bytes + 654, 19}},
+      .data.refcounted = {g_bytes + 661, 5}},
-     {.refcount = &grpc_static_metadata_refcounts[23],
-      .data.refcounted = {g_bytes + 302, 0}}},
-    {{.refcount = &grpc_static_metadata_refcounts[15],
-      .data.refcounted = {g_bytes + 170, 16}},
-     {.refcount = &grpc_static_metadata_refcounts[32],
-      .data.refcounted = {g_bytes + 433, 8}}},
-    {{.refcount = &grpc_static_metadata_refcounts[15],
-      .data.refcounted = {g_bytes + 170, 16}},
-     {.refcount = &grpc_static_metadata_refcounts[33],
-      .data.refcounted = {g_bytes + 441, 4}}},
-    {{.refcount = &grpc_static_metadata_refcounts[15],
-      .data.refcounted = {g_bytes + 170, 16}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[63],
-      .data.refcounted = {g_bytes + 673, 16}},
+      .data.refcounted = {g_bytes + 666, 13}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[64],
-      .data.refcounted = {g_bytes + 689, 14}},
+      .data.refcounted = {g_bytes + 679, 13}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[65],
-      .data.refcounted = {g_bytes + 703, 16}},
+      .data.refcounted = {g_bytes + 692, 19}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
-    {{.refcount = &grpc_static_metadata_refcounts[66],
+    {{.refcount = &grpc_static_metadata_refcounts[15],
-      .data.refcounted = {g_bytes + 719, 13}},
+      .data.refcounted = {g_bytes + 170, 16}},
+     {.refcount = &grpc_static_metadata_refcounts[35],
+      .data.refcounted = {g_bytes + 471, 8}}},
+    {{.refcount = &grpc_static_metadata_refcounts[15],
+      .data.refcounted = {g_bytes + 170, 16}},
+     {.refcount = &grpc_static_metadata_refcounts[36],
+      .data.refcounted = {g_bytes + 479, 4}}},
+    {{.refcount = &grpc_static_metadata_refcounts[15],
+      .data.refcounted = {g_bytes + 170, 16}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
-    {{.refcount = &grpc_static_metadata_refcounts[14],
+    {{.refcount = &grpc_static_metadata_refcounts[66],
-      .data.refcounted = {g_bytes + 158, 12}},
+      .data.refcounted = {g_bytes + 711, 16}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[67],
-      .data.refcounted = {g_bytes + 732, 6}},
+      .data.refcounted = {g_bytes + 727, 14}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[68],
-      .data.refcounted = {g_bytes + 738, 4}},
+      .data.refcounted = {g_bytes + 741, 16}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[69],
-      .data.refcounted = {g_bytes + 742, 4}},
+      .data.refcounted = {g_bytes + 757, 13}},
+     {.refcount = &grpc_static_metadata_refcounts[23],
+      .data.refcounted = {g_bytes + 302, 0}}},
+    {{.refcount = &grpc_static_metadata_refcounts[14],
+      .data.refcounted = {g_bytes + 158, 12}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[70],
-      .data.refcounted = {g_bytes + 746, 6}},
+      .data.refcounted = {g_bytes + 770, 6}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[71],
-      .data.refcounted = {g_bytes + 752, 7}},
+      .data.refcounted = {g_bytes + 776, 4}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[72],
-      .data.refcounted = {g_bytes + 759, 4}},
+      .data.refcounted = {g_bytes + 780, 4}},
-     {.refcount = &grpc_static_metadata_refcounts[23],
-      .data.refcounted = {g_bytes + 302, 0}}},
-    {{.refcount = &grpc_static_metadata_refcounts[20],
-      .data.refcounted = {g_bytes + 278, 4}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[73],
-      .data.refcounted = {g_bytes + 763, 8}},
+      .data.refcounted = {g_bytes + 784, 6}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[74],
-      .data.refcounted = {g_bytes + 771, 17}},
+      .data.refcounted = {g_bytes + 790, 7}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[75],
-      .data.refcounted = {g_bytes + 788, 13}},
+      .data.refcounted = {g_bytes + 797, 4}},
+     {.refcount = &grpc_static_metadata_refcounts[23],
+      .data.refcounted = {g_bytes + 302, 0}}},
+    {{.refcount = &grpc_static_metadata_refcounts[20],
+      .data.refcounted = {g_bytes + 278, 4}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[76],
@@ -699,129 +698,141 @@ grpc_mdelem_data grpc_static_mdelem_table[GRPC_STATIC_MDELEM_COUNT] = {
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[77],
-      .data.refcounted = {g_bytes + 809, 19}},
+      .data.refcounted = {g_bytes + 809, 17}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[78],
-      .data.refcounted = {g_bytes + 828, 13}},
+      .data.refcounted = {g_bytes + 826, 13}},
-     {.refcount = &grpc_static_metadata_refcounts[23],
-      .data.refcounted = {g_bytes + 302, 0}}},
-    {{.refcount = &grpc_static_metadata_refcounts[21],
-      .data.refcounted = {g_bytes + 282, 8}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[79],
-      .data.refcounted = {g_bytes + 841, 11}},
+      .data.refcounted = {g_bytes + 839, 8}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[80],
-      .data.refcounted = {g_bytes + 852, 4}},
+      .data.refcounted = {g_bytes + 847, 19}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[81],
-      .data.refcounted = {g_bytes + 856, 8}},
+      .data.refcounted = {g_bytes + 866, 13}},
+     {.refcount = &grpc_static_metadata_refcounts[23],
+      .data.refcounted = {g_bytes + 302, 0}}},
+    {{.refcount = &grpc_static_metadata_refcounts[21],
+      .data.refcounted = {g_bytes + 282, 8}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[82],
-      .data.refcounted = {g_bytes + 864, 12}},
+      .data.refcounted = {g_bytes + 879, 11}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[83],
-      .data.refcounted = {g_bytes + 876, 18}},
+      .data.refcounted = {g_bytes + 890, 4}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[84],
-      .data.refcounted = {g_bytes + 894, 19}},
+      .data.refcounted = {g_bytes + 894, 8}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[85],
-      .data.refcounted = {g_bytes + 913, 5}},
+      .data.refcounted = {g_bytes + 902, 12}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[86],
-      .data.refcounted = {g_bytes + 918, 7}},
+      .data.refcounted = {g_bytes + 914, 18}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[87],
-      .data.refcounted = {g_bytes + 925, 7}},
+      .data.refcounted = {g_bytes + 932, 19}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[88],
-      .data.refcounted = {g_bytes + 932, 11}},
+      .data.refcounted = {g_bytes + 951, 5}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[89],
-      .data.refcounted = {g_bytes + 943, 6}},
+      .data.refcounted = {g_bytes + 956, 7}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[90],
-      .data.refcounted = {g_bytes + 949, 10}},
+      .data.refcounted = {g_bytes + 963, 7}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[91],
-      .data.refcounted = {g_bytes + 959, 25}},
+      .data.refcounted = {g_bytes + 970, 11}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[92],
-      .data.refcounted = {g_bytes + 984, 17}},
+      .data.refcounted = {g_bytes + 981, 6}},
+     {.refcount = &grpc_static_metadata_refcounts[23],
+      .data.refcounted = {g_bytes + 302, 0}}},
+    {{.refcount = &grpc_static_metadata_refcounts[93],
+      .data.refcounted = {g_bytes + 987, 10}},
+     {.refcount = &grpc_static_metadata_refcounts[23],
+      .data.refcounted = {g_bytes + 302, 0}}},
+    {{.refcount = &grpc_static_metadata_refcounts[94],
+      .data.refcounted = {g_bytes + 997, 25}},
+     {.refcount = &grpc_static_metadata_refcounts[23],
+      .data.refcounted = {g_bytes + 302, 0}}},
+    {{.refcount = &grpc_static_metadata_refcounts[95],
+      .data.refcounted = {g_bytes + 1022, 17}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[19],
       .data.refcounted = {g_bytes + 268, 10}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
-    {{.refcount = &grpc_static_metadata_refcounts[93],
+    {{.refcount = &grpc_static_metadata_refcounts[96],
-      .data.refcounted = {g_bytes + 1001, 4}},
+      .data.refcounted = {g_bytes + 1039, 4}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
-    {{.refcount = &grpc_static_metadata_refcounts[94],
+    {{.refcount = &grpc_static_metadata_refcounts[97],
-      .data.refcounted = {g_bytes + 1005, 3}},
+      .data.refcounted = {g_bytes + 1043, 3}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
-    {{.refcount = &grpc_static_metadata_refcounts[95],
+    {{.refcount = &grpc_static_metadata_refcounts[98],
-      .data.refcounted = {g_bytes + 1008, 16}},
+      .data.refcounted = {g_bytes + 1046, 16}},
      {.refcount = &grpc_static_metadata_refcounts[23],
       .data.refcounted = {g_bytes + 302, 0}}},
     {{.refcount = &grpc_static_metadata_refcounts[10],
       .data.refcounted = {g_bytes + 90, 20}},
-     {.refcount = &grpc_static_metadata_refcounts[32],
+     {.refcount = &grpc_static_metadata_refcounts[35],
-      .data.refcounted = {g_bytes + 433, 8}}},
+      .data.refcounted = {g_bytes + 471, 8}}},
     {{.refcount = &grpc_static_metadata_refcounts[10],
       .data.refcounted = {g_bytes + 90, 20}},
-     {.refcount = &grpc_static_metadata_refcounts[34],
+     {.refcount = &grpc_static_metadata_refcounts[37],
-      .data.refcounted = {g_bytes + 445, 7}}},
+      .data.refcounted = {g_bytes + 483, 7}}},
     {{.refcount = &grpc_static_metadata_refcounts[10],
       .data.refcounted = {g_bytes + 90, 20}},
-     {.refcount = &grpc_static_metadata_refcounts[96],
+     {.refcount = &grpc_static_metadata_refcounts[99],
-      .data.refcounted = {g_bytes + 1024, 16}}},
+      .data.refcounted = {g_bytes + 1062, 16}}},
     {{.refcount = &grpc_static_metadata_refcounts[10],
       .data.refcounted = {g_bytes + 90, 20}},
-     {.refcount = &grpc_static_metadata_refcounts[33],
+     {.refcount = &grpc_static_metadata_refcounts[36],
-      .data.refcounted = {g_bytes + 441, 4}}},
+      .data.refcounted = {g_bytes + 479, 4}}},
     {{.refcount = &grpc_static_metadata_refcounts[10],
       .data.refcounted = {g_bytes + 90, 20}},
-     {.refcount = &grpc_static_metadata_refcounts[97],
+     {.refcount = &grpc_static_metadata_refcounts[100],
-      .data.refcounted = {g_bytes + 1040, 13}}},
+      .data.refcounted = {g_bytes + 1078, 13}}},
     {{.refcount = &grpc_static_metadata_refcounts[10],
       .data.refcounted = {g_bytes + 90, 20}},
-     {.refcount = &grpc_static_metadata_refcounts[98],
+     {.refcount = &grpc_static_metadata_refcounts[101],
-      .data.refcounted = {g_bytes + 1053, 12}}},
+      .data.refcounted = {g_bytes + 1091, 12}}},
     {{.refcount = &grpc_static_metadata_refcounts[10],
       .data.refcounted = {g_bytes + 90, 20}},
-     {.refcount = &grpc_static_metadata_refcounts[99],
+     {.refcount = &grpc_static_metadata_refcounts[102],
-      .data.refcounted = {g_bytes + 1065, 21}}},
+      .data.refcounted = {g_bytes + 1103, 21}}},
     {{.refcount = &grpc_static_metadata_refcounts[16],
       .data.refcounted = {g_bytes + 186, 15}},
-     {.refcount = &grpc_static_metadata_refcounts[32],
+     {.refcount = &grpc_static_metadata_refcounts[35],
-      .data.refcounted = {g_bytes + 433, 8}}},
+      .data.refcounted = {g_bytes + 471, 8}}},
     {{.refcount = &grpc_static_metadata_refcounts[16],
       .data.refcounted = {g_bytes + 186, 15}},
-     {.refcount = &grpc_static_metadata_refcounts[33],
+     {.refcount = &grpc_static_metadata_refcounts[36],
-      .data.refcounted = {g_bytes + 441, 4}}},
+      .data.refcounted = {g_bytes + 479, 4}}},
     {{.refcount = &grpc_static_metadata_refcounts[16],
       .data.refcounted = {g_bytes + 186, 15}},
-     {.refcount = &grpc_static_metadata_refcounts[97],
+     {.refcount = &grpc_static_metadata_refcounts[100],
-      .data.refcounted = {g_bytes + 1040, 13}}},
+      .data.refcounted = {g_bytes + 1078, 13}}},
 };
 bool grpc_static_callout_is_default[GRPC_BATCH_CALLOUTS_COUNT] = {
     true,  // :path

src/core/lib/transport/static_metadata.h

@@ -29,7 +29,7 @@
 
 #include "src/core/lib/transport/metadata.h"
 
-#define GRPC_STATIC_MDSTR_COUNT 100
+#define GRPC_STATIC_MDSTR_COUNT 103
 extern const grpc_slice grpc_static_slice_table[GRPC_STATIC_MDSTR_COUNT];
 /* ":path" */
 #define GRPC_MDSTR_PATH (grpc_static_slice_table[0])
@@ -93,149 +93,155 @@ extern const grpc_slice grpc_static_slice_table[GRPC_STATIC_MDSTR_COUNT];
 /* "/grpc.lb.v1.LoadBalancer/BalanceLoad" */
 #define GRPC_MDSTR_SLASH_GRPC_DOT_LB_DOT_V1_DOT_LOADBALANCER_SLASH_BALANCELOAD \
   (grpc_static_slice_table[28])
+/* "message/deflate" */
+#define GRPC_MDSTR_MESSAGE_SLASH_DEFLATE (grpc_static_slice_table[29])
+/* "message/gzip" */
+#define GRPC_MDSTR_MESSAGE_SLASH_GZIP (grpc_static_slice_table[30])
+/* "stream/gzip" */
+#define GRPC_MDSTR_STREAM_SLASH_GZIP (grpc_static_slice_table[31])
 /* "0" */
-#define GRPC_MDSTR_0 (grpc_static_slice_table[29])
+#define GRPC_MDSTR_0 (grpc_static_slice_table[32])
 /* "1" */
-#define GRPC_MDSTR_1 (grpc_static_slice_table[30])
+#define GRPC_MDSTR_1 (grpc_static_slice_table[33])
 /* "2" */
-#define GRPC_MDSTR_2 (grpc_static_slice_table[31])
+#define GRPC_MDSTR_2 (grpc_static_slice_table[34])
 /* "identity" */
-#define GRPC_MDSTR_IDENTITY (grpc_static_slice_table[32])
+#define GRPC_MDSTR_IDENTITY (grpc_static_slice_table[35])
 /* "gzip" */
-#define GRPC_MDSTR_GZIP (grpc_static_slice_table[33])
+#define GRPC_MDSTR_GZIP (grpc_static_slice_table[36])
 /* "deflate" */
-#define GRPC_MDSTR_DEFLATE (grpc_static_slice_table[34])
+#define GRPC_MDSTR_DEFLATE (grpc_static_slice_table[37])
 /* "trailers" */
-#define GRPC_MDSTR_TRAILERS (grpc_static_slice_table[35])
+#define GRPC_MDSTR_TRAILERS (grpc_static_slice_table[38])
 /* "application/grpc" */
-#define GRPC_MDSTR_APPLICATION_SLASH_GRPC (grpc_static_slice_table[36])
+#define GRPC_MDSTR_APPLICATION_SLASH_GRPC (grpc_static_slice_table[39])
 /* "POST" */
-#define GRPC_MDSTR_POST (grpc_static_slice_table[37])
+#define GRPC_MDSTR_POST (grpc_static_slice_table[40])
 /* "200" */
-#define GRPC_MDSTR_200 (grpc_static_slice_table[38])
+#define GRPC_MDSTR_200 (grpc_static_slice_table[41])
 /* "404" */
-#define GRPC_MDSTR_404 (grpc_static_slice_table[39])
+#define GRPC_MDSTR_404 (grpc_static_slice_table[42])
 /* "http" */
-#define GRPC_MDSTR_HTTP (grpc_static_slice_table[40])
+#define GRPC_MDSTR_HTTP (grpc_static_slice_table[43])
 /* "https" */
-#define GRPC_MDSTR_HTTPS (grpc_static_slice_table[41])
+#define GRPC_MDSTR_HTTPS (grpc_static_slice_table[44])
 /* "grpc" */
-#define GRPC_MDSTR_GRPC (grpc_static_slice_table[42])
+#define GRPC_MDSTR_GRPC (grpc_static_slice_table[45])
 /* "GET" */
-#define GRPC_MDSTR_GET (grpc_static_slice_table[43])
+#define GRPC_MDSTR_GET (grpc_static_slice_table[46])
 /* "PUT" */
-#define GRPC_MDSTR_PUT (grpc_static_slice_table[44])
+#define GRPC_MDSTR_PUT (grpc_static_slice_table[47])
 /* "/" */
-#define GRPC_MDSTR_SLASH (grpc_static_slice_table[45])
+#define GRPC_MDSTR_SLASH (grpc_static_slice_table[48])
 /* "/index.html" */
-#define GRPC_MDSTR_SLASH_INDEX_DOT_HTML (grpc_static_slice_table[46])
+#define GRPC_MDSTR_SLASH_INDEX_DOT_HTML (grpc_static_slice_table[49])
 /* "204" */
-#define GRPC_MDSTR_204 (grpc_static_slice_table[47])
+#define GRPC_MDSTR_204 (grpc_static_slice_table[50])
 /* "206" */
-#define GRPC_MDSTR_206 (grpc_static_slice_table[48])
+#define GRPC_MDSTR_206 (grpc_static_slice_table[51])
 /* "304" */
-#define GRPC_MDSTR_304 (grpc_static_slice_table[49])
+#define GRPC_MDSTR_304 (grpc_static_slice_table[52])
 /* "400" */
-#define GRPC_MDSTR_400 (grpc_static_slice_table[50])
+#define GRPC_MDSTR_400 (grpc_static_slice_table[53])
 /* "500" */
-#define GRPC_MDSTR_500 (grpc_static_slice_table[51])
+#define GRPC_MDSTR_500 (grpc_static_slice_table[54])
 /* "accept-charset" */
-#define GRPC_MDSTR_ACCEPT_CHARSET (grpc_static_slice_table[52])
+#define GRPC_MDSTR_ACCEPT_CHARSET (grpc_static_slice_table[55])
 /* "gzip, deflate" */
-#define GRPC_MDSTR_GZIP_COMMA_DEFLATE (grpc_static_slice_table[53])
+#define GRPC_MDSTR_GZIP_COMMA_DEFLATE (grpc_static_slice_table[56])
 /* "accept-language" */
-#define GRPC_MDSTR_ACCEPT_LANGUAGE (grpc_static_slice_table[54])
+#define GRPC_MDSTR_ACCEPT_LANGUAGE (grpc_static_slice_table[57])
 /* "accept-ranges" */
-#define GRPC_MDSTR_ACCEPT_RANGES (grpc_static_slice_table[55])
+#define GRPC_MDSTR_ACCEPT_RANGES (grpc_static_slice_table[58])
 /* "accept" */
-#define GRPC_MDSTR_ACCEPT (grpc_static_slice_table[56])
+#define GRPC_MDSTR_ACCEPT (grpc_static_slice_table[59])
 /* "access-control-allow-origin" */
-#define GRPC_MDSTR_ACCESS_CONTROL_ALLOW_ORIGIN (grpc_static_slice_table[57])
+#define GRPC_MDSTR_ACCESS_CONTROL_ALLOW_ORIGIN (grpc_static_slice_table[60])
 /* "age" */
-#define GRPC_MDSTR_AGE (grpc_static_slice_table[58])
+#define GRPC_MDSTR_AGE (grpc_static_slice_table[61])
 /* "allow" */
-#define GRPC_MDSTR_ALLOW (grpc_static_slice_table[59])
+#define GRPC_MDSTR_ALLOW (grpc_static_slice_table[62])
 /* "authorization" */
-#define GRPC_MDSTR_AUTHORIZATION (grpc_static_slice_table[60])
+#define GRPC_MDSTR_AUTHORIZATION (grpc_static_slice_table[63])
 /* "cache-control" */
-#define GRPC_MDSTR_CACHE_CONTROL (grpc_static_slice_table[61])
+#define GRPC_MDSTR_CACHE_CONTROL (grpc_static_slice_table[64])
 /* "content-disposition" */
-#define GRPC_MDSTR_CONTENT_DISPOSITION (grpc_static_slice_table[62])
+#define GRPC_MDSTR_CONTENT_DISPOSITION (grpc_static_slice_table[65])
 /* "content-language" */
-#define GRPC_MDSTR_CONTENT_LANGUAGE (grpc_static_slice_table[63])
+#define GRPC_MDSTR_CONTENT_LANGUAGE (grpc_static_slice_table[66])
 /* "content-length" */
-#define GRPC_MDSTR_CONTENT_LENGTH (grpc_static_slice_table[64])
+#define GRPC_MDSTR_CONTENT_LENGTH (grpc_static_slice_table[67])
 /* "content-location" */
-#define GRPC_MDSTR_CONTENT_LOCATION (grpc_static_slice_table[65])
+#define GRPC_MDSTR_CONTENT_LOCATION (grpc_static_slice_table[68])
 /* "content-range" */
-#define GRPC_MDSTR_CONTENT_RANGE (grpc_static_slice_table[66])
+#define GRPC_MDSTR_CONTENT_RANGE (grpc_static_slice_table[69])
 /* "cookie" */
-#define GRPC_MDSTR_COOKIE (grpc_static_slice_table[67])
+#define GRPC_MDSTR_COOKIE (grpc_static_slice_table[70])
 /* "date" */
-#define GRPC_MDSTR_DATE (grpc_static_slice_table[68])
+#define GRPC_MDSTR_DATE (grpc_static_slice_table[71])
 /* "etag" */
-#define GRPC_MDSTR_ETAG (grpc_static_slice_table[69])
+#define GRPC_MDSTR_ETAG (grpc_static_slice_table[72])
 /* "expect" */
-#define GRPC_MDSTR_EXPECT (grpc_static_slice_table[70])
+#define GRPC_MDSTR_EXPECT (grpc_static_slice_table[73])
 /* "expires" */
-#define GRPC_MDSTR_EXPIRES (grpc_static_slice_table[71])
+#define GRPC_MDSTR_EXPIRES (grpc_static_slice_table[74])
 /* "from" */
-#define GRPC_MDSTR_FROM (grpc_static_slice_table[72])
+#define GRPC_MDSTR_FROM (grpc_static_slice_table[75])
 /* "if-match" */
-#define GRPC_MDSTR_IF_MATCH (grpc_static_slice_table[73])
+#define GRPC_MDSTR_IF_MATCH (grpc_static_slice_table[76])
 /* "if-modified-since" */
-#define GRPC_MDSTR_IF_MODIFIED_SINCE (grpc_static_slice_table[74])
+#define GRPC_MDSTR_IF_MODIFIED_SINCE (grpc_static_slice_table[77])
 /* "if-none-match" */
-#define GRPC_MDSTR_IF_NONE_MATCH (grpc_static_slice_table[75])
+#define GRPC_MDSTR_IF_NONE_MATCH (grpc_static_slice_table[78])
 /* "if-range" */
-#define GRPC_MDSTR_IF_RANGE (grpc_static_slice_table[76])
+#define GRPC_MDSTR_IF_RANGE (grpc_static_slice_table[79])
 /* "if-unmodified-since" */
-#define GRPC_MDSTR_IF_UNMODIFIED_SINCE (grpc_static_slice_table[77])
+#define GRPC_MDSTR_IF_UNMODIFIED_SINCE (grpc_static_slice_table[80])
 /* "last-modified" */
-#define GRPC_MDSTR_LAST_MODIFIED (grpc_static_slice_table[78])
+#define GRPC_MDSTR_LAST_MODIFIED (grpc_static_slice_table[81])
 /* "lb-cost-bin" */
-#define GRPC_MDSTR_LB_COST_BIN (grpc_static_slice_table[79])
+#define GRPC_MDSTR_LB_COST_BIN (grpc_static_slice_table[82])
 /* "link" */
-#define GRPC_MDSTR_LINK (grpc_static_slice_table[80])
+#define GRPC_MDSTR_LINK (grpc_static_slice_table[83])
 /* "location" */
-#define GRPC_MDSTR_LOCATION (grpc_static_slice_table[81])
+#define GRPC_MDSTR_LOCATION (grpc_static_slice_table[84])
 /* "max-forwards" */
-#define GRPC_MDSTR_MAX_FORWARDS (grpc_static_slice_table[82])
+#define GRPC_MDSTR_MAX_FORWARDS (grpc_static_slice_table[85])
 /* "proxy-authenticate" */
-#define GRPC_MDSTR_PROXY_AUTHENTICATE (grpc_static_slice_table[83])
+#define GRPC_MDSTR_PROXY_AUTHENTICATE (grpc_static_slice_table[86])
 /* "proxy-authorization" */
-#define GRPC_MDSTR_PROXY_AUTHORIZATION (grpc_static_slice_table[84])
+#define GRPC_MDSTR_PROXY_AUTHORIZATION (grpc_static_slice_table[87])
 /* "range" */
-#define GRPC_MDSTR_RANGE (grpc_static_slice_table[85])
+#define GRPC_MDSTR_RANGE (grpc_static_slice_table[88])
 /* "referer" */
-#define GRPC_MDSTR_REFERER (grpc_static_slice_table[86])
+#define GRPC_MDSTR_REFERER (grpc_static_slice_table[89])
 /* "refresh" */
-#define GRPC_MDSTR_REFRESH (grpc_static_slice_table[87])
+#define GRPC_MDSTR_REFRESH (grpc_static_slice_table[90])
 /* "retry-after" */
-#define GRPC_MDSTR_RETRY_AFTER (grpc_static_slice_table[88])
+#define GRPC_MDSTR_RETRY_AFTER (grpc_static_slice_table[91])
 /* "server" */
-#define GRPC_MDSTR_SERVER (grpc_static_slice_table[89])
+#define GRPC_MDSTR_SERVER (grpc_static_slice_table[92])
 /* "set-cookie" */
-#define GRPC_MDSTR_SET_COOKIE (grpc_static_slice_table[90])
+#define GRPC_MDSTR_SET_COOKIE (grpc_static_slice_table[93])
 /* "strict-transport-security" */
-#define GRPC_MDSTR_STRICT_TRANSPORT_SECURITY (grpc_static_slice_table[91])
+#define GRPC_MDSTR_STRICT_TRANSPORT_SECURITY (grpc_static_slice_table[94])
 /* "transfer-encoding" */
-#define GRPC_MDSTR_TRANSFER_ENCODING (grpc_static_slice_table[92])
+#define GRPC_MDSTR_TRANSFER_ENCODING (grpc_static_slice_table[95])
 /* "vary" */
-#define GRPC_MDSTR_VARY (grpc_static_slice_table[93])
+#define GRPC_MDSTR_VARY (grpc_static_slice_table[96])
 /* "via" */
-#define GRPC_MDSTR_VIA (grpc_static_slice_table[94])
+#define GRPC_MDSTR_VIA (grpc_static_slice_table[97])
 /* "www-authenticate" */
-#define GRPC_MDSTR_WWW_AUTHENTICATE (grpc_static_slice_table[95])
+#define GRPC_MDSTR_WWW_AUTHENTICATE (grpc_static_slice_table[98])
 /* "identity,deflate" */
-#define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE (grpc_static_slice_table[96])
+#define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE (grpc_static_slice_table[99])
 /* "identity,gzip" */
-#define GRPC_MDSTR_IDENTITY_COMMA_GZIP (grpc_static_slice_table[97])
+#define GRPC_MDSTR_IDENTITY_COMMA_GZIP (grpc_static_slice_table[100])
 /* "deflate,gzip" */
-#define GRPC_MDSTR_DEFLATE_COMMA_GZIP (grpc_static_slice_table[98])
+#define GRPC_MDSTR_DEFLATE_COMMA_GZIP (grpc_static_slice_table[101])
 /* "identity,deflate,gzip" */
 #define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE_COMMA_GZIP \
-  (grpc_static_slice_table[99])
+  (grpc_static_slice_table[102])
 
 extern const grpc_slice_refcount_vtable grpc_static_metadata_vtable;
 extern grpc_slice_refcount

test/core/channel/channel_args_test.c

@@ -64,7 +64,7 @@ static void test_set_compression_algorithm(void) {
   grpc_channel_args *ch_args;
 
   ch_args =
-      grpc_channel_args_set_compression_algorithm(NULL, GRPC_COMPRESS_GZIP);
+      grpc_channel_args_set_compression_algorithm(NULL, GRPC_COMPRESS_MESSAGE_GZIP);
   GPR_ASSERT(ch_args->num_args == 1);
   GPR_ASSERT(strcmp(ch_args->args[0].key,
                     GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM) == 0);
@@ -76,7 +76,7 @@ static void test_set_compression_algorithm(void) {
 
 static void test_compression_algorithm_states(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_channel_args *ch_args, *ch_args_wo_gzip, *ch_args_wo_gzip_deflate;
+  grpc_channel_args *ch_args, *ch_args_wo_gzip, *ch_args_wo_gzip_deflate, *ch_args_wo_gzip_deflate_gzip;
   unsigned states_bitset;
   size_t i;
 
@@ -89,33 +89,38 @@ static void test_compression_algorithm_states(void) {
     GPR_ASSERT(GPR_BITGET(states_bitset, i));
   }
 
-  /* disable gzip and deflate */
+  /* disable message/gzip and message/deflate and stream/gzip */
   ch_args_wo_gzip = grpc_channel_args_compression_algorithm_set_state(
-      &exec_ctx, &ch_args, GRPC_COMPRESS_GZIP, 0);
+      &exec_ctx, &ch_args, GRPC_COMPRESS_MESSAGE_GZIP, 0);
   GPR_ASSERT(ch_args == ch_args_wo_gzip);
   ch_args_wo_gzip_deflate = grpc_channel_args_compression_algorithm_set_state(
-      &exec_ctx, &ch_args_wo_gzip, GRPC_COMPRESS_DEFLATE, 0);
+      &exec_ctx, &ch_args_wo_gzip, GRPC_COMPRESS_MESSAGE_DEFLATE, 0);
   GPR_ASSERT(ch_args_wo_gzip == ch_args_wo_gzip_deflate);
+  ch_args_wo_gzip_deflate_gzip = grpc_channel_args_compression_algorithm_set_state(
+      &exec_ctx, &ch_args_wo_gzip_deflate, GRPC_COMPRESS_STREAM_GZIP, 0);
+  GPR_ASSERT(ch_args_wo_gzip_deflate == ch_args_wo_gzip_deflate_gzip);
 
   states_bitset = (unsigned)grpc_channel_args_compression_algorithm_get_states(
       ch_args_wo_gzip_deflate);
   for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
-    if (i == GRPC_COMPRESS_GZIP || i == GRPC_COMPRESS_DEFLATE) {
+    if (i == GRPC_COMPRESS_MESSAGE_GZIP || i == GRPC_COMPRESS_MESSAGE_DEFLATE || i == GRPC_COMPRESS_STREAM_GZIP) {
       GPR_ASSERT(GPR_BITGET(states_bitset, i) == 0);
     } else {
       GPR_ASSERT(GPR_BITGET(states_bitset, i) != 0);
     }
   }
 
-  /* re-enabled gzip only */
+  /* re-enabled message/gzip and stream/gzip only */
   ch_args_wo_gzip = grpc_channel_args_compression_algorithm_set_state(
-      &exec_ctx, &ch_args_wo_gzip_deflate, GRPC_COMPRESS_GZIP, 1);
+      &exec_ctx, &ch_args_wo_gzip_deflate_gzip, GRPC_COMPRESS_MESSAGE_GZIP, 1);
-  GPR_ASSERT(ch_args_wo_gzip == ch_args_wo_gzip_deflate);
+  ch_args_wo_gzip = grpc_channel_args_compression_algorithm_set_state(
+      &exec_ctx, &ch_args_wo_gzip, GRPC_COMPRESS_STREAM_GZIP, 1);
+  GPR_ASSERT(ch_args_wo_gzip == ch_args_wo_gzip_deflate_gzip);
 
   states_bitset = (unsigned)grpc_channel_args_compression_algorithm_get_states(
       ch_args_wo_gzip);
   for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
-    if (i == GRPC_COMPRESS_DEFLATE) {
+    if (i == GRPC_COMPRESS_MESSAGE_DEFLATE) {
       GPR_ASSERT(GPR_BITGET(states_bitset, i) == 0);
     } else {
       GPR_ASSERT(GPR_BITGET(states_bitset, i) != 0);

test/core/compression/BUILD

@@ -53,3 +53,15 @@ grpc_cc_test(
         "//test/core/util:grpc_test_util",
     ],
 )
+
+grpc_cc_test(
+    name = "stream_compress_test",
+    srcs = ["stream_compress_test.c"],
+    language = "C",
+    deps = [
+        "//:gpr",
+        "//:grpc",
+        "//test/core/util:gpr_test_util",
+        "//test/core/util:grpc_test_util",
+    ],
+)

test/core/compression/algorithm_test.c

@@ -29,6 +29,8 @@
 #include "src/core/lib/transport/static_metadata.h"
 #include "test/core/util/test_config.h"
 
+const uint32_t message_prefix_length = 8;
+const uint32_t stream_prefix_length = 7;
 static void test_algorithm_mesh(void) {
   int i;
 
@@ -48,9 +50,19 @@ static void test_algorithm_mesh(void) {
     mdstr = grpc_slice_from_copied_string(name);
     GPR_ASSERT(grpc_slice_eq(mdstr, grpc_compression_algorithm_slice(parsed)));
     GPR_ASSERT(parsed == grpc_compression_algorithm_from_slice(mdstr));
-    mdelem = grpc_compression_encoding_mdelem(parsed);
+    if (parsed == 0) {
-    GPR_ASSERT(grpc_slice_eq(GRPC_MDVALUE(mdelem), mdstr));
+      continue;
-    GPR_ASSERT(grpc_slice_eq(GRPC_MDKEY(mdelem), GRPC_MDSTR_GRPC_ENCODING));
+    } else if (grpc_compression_algorithm_is_message(parsed)) {
+      mdelem = grpc_message_compression_encoding_mdelem(grpc_compression_algorithm_to_message_compression_algorithm(parsed));
+      grpc_slice value = GRPC_MDVALUE(mdelem);
+      GPR_ASSERT(0 == memcmp(&name[message_prefix_length], GRPC_SLICE_START_PTR(value), GRPC_SLICE_LENGTH(value)));
+      GPR_ASSERT(grpc_slice_eq(GRPC_MDKEY(mdelem), GRPC_MDSTR_GRPC_ENCODING));
+    } else {
+      mdelem = grpc_stream_compression_encoding_mdelem(grpc_compression_algorithm_to_stream_compression_algorithm(parsed));
+      grpc_slice value = GRPC_MDVALUE(mdelem);
+      GPR_ASSERT(0 == memcmp(&name[stream_prefix_length], GRPC_SLICE_START_PTR(value), GRPC_SLICE_LENGTH(value)));
+      GPR_ASSERT(grpc_slice_eq(GRPC_MDKEY(mdelem), GRPC_MDSTR_CONTENT_ENCODING));
+    }
     grpc_slice_unref_internal(&exec_ctx, mdstr);
     GRPC_MDELEM_UNREF(&exec_ctx, mdelem);
     grpc_exec_ctx_finish(&exec_ctx);

test/core/compression/compression_test.c

@@ -28,9 +28,9 @@
 
 static void test_compression_algorithm_parse(void) {
   size_t i;
-  const char *valid_names[] = {"identity", "gzip", "deflate"};
+  const char *valid_names[] = {"identity", "message/gzip", "message/deflate", "stream/gzip"};
   const grpc_compression_algorithm valid_algorithms[] = {
-      GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_DEFLATE};
+      GRPC_COMPRESS_NONE, GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_DEFLATE, GRPC_COMPRESS_STREAM_GZIP};
   const char *invalid_names[] = {"gzip2", "foo", "", "2gzip"};
 
   gpr_log(GPR_DEBUG, "test_compression_algorithm_parse");
@@ -59,9 +59,9 @@ static void test_compression_algorithm_name(void) {
   int success;
   char *name;
   size_t i;
-  const char *valid_names[] = {"identity", "gzip", "deflate"};
+  const char *valid_names[] = {"identity", "message/gzip", "message/deflate", "stream/gzip"};
   const grpc_compression_algorithm valid_algorithms[] = {
-      GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_DEFLATE};
+      GRPC_COMPRESS_NONE, GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_DEFLATE, GRPC_COMPRESS_STREAM_GZIP};
 
   gpr_log(GPR_DEBUG, "test_compression_algorithm_name");
 
@@ -90,15 +90,27 @@ static void test_compression_algorithm_for_level(void) {
                                                     accepted_encodings));
 
     GPR_ASSERT(GRPC_COMPRESS_NONE ==
-               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW,
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_LOW,
                                                     accepted_encodings));
 
     GPR_ASSERT(GRPC_COMPRESS_NONE ==
-               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED,
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_MED,
                                                     accepted_encodings));
 
     GPR_ASSERT(GRPC_COMPRESS_NONE ==
-               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH,
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_HIGH,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_NONE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_LOW,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_NONE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_MED,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_NONE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_HIGH,
                                                     accepted_encodings));
   }
 
@@ -106,22 +118,34 @@ static void test_compression_algorithm_for_level(void) {
     /* accept only gzip */
     uint32_t accepted_encodings = 0;
     GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */
-    GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_GZIP);
+    GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_MESSAGE_GZIP);
 
     GPR_ASSERT(GRPC_COMPRESS_NONE ==
                grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE,
                                                     accepted_encodings));
 
-    GPR_ASSERT(GRPC_COMPRESS_GZIP ==
+    GPR_ASSERT(GRPC_COMPRESS_MESSAGE_GZIP ==
-               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW,
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_LOW,
                                                     accepted_encodings));
 
-    GPR_ASSERT(GRPC_COMPRESS_GZIP ==
+    GPR_ASSERT(GRPC_COMPRESS_MESSAGE_GZIP ==
-               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED,
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_MED,
                                                     accepted_encodings));
 
-    GPR_ASSERT(GRPC_COMPRESS_GZIP ==
+    GPR_ASSERT(GRPC_COMPRESS_MESSAGE_GZIP ==
-               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH,
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_HIGH,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_NONE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_LOW,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_NONE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_MED,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_NONE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_HIGH,
                                                     accepted_encodings));
   }
 
@@ -129,22 +153,34 @@ static void test_compression_algorithm_for_level(void) {
     /* accept only deflate */
     uint32_t accepted_encodings = 0;
     GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */
-    GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_DEFLATE);
+    GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_MESSAGE_DEFLATE);
 
     GPR_ASSERT(GRPC_COMPRESS_NONE ==
                grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE,
                                                     accepted_encodings));
 
-    GPR_ASSERT(GRPC_COMPRESS_DEFLATE ==
+    GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE ==
-               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW,
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_LOW,
                                                     accepted_encodings));
 
-    GPR_ASSERT(GRPC_COMPRESS_DEFLATE ==
+    GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE ==
-               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED,
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_MED,
                                                     accepted_encodings));
 
-    GPR_ASSERT(GRPC_COMPRESS_DEFLATE ==
+    GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE ==
-               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH,
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_HIGH,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_NONE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_LOW,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_NONE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_MED,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_NONE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_HIGH,
                                                     accepted_encodings));
   }
 
@@ -152,23 +188,107 @@ static void test_compression_algorithm_for_level(void) {
     /* accept gzip and deflate */
     uint32_t accepted_encodings = 0;
     GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */
-    GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_GZIP);
+    GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_MESSAGE_GZIP);
-    GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_DEFLATE);
+    GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_MESSAGE_DEFLATE);
 
     GPR_ASSERT(GRPC_COMPRESS_NONE ==
                grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE,
                                                     accepted_encodings));
 
-    GPR_ASSERT(GRPC_COMPRESS_GZIP ==
+    GPR_ASSERT(GRPC_COMPRESS_MESSAGE_GZIP ==
-               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW,
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_LOW,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_MED,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_HIGH,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_NONE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_LOW,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_NONE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_MED,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_NONE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_HIGH,
+                                                    accepted_encodings));
+  }
+
+  {
+    /* accept stream gzip */
+    uint32_t accepted_encodings = 0;
+    GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */
+    GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_STREAM_GZIP);
+
+    GPR_ASSERT(GRPC_COMPRESS_NONE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_NONE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_LOW,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_NONE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_MED,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_NONE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_HIGH,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_STREAM_GZIP ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_LOW,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_STREAM_GZIP ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_MED,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_STREAM_GZIP ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_HIGH,
+                                                    accepted_encodings));
+  }
+
+  {
+    /* accept all algorithms */
+    uint32_t accepted_encodings = 0;
+    GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */
+    GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_MESSAGE_GZIP);
+    GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_MESSAGE_DEFLATE);
+    GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_STREAM_GZIP);
+
+    GPR_ASSERT(GRPC_COMPRESS_NONE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_MESSAGE_GZIP ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_LOW,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_MED,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MESSAGE_HIGH,
+                                                    accepted_encodings));
+
+    GPR_ASSERT(GRPC_COMPRESS_STREAM_GZIP ==
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_LOW,
                                                     accepted_encodings));
 
-    GPR_ASSERT(GRPC_COMPRESS_DEFLATE ==
+    GPR_ASSERT(GRPC_COMPRESS_STREAM_GZIP ==
-               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED,
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_MED,
                                                     accepted_encodings));
 
-    GPR_ASSERT(GRPC_COMPRESS_DEFLATE ==
+    GPR_ASSERT(GRPC_COMPRESS_STREAM_GZIP ==
-               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH,
+               grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_STREAM_HIGH,
                                                     accepted_encodings));
   }
 }

test/core/compression/message_compress_test.c

@@ -39,7 +39,7 @@ typedef enum {
 } compressability;
 
 static void assert_passthrough(grpc_slice value,
-                               grpc_compression_algorithm algorithm,
+                               grpc_message_compression_algorithm algorithm,
                                grpc_slice_split_mode uncompressed_split_mode,
                                grpc_slice_split_mode compressed_split_mode,
                                compressability compress_result_check) {
@@ -51,7 +51,7 @@ static void assert_passthrough(grpc_slice value,
   int was_compressed;
   char *algorithm_name;
 
-  GPR_ASSERT(grpc_compression_algorithm_name(algorithm, &algorithm_name) != 0);
+  GPR_ASSERT(grpc_message_compression_algorithm_name(algorithm, &algorithm_name) != 0);
   gpr_log(
       GPR_INFO, "assert_passthrough: value_length=%" PRIuPTR
                 " value_hash=0x%08x "
@@ -93,7 +93,7 @@ static void assert_passthrough(grpc_slice value,
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     GPR_ASSERT(grpc_msg_decompress(
-        &exec_ctx, was_compressed ? algorithm : GRPC_COMPRESS_NONE, &compressed,
+        &exec_ctx, was_compressed ? algorithm : GRPC_MESSAGE_COMPRESS_NONE, &compressed,
         &output));
     grpc_exec_ctx_finish(&exec_ctx);
   }
@@ -115,8 +115,8 @@ static grpc_slice repeated(char c, size_t length) {
 }
 
 static compressability get_compressability(
-    test_value id, grpc_compression_algorithm algorithm) {
+    test_value id, grpc_message_compression_algorithm algorithm) {
-  if (algorithm == GRPC_COMPRESS_NONE) return SHOULD_NOT_COMPRESS;
+  if (algorithm == GRPC_MESSAGE_COMPRESS_NONE) return SHOULD_NOT_COMPRESS;
   switch (id) {
     case ONE_A:
       return SHOULD_NOT_COMPRESS;
@@ -148,14 +148,14 @@ static grpc_slice create_test_value(test_value id) {
 static void test_tiny_data_compress(void) {
   grpc_slice_buffer input;
   grpc_slice_buffer output;
-  grpc_compression_algorithm i;
+  grpc_message_compression_algorithm i;
 
   grpc_slice_buffer_init(&input);
   grpc_slice_buffer_init(&output);
   grpc_slice_buffer_add(&input, create_test_value(ONE_A));
 
-  for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
+  for (i = 0; i < GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT; i++) {
-    if (i == GRPC_COMPRESS_NONE) continue;
+    if (i == GRPC_MESSAGE_COMPRESS_NONE) continue;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     GPR_ASSERT(0 == grpc_msg_compress(&exec_ctx, i, &input, &output));
     grpc_exec_ctx_finish(&exec_ctx);
@@ -180,7 +180,7 @@ static void test_bad_decompression_data_crc(void) {
 
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   /* compress it */
-  grpc_msg_compress(&exec_ctx, GRPC_COMPRESS_GZIP, &input, &corrupted);
+  grpc_msg_compress(&exec_ctx, GRPC_MESSAGE_COMPRESS_GZIP, &input, &corrupted);
   /* corrupt the output by smashing the CRC */
   GPR_ASSERT(corrupted.count > 1);
   GPR_ASSERT(GRPC_SLICE_LENGTH(corrupted.slices[1]) > 8);
@@ -188,7 +188,7 @@ static void test_bad_decompression_data_crc(void) {
   memcpy(GRPC_SLICE_START_PTR(corrupted.slices[1]) + idx, &bad, 4);
 
   /* try (and fail) to decompress the corrupted compresed buffer */
-  GPR_ASSERT(0 == grpc_msg_decompress(&exec_ctx, GRPC_COMPRESS_GZIP, &corrupted,
+  GPR_ASSERT(0 == grpc_msg_decompress(&exec_ctx, GRPC_MESSAGE_COMPRESS_GZIP, &corrupted,
                                       &output));
   grpc_exec_ctx_finish(&exec_ctx);
 
@@ -210,7 +210,7 @@ static void test_bad_decompression_data_trailing_garbage(void) {
 
   /* try (and fail) to decompress the invalid compresed buffer */
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  GPR_ASSERT(0 == grpc_msg_decompress(&exec_ctx, GRPC_COMPRESS_DEFLATE, &input,
+  GPR_ASSERT(0 == grpc_msg_decompress(&exec_ctx, GRPC_MESSAGE_COMPRESS_DEFLATE, &input,
                                       &output));
   grpc_exec_ctx_finish(&exec_ctx);
 
@@ -229,7 +229,7 @@ static void test_bad_decompression_data_stream(void) {
 
   /* try (and fail) to decompress the invalid compresed buffer */
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  GPR_ASSERT(0 == grpc_msg_decompress(&exec_ctx, GRPC_COMPRESS_DEFLATE, &input,
+  GPR_ASSERT(0 == grpc_msg_decompress(&exec_ctx, GRPC_MESSAGE_COMPRESS_DEFLATE, &input,
                                       &output));
   grpc_exec_ctx_finish(&exec_ctx);
 
@@ -248,12 +248,12 @@ static void test_bad_compression_algorithm(void) {
       &input, grpc_slice_from_copied_string("Never gonna give you up"));
 
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  was_compressed = grpc_msg_compress(&exec_ctx, GRPC_COMPRESS_ALGORITHMS_COUNT,
+  was_compressed = grpc_msg_compress(&exec_ctx, GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT,
                                      &input, &output);
   GPR_ASSERT(0 == was_compressed);
 
   was_compressed = grpc_msg_compress(
-      &exec_ctx, GRPC_COMPRESS_ALGORITHMS_COUNT + 123, &input, &output);
+      &exec_ctx, GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT + 123, &input, &output);
   GPR_ASSERT(0 == was_compressed);
   grpc_exec_ctx_finish(&exec_ctx);
 
@@ -273,11 +273,11 @@ static void test_bad_decompression_algorithm(void) {
                             "I'm not really compressed but it doesn't matter"));
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   was_decompressed = grpc_msg_decompress(
-      &exec_ctx, GRPC_COMPRESS_ALGORITHMS_COUNT, &input, &output);
+      &exec_ctx, GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT, &input, &output);
   GPR_ASSERT(0 == was_decompressed);
 
   was_decompressed = grpc_msg_decompress(
-      &exec_ctx, GRPC_COMPRESS_ALGORITHMS_COUNT + 123, &input, &output);
+      &exec_ctx, GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT + 123, &input, &output);
   GPR_ASSERT(0 == was_decompressed);
   grpc_exec_ctx_finish(&exec_ctx);
 
@@ -296,7 +296,7 @@ int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
   grpc_init();
 
-  for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
+  for (i = 0; i < GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT; i++) {
     for (j = 0; j < GPR_ARRAY_SIZE(uncompressed_split_modes); j++) {
       for (k = 0; k < GPR_ARRAY_SIZE(compressed_split_modes); k++) {
         for (m = 0; m < TEST_VALUE_COUNT; m++) {

test/core/end2end/fixtures/h2_compress.c

@@ -69,7 +69,7 @@ void chttp2_init_client_fullstack_compression(grpc_end2end_test_fixture *f,
     grpc_exec_ctx_finish(&exec_ctx);
   }
   ffd->client_args_compression = grpc_channel_args_set_compression_algorithm(
-      client_args, GRPC_COMPRESS_GZIP);
+      client_args, GRPC_COMPRESS_MESSAGE_GZIP);
   f->client = grpc_insecure_channel_create(ffd->localaddr,
                                            ffd->client_args_compression, NULL);
 }
@@ -83,7 +83,7 @@ void chttp2_init_server_fullstack_compression(grpc_end2end_test_fixture *f,
     grpc_exec_ctx_finish(&exec_ctx);
   }
   ffd->server_args_compression = grpc_channel_args_set_compression_algorithm(
-      server_args, GRPC_COMPRESS_GZIP);
+      server_args, GRPC_COMPRESS_MESSAGE_GZIP);
   if (f->server) {
     grpc_server_destroy(f->server);
   }

test/core/end2end/fuzzers/hpack.dictionary

@@ -28,6 +28,9 @@
 "\x1Egrpc.max_request_message_bytes"
 "\x1Fgrpc.max_response_message_bytes"
 "$/grpc.lb.v1.LoadBalancer/BalanceLoad"
+"\x0Fmessage/deflate"
+"\x0Cmessage/gzip"
+"\x0Bstream/gzip"
 "\x010"
 "\x011"
 "\x012"

test/core/end2end/tests/compressed_payload.c

@@ -384,9 +384,9 @@ static void request_with_payload_template(
   GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
                         GRPC_COMPRESS_NONE) != 0);
   GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
-                        GRPC_COMPRESS_DEFLATE) != 0);
+                        GRPC_COMPRESS_MESSAGE_DEFLATE) != 0);
   GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
-                        GRPC_COMPRESS_GZIP) != 0);
+                        GRPC_COMPRESS_MESSAGE_GZIP) != 0);
 
   memset(ops, 0, sizeof(ops));
   op = ops;
@@ -549,8 +549,9 @@ static void test_invoke_request_with_exceptionally_uncompressed_payload(
     grpc_end2end_test_config config) {
   request_with_payload_template(
       config, "test_invoke_request_with_exceptionally_uncompressed_payload",
-      GRPC_WRITE_NO_COMPRESS, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
+      GRPC_WRITE_NO_COMPRESS, GRPC_COMPRESS_MESSAGE_GZIP,
-      GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, NULL, false,
+      GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_NONE,
+      GRPC_COMPRESS_MESSAGE_GZIP, NULL, false,
       /* ignored */ GRPC_COMPRESS_LEVEL_NONE, false);
 }
 
@@ -567,18 +568,18 @@ static void test_invoke_request_with_compressed_payload(
     grpc_end2end_test_config config) {
   request_with_payload_template(
       config, "test_invoke_request_with_compressed_payload", 0,
-      GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
+      GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_GZIP,
-      GRPC_COMPRESS_GZIP, NULL, false, /* ignored */ GRPC_COMPRESS_LEVEL_NONE,
+      GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_GZIP, NULL, false,
-      false);
+      /* ignored */ GRPC_COMPRESS_LEVEL_NONE, false);
 }
 
 static void test_invoke_request_with_send_message_before_initial_metadata(
     grpc_end2end_test_config config) {
   request_with_payload_template(
       config, "test_invoke_request_with_compressed_payload", 0,
-      GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
+      GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_GZIP,
-      GRPC_COMPRESS_GZIP, NULL, false, /* ignored */ GRPC_COMPRESS_LEVEL_NONE,
+      GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_GZIP, NULL, false,
-      true);
+      /* ignored */ GRPC_COMPRESS_LEVEL_NONE, true);
 }
 
 static void test_invoke_request_with_server_level(
@@ -586,7 +587,7 @@ static void test_invoke_request_with_server_level(
   request_with_payload_template(
       config, "test_invoke_request_with_server_level", 0, GRPC_COMPRESS_NONE,
       GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE /* ignored */,
-      NULL, true, GRPC_COMPRESS_LEVEL_HIGH, false);
+      NULL, true, GRPC_COMPRESS_LEVEL_MESSAGE_HIGH, false);
 }
 
 static void test_invoke_request_with_compressed_payload_md_override(
@@ -595,7 +596,7 @@ static void test_invoke_request_with_compressed_payload_md_override(
   grpc_metadata identity_compression_override;
 
   gzip_compression_override.key = GRPC_MDSTR_GRPC_INTERNAL_ENCODING_REQUEST;
-  gzip_compression_override.value = grpc_slice_from_static_string("gzip");
+  gzip_compression_override.value = grpc_slice_from_static_string("message/gzip");
   memset(&gzip_compression_override.internal_data, 0,
          sizeof(gzip_compression_override.internal_data));
 
@@ -608,21 +609,22 @@ static void test_invoke_request_with_compressed_payload_md_override(
   /* Channel default NONE (aka IDENTITY), call override to GZIP */
   request_with_payload_template(
       config, "test_invoke_request_with_compressed_payload_md_override_1", 0,
-      GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP,
+      GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_MESSAGE_GZIP,
       GRPC_COMPRESS_NONE, &gzip_compression_override, false,
       /*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false);
 
   /* Channel default DEFLATE, call override to GZIP */
   request_with_payload_template(
       config, "test_invoke_request_with_compressed_payload_md_override_2", 0,
-      GRPC_COMPRESS_DEFLATE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP,
+      GRPC_COMPRESS_MESSAGE_DEFLATE, GRPC_COMPRESS_NONE,
-      GRPC_COMPRESS_NONE, &gzip_compression_override, false,
+      GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_NONE,
+      &gzip_compression_override, false,
       /*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false);
 
   /* Channel default DEFLATE, call override to NONE (aka IDENTITY) */
   request_with_payload_template(
       config, "test_invoke_request_with_compressed_payload_md_override_3", 0,
-      GRPC_COMPRESS_DEFLATE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
+      GRPC_COMPRESS_MESSAGE_DEFLATE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
       GRPC_COMPRESS_NONE, &identity_compression_override, false,
       /*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false);
 }
@@ -631,7 +633,8 @@ static void test_invoke_request_with_disabled_algorithm(
     grpc_end2end_test_config config) {
   request_for_disabled_algorithm(
       config, "test_invoke_request_with_disabled_algorithm", 0,
-      GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_STATUS_UNIMPLEMENTED, NULL);
+      GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_GZIP,
+      GRPC_STATUS_UNIMPLEMENTED, NULL);
 }
 
 void compressed_payload(grpc_end2end_test_config config) {

test/core/end2end/tests/stream_compression_compressed_payload.c

@@ -95,8 +95,8 @@ static void end_test(grpc_end2end_test_fixture *f) {
 static void request_for_disabled_algorithm(
     grpc_end2end_test_config config, const char *test_name,
     uint32_t send_flags_bitmask,
-    grpc_stream_compression_algorithm algorithm_to_disable,
+    grpc_compression_algorithm algorithm_to_disable,
-    grpc_stream_compression_algorithm requested_client_compression_algorithm,
+    grpc_compression_algorithm requested_client_compression_algorithm,
     grpc_status_code expected_error, grpc_metadata *client_metadata) {
   grpc_call *c;
   grpc_call *s;
@@ -124,13 +124,13 @@ static void request_for_disabled_algorithm(
   request_payload_slice = grpc_slice_from_copied_string(str);
   request_payload = grpc_raw_byte_buffer_create(&request_payload_slice, 1);
 
-  client_args = grpc_channel_args_set_stream_compression_algorithm(
+  client_args = grpc_channel_args_set_compression_algorithm(
       NULL, requested_client_compression_algorithm);
-  server_args = grpc_channel_args_set_stream_compression_algorithm(
+  server_args =
-      NULL, GRPC_STREAM_COMPRESS_NONE);
+      grpc_channel_args_set_compression_algorithm(NULL, GRPC_COMPRESS_NONE);
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    server_args = grpc_channel_args_stream_compression_algorithm_set_state(
+    server_args = grpc_channel_args_compression_algorithm_set_state(
         &exec_ctx, &server_args, algorithm_to_disable, false);
     grpc_exec_ctx_finish(&exec_ctx);
   }
@@ -229,11 +229,10 @@ static void request_for_disabled_algorithm(
   GPR_ASSERT(status == expected_error);
 
   char *algo_name = NULL;
-  GPR_ASSERT(
+  GPR_ASSERT(grpc_compression_algorithm_name(algorithm_to_disable, &algo_name));
-      grpc_stream_compression_algorithm_name(algorithm_to_disable, &algo_name));
   char *expected_details = NULL;
   gpr_asprintf(&expected_details,
-               "Stream compression algorithm '%s' is disabled.", algo_name);
+               "Compression algorithm '%s' is disabled.", algo_name);
   /* and we expect a specific reason for it */
   GPR_ASSERT(0 == grpc_slice_str_cmp(details, expected_details));
   gpr_free(expected_details);
@@ -270,14 +269,12 @@ static void request_for_disabled_algorithm(
 static void request_with_payload_template(
     grpc_end2end_test_config config, const char *test_name,
     uint32_t client_send_flags_bitmask,
-    grpc_stream_compression_algorithm
+    grpc_compression_algorithm default_client_channel_compression_algorithm,
-        default_client_channel_compression_algorithm,
+    grpc_compression_algorithm default_server_channel_compression_algorithm,
-    grpc_stream_compression_algorithm
+    grpc_compression_algorithm expected_client_compression_algorithm,
-        default_server_channel_compression_algorithm,
+    grpc_compression_algorithm expected_server_compression_algorithm,
-    grpc_stream_compression_algorithm expected_client_compression_algorithm,
-    grpc_stream_compression_algorithm expected_server_compression_algorithm,
     grpc_metadata *client_init_metadata, bool set_server_level,
-    grpc_stream_compression_level server_compression_level,
+    grpc_compression_level server_compression_level,
     bool send_message_before_initial_metadata,
     bool set_default_server_message_compression_algorithm,
     grpc_compression_algorithm default_server_message_compression_algorithm) {
@@ -315,13 +312,13 @@ static void request_with_payload_template(
   grpc_slice response_payload_slice =
       grpc_slice_from_copied_string(response_str);
 
-  client_args = grpc_channel_args_set_stream_compression_algorithm(
+  client_args = grpc_channel_args_set_compression_algorithm(
       NULL, default_client_channel_compression_algorithm);
   if (set_default_server_message_compression_algorithm) {
     server_args = grpc_channel_args_set_compression_algorithm(
         NULL, default_server_message_compression_algorithm);
   } else {
-    server_args = grpc_channel_args_set_stream_compression_algorithm(
+    server_args = grpc_channel_args_set_compression_algorithm(
         NULL, default_server_channel_compression_algorithm);
   }
 
@@ -394,26 +391,21 @@ static void request_with_payload_template(
   GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
                         GRPC_COMPRESS_NONE) != 0);
   GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
-                        GRPC_COMPRESS_DEFLATE) != 0);
+                        GRPC_COMPRESS_MESSAGE_DEFLATE) != 0);
+  GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
+                        GRPC_COMPRESS_MESSAGE_GZIP) != 0);
   GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
-                        GRPC_COMPRESS_GZIP) != 0);
+                        GRPC_COMPRESS_STREAM_GZIP) != 0);
-  GPR_ASSERT(
+  GPR_ASSERT(GPR_BITCOUNT(grpc_call_test_only_get_encodings_accepted_by_peer(
-      GPR_BITCOUNT(grpc_call_test_only_get_stream_encodings_accepted_by_peer(
+                 s)) == GRPC_COMPRESS_ALGORITHMS_COUNT);
-          s)) == GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT);
-  GPR_ASSERT(
-      GPR_BITGET(grpc_call_test_only_get_stream_encodings_accepted_by_peer(s),
-                 GRPC_STREAM_COMPRESS_NONE) != 0);
-  GPR_ASSERT(
-      GPR_BITGET(grpc_call_test_only_get_stream_encodings_accepted_by_peer(s),
-                 GRPC_STREAM_COMPRESS_GZIP) != 0);
 
   memset(ops, 0, sizeof(ops));
   op = ops;
   op->op = GRPC_OP_SEND_INITIAL_METADATA;
   op->data.send_initial_metadata.count = 0;
   if (set_server_level) {
-    op->data.send_initial_metadata.maybe_stream_compression_level.is_set = true;
+    op->data.send_initial_metadata.maybe_compression_level.is_set = true;
-    op->data.send_initial_metadata.maybe_stream_compression_level.level =
+    op->data.send_initial_metadata.maybe_compression_level.level =
         server_compression_level;
   }
   op->flags = 0;
@@ -557,29 +549,28 @@ static void test_invoke_request_with_compressed_payload(
     grpc_end2end_test_config config) {
   request_with_payload_template(
       config, "test_invoke_request_with_compressed_payload", 0,
-      GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_GZIP,
+      GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_STREAM_GZIP,
-      GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_GZIP, NULL,
+      GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_STREAM_GZIP, NULL,
       false, /* ignored */
-      GRPC_STREAM_COMPRESS_LEVEL_NONE, false, false, GRPC_COMPRESS_NONE);
+      GRPC_COMPRESS_LEVEL_NONE, false, false, GRPC_COMPRESS_NONE);
 }
 
 static void test_invoke_request_with_send_message_before_initial_metadata(
     grpc_end2end_test_config config) {
   request_with_payload_template(
       config, "test_invoke_request_with_send_message_before_initial_metadata",
-      0, GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_GZIP,
+      0, GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_STREAM_GZIP,
-      GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_GZIP, NULL,
+      GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_STREAM_GZIP, NULL,
       false, /* ignored */
-      GRPC_STREAM_COMPRESS_LEVEL_NONE, true, false, GRPC_COMPRESS_NONE);
+      GRPC_COMPRESS_LEVEL_NONE, true, false, GRPC_COMPRESS_NONE);
 }
 
 static void test_invoke_request_with_server_level(
     grpc_end2end_test_config config) {
   request_with_payload_template(
-      config, "test_invoke_request_with_server_level", 0,
+      config, "test_invoke_request_with_server_level", 0, GRPC_COMPRESS_NONE,
-      GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_NONE,
+      GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_STREAM_GZIP,
-      GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_GZIP,
+      /* ignored */ NULL, true, GRPC_COMPRESS_LEVEL_STREAM_HIGH, false, false,
-      /* ignored */ NULL, true, GRPC_STREAM_COMPRESS_LEVEL_HIGH, false, false,
       GRPC_COMPRESS_NONE);
 }
 
@@ -590,7 +581,7 @@ static void test_invoke_request_with_compressed_payload_md_override(
 
   gzip_compression_override.key =
       GRPC_MDSTR_GRPC_INTERNAL_STREAM_ENCODING_REQUEST;
-  gzip_compression_override.value = grpc_slice_from_static_string("gzip");
+  gzip_compression_override.value = grpc_slice_from_static_string("stream/gzip");
   memset(&gzip_compression_override.internal_data, 0,
          sizeof(gzip_compression_override.internal_data));
 
@@ -604,40 +595,35 @@ static void test_invoke_request_with_compressed_payload_md_override(
   /* Channel default NONE (aka IDENTITY), call override to stream GZIP */
   request_with_payload_template(
       config, "test_invoke_request_with_compressed_payload_md_override_1", 0,
-      GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_NONE,
+      GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_STREAM_GZIP,
-      GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_NONE,
+      GRPC_COMPRESS_NONE, &gzip_compression_override, false,
-      &gzip_compression_override, false,
+      /*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false, false, GRPC_COMPRESS_NONE);
-      /*ignored*/ GRPC_STREAM_COMPRESS_LEVEL_NONE, false, false,
-      GRPC_COMPRESS_NONE);
 
   /* Channel default stream GZIP, call override to NONE (aka IDENTITY) */
   request_with_payload_template(
       config, "test_invoke_request_with_compressed_payload_md_override_3", 0,
-      GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_NONE,
+      GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
-      GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_NONE,
+      GRPC_COMPRESS_NONE, &identity_compression_override, false,
-      &identity_compression_override, false,
+      /*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false, false, GRPC_COMPRESS_NONE);
-      /*ignored*/ GRPC_STREAM_COMPRESS_LEVEL_NONE, false, false,
-      GRPC_COMPRESS_NONE);
 }
 
 static void test_invoke_request_with_disabled_algorithm(
     grpc_end2end_test_config config) {
   request_for_disabled_algorithm(
       config, "test_invoke_request_with_disabled_algorithm", 0,
-      GRPC_STREAM_COMPRESS_GZIP, GRPC_STREAM_COMPRESS_GZIP,
+      GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_STREAM_GZIP,
       GRPC_STATUS_UNIMPLEMENTED, NULL);
 }
 
 static void test_stream_compression_override_message_compression(
     grpc_end2end_test_config config) {
-  grpc_stream_compression_level level = GRPC_STREAM_COMPRESS_LEVEL_MED;
+  grpc_compression_level level = GRPC_COMPRESS_LEVEL_STREAM_MED;
   request_with_payload_template(
       config, "test_stream_compression_override_message_compression", 0,
-      GRPC_STREAM_COMPRESS_NONE, GRPC_STREAM_COMPRESS_NONE,
+      GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
-      GRPC_STREAM_COMPRESS_NONE,
+      grpc_compression_algorithm_for_level(
-      grpc_stream_compression_algorithm_for_level(
+          level, (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1),
-          level, (1u << GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) - 1),
+      /* ignored */ NULL, true, level, false, true, GRPC_COMPRESS_MESSAGE_GZIP);
-      /* ignored */ NULL, true, level, false, true, GRPC_COMPRESS_GZIP);
 }
 
 void stream_compression_compressed_payload(grpc_end2end_test_config config) {

test/core/end2end/tests/stream_compression_payload.c

@@ -265,12 +265,10 @@ static void request_response_with_payload(grpc_end2end_test_config config,
    payload and status. */
 static void test_invoke_request_response_with_payload(
     grpc_end2end_test_config config) {
-  grpc_channel_args *client_args =
+  grpc_channel_args *client_args = grpc_channel_args_set_compression_algorithm(
-      grpc_channel_args_set_stream_compression_algorithm(
+      NULL, GRPC_COMPRESS_STREAM_GZIP);
-          NULL, GRPC_STREAM_COMPRESS_GZIP);
+  grpc_channel_args *server_args = grpc_channel_args_set_compression_algorithm(
-  grpc_channel_args *server_args =
+      NULL, GRPC_COMPRESS_STREAM_GZIP);
-      grpc_channel_args_set_stream_compression_algorithm(
-          NULL, GRPC_STREAM_COMPRESS_GZIP);
   grpc_end2end_test_fixture f =
       begin_test(config, "test_invoke_request_response_with_payload",
                  client_args, server_args);

test/core/end2end/tests/stream_compression_ping_pong_streaming.c

@@ -90,12 +90,10 @@ static void end_test(grpc_end2end_test_fixture *f) {
 /* Client pings and server pongs. Repeat messages rounds before finishing. */
 static void test_pingpong_streaming(grpc_end2end_test_config config,
                                     int messages) {
-  grpc_channel_args *client_args =
+  grpc_channel_args *client_args = grpc_channel_args_set_compression_algorithm(
-      grpc_channel_args_set_stream_compression_algorithm(
+      NULL, GRPC_COMPRESS_STREAM_GZIP);
-          NULL, GRPC_STREAM_COMPRESS_GZIP);
+  grpc_channel_args *server_args = grpc_channel_args_set_compression_algorithm(
-  grpc_channel_args *server_args =
+      NULL, GRPC_COMPRESS_STREAM_GZIP);
-      grpc_channel_args_set_stream_compression_algorithm(
-          NULL, GRPC_STREAM_COMPRESS_GZIP);
   grpc_end2end_test_fixture f =
       begin_test(config, "test_pingpong_streaming", client_args, server_args);
   grpc_call *c;

test/core/end2end/tests/workaround_cronet_compression.c

@@ -208,9 +208,9 @@ static void request_with_payload_template(
   GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
                         GRPC_COMPRESS_NONE) != 0);
   GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
-                        GRPC_COMPRESS_DEFLATE) != 0);
+                        GRPC_COMPRESS_MESSAGE_DEFLATE) != 0);
   GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
-                        GRPC_COMPRESS_GZIP) != 0);
+                        GRPC_COMPRESS_MESSAGE_GZIP) != 0);
 
   memset(ops, 0, sizeof(ops));
   op = ops;
@@ -365,13 +365,13 @@ typedef struct workaround_cronet_compression_config {
 } workaround_cronet_compression_config;
 
 static workaround_cronet_compression_config workaround_configs[] = {
-    {NULL, GRPC_COMPRESS_GZIP},
+    {NULL, GRPC_COMPRESS_MESSAGE_GZIP},
     {"grpc-objc/1.3.0-dev grpc-c/3.0.0-dev (ios; cronet_http; gentle)",
      GRPC_COMPRESS_NONE},
     {"grpc-objc/1.3.0-dev grpc-c/3.0.0-dev (ios; chttp2; gentle)",
-     GRPC_COMPRESS_GZIP},
+     GRPC_COMPRESS_MESSAGE_GZIP},
     {"grpc-objc/1.4.0 grpc-c/3.0.0-dev (ios; cronet_http; gentle)",
-     GRPC_COMPRESS_GZIP}};
+     GRPC_COMPRESS_MESSAGE_GZIP}};
 static const size_t workaround_configs_num =
     sizeof(workaround_configs) / sizeof(*workaround_configs);
 
@@ -380,7 +380,8 @@ static void test_workaround_cronet_compression(
   for (uint32_t i = 0; i < workaround_configs_num; i++) {
     request_with_payload_template(
         config, "test_invoke_request_with_compressed_payload", 0,
-        GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
+        GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_GZIP,
+        GRPC_COMPRESS_MESSAGE_GZIP,
         workaround_configs[i].expected_algorithm_from_server, NULL, false,
         /* ignored */ GRPC_COMPRESS_LEVEL_NONE,
         workaround_configs[i].user_agent_override);

test/core/surface/byte_buffer_reader_test.c

@@ -109,7 +109,7 @@ static void test_read_corrupted_slice(void) {
   LOG_TEST("test_read_corrupted_slice");
   slice = grpc_slice_from_copied_string("test");
   buffer = grpc_raw_byte_buffer_create(&slice, 1);
-  buffer->data.raw.compression = GRPC_COMPRESS_GZIP; /* lies! */
+  buffer->data.raw.compression = GRPC_COMPRESS_MESSAGE_GZIP; /* lies! */
   grpc_slice_unref(slice);
   GPR_ASSERT(!grpc_byte_buffer_reader_init(&reader, buffer));
   grpc_byte_buffer_destroy(buffer);
@@ -134,7 +134,7 @@ static void read_compressed_slice(grpc_compression_algorithm algorithm,
   {
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
     GPR_ASSERT(
-        grpc_msg_compress(&exec_ctx, algorithm, &sliceb_in, &sliceb_out));
+        grpc_msg_compress(&exec_ctx, grpc_compression_algorithm_to_message_compression_algorithm(algorithm), &sliceb_in, &sliceb_out));
     grpc_exec_ctx_finish(&exec_ctx);
   }
 
@@ -160,13 +160,13 @@ static void read_compressed_slice(grpc_compression_algorithm algorithm,
 static void test_read_gzip_compressed_slice(void) {
   const size_t INPUT_SIZE = 2048;
   LOG_TEST("test_read_gzip_compressed_slice");
-  read_compressed_slice(GRPC_COMPRESS_GZIP, INPUT_SIZE);
+  read_compressed_slice(GRPC_COMPRESS_MESSAGE_GZIP, INPUT_SIZE);
 }
 
 static void test_read_deflate_compressed_slice(void) {
   const size_t INPUT_SIZE = 2048;
   LOG_TEST("test_read_deflate_compressed_slice");
-  read_compressed_slice(GRPC_COMPRESS_DEFLATE, INPUT_SIZE);
+  read_compressed_slice(GRPC_COMPRESS_MESSAGE_DEFLATE, INPUT_SIZE);
 }
 
 static void test_byte_buffer_from_reader(void) {

tools/codegen/core/gen_static_metadata.py

@@ -53,6 +53,10 @@ CONFIG = [
     'grpc.max_response_message_bytes',
     # well known method names
     '/grpc.lb.v1.LoadBalancer/BalanceLoad',
+    # compression algorithm names
+    'message/deflate',
+    'message/gzip',
+    'stream/gzip',
     # metadata elements
     ('grpc-status', '0'),
     ('grpc-status', '1'),