grpc 1.6.7 → 1.7.0.pre1

data/src/core/ext/transport/chttp2/transport/chttp2_transport.h

@@ -25,6 +25,7 @@
 
 extern grpc_tracer_flag grpc_http_trace;
 extern grpc_tracer_flag grpc_flowctl_trace;
+extern grpc_tracer_flag grpc_trace_http2_stream_state;
 
 #ifndef NDEBUG
 extern grpc_tracer_flag grpc_trace_chttp2_refcount;

data/src/core/ext/transport/chttp2/transport/flow_control.c

@@ -18,6 +18,7 @@
 
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 
+#include <limits.h>
 #include <math.h>
 #include <string.h>
 
@@ -59,24 +60,24 @@ static void pretrace(shadow_flow_control* shadow_fc,
 
 #define TRACE_PADDING 30
 
-static char* fmt_int64_diff_str(int64_t old, int64_t new) {
+static char* fmt_int64_diff_str(int64_t old_val, int64_t new_val) {
   char* str;
-  if (old != new) {
-    gpr_asprintf(&str, "%" PRId64 " -> %" PRId64 "", old, new);
+  if (old_val != new_val) {
+    gpr_asprintf(&str, "%" PRId64 " -> %" PRId64 "", old_val, new_val);
   } else {
-    gpr_asprintf(&str, "%" PRId64 "", old);
+    gpr_asprintf(&str, "%" PRId64 "", old_val);
   }
   char* str_lp = gpr_leftpad(str, ' ', TRACE_PADDING);
   gpr_free(str);
   return str_lp;
 }
 
-static char* fmt_uint32_diff_str(uint32_t old, uint32_t new) {
+static char* fmt_uint32_diff_str(uint32_t old_val, uint32_t new_val) {
   char* str;
-  if (new > 0 && old != new) {
-    gpr_asprintf(&str, "%" PRIu32 " -> %" PRIu32 "", old, new);
+  if (new_val > 0 && old_val != new_val) {
+    gpr_asprintf(&str, "%" PRIu32 " -> %" PRIu32 "", old_val, new_val);
   } else {
-    gpr_asprintf(&str, "%" PRIu32 "", old);
+    gpr_asprintf(&str, "%" PRIu32 "", old_val);
   }
   char* str_lp = gpr_leftpad(str, ' ', TRACE_PADDING);
   gpr_free(str);

data/src/core/ext/transport/chttp2/transport/frame_data.c

@@ -210,7 +210,7 @@ grpc_error *grpc_deframe_unprocessed_incoming_frames(
 
         if (cur != end) {
           grpc_slice_buffer_undo_take_first(
-              &s->unprocessed_incoming_frames_buffer,
+              slices,
               grpc_slice_sub(slice, (size_t)(cur - beg), (size_t)(end - beg)));
         }
         grpc_slice_unref_internal(exec_ctx, slice);
@@ -277,7 +277,7 @@ grpc_error *grpc_deframe_unprocessed_incoming_frames(
           p->state = GRPC_CHTTP2_DATA_FH_0;
           cur += p->frame_size;
           grpc_slice_buffer_undo_take_first(
-              &s->unprocessed_incoming_frames_buffer,
+              slices,
               grpc_slice_sub(slice, (size_t)(cur - beg), (size_t)(end - beg)));
           grpc_slice_unref_internal(exec_ctx, slice);
           return GRPC_ERROR_NONE;

data/src/core/ext/transport/chttp2/transport/frame_goaway.c

@@ -46,7 +46,7 @@ grpc_error *grpc_chttp2_goaway_parser_begin_frame(grpc_chttp2_goaway_parser *p,
 
   gpr_free(p->debug_data);
   p->debug_length = length - 8;
-  p->debug_data = gpr_malloc(p->debug_length);
+  p->debug_data = (char *)gpr_malloc(p->debug_length);
   p->debug_pos = 0;
   p->state = GRPC_CHTTP2_GOAWAY_LSI0;
   return GRPC_ERROR_NONE;
@@ -60,7 +60,7 @@ grpc_error *grpc_chttp2_goaway_parser_parse(grpc_exec_ctx *exec_ctx,
   uint8_t *const beg = GRPC_SLICE_START_PTR(slice);
   uint8_t *const end = GRPC_SLICE_END_PTR(slice);
   uint8_t *cur = beg;
-  grpc_chttp2_goaway_parser *p = parser;
+  grpc_chttp2_goaway_parser *p = (grpc_chttp2_goaway_parser *)parser;
 
   switch (p->state) {
     case GRPC_CHTTP2_GOAWAY_LSI0:

data/src/core/ext/transport/chttp2/transport/frame_ping.c

@@ -75,7 +75,7 @@ grpc_error *grpc_chttp2_ping_parser_parse(grpc_exec_ctx *exec_ctx, void *parser,
   uint8_t *const beg = GRPC_SLICE_START_PTR(slice);
   uint8_t *const end = GRPC_SLICE_END_PTR(slice);
   uint8_t *cur = beg;
-  grpc_chttp2_ping_parser *p = parser;
+  grpc_chttp2_ping_parser *p = (grpc_chttp2_ping_parser *)parser;
 
   while (p->byte != 8 && cur != end) {
     p->opaque_8bytes |= (((uint64_t)*cur) << (56 - 8 * p->byte));
@@ -92,7 +92,7 @@ grpc_error *grpc_chttp2_ping_parser_parse(grpc_exec_ctx *exec_ctx, void *parser,
         gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);
         gpr_timespec next_allowed_ping =
             gpr_time_add(t->ping_recv_state.last_ping_recv_time,
-                         t->ping_policy.min_ping_interval_without_data);
+                         t->ping_policy.min_recv_ping_interval_without_data);
 
         if (t->keepalive_permit_without_calls == 0 &&
             grpc_chttp2_stream_map_size(&t->stream_map) == 0) {
@@ -113,11 +113,12 @@ grpc_error *grpc_chttp2_ping_parser_parse(grpc_exec_ctx *exec_ctx, void *parser,
       if (!g_disable_ping_ack) {
         if (t->ping_ack_count == t->ping_ack_capacity) {
           t->ping_ack_capacity = GPR_MAX(t->ping_ack_capacity * 3 / 2, 3);
-          t->ping_acks = gpr_realloc(
+          t->ping_acks = (uint64_t *)gpr_realloc(
               t->ping_acks, t->ping_ack_capacity * sizeof(*t->ping_acks));
         }
         t->ping_acks[t->ping_ack_count++] = p->opaque_8bytes;
-        grpc_chttp2_initiate_write(exec_ctx, t, "ping response");
+        grpc_chttp2_initiate_write(exec_ctx, t,
+                                   GRPC_CHTTP2_INITIATE_WRITE_PING_RESPONSE);
       }
     }
   }

data/src/core/ext/transport/chttp2/transport/frame_rst_stream.c

@@ -77,7 +77,7 @@ grpc_error *grpc_chttp2_rst_stream_parser_parse(grpc_exec_ctx *exec_ctx,
   uint8_t *const beg = GRPC_SLICE_START_PTR(slice);
   uint8_t *const end = GRPC_SLICE_END_PTR(slice);
   uint8_t *cur = beg;
-  grpc_chttp2_rst_stream_parser *p = parser;
+  grpc_chttp2_rst_stream_parser *p = (grpc_chttp2_rst_stream_parser *)parser;
 
   while (p->byte != 4 && cur != end) {
     p->reason_bytes[p->byte] = *cur;

data/src/core/ext/transport/chttp2/transport/frame_settings.c

@@ -44,7 +44,8 @@ static uint8_t *fill_header(uint8_t *out, uint32_t length, uint8_t flags) {
   return out;
 }
 
-grpc_slice grpc_chttp2_settings_create(uint32_t *old, const uint32_t *new,
+grpc_slice grpc_chttp2_settings_create(uint32_t *old_settings,
+                                       const uint32_t *new_settings,
                                        uint32_t force_mask, size_t count) {
   size_t i;
   uint32_t n = 0;
@@ -52,21 +53,21 @@ grpc_slice grpc_chttp2_settings_create(uint32_t *old, const uint32_t *new,
   uint8_t *p;
 
   for (i = 0; i < count; i++) {
-    n += (new[i] != old[i] || (force_mask & (1u << i)) != 0);
+    n += (new_settings[i] != old_settings[i] || (force_mask & (1u << i)) != 0);
   }
 
   output = GRPC_SLICE_MALLOC(9 + 6 * n);
   p = fill_header(GRPC_SLICE_START_PTR(output), 6 * n, 0);
 
   for (i = 0; i < count; i++) {
-    if (new[i] != old[i] || (force_mask & (1u << i)) != 0) {
+    if (new_settings[i] != old_settings[i] || (force_mask & (1u << i)) != 0) {
       *p++ = (uint8_t)(grpc_setting_id_to_wire_id[i] >> 8);
       *p++ = (uint8_t)(grpc_setting_id_to_wire_id[i]);
-      *p++ = (uint8_t)(new[i] >> 24);
-      *p++ = (uint8_t)(new[i] >> 16);
-      *p++ = (uint8_t)(new[i] >> 8);
-      *p++ = (uint8_t)(new[i]);
-      old[i] = new[i];
+      *p++ = (uint8_t)(new_settings[i] >> 24);
+      *p++ = (uint8_t)(new_settings[i] >> 16);
+      *p++ = (uint8_t)(new_settings[i] >> 8);
+      *p++ = (uint8_t)(new_settings[i]);
+      old_settings[i] = new_settings[i];
     }
   }
 
@@ -111,7 +112,7 @@ grpc_error *grpc_chttp2_settings_parser_parse(grpc_exec_ctx *exec_ctx, void *p,
                                               grpc_chttp2_transport *t,
                                               grpc_chttp2_stream *s,
                                               grpc_slice slice, int is_last) {
-  grpc_chttp2_settings_parser *parser = p;
+  grpc_chttp2_settings_parser *parser = (grpc_chttp2_settings_parser *)p;
   const uint8_t *cur = GRPC_SLICE_START_PTR(slice);
   const uint8_t *end = GRPC_SLICE_END_PTR(slice);
   char *msg;

data/src/core/ext/transport/chttp2/transport/frame_window_update.c

@@ -70,7 +70,8 @@ grpc_error *grpc_chttp2_window_update_parser_parse(
   uint8_t *const beg = GRPC_SLICE_START_PTR(slice);
   uint8_t *const end = GRPC_SLICE_END_PTR(slice);
   uint8_t *cur = beg;
-  grpc_chttp2_window_update_parser *p = parser;
+  grpc_chttp2_window_update_parser *p =
+      (grpc_chttp2_window_update_parser *)parser;
 
   while (p->byte != 4 && cur != end) {
     p->amount |= ((uint32_t)*cur) << (8 * (3 - p->byte));
@@ -98,9 +99,10 @@ grpc_error *grpc_chttp2_window_update_parser_parse(
         grpc_chttp2_flowctl_recv_stream_update(
             &t->flow_control, &s->flow_control, received_update);
         if (grpc_chttp2_list_remove_stalled_by_stream(t, s)) {
-          grpc_chttp2_become_writable(
-              exec_ctx, t, s, GRPC_CHTTP2_STREAM_WRITE_INITIATE_UNCOVERED,
-              "stream.read_flow_control");
+          grpc_chttp2_mark_stream_writable(exec_ctx, t, s);
+          grpc_chttp2_initiate_write(
+              exec_ctx, t,
+              GRPC_CHTTP2_INITIATE_WRITE_FLOW_CONTROL_UNSTALLED_BY_UPDATE);
         }
       }
     } else {
@@ -109,7 +111,9 @@ grpc_error *grpc_chttp2_window_update_parser_parse(
                                                 received_update);
       bool is_zero = t->flow_control.remote_window <= 0;
       if (was_zero && !is_zero) {
-        grpc_chttp2_initiate_write(exec_ctx, t, "new_global_flow_control");
+        grpc_chttp2_initiate_write(
+            exec_ctx, t,
+            GRPC_CHTTP2_INITIATE_WRITE_TRANSPORT_FLOW_CONTROL_UNSTALLED);
       }
     }
   }

data/src/core/ext/transport/chttp2/transport/hpack_encoder.c

@@ -33,6 +33,7 @@
 #include "src/core/ext/transport/chttp2/transport/bin_encoder.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_table.h"
 #include "src/core/ext/transport/chttp2/transport/varint.h"
+#include "src/core/lib/debug/stats.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/transport/metadata.h"
@@ -51,8 +52,10 @@
 #define MAX_DECODER_SPACE_USAGE 512
 
 static grpc_slice_refcount terminal_slice_refcount = {NULL, NULL};
-static const grpc_slice terminal_slice = {&terminal_slice_refcount,
-                                          .data.refcounted = {0, 0}};
+static const grpc_slice terminal_slice = {
+    &terminal_slice_refcount, /* refcount */
+    {{0, 0}}                  /* data.refcounted */
+};
 
 extern grpc_tracer_flag grpc_http_trace;
 
@@ -269,8 +272,10 @@ static void add_elem(grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_compressor *c,
   }
 }
 
-static void emit_indexed(grpc_chttp2_hpack_compressor *c, uint32_t elem_index,
+static void emit_indexed(grpc_exec_ctx *exec_ctx,
+                         grpc_chttp2_hpack_compressor *c, uint32_t elem_index,
                          framer_state *st) {
+  GRPC_STATS_INC_HPACK_SEND_INDEXED(exec_ctx);
   uint32_t len = GRPC_CHTTP2_VARINT_LENGTH(elem_index, 1);
   GRPC_CHTTP2_WRITE_VARINT(elem_index, 1, 0x80, add_tiny_header_data(st, len),
                            len);
@@ -282,30 +287,31 @@ typedef struct {
   bool insert_null_before_wire_value;
 } wire_value;
 
-static wire_value get_wire_value(grpc_mdelem elem, bool true_binary_enabled) {
+static wire_value get_wire_value(grpc_exec_ctx *exec_ctx, grpc_mdelem elem,
+                                 bool true_binary_enabled) {
+  wire_value wire_val;
   if (grpc_is_binary_header(GRPC_MDKEY(elem))) {
     if (true_binary_enabled) {
-      return (wire_value){
-          .huffman_prefix = 0x00,
-          .insert_null_before_wire_value = true,
-          .data = grpc_slice_ref_internal(GRPC_MDVALUE(elem)),
-      };
+      GRPC_STATS_INC_HPACK_SEND_BINARY(exec_ctx);
+      wire_val.huffman_prefix = 0x00;
+      wire_val.insert_null_before_wire_value = true;
+      wire_val.data = grpc_slice_ref_internal(GRPC_MDVALUE(elem));
+
     } else {
-      return (wire_value){
-          .huffman_prefix = 0x80,
-          .insert_null_before_wire_value = false,
-          .data = grpc_chttp2_base64_encode_and_huffman_compress(
-              GRPC_MDVALUE(elem)),
-      };
+      GRPC_STATS_INC_HPACK_SEND_BINARY_BASE64(exec_ctx);
+      wire_val.huffman_prefix = 0x80;
+      wire_val.insert_null_before_wire_value = false;
+      wire_val.data =
+          grpc_chttp2_base64_encode_and_huffman_compress(GRPC_MDVALUE(elem));
     }
   } else {
     /* TODO(ctiller): opportunistically compress non-binary headers */
-    return (wire_value){
-        .huffman_prefix = 0x00,
-        .insert_null_before_wire_value = false,
-        .data = grpc_slice_ref_internal(GRPC_MDVALUE(elem)),
-    };
+    GRPC_STATS_INC_HPACK_SEND_UNCOMPRESSED(exec_ctx);
+    wire_val.huffman_prefix = 0x00;
+    wire_val.insert_null_before_wire_value = false;
+    wire_val.data = grpc_slice_ref_internal(GRPC_MDVALUE(elem));
   }
+  return wire_val;
 }
 
 static size_t wire_value_length(wire_value v) {
@@ -317,11 +323,14 @@ static void add_wire_value(framer_state *st, wire_value v) {
   add_header_data(st, v.data);
 }
 
-static void emit_lithdr_incidx(grpc_chttp2_hpack_compressor *c,
+static void emit_lithdr_incidx(grpc_exec_ctx *exec_ctx,
+                               grpc_chttp2_hpack_compressor *c,
                                uint32_t key_index, grpc_mdelem elem,
                                framer_state *st) {
+  GRPC_STATS_INC_HPACK_SEND_LITHDR_INCIDX(exec_ctx);
   uint32_t len_pfx = GRPC_CHTTP2_VARINT_LENGTH(key_index, 2);
-  wire_value value = get_wire_value(elem, st->use_true_binary_metadata);
+  wire_value value =
+      get_wire_value(exec_ctx, elem, st->use_true_binary_metadata);
   size_t len_val = wire_value_length(value);
   uint32_t len_val_len;
   GPR_ASSERT(len_val <= UINT32_MAX);
@@ -333,11 +342,14 @@ static void emit_lithdr_incidx(grpc_chttp2_hpack_compressor *c,
   add_wire_value(st, value);
 }
 
-static void emit_lithdr_noidx(grpc_chttp2_hpack_compressor *c,
+static void emit_lithdr_noidx(grpc_exec_ctx *exec_ctx,
+                              grpc_chttp2_hpack_compressor *c,
                               uint32_t key_index, grpc_mdelem elem,
                               framer_state *st) {
+  GRPC_STATS_INC_HPACK_SEND_LITHDR_NOTIDX(exec_ctx);
   uint32_t len_pfx = GRPC_CHTTP2_VARINT_LENGTH(key_index, 4);
-  wire_value value = get_wire_value(elem, st->use_true_binary_metadata);
+  wire_value value =
+      get_wire_value(exec_ctx, elem, st->use_true_binary_metadata);
   size_t len_val = wire_value_length(value);
   uint32_t len_val_len;
   GPR_ASSERT(len_val <= UINT32_MAX);
@@ -349,10 +361,14 @@ static void emit_lithdr_noidx(grpc_chttp2_hpack_compressor *c,
   add_wire_value(st, value);
 }
 
-static void emit_lithdr_incidx_v(grpc_chttp2_hpack_compressor *c,
+static void emit_lithdr_incidx_v(grpc_exec_ctx *exec_ctx,
+                                 grpc_chttp2_hpack_compressor *c,
                                  grpc_mdelem elem, framer_state *st) {
+  GRPC_STATS_INC_HPACK_SEND_LITHDR_INCIDX_V(exec_ctx);
+  GRPC_STATS_INC_HPACK_SEND_UNCOMPRESSED(exec_ctx);
   uint32_t len_key = (uint32_t)GRPC_SLICE_LENGTH(GRPC_MDKEY(elem));
-  wire_value value = get_wire_value(elem, st->use_true_binary_metadata);
+  wire_value value =
+      get_wire_value(exec_ctx, elem, st->use_true_binary_metadata);
   uint32_t len_val = (uint32_t)wire_value_length(value);
   uint32_t len_key_len = GRPC_CHTTP2_VARINT_LENGTH(len_key, 1);
   uint32_t len_val_len = GRPC_CHTTP2_VARINT_LENGTH(len_val, 1);
@@ -367,10 +383,14 @@ static void emit_lithdr_incidx_v(grpc_chttp2_hpack_compressor *c,
   add_wire_value(st, value);
 }
 
-static void emit_lithdr_noidx_v(grpc_chttp2_hpack_compressor *c,
+static void emit_lithdr_noidx_v(grpc_exec_ctx *exec_ctx,
+                                grpc_chttp2_hpack_compressor *c,
                                 grpc_mdelem elem, framer_state *st) {
+  GRPC_STATS_INC_HPACK_SEND_LITHDR_NOTIDX_V(exec_ctx);
+  GRPC_STATS_INC_HPACK_SEND_UNCOMPRESSED(exec_ctx);
   uint32_t len_key = (uint32_t)GRPC_SLICE_LENGTH(GRPC_MDKEY(elem));
-  wire_value value = get_wire_value(elem, st->use_true_binary_metadata);
+  wire_value value =
+      get_wire_value(exec_ctx, elem, st->use_true_binary_metadata);
   uint32_t len_val = (uint32_t)wire_value_length(value);
   uint32_t len_key_len = GRPC_CHTTP2_VARINT_LENGTH(len_key, 1);
   uint32_t len_val_len = GRPC_CHTTP2_VARINT_LENGTH(len_val, 1);
@@ -423,7 +443,7 @@ static void hpack_enc(grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_compressor *c,
     gpr_free(v);
   }
   if (!GRPC_MDELEM_IS_INTERNED(elem)) {
-    emit_lithdr_noidx_v(c, elem, st);
+    emit_lithdr_noidx_v(exec_ctx, c, elem, st);
     return;
   }
 
@@ -445,16 +465,16 @@ static void hpack_enc(grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_compressor *c,
   if (grpc_mdelem_eq(c->entries_elems[HASH_FRAGMENT_2(elem_hash)], elem) &&
       c->indices_elems[HASH_FRAGMENT_2(elem_hash)] > c->tail_remote_index) {
     /* HIT: complete element (first cuckoo hash) */
-    emit_indexed(c, dynidx(c, c->indices_elems[HASH_FRAGMENT_2(elem_hash)]),
-                 st);
+    emit_indexed(exec_ctx, c,
+                 dynidx(c, c->indices_elems[HASH_FRAGMENT_2(elem_hash)]), st);
     return;
   }
 
   if (grpc_mdelem_eq(c->entries_elems[HASH_FRAGMENT_3(elem_hash)], elem) &&
       c->indices_elems[HASH_FRAGMENT_3(elem_hash)] > c->tail_remote_index) {
     /* HIT: complete element (second cuckoo hash) */
-    emit_indexed(c, dynidx(c, c->indices_elems[HASH_FRAGMENT_3(elem_hash)]),
-                 st);
+    emit_indexed(exec_ctx, c,
+                 dynidx(c, c->indices_elems[HASH_FRAGMENT_3(elem_hash)]), st);
     return;
   }
 
@@ -472,11 +492,11 @@ static void hpack_enc(grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_compressor *c,
       indices_key > c->tail_remote_index) {
     /* HIT: key (first cuckoo hash) */
     if (should_add_elem) {
-      emit_lithdr_incidx(c, dynidx(c, indices_key), elem, st);
+      emit_lithdr_incidx(exec_ctx, c, dynidx(c, indices_key), elem, st);
       add_elem(exec_ctx, c, elem);
       return;
     } else {
-      emit_lithdr_noidx(c, dynidx(c, indices_key), elem, st);
+      emit_lithdr_noidx(exec_ctx, c, dynidx(c, indices_key), elem, st);
       return;
     }
     GPR_UNREACHABLE_CODE(return );
@@ -488,11 +508,11 @@ static void hpack_enc(grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_compressor *c,
       indices_key > c->tail_remote_index) {
     /* HIT: key (first cuckoo hash) */
     if (should_add_elem) {
-      emit_lithdr_incidx(c, dynidx(c, indices_key), elem, st);
+      emit_lithdr_incidx(exec_ctx, c, dynidx(c, indices_key), elem, st);
       add_elem(exec_ctx, c, elem);
       return;
     } else {
-      emit_lithdr_noidx(c, dynidx(c, indices_key), elem, st);
+      emit_lithdr_noidx(exec_ctx, c, dynidx(c, indices_key), elem, st);
       return;
     }
     GPR_UNREACHABLE_CODE(return );
@@ -501,11 +521,11 @@ static void hpack_enc(grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_compressor *c,
   /* no elem, key in the table... fall back to literal emission */
 
   if (should_add_elem) {
-    emit_lithdr_incidx_v(c, elem, st);
+    emit_lithdr_incidx_v(exec_ctx, c, elem, st);
     add_elem(exec_ctx, c, elem);
     return;
   } else {
-    emit_lithdr_noidx_v(c, elem, st);
+    emit_lithdr_noidx_v(exec_ctx, c, elem, st);
     return;
   }
   GPR_UNREACHABLE_CODE(return );
@@ -536,7 +556,7 @@ void grpc_chttp2_hpack_compressor_init(grpc_chttp2_hpack_compressor *c) {
   c->max_table_elems = c->cap_table_elems;
   c->max_usable_size = GRPC_CHTTP2_HPACKC_INITIAL_TABLE_SIZE;
   c->table_elem_size =
-      gpr_malloc(sizeof(*c->table_elem_size) * c->cap_table_elems);
+      (uint16_t *)gpr_malloc(sizeof(*c->table_elem_size) * c->cap_table_elems);
   memset(c->table_elem_size, 0,
          sizeof(*c->table_elem_size) * c->cap_table_elems);
   for (size_t i = 0; i < GPR_ARRAY_SIZE(c->entries_keys); i++) {
@@ -564,7 +584,8 @@ void grpc_chttp2_hpack_compressor_set_max_usable_size(
 }
 
 static void rebuild_elems(grpc_chttp2_hpack_compressor *c, uint32_t new_cap) {
-  uint16_t *table_elem_size = gpr_malloc(sizeof(*table_elem_size) * new_cap);
+  uint16_t *table_elem_size =
+      (uint16_t *)gpr_malloc(sizeof(*table_elem_size) * new_cap);
   uint32_t i;
 
   memset(table_elem_size, 0, sizeof(*table_elem_size) * new_cap);

data/src/core/ext/transport/chttp2/transport/hpack_parser.c

@@ -30,6 +30,7 @@
 #include <grpc/support/useful.h>
 
 #include "src/core/ext/transport/chttp2/transport/bin_encoder.h"
+#include "src/core/lib/debug/stats.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/support/string.h"
@@ -777,8 +778,7 @@ static grpc_error *parse_stream_dep0(grpc_exec_ctx *exec_ctx,
   return parse_stream_dep1(exec_ctx, p, cur + 1, end);
 }
 
-/* emit an indexed field; for now just logs it to console; jumps to
-   begin the next field on completion */
+/* emit an indexed field; jumps to begin the next field on completion */
 static grpc_error *finish_indexed_field(grpc_exec_ctx *exec_ctx,
                                         grpc_chttp2_hpack_parser *p,
                                         const uint8_t *cur,
@@ -792,6 +792,7 @@ static grpc_error *finish_indexed_field(grpc_exec_ctx *exec_ctx,
         GRPC_ERROR_INT_SIZE, (intptr_t)p->table.num_ents);
   }
   GRPC_MDELEM_REF(md);
+  GRPC_STATS_INC_HPACK_RECV_INDEXED(exec_ctx);
   grpc_error *err = on_hdr(exec_ctx, p, md, 0);
   if (err != GRPC_ERROR_NONE) return err;
   return parse_begin(exec_ctx, p, cur, end);
@@ -820,14 +821,14 @@ static grpc_error *parse_indexed_field_x(grpc_exec_ctx *exec_ctx,
   return parse_value0(exec_ctx, p, cur + 1, end);
 }
 
-/* finish a literal header with incremental indexing: just log, and jump to '
-   begin */
+/* finish a literal header with incremental indexing */
 static grpc_error *finish_lithdr_incidx(grpc_exec_ctx *exec_ctx,
                                         grpc_chttp2_hpack_parser *p,
                                         const uint8_t *cur,
                                         const uint8_t *end) {
   grpc_mdelem md = grpc_chttp2_hptbl_lookup(&p->table, p->index);
   GPR_ASSERT(!GRPC_MDISNULL(md)); /* handled in string parsing */
+  GRPC_STATS_INC_HPACK_RECV_LITHDR_INCIDX(exec_ctx);
   grpc_error *err = on_hdr(
       exec_ctx, p,
       grpc_mdelem_from_slices(exec_ctx, grpc_slice_ref_internal(GRPC_MDKEY(md)),
@@ -842,6 +843,7 @@ static grpc_error *finish_lithdr_incidx_v(grpc_exec_ctx *exec_ctx,
                                           grpc_chttp2_hpack_parser *p,
                                           const uint8_t *cur,
                                           const uint8_t *end) {
+  GRPC_STATS_INC_HPACK_RECV_LITHDR_INCIDX_V(exec_ctx);
   grpc_error *err = on_hdr(
       exec_ctx, p,
       grpc_mdelem_from_slices(exec_ctx, take_string(exec_ctx, p, &p->key, true),
@@ -898,6 +900,7 @@ static grpc_error *finish_lithdr_notidx(grpc_exec_ctx *exec_ctx,
                                         const uint8_t *end) {
   grpc_mdelem md = grpc_chttp2_hptbl_lookup(&p->table, p->index);
   GPR_ASSERT(!GRPC_MDISNULL(md)); /* handled in string parsing */
+  GRPC_STATS_INC_HPACK_RECV_LITHDR_NOTIDX(exec_ctx);
   grpc_error *err = on_hdr(
       exec_ctx, p,
       grpc_mdelem_from_slices(exec_ctx, grpc_slice_ref_internal(GRPC_MDKEY(md)),
@@ -912,6 +915,7 @@ static grpc_error *finish_lithdr_notidx_v(grpc_exec_ctx *exec_ctx,
                                           grpc_chttp2_hpack_parser *p,
                                           const uint8_t *cur,
                                           const uint8_t *end) {
+  GRPC_STATS_INC_HPACK_RECV_LITHDR_NOTIDX_V(exec_ctx);
   grpc_error *err = on_hdr(
       exec_ctx, p,
       grpc_mdelem_from_slices(exec_ctx, take_string(exec_ctx, p, &p->key, true),
@@ -968,6 +972,7 @@ static grpc_error *finish_lithdr_nvridx(grpc_exec_ctx *exec_ctx,
                                         const uint8_t *end) {
   grpc_mdelem md = grpc_chttp2_hptbl_lookup(&p->table, p->index);
   GPR_ASSERT(!GRPC_MDISNULL(md)); /* handled in string parsing */
+  GRPC_STATS_INC_HPACK_RECV_LITHDR_NVRIDX(exec_ctx);
   grpc_error *err = on_hdr(
       exec_ctx, p,
       grpc_mdelem_from_slices(exec_ctx, grpc_slice_ref_internal(GRPC_MDKEY(md)),
@@ -982,6 +987,7 @@ static grpc_error *finish_lithdr_nvridx_v(grpc_exec_ctx *exec_ctx,
                                           grpc_chttp2_hpack_parser *p,
                                           const uint8_t *cur,
                                           const uint8_t *end) {
+  GRPC_STATS_INC_HPACK_RECV_LITHDR_NVRIDX_V(exec_ctx);
   grpc_error *err = on_hdr(
       exec_ctx, p,
       grpc_mdelem_from_slices(exec_ctx, take_string(exec_ctx, p, &p->key, true),
@@ -1284,7 +1290,7 @@ static void append_bytes(grpc_chttp2_hpack_parser_string *str,
     GPR_ASSERT(str->data.copied.length + length <= UINT32_MAX);
     str->data.copied.capacity = (uint32_t)(str->data.copied.length + length);
     str->data.copied.str =
-        gpr_realloc(str->data.copied.str, str->data.copied.capacity);
+        (char *)gpr_realloc(str->data.copied.str, str->data.copied.capacity);
   }
   memcpy(str->data.copied.str + str->data.copied.length, data, length);
   GPR_ASSERT(length <= UINT32_MAX - str->data.copied.length);
@@ -1310,9 +1316,11 @@ static grpc_error *append_string(grpc_exec_ctx *exec_ctx,
         /* 'true-binary' case */
         ++cur;
         p->binary = NOT_BINARY;
+        GRPC_STATS_INC_HPACK_RECV_BINARY(exec_ctx);
         append_bytes(str, cur, (size_t)(end - cur));
         return GRPC_ERROR_NONE;
       }
+      GRPC_STATS_INC_HPACK_RECV_BINARY_BASE64(exec_ctx);
     /* fallthrough */
     b64_byte0:
     case B64_BYTE0:
@@ -1510,6 +1518,7 @@ static grpc_error *begin_parse_string(grpc_exec_ctx *exec_ctx,
                                       grpc_chttp2_hpack_parser_string *str) {
   if (!p->huff && binary == NOT_BINARY && (end - cur) >= (intptr_t)p->strlen &&
       p->current_slice_refcount != NULL) {
+    GRPC_STATS_INC_HPACK_RECV_UNCOMPRESSED(exec_ctx);
     str->copied = false;
     str->data.referenced.refcount = p->current_slice_refcount;
     str->data.referenced.data.refcounted.bytes = (uint8_t *)cur;
@@ -1523,6 +1532,20 @@ static grpc_error *begin_parse_string(grpc_exec_ctx *exec_ctx,
   p->parsing.str = str;
   p->huff_state = 0;
   p->binary = binary;
+  switch (p->binary) {
+    case NOT_BINARY:
+      if (p->huff) {
+        GRPC_STATS_INC_HPACK_RECV_HUFFMAN(exec_ctx);
+      } else {
+        GRPC_STATS_INC_HPACK_RECV_UNCOMPRESSED(exec_ctx);
+      }
+      break;
+    case BINARY_BEGIN:
+      /* stats incremented later: don't know true binary or not */
+      break;
+    default:
+      abort();
+  }
   return parse_string(exec_ctx, p, cur, end);
 }
 
@@ -1643,24 +1666,38 @@ static const maybe_complete_func_type maybe_complete_funcs[] = {
 
 static void force_client_rst_stream(grpc_exec_ctx *exec_ctx, void *sp,
                                     grpc_error *error) {
-  grpc_chttp2_stream *s = sp;
+  grpc_chttp2_stream *s = (grpc_chttp2_stream *)sp;
   grpc_chttp2_transport *t = s->t;
   if (!s->write_closed) {
     grpc_slice_buffer_add(
         &t->qbuf, grpc_chttp2_rst_stream_create(s->id, GRPC_HTTP2_NO_ERROR,
                                                 &s->stats.outgoing));
-    grpc_chttp2_initiate_write(exec_ctx, t, "force_rst_stream");
+    grpc_chttp2_initiate_write(exec_ctx, t,
+                               GRPC_CHTTP2_INITIATE_WRITE_FORCE_RST_STREAM);
     grpc_chttp2_mark_stream_closed(exec_ctx, t, s, true, true, GRPC_ERROR_NONE);
   }
   GRPC_CHTTP2_STREAM_UNREF(exec_ctx, s, "final_rst");
 }
 
+static void parse_stream_compression_md(grpc_exec_ctx *exec_ctx,
+                                        grpc_chttp2_transport *t,
+                                        grpc_chttp2_stream *s,
+                                        grpc_metadata_batch *initial_metadata) {
+  if (initial_metadata->idx.named.content_encoding == NULL ||
+      grpc_stream_compression_method_parse(
+          GRPC_MDVALUE(initial_metadata->idx.named.content_encoding->md), false,
+          &s->stream_decompression_method) == 0) {
+    s->stream_decompression_method =
+        GRPC_STREAM_COMPRESSION_IDENTITY_DECOMPRESS;
+  }
+}
+
 grpc_error *grpc_chttp2_header_parser_parse(grpc_exec_ctx *exec_ctx,
                                             void *hpack_parser,
                                             grpc_chttp2_transport *t,
                                             grpc_chttp2_stream *s,
                                             grpc_slice slice, int is_last) {
-  grpc_chttp2_hpack_parser *parser = hpack_parser;
+  grpc_chttp2_hpack_parser *parser = (grpc_chttp2_hpack_parser *)hpack_parser;
   GPR_TIMER_BEGIN("grpc_chttp2_hpack_parser_parse", 0);
   if (s != NULL) {
     s->stats.incoming.header_bytes += GRPC_SLICE_LENGTH(slice);
@@ -1681,9 +1718,16 @@ grpc_error *grpc_chttp2_header_parser_parse(grpc_exec_ctx *exec_ctx,
     if (s != NULL) {
       if (parser->is_boundary) {
         if (s->header_frames_received == GPR_ARRAY_SIZE(s->metadata_buffer)) {
+          GPR_TIMER_END("grpc_chttp2_hpack_parser_parse", 0);
           return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
               "Too many trailer frames");
         }
+        /* Process stream compression md element if it exists */
+        if (s->header_frames_received ==
+            0) { /* Only acts on initial metadata */
+          parse_stream_compression_md(exec_ctx, t, s,
+                                      &s->metadata_buffer[0].batch);
+        }
         s->published_metadata[s->header_frames_received] =
             GRPC_METADATA_PUBLISHED_FROM_WIRE;
         maybe_complete_funcs[s->header_frames_received](exec_ctx, t, s);