grpc 1.9.1 → 1.10.0.pre1

data/src/core/lib/channel/channel_stack_builder.cc

@@ -52,7 +52,7 @@ struct grpc_channel_stack_builder_iterator {
 
 grpc_channel_stack_builder* grpc_channel_stack_builder_create(void) {
   grpc_channel_stack_builder* b =
-      (grpc_channel_stack_builder*)gpr_zalloc(sizeof(*b));
+      static_cast<grpc_channel_stack_builder*>(gpr_zalloc(sizeof(*b)));
 
   b->begin.filter = nullptr;
   b->end.filter = nullptr;
@@ -78,7 +78,8 @@ const char* grpc_channel_stack_builder_get_target(
 static grpc_channel_stack_builder_iterator* create_iterator_at_filter_node(
     grpc_channel_stack_builder* builder, filter_node* node) {
   grpc_channel_stack_builder_iterator* it =
-      (grpc_channel_stack_builder_iterator*)gpr_malloc(sizeof(*it));
+      static_cast<grpc_channel_stack_builder_iterator*>(
+          gpr_malloc(sizeof(*it)));
   it->builder = builder;
   it->node = node;
   return it;
@@ -213,7 +214,8 @@ bool grpc_channel_stack_builder_prepend_filter(
 static void add_after(filter_node* before, const grpc_channel_filter* filter,
                       grpc_post_filter_create_init_func post_init_func,
                       void* user_data) {
-  filter_node* new_node = (filter_node*)gpr_malloc(sizeof(*new_node));
+  filter_node* new_node =
+      static_cast<filter_node*>(gpr_malloc(sizeof(*new_node)));
   new_node->next = before->next;
   new_node->prev = before;
   new_node->next->prev = new_node->prev->next = new_node;
@@ -265,7 +267,8 @@ grpc_error* grpc_channel_stack_builder_finish(
 
   // create an array of filters
   const grpc_channel_filter** filters =
-      (const grpc_channel_filter**)gpr_malloc(sizeof(*filters) * num_filters);
+      static_cast<const grpc_channel_filter**>(
+          gpr_malloc(sizeof(*filters) * num_filters));
   size_t i = 0;
   for (filter_node* p = builder->begin.next; p != &builder->end; p = p->next) {
     filters[i++] = p->filter;
@@ -277,8 +280,8 @@ grpc_error* grpc_channel_stack_builder_finish(
   // allocate memory, with prefix_bytes followed by channel_stack_size
   *result = gpr_zalloc(prefix_bytes + channel_stack_size);
   // fetch a pointer to the channel stack
-  grpc_channel_stack* channel_stack =
-      (grpc_channel_stack*)((char*)(*result) + prefix_bytes);
+  grpc_channel_stack* channel_stack = reinterpret_cast<grpc_channel_stack*>(
+      static_cast<char*>(*result) + prefix_bytes);
   // and initialize it
   grpc_error* error = grpc_channel_stack_init(
       initial_refs, destroy, destroy_arg == nullptr ? *result : destroy_arg,
@@ -303,7 +306,7 @@ grpc_error* grpc_channel_stack_builder_finish(
   }
 
   grpc_channel_stack_builder_destroy(builder);
-  gpr_free((grpc_channel_filter**)filters);
+  gpr_free(const_cast<grpc_channel_filter**>(filters));
 
   return error;
 }

data/src/core/lib/channel/connected_channel.cc

@@ -52,7 +52,7 @@ typedef struct connected_channel_call_data {
 } call_data;
 
 static void run_in_call_combiner(void* arg, grpc_error* error) {
-  callback_state* state = (callback_state*)arg;
+  callback_state* state = static_cast<callback_state*>(arg);
   GRPC_CALL_COMBINER_START(state->call_combiner, state->original_closure,
                            GRPC_ERROR_REF(error), state->reason);
 }
@@ -96,8 +96,8 @@ static callback_state* get_state_for_batch(
    into transport stream operations */
 static void con_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
-  call_data* calld = (call_data*)elem->call_data;
-  channel_data* chand = (channel_data*)elem->channel_data;
+  call_data* calld = static_cast<call_data*>(elem->call_data);
+  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   if (batch->recv_initial_metadata) {
     callback_state* state = &calld->recv_initial_metadata_ready;
     intercept_callback(
@@ -115,7 +115,8 @@ static void con_start_transport_stream_op_batch(
     // calld->on_complete like we can for the other ops.  However,
     // cancellation isn't in the fast path, so we just allocate a new
     // closure for each one.
-    callback_state* state = (callback_state*)gpr_malloc(sizeof(*state));
+    callback_state* state =
+        static_cast<callback_state*>(gpr_malloc(sizeof(*state)));
     intercept_callback(calld, state, true, "on_complete (cancel_stream)",
                        &batch->on_complete);
   } else {
@@ -129,15 +130,15 @@ static void con_start_transport_stream_op_batch(
 
 static void con_start_transport_op(grpc_channel_element* elem,
                                    grpc_transport_op* op) {
-  channel_data* chand = (channel_data*)elem->channel_data;
+  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   grpc_transport_perform_op(chand->transport, op);
 }
 
 /* Constructor for call_data */
 static grpc_error* init_call_elem(grpc_call_element* elem,
                                   const grpc_call_element_args* args) {
-  call_data* calld = (call_data*)elem->call_data;
-  channel_data* chand = (channel_data*)elem->channel_data;
+  call_data* calld = static_cast<call_data*>(elem->call_data);
+  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   calld->call_combiner = args->call_combiner;
   int r = grpc_transport_init_stream(
       chand->transport, TRANSPORT_STREAM_FROM_CALL_DATA(calld),
@@ -149,8 +150,8 @@ static grpc_error* init_call_elem(grpc_call_element* elem,
 
 static void set_pollset_or_pollset_set(grpc_call_element* elem,
                                        grpc_polling_entity* pollent) {
-  call_data* calld = (call_data*)elem->call_data;
-  channel_data* chand = (channel_data*)elem->channel_data;
+  call_data* calld = static_cast<call_data*>(elem->call_data);
+  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   grpc_transport_set_pops(chand->transport,
                           TRANSPORT_STREAM_FROM_CALL_DATA(calld), pollent);
 }
@@ -159,8 +160,8 @@ static void set_pollset_or_pollset_set(grpc_call_element* elem,
 static void destroy_call_elem(grpc_call_element* elem,
                               const grpc_call_final_info* final_info,
                               grpc_closure* then_schedule_closure) {
-  call_data* calld = (call_data*)elem->call_data;
-  channel_data* chand = (channel_data*)elem->channel_data;
+  call_data* calld = static_cast<call_data*>(elem->call_data);
+  channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   grpc_transport_destroy_stream(chand->transport,
                                 TRANSPORT_STREAM_FROM_CALL_DATA(calld),
                                 then_schedule_closure);
@@ -169,7 +170,7 @@ static void destroy_call_elem(grpc_call_element* elem,
 /* Constructor for channel_data */
 static grpc_error* init_channel_elem(grpc_channel_element* elem,
                                      grpc_channel_element_args* args) {
-  channel_data* cd = (channel_data*)elem->channel_data;
+  channel_data* cd = static_cast<channel_data*>(elem->channel_data);
   GPR_ASSERT(args->is_last);
   cd->transport = nullptr;
   return GRPC_ERROR_NONE;
@@ -177,7 +178,7 @@ static grpc_error* init_channel_elem(grpc_channel_element* elem,
 
 /* Destructor for channel_data */
 static void destroy_channel_elem(grpc_channel_element* elem) {
-  channel_data* cd = (channel_data*)elem->channel_data;
+  channel_data* cd = static_cast<channel_data*>(elem->channel_data);
   if (cd->transport) {
     grpc_transport_destroy(cd->transport);
   }
@@ -203,10 +204,10 @@ const grpc_channel_filter grpc_connected_filter = {
 
 static void bind_transport(grpc_channel_stack* channel_stack,
                            grpc_channel_element* elem, void* t) {
-  channel_data* cd = (channel_data*)elem->channel_data;
+  channel_data* cd = static_cast<channel_data*>(elem->channel_data);
   GPR_ASSERT(elem->filter == &grpc_connected_filter);
   GPR_ASSERT(cd->transport == nullptr);
-  cd->transport = (grpc_transport*)t;
+  cd->transport = static_cast<grpc_transport*>(t);
 
   /* HACK(ctiller): increase call stack size for the channel to make space
      for channel data. We need a cleaner (but performant) way to do this,
@@ -215,7 +216,7 @@ static void bind_transport(grpc_channel_stack* channel_stack,
      the last call element, and the last call element MUST be the connected
      channel. */
   channel_stack->call_stack_size +=
-      grpc_transport_stream_size((grpc_transport*)t);
+      grpc_transport_stream_size(static_cast<grpc_transport*>(t));
 }
 
 bool grpc_add_connected_filter(grpc_channel_stack_builder* builder,
@@ -228,6 +229,6 @@ bool grpc_add_connected_filter(grpc_channel_stack_builder* builder,
 }
 
 grpc_stream* grpc_connected_channel_get_stream(grpc_call_element* elem) {
-  call_data* calld = (call_data*)elem->call_data;
+  call_data* calld = static_cast<call_data*>(elem->call_data);
   return TRANSPORT_STREAM_FROM_CALL_DATA(calld);
 }

data/src/core/lib/channel/handshaker.cc

@@ -81,8 +81,8 @@ struct grpc_handshake_manager {
 };
 
 grpc_handshake_manager* grpc_handshake_manager_create() {
-  grpc_handshake_manager* mgr =
-      (grpc_handshake_manager*)gpr_zalloc(sizeof(grpc_handshake_manager));
+  grpc_handshake_manager* mgr = static_cast<grpc_handshake_manager*>(
+      gpr_zalloc(sizeof(grpc_handshake_manager)));
   gpr_mu_init(&mgr->mu);
   gpr_ref_init(&mgr->refs, 1);
   return mgr;
@@ -135,8 +135,8 @@ void grpc_handshake_manager_add(grpc_handshake_manager* mgr,
     realloc_count = mgr->count * 2;
   }
   if (realloc_count > 0) {
-    mgr->handshakers = (grpc_handshaker**)gpr_realloc(
-        mgr->handshakers, realloc_count * sizeof(grpc_handshaker*));
+    mgr->handshakers = static_cast<grpc_handshaker**>(gpr_realloc(
+        mgr->handshakers, realloc_count * sizeof(grpc_handshaker*)));
   }
   mgr->handshakers[mgr->count++] = handshaker;
   gpr_mu_unlock(&mgr->mu);
@@ -197,7 +197,7 @@ static bool call_next_handshaker_locked(grpc_handshake_manager* mgr,
 // A function used as the handshaker-done callback when chaining
 // handshakers together.
 static void call_next_handshaker(void* arg, grpc_error* error) {
-  grpc_handshake_manager* mgr = (grpc_handshake_manager*)arg;
+  grpc_handshake_manager* mgr = static_cast<grpc_handshake_manager*>(arg);
   gpr_mu_lock(&mgr->mu);
   bool done = call_next_handshaker_locked(mgr, GRPC_ERROR_REF(error));
   gpr_mu_unlock(&mgr->mu);
@@ -211,7 +211,7 @@ static void call_next_handshaker(void* arg, grpc_error* error) {
 
 // Callback invoked when deadline is exceeded.
 static void on_timeout(void* arg, grpc_error* error) {
-  grpc_handshake_manager* mgr = (grpc_handshake_manager*)arg;
+  grpc_handshake_manager* mgr = static_cast<grpc_handshake_manager*>(arg);
   if (error == GRPC_ERROR_NONE) {  // Timer fired, rather than being cancelled.
     grpc_handshake_manager_shutdown(
         mgr, GRPC_ERROR_CREATE_FROM_STATIC_STRING("Handshake timed out"));
@@ -233,8 +233,8 @@ void grpc_handshake_manager_do_handshake(
   mgr->args.endpoint = endpoint;
   mgr->args.args = grpc_channel_args_copy(channel_args);
   mgr->args.user_data = user_data;
-  mgr->args.read_buffer =
-      (grpc_slice_buffer*)gpr_malloc(sizeof(*mgr->args.read_buffer));
+  mgr->args.read_buffer = static_cast<grpc_slice_buffer*>(
+      gpr_malloc(sizeof(*mgr->args.read_buffer)));
   grpc_slice_buffer_init(mgr->args.read_buffer);
   // Initialize state needed for calling handshakers.
   mgr->acceptor = acceptor;

data/src/core/lib/channel/handshaker_registry.cc

@@ -34,8 +34,9 @@ typedef struct {
 static void grpc_handshaker_factory_list_register(
     grpc_handshaker_factory_list* list, bool at_start,
     grpc_handshaker_factory* factory) {
-  list->list = (grpc_handshaker_factory**)gpr_realloc(
-      list->list, (list->num_factories + 1) * sizeof(grpc_handshaker_factory*));
+  list->list = static_cast<grpc_handshaker_factory**>(gpr_realloc(
+      list->list,
+      (list->num_factories + 1) * sizeof(grpc_handshaker_factory*)));
   if (at_start) {
     memmove(list->list + 1, list->list,
             sizeof(grpc_handshaker_factory*) * list->num_factories);

data/src/core/lib/compression/algorithm_metadata.h

@@ -20,20 +20,27 @@
 #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 */
-grpc_slice grpc_stream_compression_algorithm_slice(
-    grpc_stream_compression_algorithm algorithm);
+/** Find compression algorithm based on passed in mdstr - returns
+ *  GRPC_COMPRESS_ALGORITHM_COUNT on failure */
+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 +48,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_slice str);
+grpc_message_compression_algorithm
+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 */

data/src/core/lib/compression/compression.cc

@@ -20,43 +20,42 @@
 #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/gpr/useful.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_DEFLATE && algorithm <= GRPC_COMPRESS_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)) {
-    *algorithm = GRPC_COMPRESS_GZIP;
-    return 1;
   } else if (grpc_slice_eq(name, GRPC_MDSTR_DEFLATE)) {
     *algorithm = GRPC_COMPRESS_DEFLATE;
     return 1;
-  } else {
-    return 0;
-  }
-}
-
-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)) {
-    *algorithm = GRPC_STREAM_COMPRESS_GZIP;
+    *algorithm = GRPC_COMPRESS_GZIP;
+    return 1;
+  } else if (grpc_slice_eq(name, GRPC_MDSTR_STREAM_SLASH_GZIP)) {
+    *algorithm = GRPC_COMPRESS_STREAM_GZIP;
     return 1;
   } else {
     return 0;
   }
+  return 0;
 }
 
 int grpc_compression_algorithm_name(grpc_compression_algorithm algorithm,
@@ -73,43 +72,59 @@ int grpc_compression_algorithm_name(grpc_compression_algorithm algorithm,
     case GRPC_COMPRESS_GZIP:
       *name = "gzip";
       return 1;
+    case GRPC_COMPRESS_STREAM_GZIP:
+      *name = "stream/gzip";
+      return 1;
     case GRPC_COMPRESS_ALGORITHMS_COUNT:
       return 0;
   }
   return 0;
 }
 
-int grpc_stream_compression_algorithm_name(
-    grpc_stream_compression_algorithm algorithm, const char** name) {
-  GRPC_API_TRACE(
-      "grpc_stream_compression_algorithm_parse(algorithm=%d, name=%p)", 2,
-      ((int)algorithm, name));
-  switch (algorithm) {
-    case GRPC_STREAM_COMPRESS_NONE:
-      *name = "identity";
-      return 1;
-    case GRPC_STREAM_COMPRESS_GZIP:
-      *name = "gzip";
-      return 1;
-    case GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT:
-      return 0;
+grpc_compression_algorithm grpc_compression_algorithm_for_level(
+    grpc_compression_level level, uint32_t accepted_encodings) {
+  grpc_compression_algorithm algo;
+  if (level == GRPC_COMPRESS_LEVEL_NONE) {
+    return GRPC_COMPRESS_NONE;
+  } else if (level <= GRPC_COMPRESS_LEVEL_HIGH) {
+    // TODO(mxyan): Design algorithm to select from all algorithms, including
+    // stream compression algorithm
+    if (!grpc_compression_algorithm_from_message_stream_compression_algorithm(
+            &algo,
+            grpc_message_compression_algorithm_for_level(
+                level,
+                grpc_compression_bitset_to_message_bitset(accepted_encodings)),
+            static_cast<grpc_stream_compression_algorithm>(0))) {
+      gpr_log(GPR_ERROR, "Parse compression level error");
+      return GRPC_COMPRESS_NONE;
+    }
+    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(
-    grpc_slice str) {
-  if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY)) return GRPC_COMPRESS_NONE;
-  if (grpc_slice_eq(str, GRPC_MDSTR_DEFLATE)) return GRPC_COMPRESS_DEFLATE;
-  if (grpc_slice_eq(str, GRPC_MDSTR_GZIP)) return GRPC_COMPRESS_GZIP;
-  return GRPC_COMPRESS_ALGORITHMS_COUNT;
+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;
 }
 
-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;
+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);
 }
 
 grpc_slice grpc_compression_algorithm_slice(
@@ -121,23 +136,22 @@ grpc_slice grpc_compression_algorithm_slice(
       return GRPC_MDSTR_DEFLATE;
     case GRPC_COMPRESS_GZIP:
       return GRPC_MDSTR_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_stream_compression_algorithm algorithm) {
-  switch (algorithm) {
-    case GRPC_STREAM_COMPRESS_NONE:
-      return GRPC_MDSTR_IDENTITY;
-    case GRPC_STREAM_COMPRESS_GZIP:
-      return GRPC_MDSTR_GZIP;
-    case GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT:
-      return grpc_empty_slice();
-  }
-  return grpc_empty_slice();
+grpc_compression_algorithm grpc_compression_algorithm_from_slice(
+    grpc_slice str) {
+  if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY)) return GRPC_COMPRESS_NONE;
+  if (grpc_slice_eq(str, GRPC_MDSTR_DEFLATE)) return GRPC_COMPRESS_DEFLATE;
+  if (grpc_slice_eq(str, GRPC_MDSTR_GZIP)) return GRPC_COMPRESS_GZIP;
+  if (grpc_slice_eq(str, GRPC_MDSTR_STREAM_SLASH_GZIP))
+    return GRPC_COMPRESS_STREAM_GZIP;
+  return GRPC_COMPRESS_ALGORITHMS_COUNT;
 }
 
 grpc_mdelem grpc_compression_encoding_mdelem(
@@ -149,135 +163,10 @@ grpc_mdelem grpc_compression_encoding_mdelem(
       return GRPC_MDELEM_GRPC_ENCODING_DEFLATE;
     case GRPC_COMPRESS_GZIP:
       return GRPC_MDELEM_GRPC_ENCODING_GZIP;
+    case GRPC_COMPRESS_STREAM_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;
-}
-
-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();
-  }
-}