grpc 1.9.1 → 1.10.0.pre1

data/src/core/lib/slice/slice_buffer.cc

@@ -23,8 +23,8 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/useful.h>
 
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 /* grow a buffer; requires GRPC_SLICE_BUFFER_INLINE_ELEMENTS > 1 */
@@ -32,7 +32,7 @@
 
 static void maybe_embiggen(grpc_slice_buffer* sb) {
   /* How far away from sb->base_slices is sb->slices pointer */
-  size_t slice_offset = (size_t)(sb->slices - sb->base_slices);
+  size_t slice_offset = static_cast<size_t>(sb->slices - sb->base_slices);
   size_t slice_count = sb->count + slice_offset;
 
   if (slice_count == sb->capacity) {
@@ -45,12 +45,12 @@ static void maybe_embiggen(grpc_slice_buffer* sb) {
       sb->capacity = GROW(sb->capacity);
       GPR_ASSERT(sb->capacity > slice_count);
       if (sb->base_slices == sb->inlined) {
-        sb->base_slices =
-            (grpc_slice*)gpr_malloc(sb->capacity * sizeof(grpc_slice));
+        sb->base_slices = static_cast<grpc_slice*>(
+            gpr_malloc(sb->capacity * sizeof(grpc_slice)));
         memcpy(sb->base_slices, sb->inlined, slice_count * sizeof(grpc_slice));
       } else {
-        sb->base_slices = (grpc_slice*)gpr_realloc(
-            sb->base_slices, sb->capacity * sizeof(grpc_slice));
+        sb->base_slices = static_cast<grpc_slice*>(
+            gpr_realloc(sb->base_slices, sb->capacity * sizeof(grpc_slice)));
       }
 
       sb->slices = sb->base_slices + slice_offset;
@@ -89,7 +89,8 @@ uint8_t* grpc_slice_buffer_tiny_add(grpc_slice_buffer* sb, size_t n) {
   if ((back->data.inlined.length + n) > sizeof(back->data.inlined.bytes))
     goto add_new;
   out = back->data.inlined.bytes + back->data.inlined.length;
-  back->data.inlined.length = (uint8_t)(back->data.inlined.length + n);
+  back->data.inlined.length =
+      static_cast<uint8_t>(back->data.inlined.length + n);
   return out;
 
 add_new:
@@ -97,7 +98,7 @@ add_new:
   back = &sb->slices[sb->count];
   sb->count++;
   back->refcount = nullptr;
-  back->data.inlined.length = (uint8_t)n;
+  back->data.inlined.length = static_cast<uint8_t>(n);
   return back->data.inlined.bytes;
 }
 
@@ -125,8 +126,8 @@ void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice s) {
           GRPC_SLICE_INLINED_SIZE) {
         memcpy(back->data.inlined.bytes + back->data.inlined.length,
                s.data.inlined.bytes, s.data.inlined.length);
-        back->data.inlined.length =
-            (uint8_t)(back->data.inlined.length + s.data.inlined.length);
+        back->data.inlined.length = static_cast<uint8_t>(
+            back->data.inlined.length + s.data.inlined.length);
       } else {
         size_t cp1 = GRPC_SLICE_INLINED_SIZE - back->data.inlined.length;
         memcpy(back->data.inlined.bytes + back->data.inlined.length,
@@ -136,7 +137,8 @@ void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice s) {
         back = &sb->slices[n];
         sb->count = n + 1;
         back->refcount = nullptr;
-        back->data.inlined.length = (uint8_t)(s.data.inlined.length - cp1);
+        back->data.inlined.length =
+            static_cast<uint8_t>(s.data.inlined.length - cp1);
         memcpy(back->data.inlined.bytes, s.data.inlined.bytes + cp1,
                s.data.inlined.length - cp1);
       }
@@ -177,8 +179,8 @@ void grpc_slice_buffer_reset_and_unref(grpc_slice_buffer* sb) {
 }
 
 void grpc_slice_buffer_swap(grpc_slice_buffer* a, grpc_slice_buffer* b) {
-  size_t a_offset = (size_t)(a->slices - a->base_slices);
-  size_t b_offset = (size_t)(b->slices - b->base_slices);
+  size_t a_offset = static_cast<size_t>(a->slices - a->base_slices);
+  size_t b_offset = static_cast<size_t>(b->slices - b->base_slices);
 
   size_t a_count = a->count + a_offset;
   size_t b_count = b->count + b_offset;
@@ -287,7 +289,7 @@ void grpc_slice_buffer_move_first_no_ref(grpc_slice_buffer* src, size_t n,
 
 void grpc_slice_buffer_move_first_into_buffer(grpc_slice_buffer* src, size_t n,
                                               void* dst) {
-  char* dstp = (char*)dst;
+  char* dstp = static_cast<char*>(dst);
   GPR_ASSERT(src->length >= n);
 
   while (n > 0) {

data/src/core/lib/slice/slice_hash_table.cc

@@ -60,14 +60,15 @@ grpc_slice_hash_table* grpc_slice_hash_table_create(
     size_t num_entries, grpc_slice_hash_table_entry* entries,
     void (*destroy_value)(void* value), int (*value_cmp)(void* a, void* b)) {
   grpc_slice_hash_table* table =
-      (grpc_slice_hash_table*)gpr_zalloc(sizeof(*table));
+      static_cast<grpc_slice_hash_table*>(gpr_zalloc(sizeof(*table)));
   gpr_ref_init(&table->refs, 1);
   table->destroy_value = destroy_value;
   table->value_cmp = value_cmp;
   // Keep load factor low to improve performance of lookups.
   table->size = num_entries * 2;
   const size_t entry_size = sizeof(grpc_slice_hash_table_entry) * table->size;
-  table->entries = (grpc_slice_hash_table_entry*)gpr_zalloc(entry_size);
+  table->entries =
+      static_cast<grpc_slice_hash_table_entry*>(gpr_zalloc(entry_size));
   for (size_t i = 0; i < num_entries; ++i) {
     grpc_slice_hash_table_entry* entry = &entries[i];
     grpc_slice_hash_table_add(table, entry->key, entry->value);

data/src/core/lib/slice/slice_intern.cc

@@ -70,7 +70,7 @@ static uint32_t max_static_metadata_hash_probe;
 static uint32_t static_metadata_hash_values[GRPC_STATIC_MDSTR_COUNT];
 
 static void interned_slice_ref(void* p) {
-  interned_slice_refcount* s = (interned_slice_refcount*)p;
+  interned_slice_refcount* s = static_cast<interned_slice_refcount*>(p);
   GPR_ASSERT(gpr_atm_no_barrier_fetch_add(&s->refcnt, 1) > 0);
 }
 
@@ -91,22 +91,25 @@ static void interned_slice_destroy(interned_slice_refcount* s) {
 }
 
 static void interned_slice_unref(void* p) {
-  interned_slice_refcount* s = (interned_slice_refcount*)p;
+  interned_slice_refcount* s = static_cast<interned_slice_refcount*>(p);
   if (1 == gpr_atm_full_fetch_add(&s->refcnt, -1)) {
     interned_slice_destroy(s);
   }
 }
 
 static void interned_slice_sub_ref(void* p) {
-  interned_slice_ref(((char*)p) - offsetof(interned_slice_refcount, sub));
+  interned_slice_ref((static_cast<char*>(p)) -
+                     offsetof(interned_slice_refcount, sub));
 }
 
 static void interned_slice_sub_unref(void* p) {
-  interned_slice_unref(((char*)p) - offsetof(interned_slice_refcount, sub));
+  interned_slice_unref((static_cast<char*>(p)) -
+                       offsetof(interned_slice_refcount, sub));
 }
 
 static uint32_t interned_slice_hash(grpc_slice slice) {
-  interned_slice_refcount* s = (interned_slice_refcount*)slice.refcount;
+  interned_slice_refcount* s =
+      reinterpret_cast<interned_slice_refcount*>(slice.refcount);
   return s->hash;
 }
 
@@ -122,15 +125,15 @@ static const grpc_slice_refcount_vtable interned_slice_sub_vtable = {
     grpc_slice_default_eq_impl, grpc_slice_default_hash_impl};
 
 static void grow_shard(slice_shard* shard) {
+  GPR_TIMER_SCOPE("grow_strtab", 0);
+
   size_t capacity = shard->capacity * 2;
   size_t i;
   interned_slice_refcount** strtab;
   interned_slice_refcount *s, *next;
 
-  GPR_TIMER_BEGIN("grow_strtab", 0);
-
-  strtab = (interned_slice_refcount**)gpr_zalloc(
-      sizeof(interned_slice_refcount*) * capacity);
+  strtab = static_cast<interned_slice_refcount**>(
+      gpr_zalloc(sizeof(interned_slice_refcount*) * capacity));
 
   for (i = 0; i < shard->capacity; i++) {
     for (s = shard->strs[i]; s; s = next) {
@@ -140,18 +143,15 @@ static void grow_shard(slice_shard* shard) {
       strtab[idx] = s;
     }
   }
-
   gpr_free(shard->strs);
   shard->strs = strtab;
   shard->capacity = capacity;
-
-  GPR_TIMER_END("grow_strtab", 0);
 }
 
 static grpc_slice materialize(interned_slice_refcount* s) {
   grpc_slice slice;
   slice.refcount = &s->base;
-  slice.data.refcounted.bytes = (uint8_t*)(s + 1);
+  slice.data.refcounted.bytes = reinterpret_cast<uint8_t*>(s + 1);
   slice.data.refcounted.length = s->length;
   return slice;
 }
@@ -200,9 +200,8 @@ bool grpc_slice_is_interned(grpc_slice slice) {
 }
 
 grpc_slice grpc_slice_intern(grpc_slice slice) {
-  GPR_TIMER_BEGIN("grpc_slice_intern", 0);
+  GPR_TIMER_SCOPE("grpc_slice_intern", 0);
   if (GRPC_IS_STATIC_METADATA_STRING(slice)) {
-    GPR_TIMER_END("grpc_slice_intern", 0);
     return slice;
   }
 
@@ -212,7 +211,6 @@ grpc_slice grpc_slice_intern(grpc_slice slice) {
         static_metadata_hash[(hash + i) % GPR_ARRAY_SIZE(static_metadata_hash)];
     if (ent.hash == hash && ent.idx < GRPC_STATIC_MDSTR_COUNT &&
         grpc_slice_eq(grpc_static_slice_table[ent.idx], slice)) {
-      GPR_TIMER_END("grpc_slice_intern", 0);
       return grpc_static_slice_table[ent.idx];
     }
   }
@@ -235,7 +233,6 @@ grpc_slice grpc_slice_intern(grpc_slice slice) {
         /* and treat this as if we were never here... sshhh */
       } else {
         gpr_mu_unlock(&shard->mu);
-        GPR_TIMER_END("grpc_slice_intern", 0);
         return materialize(s);
       }
     }
@@ -243,8 +240,8 @@ grpc_slice grpc_slice_intern(grpc_slice slice) {
 
   /* not found: create a new string */
   /* string data goes after the internal_string header */
-  s = (interned_slice_refcount*)gpr_malloc(sizeof(*s) +
-                                           GRPC_SLICE_LENGTH(slice));
+  s = static_cast<interned_slice_refcount*>(
+      gpr_malloc(sizeof(*s) + GRPC_SLICE_LENGTH(slice)));
   gpr_atm_rel_store(&s->refcnt, 1);
   s->length = GRPC_SLICE_LENGTH(slice);
   s->hash = hash;
@@ -264,7 +261,6 @@ grpc_slice grpc_slice_intern(grpc_slice slice) {
 
   gpr_mu_unlock(&shard->mu);
 
-  GPR_TIMER_END("grpc_slice_intern", 0);
   return materialize(s);
 }
 
@@ -275,15 +271,15 @@ void grpc_test_only_set_slice_hash_seed(uint32_t seed) {
 
 void grpc_slice_intern_init(void) {
   if (!g_forced_hash_seed) {
-    g_hash_seed = (uint32_t)gpr_now(GPR_CLOCK_REALTIME).tv_nsec;
+    g_hash_seed = static_cast<uint32_t>(gpr_now(GPR_CLOCK_REALTIME).tv_nsec);
   }
   for (size_t i = 0; i < SHARD_COUNT; i++) {
     slice_shard* shard = &g_shards[i];
     gpr_mu_init(&shard->mu);
     shard->count = 0;
     shard->capacity = INITIAL_SHARD_CAPACITY;
-    shard->strs = (interned_slice_refcount**)gpr_zalloc(sizeof(*shard->strs) *
-                                                        shard->capacity);
+    shard->strs = static_cast<interned_slice_refcount**>(
+        gpr_zalloc(sizeof(*shard->strs) * shard->capacity));
   }
   for (size_t i = 0; i < GPR_ARRAY_SIZE(static_metadata_hash); i++) {
     static_metadata_hash[i].hash = 0;
@@ -298,9 +294,9 @@ void grpc_slice_intern_init(void) {
                     GPR_ARRAY_SIZE(static_metadata_hash);
       if (static_metadata_hash[slot].idx == GRPC_STATIC_MDSTR_COUNT) {
         static_metadata_hash[slot].hash = static_metadata_hash_values[i];
-        static_metadata_hash[slot].idx = (uint32_t)i;
+        static_metadata_hash[slot].idx = static_cast<uint32_t>(i);
         if (j > max_static_metadata_hash_probe) {
-          max_static_metadata_hash_probe = (uint32_t)j;
+          max_static_metadata_hash_probe = static_cast<uint32_t>(j);
         }
         break;
       }

data/src/core/lib/slice/slice_string_helpers.cc

@@ -26,8 +26,8 @@
 #include "src/core/lib/slice/slice_internal.h"
 
 char* grpc_dump_slice(grpc_slice s, uint32_t flags) {
-  return gpr_dump((const char*)GRPC_SLICE_START_PTR(s), GRPC_SLICE_LENGTH(s),
-                  flags);
+  return gpr_dump(reinterpret_cast<const char*> GRPC_SLICE_START_PTR(s),
+                  GRPC_SLICE_LENGTH(s), flags);
 }
 
 /** Finds the initial (\a begin) and final (\a end) offsets of the next
@@ -56,25 +56,61 @@ static int slice_find_separator_offset(const grpc_slice str, const char* sep,
   return 0;
 }
 
-void grpc_slice_split(grpc_slice str, const char* sep, grpc_slice_buffer* dst) {
+static void skip_leading_trailing_spaces(const uint8_t* str_buffer,
+                                         size_t* begin, size_t* end) {
+  while (*begin < *end && str_buffer[*begin] == ' ') {
+    (*begin)++;
+  }
+  while (*begin < *end && str_buffer[*end - 1] == ' ') {
+    (*end)--;
+  }
+}
+
+static void grpc_slice_split_inner(grpc_slice str, const char* sep,
+                                   grpc_slice_buffer* dst, bool no_space) {
   const size_t sep_len = strlen(sep);
   size_t begin, end;
+  const uint8_t* str_buffer = GRPC_SLICE_START_PTR(str);
+  size_t sep_pos;
 
   GPR_ASSERT(sep_len > 0);
 
   if (slice_find_separator_offset(str, sep, 0, &begin, &end) != 0) {
     do {
+      sep_pos = end;
+      if (no_space) {
+        skip_leading_trailing_spaces(str_buffer, &begin, &end);
+      }
       grpc_slice_buffer_add_indexed(dst, grpc_slice_sub(str, begin, end));
-    } while (slice_find_separator_offset(str, sep, end + sep_len, &begin,
+    } while (slice_find_separator_offset(str, sep, sep_pos + sep_len, &begin,
                                          &end) != 0);
-    grpc_slice_buffer_add_indexed(
-        dst, grpc_slice_sub(str, end + sep_len, GRPC_SLICE_LENGTH(str)));
+    begin = sep_pos + sep_len;
+    end = GRPC_SLICE_LENGTH(str);
+    if (no_space) {
+      skip_leading_trailing_spaces(str_buffer, &begin, &end);
+    }
+    grpc_slice_buffer_add_indexed(dst, grpc_slice_sub(str, begin, end));
   } else { /* no sep found, add whole input */
-    grpc_slice_buffer_add_indexed(dst, grpc_slice_ref_internal(str));
+    begin = 0;
+    end = GRPC_SLICE_LENGTH(str);
+    if (no_space) {
+      skip_leading_trailing_spaces(str_buffer, &begin, &end);
+    }
+    grpc_slice_buffer_add_indexed(dst, grpc_slice_sub(str, begin, end));
   }
 }
 
+void grpc_slice_split(grpc_slice str, const char* sep, grpc_slice_buffer* dst) {
+  grpc_slice_split_inner(str, sep, dst, false);
+}
+
+void grpc_slice_split_without_space(grpc_slice str, const char* sep,
+                                    grpc_slice_buffer* dst) {
+  grpc_slice_split_inner(str, sep, dst, true);
+}
+
 bool grpc_parse_slice_to_uint32(grpc_slice str, uint32_t* result) {
-  return gpr_parse_bytes_to_uint32((const char*)GRPC_SLICE_START_PTR(str),
-                                   GRPC_SLICE_LENGTH(str), result) != 0;
+  return gpr_parse_bytes_to_uint32(
+             reinterpret_cast<const char*> GRPC_SLICE_START_PTR(str),
+             GRPC_SLICE_LENGTH(str), result) != 0;
 }

data/src/core/lib/slice/slice_string_helpers.h

@@ -35,6 +35,12 @@ char* grpc_dump_slice(grpc_slice slice, uint32_t flags);
  * should be a properly initialized instance. */
 void grpc_slice_split(grpc_slice str, const char* sep, grpc_slice_buffer* dst);
 
+/** Split \a str by the separator \a sep and remove the leading and trailing
+ * spaces of each resulting token. Results are stored in \a dst, which should be
+ * a properly initialized instance. */
+void grpc_slice_split_without_space(grpc_slice str, const char* sep,
+                                    grpc_slice_buffer* dst);
+
 bool grpc_parse_slice_to_uint32(grpc_slice str, uint32_t* result);
 
 #endif /* GRPC_CORE_LIB_SLICE_SLICE_STRING_HELPERS_H */

data/src/core/lib/surface/byte_buffer.cc

@@ -33,7 +33,7 @@ grpc_byte_buffer* grpc_raw_compressed_byte_buffer_create(
     grpc_compression_algorithm compression) {
   size_t i;
   grpc_byte_buffer* bb =
-      (grpc_byte_buffer*)gpr_malloc(sizeof(grpc_byte_buffer));
+      static_cast<grpc_byte_buffer*>(gpr_malloc(sizeof(grpc_byte_buffer)));
   bb->type = GRPC_BB_RAW;
   bb->data.raw.compression = compression;
   grpc_slice_buffer_init(&bb->data.raw.slice_buffer);
@@ -47,7 +47,7 @@ grpc_byte_buffer* grpc_raw_compressed_byte_buffer_create(
 grpc_byte_buffer* grpc_raw_byte_buffer_from_reader(
     grpc_byte_buffer_reader* reader) {
   grpc_byte_buffer* bb =
-      (grpc_byte_buffer*)gpr_malloc(sizeof(grpc_byte_buffer));
+      static_cast<grpc_byte_buffer*>(gpr_malloc(sizeof(grpc_byte_buffer)));
   grpc_slice slice;
   bb->type = GRPC_BB_RAW;
   bb->data.raw.compression = GRPC_COMPRESS_NONE;

data/src/core/lib/surface/byte_buffer_reader.cc

@@ -49,9 +49,12 @@ int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader,
     case GRPC_BB_RAW:
       grpc_slice_buffer_init(&decompressed_slices_buffer);
       if (is_compressed(reader->buffer_in)) {
-        if (grpc_msg_decompress(reader->buffer_in->data.raw.compression,
-                                &reader->buffer_in->data.raw.slice_buffer,
-                                &decompressed_slices_buffer) == 0) {
+        if (grpc_msg_decompress(
+
+                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,
                   "Unexpected error decompressing data for algorithm with enum "
                   "value '%d'.",

data/src/core/lib/surface/call.cc

@@ -28,13 +28,13 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
-#include <grpc/support/useful.h>
 
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/compression/algorithm_metadata.h"
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/gpr/arena.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -97,7 +97,7 @@ static received_status unpack_received_status(gpr_atm atm) {
   if ((atm & 1) == 0) {
     return {false, GRPC_ERROR_NONE};
   } else {
-    return {true, (grpc_error*)(atm & ~(gpr_atm)1)};
+    return {true, (grpc_error*)(atm & ~static_cast<gpr_atm>(1))};
   }
 }
 
@@ -201,7 +201,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 */
@@ -304,7 +304,7 @@ void* grpc_call_arena_alloc(grpc_call* call, size_t size) {
 static parent_call* get_or_create_parent_call(grpc_call* call) {
   parent_call* p = (parent_call*)gpr_atm_acq_load(&call->parent_call_atm);
   if (p == nullptr) {
-    p = (parent_call*)gpr_arena_alloc(call->arena, sizeof(*p));
+    p = static_cast<parent_call*>(gpr_arena_alloc(call->arena, sizeof(*p)));
     gpr_mu_init(&p->child_list_mu);
     if (!gpr_atm_rel_cas(&call->parent_call_atm, (gpr_atm) nullptr,
                          (gpr_atm)p)) {
@@ -321,17 +321,17 @@ static parent_call* get_parent_call(grpc_call* call) {
 
 grpc_error* grpc_call_create(const grpc_call_create_args* args,
                              grpc_call** out_call) {
+  GPR_TIMER_SCOPE("grpc_call_create", 0);
   size_t i, j;
   grpc_error* error = GRPC_ERROR_NONE;
   grpc_channel_stack* channel_stack =
       grpc_channel_get_channel_stack(args->channel);
   grpc_call* call;
-  GPR_TIMER_BEGIN("grpc_call_create", 0);
   size_t initial_size = grpc_channel_get_call_size_estimate(args->channel);
   GRPC_STATS_INC_CALL_INITIAL_SIZE(initial_size);
   gpr_arena* arena = gpr_arena_create(initial_size);
-  call = (grpc_call*)gpr_arena_alloc(
-      arena, sizeof(grpc_call) + channel_stack->call_stack_size);
+  call = static_cast<grpc_call*>(gpr_arena_alloc(
+      arena, sizeof(grpc_call) + channel_stack->call_stack_size));
   gpr_ref_init(&call->ext_ref, 1);
   call->arena = arena;
   grpc_call_combiner_init(&call->call_combiner);
@@ -340,7 +340,7 @@ grpc_error* grpc_call_create(const grpc_call_create_args* args,
   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 == nullptr;
   if (call->is_client) {
     GRPC_STATS_INC_CLIENT_CALLS_CREATED();
@@ -360,7 +360,8 @@ grpc_error* grpc_call_create(const grpc_call_create_args* args,
             GRPC_MDVALUE(args->add_initial_metadata[i]));
       }
     }
-    call->send_extra_metadata_count = (int)args->add_initial_metadata_count;
+    call->send_extra_metadata_count =
+        static_cast<int>(args->add_initial_metadata_count);
   } else {
     GPR_ASSERT(args->add_initial_metadata_count == 0);
     call->send_extra_metadata_count = 0;
@@ -376,7 +377,7 @@ grpc_error* grpc_call_create(const grpc_call_create_args* args,
 
   if (args->parent != nullptr) {
     child_call* cc = call->child =
-        (child_call*)gpr_arena_alloc(arena, sizeof(child_call));
+        static_cast<child_call*>(gpr_arena_alloc(arena, sizeof(child_call)));
     call->child->parent = args->parent;
 
     GRPC_CALL_INTERNAL_REF(args->parent, "child");
@@ -449,9 +450,9 @@ grpc_error* grpc_call_create(const grpc_call_create_args* args,
     cancel_with_error(call, STATUS_FROM_API_OVERRIDE, GRPC_ERROR_CANCELLED);
   }
   if (args->cq != nullptr) {
-    GPR_ASSERT(
-        args->pollset_set_alternative == nullptr &&
-        "Only one of 'cq' and 'pollset_set_alternative' should be non-NULL.");
+    GPR_ASSERT(args->pollset_set_alternative == nullptr &&
+               "Only one of 'cq' and 'pollset_set_alternative' should be "
+               "non-nullptr.");
     GRPC_CQ_INTERNAL_REF(args->cq, "bind");
     call->pollent =
         grpc_polling_entity_create_from_pollset(grpc_cq_pollset(args->cq));
@@ -467,7 +468,6 @@ grpc_error* grpc_call_create(const grpc_call_create_args* args,
 
   grpc_slice_unref_internal(path);
 
-  GPR_TIMER_END("grpc_call_create", 0);
   return error;
 }
 
@@ -501,7 +501,7 @@ void grpc_call_internal_unref(grpc_call* c REF_ARG) {
 }
 
 static void release_call(void* call, grpc_error* error) {
-  grpc_call* c = (grpc_call*)call;
+  grpc_call* c = static_cast<grpc_call*>(call);
   grpc_channel* channel = c->channel;
   grpc_call_combiner_destroy(&c->call_combiner);
   gpr_free((char*)c->peer_string);
@@ -511,10 +511,10 @@ static void release_call(void* call, grpc_error* error) {
 
 static void set_status_value_directly(grpc_status_code status, void* dest);
 static void destroy_call(void* call, grpc_error* error) {
+  GPR_TIMER_SCOPE("destroy_call", 0);
   size_t i;
   int ii;
-  grpc_call* c = (grpc_call*)call;
-  GPR_TIMER_BEGIN("destroy_call", 0);
+  grpc_call* c = static_cast<grpc_call*>(call);
   for (i = 0; i < 2; i++) {
     grpc_metadata_batch_destroy(
         &c->metadata_batch[1 /* is_receiving */][i /* is_initial */]);
@@ -551,7 +551,6 @@ static void destroy_call(void* call, grpc_error* error) {
   grpc_call_stack_destroy(CALL_STACK_FROM_CALL(c), &c->final_info,
                           GRPC_CLOSURE_INIT(&c->release_call, release_call, c,
                                             grpc_schedule_on_exec_ctx));
-  GPR_TIMER_END("destroy_call", 0);
 }
 
 void grpc_call_ref(grpc_call* c) { gpr_ref(&c->ext_ref); }
@@ -559,10 +558,11 @@ void grpc_call_ref(grpc_call* c) { gpr_ref(&c->ext_ref); }
 void grpc_call_unref(grpc_call* c) {
   if (!gpr_unref(&c->ext_ref)) return;
 
+  GPR_TIMER_SCOPE("grpc_call_unref", 0);
+
   child_call* cc = c->child;
   grpc_core::ExecCtx exec_ctx;
 
-  GPR_TIMER_BEGIN("grpc_call_unref", 0);
   GRPC_API_TRACE("grpc_call_unref(c=%p)", 1, (c));
 
   if (cc) {
@@ -594,8 +594,6 @@ void grpc_call_unref(grpc_call* c) {
     grpc_call_combiner_set_notify_on_cancel(&c->call_combiner, nullptr);
   }
   GRPC_CALL_INTERNAL_UNREF(c, "destroy");
-
-  GPR_TIMER_END("grpc_call_unref", 0);
 }
 
 grpc_call_error grpc_call_cancel(grpc_call* call, void* reserved) {
@@ -610,13 +608,13 @@ grpc_call_error grpc_call_cancel(grpc_call* call, void* reserved) {
 // This is called via the call combiner to start sending a batch down
 // the filter stack.
 static void execute_batch_in_call_combiner(void* arg, grpc_error* ignored) {
-  grpc_transport_stream_op_batch* batch = (grpc_transport_stream_op_batch*)arg;
-  grpc_call* call = (grpc_call*)batch->handler_private.extra_arg;
-  GPR_TIMER_BEGIN("execute_batch", 0);
+  GPR_TIMER_SCOPE("execute_batch", 0);
+  grpc_transport_stream_op_batch* batch =
+      static_cast<grpc_transport_stream_op_batch*>(arg);
+  grpc_call* call = static_cast<grpc_call*>(batch->handler_private.extra_arg);
   grpc_call_element* elem = CALL_ELEM_FROM_CALL(call, 0);
   GRPC_CALL_LOG_OP(GPR_INFO, elem, batch);
   elem->filter->start_transport_stream_op_batch(elem, batch);
-  GPR_TIMER_END("execute_batch", 0);
 }
 
 // start_batch_closure points to a caller-allocated closure to be used
@@ -671,7 +669,7 @@ typedef struct {
 // The on_complete callback used when sending a cancel_stream batch down
 // the filter stack.  Yields the call combiner when the batch is done.
 static void done_termination(void* arg, grpc_error* error) {
-  cancel_state* state = (cancel_state*)arg;
+  cancel_state* state = static_cast<cancel_state*>(arg);
   GRPC_CALL_COMBINER_STOP(&state->call->call_combiner,
                           "on_complete for cancel_stream op");
   GRPC_CALL_INTERNAL_UNREF(state->call, "termination");
@@ -687,7 +685,7 @@ static void cancel_with_error(grpc_call* c, status_source source,
   // down the filter stack in a timely manner.
   grpc_call_combiner_cancel(&c->call_combiner, GRPC_ERROR_REF(error));
   set_status_from_error(c, source, GRPC_ERROR_REF(error));
-  cancel_state* state = (cancel_state*)gpr_malloc(sizeof(*state));
+  cancel_state* state = static_cast<cancel_state*>(gpr_malloc(sizeof(*state)));
   state->call = c;
   GRPC_CLOSURE_INIT(&state->finish_batch, done_termination, state,
                     grpc_schedule_on_exec_ctx);
@@ -801,10 +799,10 @@ static void set_status_from_error(grpc_call* call, status_source source,
  * COMPRESSION
  */
 
-static void set_incoming_compression_algorithm(
-    grpc_call* call, grpc_compression_algorithm algo) {
-  GPR_ASSERT(algo < GRPC_COMPRESS_ALGORITHMS_COUNT);
-  call->incoming_compression_algorithm = algo;
+static void set_incoming_message_compression_algorithm(
+    grpc_call* call, grpc_message_compression_algorithm algo) {
+  GPR_ASSERT(algo < GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT);
+  call->incoming_message_compression_algorithm = algo;
 }
 
 static void set_incoming_stream_compression_algorithm(
@@ -815,8 +813,10 @@ static void set_incoming_stream_compression_algorithm(
 
 grpc_compression_algorithm grpc_call_test_only_get_compression_algorithm(
     grpc_call* call) {
-  grpc_compression_algorithm algorithm;
-  algorithm = call->incoming_compression_algorithm;
+  grpc_compression_algorithm algorithm = GRPC_COMPRESS_NONE;
+  grpc_compression_algorithm_from_message_stream_compression_algorithm(
+      &algorithm, call->incoming_message_compression_algorithm,
+      call->incoming_stream_compression_algorithm);
   return algorithm;
 }
 
@@ -826,13 +826,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;
@@ -841,9 +834,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_call* call, grpc_mdelem mdel) {
+static void set_encodings_accepted_by_peer(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;
@@ -851,69 +846,33 @@ static void set_encodings_accepted_by_peer(grpc_call* call, grpc_mdelem mdel) {
   accepted_user_data =
       grpc_mdelem_get_user_data(mdel, destroy_encodings_accepted_by_peer);
   if (accepted_user_data != nullptr) {
-    call->encodings_accepted_by_peer =
-        (uint32_t)(((uintptr_t)accepted_user_data) - 1);
+    *encodings_accepted_by_peer =
+        static_cast<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);
+  grpc_slice_split_without_space(accept_encoding_slice, ",",
+                                 &accept_encoding_parts);
 
-  /* No need to zero call->encodings_accepted_by_peer: grpc_call_create already
-   * zeroes the whole grpc_call */
-  /* Always support no compression */
-  GPR_BITSET(&call->encodings_accepted_by_peer, GRPC_COMPRESS_NONE);
+  GPR_BITSET(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,
-                                         &algorithm)) {
-      GPR_BITSET(&call->encodings_accepted_by_peer, algorithm);
+    if (!stream_encoding) {
+      r = grpc_message_compression_algorithm_parse(
+          accept_encoding_entry_slice,
+          reinterpret_cast<grpc_message_compression_algorithm*>(&algorithm));
     } else {
-      char* accept_encoding_entry_str =
-          grpc_slice_to_c_string(accept_encoding_entry_slice);
-      gpr_log(GPR_ERROR,
-              "Invalid entry in accept encoding metadata: '%s'. Ignoring.",
-              accept_encoding_entry_str);
-      gpr_free(accept_encoding_entry_str);
+      r = grpc_stream_compression_algorithm_parse(
+          accept_encoding_entry_slice,
+          reinterpret_cast<grpc_stream_compression_algorithm*>(&algorithm));
     }
-  }
-
-  grpc_slice_buffer_destroy_internal(&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_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 != nullptr) {
-    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);
+    if (r) {
+      GPR_BITSET(encodings_accepted_by_peer, algorithm);
     } else {
       char* accept_encoding_entry_str =
           grpc_slice_to_c_string(accept_encoding_entry_slice);
@@ -928,7 +887,7 @@ static void set_stream_encodings_accepted_by_peer(grpc_call* call,
 
   grpc_mdelem_set_user_data(
       mdel, destroy_encodings_accepted_by_peer,
-      (void*)(((uintptr_t)call->stream_encodings_accepted_by_peer) + 1));
+      (void*)((static_cast<uintptr_t>(*encodings_accepted_by_peer)) + 1));
 }
 
 uint32_t grpc_call_test_only_get_encodings_accepted_by_peer(grpc_call* call) {
@@ -937,13 +896,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;
@@ -986,7 +938,7 @@ static int prepare_application_metadata(grpc_call* call, int count,
                    grpc_validate_header_nonbin_value_is_legal(md->value))) {
       break;
     }
-    l->md = grpc_mdelem_from_grpc_metadata((grpc_metadata*)md);
+    l->md = grpc_mdelem_from_grpc_metadata(const_cast<grpc_metadata*>(md));
   }
   if (i != total_count) {
     for (int j = 0; j < i; j++) {
@@ -1036,28 +988,30 @@ static uint32_t decode_status(grpc_mdelem md) {
   if (grpc_mdelem_eq(md, GRPC_MDELEM_GRPC_STATUS_2)) return 2;
   user_data = grpc_mdelem_get_user_data(md, destroy_status);
   if (user_data != nullptr) {
-    status = ((uint32_t)(intptr_t)user_data) - STATUS_OFFSET;
+    status = (static_cast<uint32_t>((intptr_t)user_data)) - STATUS_OFFSET;
   } else {
     if (!grpc_parse_slice_to_uint32(GRPC_MDVALUE(md), &status)) {
       status = GRPC_STATUS_UNKNOWN; /* could not parse status code */
     }
-    grpc_mdelem_set_user_data(md, destroy_status,
-                              (void*)(intptr_t)(status + STATUS_OFFSET));
+    grpc_mdelem_set_user_data(
+        md, destroy_status,
+        (void*)static_cast<intptr_t>(status + STATUS_OFFSET));
   }
   return status;
 }
 
-static grpc_compression_algorithm decode_compression(grpc_mdelem md) {
-  grpc_compression_algorithm algorithm =
-      grpc_compression_algorithm_from_slice(GRPC_MDVALUE(md));
-  if (algorithm == GRPC_COMPRESS_ALGORITHMS_COUNT) {
+static grpc_message_compression_algorithm decode_message_compression(
+    grpc_mdelem md) {
+  grpc_message_compression_algorithm algorithm =
+      grpc_message_compression_algorithm_from_slice(GRPC_MDVALUE(md));
+  if (algorithm == GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT) {
     char* md_c_str = grpc_slice_to_c_string(GRPC_MDVALUE(md));
     gpr_log(GPR_ERROR,
-            "Invalid incoming compression algorithm: '%s'. Interpreting "
-            "incoming data as uncompressed.",
+            "Invalid incoming message compression algorithm: '%s'. "
+            "Interpreting incoming data as uncompressed.",
             md_c_str);
     gpr_free(md_c_str);
-    return GRPC_COMPRESS_NONE;
+    return GRPC_MESSAGE_COMPRESS_NONE;
   }
   return algorithm;
 }
@@ -1082,15 +1036,15 @@ static void publish_app_metadata(grpc_call* call, grpc_metadata_batch* b,
                                  int is_trailing) {
   if (b->list.count == 0) return;
   if (is_trailing && call->buffered_metadata[1] == nullptr) return;
-  GPR_TIMER_BEGIN("publish_app_metadata", 0);
+  GPR_TIMER_SCOPE("publish_app_metadata", 0);
   grpc_metadata_array* dest;
   grpc_metadata* mdusr;
   dest = call->buffered_metadata[is_trailing];
   if (dest->count + b->list.count > dest->capacity) {
     dest->capacity =
         GPR_MAX(dest->capacity + b->list.count, dest->capacity * 3 / 2);
-    dest->metadata = (grpc_metadata*)gpr_realloc(
-        dest->metadata, sizeof(grpc_metadata) * dest->capacity);
+    dest->metadata = static_cast<grpc_metadata*>(
+        gpr_realloc(dest->metadata, sizeof(grpc_metadata) * dest->capacity));
   }
   for (grpc_linked_mdelem* l = b->list.head; l != nullptr; l = l->next) {
     mdusr = &dest->metadata[dest->count++];
@@ -1098,47 +1052,44 @@ static void publish_app_metadata(grpc_call* call, grpc_metadata_batch* b,
     mdusr->key = GRPC_MDKEY(l->md);
     mdusr->value = GRPC_MDVALUE(l->md);
   }
-  GPR_TIMER_END("publish_app_metadata", 0);
 }
 
 static void recv_initial_filter(grpc_call* call, grpc_metadata_batch* b) {
   if (b->idx.named.content_encoding != nullptr) {
-    if (b->idx.named.grpc_encoding != nullptr) {
-      gpr_log(GPR_ERROR,
-              "Received both content-encoding and grpc-encoding header. "
-              "Ignoring grpc-encoding.");
-      grpc_metadata_batch_remove(b, b->idx.named.grpc_encoding);
-    }
-    GPR_TIMER_BEGIN("incoming_stream_compression_algorithm", 0);
+    GPR_TIMER_SCOPE("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(b, b->idx.named.content_encoding);
-  } else if (b->idx.named.grpc_encoding != nullptr) {
-    GPR_TIMER_BEGIN("incoming_compression_algorithm", 0);
-    set_incoming_compression_algorithm(
-        call, decode_compression(b->idx.named.grpc_encoding->md));
-    GPR_TIMER_END("incoming_compression_algorithm", 0);
+  }
+  if (b->idx.named.grpc_encoding != nullptr) {
+    GPR_TIMER_SCOPE("incoming_message_compression_algorithm", 0);
+    set_incoming_message_compression_algorithm(
+        call, decode_message_compression(b->idx.named.grpc_encoding->md));
     grpc_metadata_batch_remove(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 != nullptr) {
-    GPR_TIMER_BEGIN("encodings_accepted_by_peer", 0);
-    set_encodings_accepted_by_peer(call, b->idx.named.grpc_accept_encoding->md);
+    GPR_TIMER_SCOPE("encodings_accepted_by_peer", 0);
+    set_encodings_accepted_by_peer(call, b->idx.named.grpc_accept_encoding->md,
+                                   &message_encodings_accepted_by_peer, false);
     grpc_metadata_batch_remove(b, b->idx.named.grpc_accept_encoding);
-    GPR_TIMER_END("encodings_accepted_by_peer", 0);
   }
   if (b->idx.named.accept_encoding != nullptr) {
-    GPR_TIMER_BEGIN("stream_encodings_accepted_by_peer", 0);
-    set_stream_encodings_accepted_by_peer(call,
-                                          b->idx.named.accept_encoding->md);
+    GPR_TIMER_SCOPE("stream_encodings_accepted_by_peer", 0);
+    set_encodings_accepted_by_peer(call, b->idx.named.accept_encoding->md,
+                                   &stream_encodings_accepted_by_peer, true);
     grpc_metadata_batch_remove(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);
 }
 
 static void recv_trailing_filter(void* args, grpc_metadata_batch* b) {
-  grpc_call* call = (grpc_call*)args;
+  grpc_call* call = static_cast<grpc_call*>(args);
   if (b->idx.named.grpc_status != nullptr) {
     uint32_t status_code = decode_status(b->idx.named.grpc_status->md);
     grpc_error* error =
@@ -1147,7 +1098,7 @@ static void recv_trailing_filter(void* args, grpc_metadata_batch* b) {
             : grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                                      "Error received from peer"),
                                  GRPC_ERROR_INT_GRPC_STATUS,
-                                 (intptr_t)status_code);
+                                 static_cast<intptr_t>(status_code));
     if (b->idx.named.grpc_message != nullptr) {
       error = grpc_error_set_str(
           error, GRPC_ERROR_STR_GRPC_MESSAGE,
@@ -1172,11 +1123,11 @@ grpc_call_stack* grpc_call_get_call_stack(grpc_call* call) {
  */
 
 static void set_status_value_directly(grpc_status_code status, void* dest) {
-  *(grpc_status_code*)dest = status;
+  *static_cast<grpc_status_code*>(dest) = status;
 }
 
 static void set_cancelled_value(grpc_status_code status, void* dest) {
-  *(int*)dest = (status != GRPC_STATUS_OK);
+  *static_cast<int*>(dest) = (status != GRPC_STATUS_OK);
 }
 
 static bool are_write_flags_valid(uint32_t flags) {
@@ -1222,8 +1173,8 @@ static batch_control* allocate_batch_control(grpc_call* call,
   int slot = batch_slot_for_op(ops[0].op);
   batch_control** pslot = &call->active_batches[slot];
   if (*pslot == nullptr) {
-    *pslot =
-        (batch_control*)gpr_arena_alloc(call->arena, sizeof(batch_control));
+    *pslot = static_cast<batch_control*>(
+        gpr_arena_alloc(call->arena, sizeof(batch_control)));
   }
   batch_control* bctl = *pslot;
   if (bctl->call != nullptr) {
@@ -1237,14 +1188,14 @@ static batch_control* allocate_batch_control(grpc_call* call,
 
 static void finish_batch_completion(void* user_data,
                                     grpc_cq_completion* storage) {
-  batch_control* bctl = (batch_control*)user_data;
+  batch_control* bctl = static_cast<batch_control*>(user_data);
   grpc_call* call = bctl->call;
   bctl->call = nullptr;
   GRPC_CALL_INTERNAL_UNREF(call, "completion");
 }
 
 static grpc_error* consolidate_batch_errors(batch_control* bctl) {
-  size_t n = (size_t)gpr_atm_acq_load(&bctl->num_errors);
+  size_t n = static_cast<size_t>(gpr_atm_acq_load(&bctl->num_errors));
   if (n == 0) {
     return GRPC_ERROR_NONE;
   } else if (n == 1) {
@@ -1271,6 +1222,7 @@ static void post_batch_completion(batch_control* bctl) {
 
   if (bctl->op.send_initial_metadata) {
     grpc_metadata_batch_destroy(
+
         &call->metadata_batch[0 /* is_receiving */][0 /* is_trailing */]);
   }
   if (bctl->op.send_message) {
@@ -1278,6 +1230,7 @@ static void post_batch_completion(batch_control* bctl) {
   }
   if (bctl->op.send_trailing_metadata) {
     grpc_metadata_batch_destroy(
+
         &call->metadata_batch[0 /* is_receiving */][1 /* is_trailing */]);
   }
   if (bctl->op.recv_trailing_metadata) {
@@ -1382,7 +1335,7 @@ static void continue_receiving_slices(batch_control* bctl) {
 }
 
 static void receiving_slice_ready(void* bctlp, grpc_error* error) {
-  batch_control* bctl = (batch_control*)bctlp;
+  batch_control* bctl = static_cast<batch_control*>(bctlp);
   grpc_call* call = bctl->call;
   grpc_byte_stream* bs = call->receiving_stream;
   bool release_error = false;
@@ -1426,9 +1379,15 @@ static void process_data_after_md(batch_control* bctl) {
   } 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->receiving_buffer = grpc_raw_compressed_byte_buffer_create(
-          nullptr, 0, call->incoming_compression_algorithm);
+        (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,
+              (grpc_stream_compression_algorithm)0));
+      *call->receiving_buffer =
+          grpc_raw_compressed_byte_buffer_create(nullptr, 0, algo);
     } else {
       *call->receiving_buffer = grpc_raw_byte_buffer_create(nullptr, 0);
     }
@@ -1439,7 +1398,7 @@ static void process_data_after_md(batch_control* bctl) {
 }
 
 static void receiving_stream_ready(void* bctlp, grpc_error* error) {
-  batch_control* bctl = (batch_control*)bctlp;
+  batch_control* bctl = static_cast<batch_control*>(bctlp);
   grpc_call* call = bctl->call;
   if (error != GRPC_ERROR_NONE) {
     if (call->receiving_stream != nullptr) {
@@ -1463,95 +1422,73 @@ static void receiving_stream_ready(void* bctlp, grpc_error* error) {
 // before processing the received message.
 static void receiving_stream_ready_in_call_combiner(void* bctlp,
                                                     grpc_error* error) {
-  batch_control* bctl = (batch_control*)bctlp;
+  batch_control* bctl = static_cast<batch_control*>(bctlp);
   grpc_call* call = bctl->call;
   GRPC_CALL_COMBINER_STOP(&call->call_combiner, "recv_message_ready");
   receiving_stream_ready(bctlp, error);
 }
 
 static void validate_filtered_metadata(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) {
-    const grpc_stream_compression_algorithm algo =
-        call->incoming_stream_compression_algorithm;
+          GRPC_STREAM_COMPRESS_NONE &&
+      call->incoming_message_compression_algorithm !=
+          GRPC_MESSAGE_COMPRESS_NONE) {
     char* error_msg = nullptr;
-    const grpc_compression_options compression_options =
-        grpc_channel_compression_options(call->channel);
-    if (algo >= GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) {
-      gpr_asprintf(&error_msg,
-                   "Invalid stream compression algorithm value '%d'.", algo);
-      gpr_log(GPR_ERROR, "%s", error_msg);
-      cancel_with_status(call, STATUS_FROM_SURFACE, GRPC_STATUS_UNIMPLEMENTED,
-                         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 */
-      const char* algo_name = nullptr;
-      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(call, STATUS_FROM_SURFACE, GRPC_STATUS_UNIMPLEMENTED,
-                         error_msg);
-    }
+    gpr_asprintf(&error_msg,
+                 "Incoming stream has both stream compression (%d) and message "
+                 "compression (%d).",
+                 call->incoming_stream_compression_algorithm,
+                 call->incoming_message_compression_algorithm);
+    gpr_log(GPR_ERROR, "%s", error_msg);
+    cancel_with_status(call, STATUS_FROM_SURFACE, GRPC_STATUS_INTERNAL,
+                       error_msg);
     gpr_free(error_msg);
-
-    GPR_ASSERT(call->stream_encodings_accepted_by_peer != 0);
-    if (!GPR_BITGET(call->stream_encodings_accepted_by_peer,
-                    call->incoming_stream_compression_algorithm)) {
-      if (grpc_compression_trace.enabled()) {
-        const char* algo_name = nullptr;
-        grpc_stream_compression_algorithm_name(
-            call->incoming_stream_compression_algorithm, &algo_name);
-        gpr_log(
-            GPR_ERROR,
-            "Stream compression algorithm (content-encoding = '%s') not "
-            "present in the bitset of accepted encodings (accept-encodings: "
-            "'0x%x')",
-            algo_name, call->stream_encodings_accepted_by_peer);
-      }
-    }
-  } else if (call->incoming_compression_algorithm != GRPC_COMPRESS_NONE) {
-    const grpc_compression_algorithm algo =
-        call->incoming_compression_algorithm;
+  } else if (
+      grpc_compression_algorithm_from_message_stream_compression_algorithm(
+          &compression_algorithm, call->incoming_message_compression_algorithm,
+          call->incoming_stream_compression_algorithm) == 0) {
+    char* error_msg = nullptr;
+    gpr_asprintf(&error_msg,
+                 "Error in incoming message compression (%d) or stream "
+                 "compression (%d).",
+                 call->incoming_stream_compression_algorithm,
+                 call->incoming_message_compression_algorithm);
+    cancel_with_status(call, STATUS_FROM_SURFACE, GRPC_STATUS_INTERNAL,
+                       error_msg);
+    gpr_free(error_msg);
+  } else {
     char* error_msg = nullptr;
     const grpc_compression_options compression_options =
         grpc_channel_compression_options(call->channel);
-    /* check if algorithm is known */
-    if (algo >= GRPC_COMPRESS_ALGORITHMS_COUNT) {
+    if (compression_algorithm >= 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(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 */
       const char* algo_name = nullptr;
-      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(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,
-                    call->incoming_compression_algorithm)) {
+    if (!GPR_BITGET(call->encodings_accepted_by_peer, compression_algorithm)) {
       if (grpc_compression_trace.enabled()) {
         const char* algo_name = nullptr;
-        grpc_compression_algorithm_name(call->incoming_compression_algorithm,
-                                        &algo_name);
+        grpc_compression_algorithm_name(compression_algorithm, &algo_name);
         gpr_log(GPR_ERROR,
-                "Compression algorithm (grpc-encoding = '%s') not present in "
-                "the bitset of accepted encodings (grpc-accept-encodings: "
-                "'0x%x')",
+                "Compression algorithm ('%s') not present in the bitset of "
+                "accepted encodings ('0x%x')",
                 algo_name, call->encodings_accepted_by_peer);
       }
     }
@@ -1561,7 +1498,7 @@ static void validate_filtered_metadata(batch_control* bctl) {
 static void add_batch_error(batch_control* bctl, grpc_error* error,
                             bool has_cancelled) {
   if (error == GRPC_ERROR_NONE) return;
-  int idx = (int)gpr_atm_full_fetch_add(&bctl->num_errors, 1);
+  int idx = static_cast<int>(gpr_atm_full_fetch_add(&bctl->num_errors, 1));
   if (idx == 0 && !has_cancelled) {
     cancel_with_error(bctl->call, STATUS_FROM_CORE, GRPC_ERROR_REF(error));
   }
@@ -1569,7 +1506,7 @@ static void add_batch_error(batch_control* bctl, grpc_error* error,
 }
 
 static void receiving_initial_metadata_ready(void* bctlp, grpc_error* error) {
-  batch_control* bctl = (batch_control*)bctlp;
+  batch_control* bctl = static_cast<batch_control*>(bctlp);
   grpc_call* call = bctl->call;
 
   GRPC_CALL_COMBINER_STOP(&call->call_combiner, "recv_initial_metadata_ready");
@@ -1581,9 +1518,8 @@ static void receiving_initial_metadata_ready(void* bctlp, grpc_error* error) {
     recv_initial_filter(call, md);
 
     /* TODO(ctiller): this could be moved into recv_initial_filter now */
-    GPR_TIMER_BEGIN("validate_filtered_metadata", 0);
+    GPR_TIMER_SCOPE("validate_filtered_metadata", 0);
     validate_filtered_metadata(bctl);
-    GPR_TIMER_END("validate_filtered_metadata", 0);
 
     if (md->deadline != GRPC_MILLIS_INF_FUTURE && !call->is_client) {
       call->send_deadline = md->deadline;
@@ -1622,7 +1558,7 @@ static void receiving_initial_metadata_ready(void* bctlp, grpc_error* error) {
 }
 
 static void finish_batch(void* bctlp, grpc_error* error) {
-  batch_control* bctl = (batch_control*)bctlp;
+  batch_control* bctl = static_cast<batch_control*>(bctlp);
   grpc_call* call = bctl->call;
   GRPC_CALL_COMBINER_STOP(&call->call_combiner, "on_complete");
   add_batch_error(bctl, GRPC_ERROR_REF(error), false);
@@ -1636,6 +1572,8 @@ static void free_no_op_completion(void* p, grpc_cq_completion* completion) {
 static grpc_call_error call_start_batch(grpc_call* call, const grpc_op* ops,
                                         size_t nops, void* notify_tag,
                                         int is_notify_tag_closure) {
+  GPR_TIMER_SCOPE("grpc_call_start_batch", 0);
+
   size_t i;
   const grpc_op* op;
   batch_control* bctl;
@@ -1644,15 +1582,15 @@ static grpc_call_error call_start_batch(grpc_call* call, const grpc_op* ops,
   grpc_transport_stream_op_batch* stream_op;
   grpc_transport_stream_op_batch_payload* stream_op_payload;
 
-  GPR_TIMER_BEGIN("grpc_call_start_batch", 0);
   GRPC_CALL_LOG_BATCH(GPR_INFO, call, ops, nops, notify_tag);
 
   if (nops == 0) {
     if (!is_notify_tag_closure) {
       GPR_ASSERT(grpc_cq_begin_op(call->cq, notify_tag));
-      grpc_cq_end_op(
-          call->cq, notify_tag, GRPC_ERROR_NONE, free_no_op_completion, nullptr,
-          (grpc_cq_completion*)gpr_malloc(sizeof(grpc_cq_completion)));
+      grpc_cq_end_op(call->cq, notify_tag, GRPC_ERROR_NONE,
+                     free_no_op_completion, nullptr,
+                     static_cast<grpc_cq_completion*>(
+                         gpr_malloc(sizeof(grpc_cq_completion))));
     } else {
       GRPC_CLOSURE_SCHED((grpc_closure*)notify_tag, GRPC_ERROR_NONE);
     }
@@ -1666,7 +1604,7 @@ static grpc_call_error call_start_batch(grpc_call* call, const grpc_op* ops,
   }
   bctl->completion_data.notify_tag.tag = notify_tag;
   bctl->completion_data.notify_tag.is_closure =
-      (uint8_t)(is_notify_tag_closure != 0);
+      static_cast<uint8_t>(is_notify_tag_closure != 0);
 
   stream_op = &bctl->op;
   stream_op_payload = &call->stream_op_payload;
@@ -1694,56 +1632,28 @@ static grpc_call_error call_start_batch(grpc_call* call, const grpc_op* ops,
         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_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) {
+        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) {
-            level_set = true;
-            effective_stream_compression_level =
-                copts.default_stream_compression_level.level;
-            stream_compression = true;
-          } else if (copts.default_level.is_set) {
+          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_stream_compression_algorithm calgo =
-                stream_compression_algorithm_for_level_locked(
-                    call, effective_stream_compression_level);
-            call->compression_md.key =
-                GRPC_MDSTR_GRPC_INTERNAL_STREAM_ENCODING_REQUEST;
-            call->compression_md.value =
-                grpc_stream_compression_algorithm_slice(calgo);
-          } 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++;
-          }
+          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 >
@@ -1754,9 +1664,10 @@ static grpc_call_error call_start_batch(grpc_call* call, const grpc_op* ops,
         stream_op->send_initial_metadata = true;
         call->sent_initial_metadata = true;
         if (!prepare_application_metadata(
-                call, (int)op->data.send_initial_metadata.count,
+                call, static_cast<int>(op->data.send_initial_metadata.count),
                 op->data.send_initial_metadata.metadata, 0, call->is_client,
-                &call->compression_md, (int)additional_metadata_count)) {
+                &call->compression_md,
+                static_cast<int>(additional_metadata_count))) {
           error = GRPC_CALL_ERROR_INVALID_METADATA;
           goto done_with_error;
         }
@@ -1873,7 +1784,8 @@ static grpc_call_error call_start_batch(grpc_call* call, const grpc_op* ops,
         }
         if (!prepare_application_metadata(
                 call,
-                (int)op->data.send_status_from_server.trailing_metadata_count,
+                static_cast<int>(
+                    op->data.send_status_from_server.trailing_metadata_count),
                 op->data.send_status_from_server.trailing_metadata, 1, 1,
                 nullptr, 0)) {
           for (int n = 0; n < call->send_extra_metadata_count; n++) {
@@ -2009,7 +1921,6 @@ static grpc_call_error call_start_batch(grpc_call* call, const grpc_op* ops,
   execute_batch(call, stream_op, &bctl->start_batch);
 
 done:
-  GPR_TIMER_END("grpc_call_start_batch", 0);
   return error;
 
 done_with_error: