grpc 1.7.3 → 1.8.0

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

@@ -34,6 +34,12 @@
 /* maximum table size we'll actually use */
 #define GRPC_CHTTP2_HPACKC_MAX_TABLE_SIZE (1024 * 1024)
 
+extern grpc_core::TraceFlag grpc_http_trace;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct {
   uint32_t filter_elems_sum;
   uint32_t max_table_size;
@@ -64,31 +70,35 @@ typedef struct {
   uint32_t indices_keys[GRPC_CHTTP2_HPACKC_NUM_VALUES];
   uint32_t indices_elems[GRPC_CHTTP2_HPACKC_NUM_VALUES];
 
-  uint16_t *table_elem_size;
+  uint16_t* table_elem_size;
 } grpc_chttp2_hpack_compressor;
 
-void grpc_chttp2_hpack_compressor_init(grpc_chttp2_hpack_compressor *c);
-void grpc_chttp2_hpack_compressor_destroy(grpc_exec_ctx *exec_ctx,
-                                          grpc_chttp2_hpack_compressor *c);
+void grpc_chttp2_hpack_compressor_init(grpc_chttp2_hpack_compressor* c);
+void grpc_chttp2_hpack_compressor_destroy(grpc_exec_ctx* exec_ctx,
+                                          grpc_chttp2_hpack_compressor* c);
 void grpc_chttp2_hpack_compressor_set_max_table_size(
-    grpc_chttp2_hpack_compressor *c, uint32_t max_table_size);
+    grpc_chttp2_hpack_compressor* c, uint32_t max_table_size);
 void grpc_chttp2_hpack_compressor_set_max_usable_size(
-    grpc_chttp2_hpack_compressor *c, uint32_t max_table_size);
+    grpc_chttp2_hpack_compressor* c, uint32_t max_table_size);
 
 typedef struct {
   uint32_t stream_id;
   bool is_eof;
   bool use_true_binary_metadata;
   size_t max_frame_size;
-  grpc_transport_one_way_stats *stats;
+  grpc_transport_one_way_stats* stats;
 } grpc_encode_header_options;
 
-void grpc_chttp2_encode_header(grpc_exec_ctx *exec_ctx,
-                               grpc_chttp2_hpack_compressor *c,
-                               grpc_mdelem **extra_headers,
+void grpc_chttp2_encode_header(grpc_exec_ctx* exec_ctx,
+                               grpc_chttp2_hpack_compressor* c,
+                               grpc_mdelem** extra_headers,
                                size_t extra_headers_size,
-                               grpc_metadata_batch *metadata,
-                               const grpc_encode_header_options *options,
-                               grpc_slice_buffer *outbuf);
+                               grpc_metadata_batch* metadata,
+                               const grpc_encode_header_options* options,
+                               grpc_slice_buffer* outbuf);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_H */

data/src/core/ext/transport/chttp2/transport/{hpack_parser.c → hpack_parser.cc}

@@ -33,6 +33,7 @@
 #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/slice/slice_string_helpers.h"
 #include "src/core/lib/support/string.h"
 #include "src/core/lib/transport/http2_errors.h"
 
@@ -60,97 +61,97 @@ typedef enum {
    a set of indirect jumps, and so not waste stack space. */
 
 /* forward declarations for parsing states */
-static grpc_error *parse_begin(grpc_exec_ctx *exec_ctx,
-                               grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-                               const uint8_t *end);
-static grpc_error *parse_error(grpc_exec_ctx *exec_ctx,
-                               grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-                               const uint8_t *end, grpc_error *error);
-static grpc_error *still_parse_error(grpc_exec_ctx *exec_ctx,
-                                     grpc_chttp2_hpack_parser *p,
-                                     const uint8_t *cur, const uint8_t *end);
-static grpc_error *parse_illegal_op(grpc_exec_ctx *exec_ctx,
-                                    grpc_chttp2_hpack_parser *p,
-                                    const uint8_t *cur, const uint8_t *end);
-
-static grpc_error *parse_string_prefix(grpc_exec_ctx *exec_ctx,
-                                       grpc_chttp2_hpack_parser *p,
-                                       const uint8_t *cur, const uint8_t *end);
-static grpc_error *parse_key_string(grpc_exec_ctx *exec_ctx,
-                                    grpc_chttp2_hpack_parser *p,
-                                    const uint8_t *cur, const uint8_t *end);
-static grpc_error *parse_value_string_with_indexed_key(
-    grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-    const uint8_t *end);
-static grpc_error *parse_value_string_with_literal_key(
-    grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-    const uint8_t *end);
-
-static grpc_error *parse_value0(grpc_exec_ctx *exec_ctx,
-                                grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-                                const uint8_t *end);
-static grpc_error *parse_value1(grpc_exec_ctx *exec_ctx,
-                                grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-                                const uint8_t *end);
-static grpc_error *parse_value2(grpc_exec_ctx *exec_ctx,
-                                grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-                                const uint8_t *end);
-static grpc_error *parse_value3(grpc_exec_ctx *exec_ctx,
-                                grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-                                const uint8_t *end);
-static grpc_error *parse_value4(grpc_exec_ctx *exec_ctx,
-                                grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-                                const uint8_t *end);
-static grpc_error *parse_value5up(grpc_exec_ctx *exec_ctx,
-                                  grpc_chttp2_hpack_parser *p,
-                                  const uint8_t *cur, const uint8_t *end);
-
-static grpc_error *parse_indexed_field(grpc_exec_ctx *exec_ctx,
-                                       grpc_chttp2_hpack_parser *p,
-                                       const uint8_t *cur, const uint8_t *end);
-static grpc_error *parse_indexed_field_x(grpc_exec_ctx *exec_ctx,
-                                         grpc_chttp2_hpack_parser *p,
-                                         const uint8_t *cur,
-                                         const uint8_t *end);
-static grpc_error *parse_lithdr_incidx(grpc_exec_ctx *exec_ctx,
-                                       grpc_chttp2_hpack_parser *p,
-                                       const uint8_t *cur, const uint8_t *end);
-static grpc_error *parse_lithdr_incidx_x(grpc_exec_ctx *exec_ctx,
-                                         grpc_chttp2_hpack_parser *p,
-                                         const uint8_t *cur,
-                                         const uint8_t *end);
-static grpc_error *parse_lithdr_incidx_v(grpc_exec_ctx *exec_ctx,
-                                         grpc_chttp2_hpack_parser *p,
-                                         const uint8_t *cur,
-                                         const uint8_t *end);
-static grpc_error *parse_lithdr_notidx(grpc_exec_ctx *exec_ctx,
-                                       grpc_chttp2_hpack_parser *p,
-                                       const uint8_t *cur, const uint8_t *end);
-static grpc_error *parse_lithdr_notidx_x(grpc_exec_ctx *exec_ctx,
-                                         grpc_chttp2_hpack_parser *p,
-                                         const uint8_t *cur,
-                                         const uint8_t *end);
-static grpc_error *parse_lithdr_notidx_v(grpc_exec_ctx *exec_ctx,
-                                         grpc_chttp2_hpack_parser *p,
-                                         const uint8_t *cur,
-                                         const uint8_t *end);
-static grpc_error *parse_lithdr_nvridx(grpc_exec_ctx *exec_ctx,
-                                       grpc_chttp2_hpack_parser *p,
-                                       const uint8_t *cur, const uint8_t *end);
-static grpc_error *parse_lithdr_nvridx_x(grpc_exec_ctx *exec_ctx,
-                                         grpc_chttp2_hpack_parser *p,
-                                         const uint8_t *cur,
-                                         const uint8_t *end);
-static grpc_error *parse_lithdr_nvridx_v(grpc_exec_ctx *exec_ctx,
-                                         grpc_chttp2_hpack_parser *p,
-                                         const uint8_t *cur,
-                                         const uint8_t *end);
-static grpc_error *parse_max_tbl_size(grpc_exec_ctx *exec_ctx,
-                                      grpc_chttp2_hpack_parser *p,
-                                      const uint8_t *cur, const uint8_t *end);
-static grpc_error *parse_max_tbl_size_x(grpc_exec_ctx *exec_ctx,
-                                        grpc_chttp2_hpack_parser *p,
-                                        const uint8_t *cur, const uint8_t *end);
+static grpc_error* parse_begin(grpc_exec_ctx* exec_ctx,
+                               grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+                               const uint8_t* end);
+static grpc_error* parse_error(grpc_exec_ctx* exec_ctx,
+                               grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+                               const uint8_t* end, grpc_error* error);
+static grpc_error* still_parse_error(grpc_exec_ctx* exec_ctx,
+                                     grpc_chttp2_hpack_parser* p,
+                                     const uint8_t* cur, const uint8_t* end);
+static grpc_error* parse_illegal_op(grpc_exec_ctx* exec_ctx,
+                                    grpc_chttp2_hpack_parser* p,
+                                    const uint8_t* cur, const uint8_t* end);
+
+static grpc_error* parse_string_prefix(grpc_exec_ctx* exec_ctx,
+                                       grpc_chttp2_hpack_parser* p,
+                                       const uint8_t* cur, const uint8_t* end);
+static grpc_error* parse_key_string(grpc_exec_ctx* exec_ctx,
+                                    grpc_chttp2_hpack_parser* p,
+                                    const uint8_t* cur, const uint8_t* end);
+static grpc_error* parse_value_string_with_indexed_key(
+    grpc_exec_ctx* exec_ctx, grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+    const uint8_t* end);
+static grpc_error* parse_value_string_with_literal_key(
+    grpc_exec_ctx* exec_ctx, grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+    const uint8_t* end);
+
+static grpc_error* parse_value0(grpc_exec_ctx* exec_ctx,
+                                grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+                                const uint8_t* end);
+static grpc_error* parse_value1(grpc_exec_ctx* exec_ctx,
+                                grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+                                const uint8_t* end);
+static grpc_error* parse_value2(grpc_exec_ctx* exec_ctx,
+                                grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+                                const uint8_t* end);
+static grpc_error* parse_value3(grpc_exec_ctx* exec_ctx,
+                                grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+                                const uint8_t* end);
+static grpc_error* parse_value4(grpc_exec_ctx* exec_ctx,
+                                grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+                                const uint8_t* end);
+static grpc_error* parse_value5up(grpc_exec_ctx* exec_ctx,
+                                  grpc_chttp2_hpack_parser* p,
+                                  const uint8_t* cur, const uint8_t* end);
+
+static grpc_error* parse_indexed_field(grpc_exec_ctx* exec_ctx,
+                                       grpc_chttp2_hpack_parser* p,
+                                       const uint8_t* cur, const uint8_t* end);
+static grpc_error* parse_indexed_field_x(grpc_exec_ctx* exec_ctx,
+                                         grpc_chttp2_hpack_parser* p,
+                                         const uint8_t* cur,
+                                         const uint8_t* end);
+static grpc_error* parse_lithdr_incidx(grpc_exec_ctx* exec_ctx,
+                                       grpc_chttp2_hpack_parser* p,
+                                       const uint8_t* cur, const uint8_t* end);
+static grpc_error* parse_lithdr_incidx_x(grpc_exec_ctx* exec_ctx,
+                                         grpc_chttp2_hpack_parser* p,
+                                         const uint8_t* cur,
+                                         const uint8_t* end);
+static grpc_error* parse_lithdr_incidx_v(grpc_exec_ctx* exec_ctx,
+                                         grpc_chttp2_hpack_parser* p,
+                                         const uint8_t* cur,
+                                         const uint8_t* end);
+static grpc_error* parse_lithdr_notidx(grpc_exec_ctx* exec_ctx,
+                                       grpc_chttp2_hpack_parser* p,
+                                       const uint8_t* cur, const uint8_t* end);
+static grpc_error* parse_lithdr_notidx_x(grpc_exec_ctx* exec_ctx,
+                                         grpc_chttp2_hpack_parser* p,
+                                         const uint8_t* cur,
+                                         const uint8_t* end);
+static grpc_error* parse_lithdr_notidx_v(grpc_exec_ctx* exec_ctx,
+                                         grpc_chttp2_hpack_parser* p,
+                                         const uint8_t* cur,
+                                         const uint8_t* end);
+static grpc_error* parse_lithdr_nvridx(grpc_exec_ctx* exec_ctx,
+                                       grpc_chttp2_hpack_parser* p,
+                                       const uint8_t* cur, const uint8_t* end);
+static grpc_error* parse_lithdr_nvridx_x(grpc_exec_ctx* exec_ctx,
+                                         grpc_chttp2_hpack_parser* p,
+                                         const uint8_t* cur,
+                                         const uint8_t* end);
+static grpc_error* parse_lithdr_nvridx_v(grpc_exec_ctx* exec_ctx,
+                                         grpc_chttp2_hpack_parser* p,
+                                         const uint8_t* cur,
+                                         const uint8_t* end);
+static grpc_error* parse_max_tbl_size(grpc_exec_ctx* exec_ctx,
+                                      grpc_chttp2_hpack_parser* p,
+                                      const uint8_t* cur, const uint8_t* end);
+static grpc_error* parse_max_tbl_size_x(grpc_exec_ctx* exec_ctx,
+                                        grpc_chttp2_hpack_parser* p,
+                                        const uint8_t* cur, const uint8_t* end);
 
 /* we translate the first byte of a hpack field into one of these decoding
    cases, then use a lookup table to jump directly to the appropriate parser.
@@ -648,11 +649,16 @@ static const uint8_t inverse_base64[256] = {
 };
 
 /* emission helpers */
-static grpc_error *on_hdr(grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_parser *p,
+static grpc_error* on_hdr(grpc_exec_ctx* exec_ctx, grpc_chttp2_hpack_parser* p,
                           grpc_mdelem md, int add_to_table) {
-  if (GRPC_TRACER_ON(grpc_http_trace) && !GRPC_MDELEM_IS_INTERNED(md)) {
-    char *k = grpc_slice_to_c_string(GRPC_MDKEY(md));
-    char *v = grpc_slice_to_c_string(GRPC_MDVALUE(md));
+  if (grpc_http_trace.enabled()) {
+    char* k = grpc_slice_to_c_string(GRPC_MDKEY(md));
+    char* v = nullptr;
+    if (grpc_is_binary_header(GRPC_MDKEY(md))) {
+      v = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX);
+    } else {
+      v = grpc_slice_to_c_string(GRPC_MDVALUE(md));
+    }
     gpr_log(
         GPR_DEBUG,
         "Decode: '%s: %s', elem_interned=%d [%d], k_interned=%d, v_interned=%d",
@@ -665,10 +671,10 @@ static grpc_error *on_hdr(grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_parser *p,
   if (add_to_table) {
     GPR_ASSERT(GRPC_MDELEM_STORAGE(md) == GRPC_MDELEM_STORAGE_INTERNED ||
                GRPC_MDELEM_STORAGE(md) == GRPC_MDELEM_STORAGE_STATIC);
-    grpc_error *err = grpc_chttp2_hptbl_add(exec_ctx, &p->table, md);
+    grpc_error* err = grpc_chttp2_hptbl_add(exec_ctx, &p->table, md);
     if (err != GRPC_ERROR_NONE) return err;
   }
-  if (p->on_header == NULL) {
+  if (p->on_header == nullptr) {
     GRPC_MDELEM_UNREF(exec_ctx, md);
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("on_header callback not set");
   }
@@ -676,9 +682,9 @@ static grpc_error *on_hdr(grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_parser *p,
   return GRPC_ERROR_NONE;
 }
 
-static grpc_slice take_string(grpc_exec_ctx *exec_ctx,
-                              grpc_chttp2_hpack_parser *p,
-                              grpc_chttp2_hpack_parser_string *str,
+static grpc_slice take_string(grpc_exec_ctx* exec_ctx,
+                              grpc_chttp2_hpack_parser* p,
+                              grpc_chttp2_hpack_parser_string* str,
                               bool intern) {
   grpc_slice s;
   if (!str->copied) {
@@ -702,18 +708,18 @@ static grpc_slice take_string(grpc_exec_ctx *exec_ctx,
 }
 
 /* jump to the next state */
-static grpc_error *parse_next(grpc_exec_ctx *exec_ctx,
-                              grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-                              const uint8_t *end) {
+static grpc_error* parse_next(grpc_exec_ctx* exec_ctx,
+                              grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+                              const uint8_t* end) {
   p->state = *p->next_state++;
   return p->state(exec_ctx, p, cur, end);
 }
 
 /* begin parsing a header: all functionality is encoded into lookup tables
    above */
-static grpc_error *parse_begin(grpc_exec_ctx *exec_ctx,
-                               grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-                               const uint8_t *end) {
+static grpc_error* parse_begin(grpc_exec_ctx* exec_ctx,
+                               grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+                               const uint8_t* end) {
   if (cur == end) {
     p->state = parse_begin;
     return GRPC_ERROR_NONE;
@@ -723,9 +729,9 @@ static grpc_error *parse_begin(grpc_exec_ctx *exec_ctx,
 }
 
 /* stream dependency and prioritization data: we just skip it */
-static grpc_error *parse_stream_weight(grpc_exec_ctx *exec_ctx,
-                                       grpc_chttp2_hpack_parser *p,
-                                       const uint8_t *cur, const uint8_t *end) {
+static grpc_error* parse_stream_weight(grpc_exec_ctx* exec_ctx,
+                                       grpc_chttp2_hpack_parser* p,
+                                       const uint8_t* cur, const uint8_t* end) {
   if (cur == end) {
     p->state = parse_stream_weight;
     return GRPC_ERROR_NONE;
@@ -734,9 +740,9 @@ static grpc_error *parse_stream_weight(grpc_exec_ctx *exec_ctx,
   return p->after_prioritization(exec_ctx, p, cur + 1, end);
 }
 
-static grpc_error *parse_stream_dep3(grpc_exec_ctx *exec_ctx,
-                                     grpc_chttp2_hpack_parser *p,
-                                     const uint8_t *cur, const uint8_t *end) {
+static grpc_error* parse_stream_dep3(grpc_exec_ctx* exec_ctx,
+                                     grpc_chttp2_hpack_parser* p,
+                                     const uint8_t* cur, const uint8_t* end) {
   if (cur == end) {
     p->state = parse_stream_dep3;
     return GRPC_ERROR_NONE;
@@ -745,9 +751,9 @@ static grpc_error *parse_stream_dep3(grpc_exec_ctx *exec_ctx,
   return parse_stream_weight(exec_ctx, p, cur + 1, end);
 }
 
-static grpc_error *parse_stream_dep2(grpc_exec_ctx *exec_ctx,
-                                     grpc_chttp2_hpack_parser *p,
-                                     const uint8_t *cur, const uint8_t *end) {
+static grpc_error* parse_stream_dep2(grpc_exec_ctx* exec_ctx,
+                                     grpc_chttp2_hpack_parser* p,
+                                     const uint8_t* cur, const uint8_t* end) {
   if (cur == end) {
     p->state = parse_stream_dep2;
     return GRPC_ERROR_NONE;
@@ -756,9 +762,9 @@ static grpc_error *parse_stream_dep2(grpc_exec_ctx *exec_ctx,
   return parse_stream_dep3(exec_ctx, p, cur + 1, end);
 }
 
-static grpc_error *parse_stream_dep1(grpc_exec_ctx *exec_ctx,
-                                     grpc_chttp2_hpack_parser *p,
-                                     const uint8_t *cur, const uint8_t *end) {
+static grpc_error* parse_stream_dep1(grpc_exec_ctx* exec_ctx,
+                                     grpc_chttp2_hpack_parser* p,
+                                     const uint8_t* cur, const uint8_t* end) {
   if (cur == end) {
     p->state = parse_stream_dep1;
     return GRPC_ERROR_NONE;
@@ -767,9 +773,9 @@ static grpc_error *parse_stream_dep1(grpc_exec_ctx *exec_ctx,
   return parse_stream_dep2(exec_ctx, p, cur + 1, end);
 }
 
-static grpc_error *parse_stream_dep0(grpc_exec_ctx *exec_ctx,
-                                     grpc_chttp2_hpack_parser *p,
-                                     const uint8_t *cur, const uint8_t *end) {
+static grpc_error* parse_stream_dep0(grpc_exec_ctx* exec_ctx,
+                                     grpc_chttp2_hpack_parser* p,
+                                     const uint8_t* cur, const uint8_t* end) {
   if (cur == end) {
     p->state = parse_stream_dep0;
     return GRPC_ERROR_NONE;
@@ -779,10 +785,10 @@ static grpc_error *parse_stream_dep0(grpc_exec_ctx *exec_ctx,
 }
 
 /* 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,
-                                        const uint8_t *end) {
+static grpc_error* finish_indexed_field(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);
   if (GRPC_MDISNULL(md)) {
     return grpc_error_set_int(
@@ -793,25 +799,25 @@ static grpc_error *finish_indexed_field(grpc_exec_ctx *exec_ctx,
   }
   GRPC_MDELEM_REF(md);
   GRPC_STATS_INC_HPACK_RECV_INDEXED(exec_ctx);
-  grpc_error *err = on_hdr(exec_ctx, p, md, 0);
+  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);
 }
 
 /* parse an indexed field with index < 127 */
-static grpc_error *parse_indexed_field(grpc_exec_ctx *exec_ctx,
-                                       grpc_chttp2_hpack_parser *p,
-                                       const uint8_t *cur, const uint8_t *end) {
+static grpc_error* parse_indexed_field(grpc_exec_ctx* exec_ctx,
+                                       grpc_chttp2_hpack_parser* p,
+                                       const uint8_t* cur, const uint8_t* end) {
   p->dynamic_table_update_allowed = 0;
   p->index = (*cur) & 0x7f;
   return finish_indexed_field(exec_ctx, p, cur + 1, end);
 }
 
 /* parse an indexed field with index >= 127 */
-static grpc_error *parse_indexed_field_x(grpc_exec_ctx *exec_ctx,
-                                         grpc_chttp2_hpack_parser *p,
-                                         const uint8_t *cur,
-                                         const uint8_t *end) {
+static grpc_error* parse_indexed_field_x(grpc_exec_ctx* exec_ctx,
+                                         grpc_chttp2_hpack_parser* p,
+                                         const uint8_t* cur,
+                                         const uint8_t* end) {
   static const grpc_chttp2_hpack_parser_state and_then[] = {
       finish_indexed_field};
   p->dynamic_table_update_allowed = 0;
@@ -822,14 +828,14 @@ static grpc_error *parse_indexed_field_x(grpc_exec_ctx *exec_ctx,
 }
 
 /* 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) {
+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(
+  grpc_error* err = on_hdr(
       exec_ctx, p,
       grpc_mdelem_from_slices(exec_ctx, grpc_slice_ref_internal(GRPC_MDKEY(md)),
                               take_string(exec_ctx, p, &p->value, true)),
@@ -839,12 +845,12 @@ static grpc_error *finish_lithdr_incidx(grpc_exec_ctx *exec_ctx,
 }
 
 /* finish a literal header with incremental indexing with no index */
-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) {
+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(
+  grpc_error* err = on_hdr(
       exec_ctx, p,
       grpc_mdelem_from_slices(exec_ctx, take_string(exec_ctx, p, &p->key, true),
                               take_string(exec_ctx, p, &p->value, true)),
@@ -854,9 +860,9 @@ static grpc_error *finish_lithdr_incidx_v(grpc_exec_ctx *exec_ctx,
 }
 
 /* parse a literal header with incremental indexing; index < 63 */
-static grpc_error *parse_lithdr_incidx(grpc_exec_ctx *exec_ctx,
-                                       grpc_chttp2_hpack_parser *p,
-                                       const uint8_t *cur, const uint8_t *end) {
+static grpc_error* parse_lithdr_incidx(grpc_exec_ctx* exec_ctx,
+                                       grpc_chttp2_hpack_parser* p,
+                                       const uint8_t* cur, const uint8_t* end) {
   static const grpc_chttp2_hpack_parser_state and_then[] = {
       parse_value_string_with_indexed_key, finish_lithdr_incidx};
   p->dynamic_table_update_allowed = 0;
@@ -866,10 +872,10 @@ static grpc_error *parse_lithdr_incidx(grpc_exec_ctx *exec_ctx,
 }
 
 /* parse a literal header with incremental indexing; index >= 63 */
-static grpc_error *parse_lithdr_incidx_x(grpc_exec_ctx *exec_ctx,
-                                         grpc_chttp2_hpack_parser *p,
-                                         const uint8_t *cur,
-                                         const uint8_t *end) {
+static grpc_error* parse_lithdr_incidx_x(grpc_exec_ctx* exec_ctx,
+                                         grpc_chttp2_hpack_parser* p,
+                                         const uint8_t* cur,
+                                         const uint8_t* end) {
   static const grpc_chttp2_hpack_parser_state and_then[] = {
       parse_string_prefix, parse_value_string_with_indexed_key,
       finish_lithdr_incidx};
@@ -881,10 +887,10 @@ static grpc_error *parse_lithdr_incidx_x(grpc_exec_ctx *exec_ctx,
 }
 
 /* parse a literal header with incremental indexing; index = 0 */
-static grpc_error *parse_lithdr_incidx_v(grpc_exec_ctx *exec_ctx,
-                                         grpc_chttp2_hpack_parser *p,
-                                         const uint8_t *cur,
-                                         const uint8_t *end) {
+static grpc_error* parse_lithdr_incidx_v(grpc_exec_ctx* exec_ctx,
+                                         grpc_chttp2_hpack_parser* p,
+                                         const uint8_t* cur,
+                                         const uint8_t* end) {
   static const grpc_chttp2_hpack_parser_state and_then[] = {
       parse_key_string, parse_string_prefix,
       parse_value_string_with_literal_key, finish_lithdr_incidx_v};
@@ -894,14 +900,14 @@ static grpc_error *parse_lithdr_incidx_v(grpc_exec_ctx *exec_ctx,
 }
 
 /* finish a literal header without incremental indexing */
-static grpc_error *finish_lithdr_notidx(grpc_exec_ctx *exec_ctx,
-                                        grpc_chttp2_hpack_parser *p,
-                                        const uint8_t *cur,
-                                        const uint8_t *end) {
+static grpc_error* finish_lithdr_notidx(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_NOTIDX(exec_ctx);
-  grpc_error *err = on_hdr(
+  grpc_error* err = on_hdr(
       exec_ctx, p,
       grpc_mdelem_from_slices(exec_ctx, grpc_slice_ref_internal(GRPC_MDKEY(md)),
                               take_string(exec_ctx, p, &p->value, false)),
@@ -911,12 +917,12 @@ static grpc_error *finish_lithdr_notidx(grpc_exec_ctx *exec_ctx,
 }
 
 /* finish a literal header without incremental indexing with index = 0 */
-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) {
+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(
+  grpc_error* err = on_hdr(
       exec_ctx, p,
       grpc_mdelem_from_slices(exec_ctx, take_string(exec_ctx, p, &p->key, true),
                               take_string(exec_ctx, p, &p->value, false)),
@@ -926,9 +932,9 @@ static grpc_error *finish_lithdr_notidx_v(grpc_exec_ctx *exec_ctx,
 }
 
 /* parse a literal header without incremental indexing; index < 15 */
-static grpc_error *parse_lithdr_notidx(grpc_exec_ctx *exec_ctx,
-                                       grpc_chttp2_hpack_parser *p,
-                                       const uint8_t *cur, const uint8_t *end) {
+static grpc_error* parse_lithdr_notidx(grpc_exec_ctx* exec_ctx,
+                                       grpc_chttp2_hpack_parser* p,
+                                       const uint8_t* cur, const uint8_t* end) {
   static const grpc_chttp2_hpack_parser_state and_then[] = {
       parse_value_string_with_indexed_key, finish_lithdr_notidx};
   p->dynamic_table_update_allowed = 0;
@@ -938,10 +944,10 @@ static grpc_error *parse_lithdr_notidx(grpc_exec_ctx *exec_ctx,
 }
 
 /* parse a literal header without incremental indexing; index >= 15 */
-static grpc_error *parse_lithdr_notidx_x(grpc_exec_ctx *exec_ctx,
-                                         grpc_chttp2_hpack_parser *p,
-                                         const uint8_t *cur,
-                                         const uint8_t *end) {
+static grpc_error* parse_lithdr_notidx_x(grpc_exec_ctx* exec_ctx,
+                                         grpc_chttp2_hpack_parser* p,
+                                         const uint8_t* cur,
+                                         const uint8_t* end) {
   static const grpc_chttp2_hpack_parser_state and_then[] = {
       parse_string_prefix, parse_value_string_with_indexed_key,
       finish_lithdr_notidx};
@@ -953,10 +959,10 @@ static grpc_error *parse_lithdr_notidx_x(grpc_exec_ctx *exec_ctx,
 }
 
 /* parse a literal header without incremental indexing; index == 0 */
-static grpc_error *parse_lithdr_notidx_v(grpc_exec_ctx *exec_ctx,
-                                         grpc_chttp2_hpack_parser *p,
-                                         const uint8_t *cur,
-                                         const uint8_t *end) {
+static grpc_error* parse_lithdr_notidx_v(grpc_exec_ctx* exec_ctx,
+                                         grpc_chttp2_hpack_parser* p,
+                                         const uint8_t* cur,
+                                         const uint8_t* end) {
   static const grpc_chttp2_hpack_parser_state and_then[] = {
       parse_key_string, parse_string_prefix,
       parse_value_string_with_literal_key, finish_lithdr_notidx_v};
@@ -966,14 +972,14 @@ static grpc_error *parse_lithdr_notidx_v(grpc_exec_ctx *exec_ctx,
 }
 
 /* finish a literal header that is never indexed */
-static grpc_error *finish_lithdr_nvridx(grpc_exec_ctx *exec_ctx,
-                                        grpc_chttp2_hpack_parser *p,
-                                        const uint8_t *cur,
-                                        const uint8_t *end) {
+static grpc_error* finish_lithdr_nvridx(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_NVRIDX(exec_ctx);
-  grpc_error *err = on_hdr(
+  grpc_error* err = on_hdr(
       exec_ctx, p,
       grpc_mdelem_from_slices(exec_ctx, grpc_slice_ref_internal(GRPC_MDKEY(md)),
                               take_string(exec_ctx, p, &p->value, false)),
@@ -983,12 +989,12 @@ static grpc_error *finish_lithdr_nvridx(grpc_exec_ctx *exec_ctx,
 }
 
 /* finish a literal header that is never indexed with an extra value */
-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) {
+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(
+  grpc_error* err = on_hdr(
       exec_ctx, p,
       grpc_mdelem_from_slices(exec_ctx, take_string(exec_ctx, p, &p->key, true),
                               take_string(exec_ctx, p, &p->value, false)),
@@ -998,9 +1004,9 @@ static grpc_error *finish_lithdr_nvridx_v(grpc_exec_ctx *exec_ctx,
 }
 
 /* parse a literal header that is never indexed; index < 15 */
-static grpc_error *parse_lithdr_nvridx(grpc_exec_ctx *exec_ctx,
-                                       grpc_chttp2_hpack_parser *p,
-                                       const uint8_t *cur, const uint8_t *end) {
+static grpc_error* parse_lithdr_nvridx(grpc_exec_ctx* exec_ctx,
+                                       grpc_chttp2_hpack_parser* p,
+                                       const uint8_t* cur, const uint8_t* end) {
   static const grpc_chttp2_hpack_parser_state and_then[] = {
       parse_value_string_with_indexed_key, finish_lithdr_nvridx};
   p->dynamic_table_update_allowed = 0;
@@ -1010,10 +1016,10 @@ static grpc_error *parse_lithdr_nvridx(grpc_exec_ctx *exec_ctx,
 }
 
 /* parse a literal header that is never indexed; index >= 15 */
-static grpc_error *parse_lithdr_nvridx_x(grpc_exec_ctx *exec_ctx,
-                                         grpc_chttp2_hpack_parser *p,
-                                         const uint8_t *cur,
-                                         const uint8_t *end) {
+static grpc_error* parse_lithdr_nvridx_x(grpc_exec_ctx* exec_ctx,
+                                         grpc_chttp2_hpack_parser* p,
+                                         const uint8_t* cur,
+                                         const uint8_t* end) {
   static const grpc_chttp2_hpack_parser_state and_then[] = {
       parse_string_prefix, parse_value_string_with_indexed_key,
       finish_lithdr_nvridx};
@@ -1025,10 +1031,10 @@ static grpc_error *parse_lithdr_nvridx_x(grpc_exec_ctx *exec_ctx,
 }
 
 /* parse a literal header that is never indexed; index == 0 */
-static grpc_error *parse_lithdr_nvridx_v(grpc_exec_ctx *exec_ctx,
-                                         grpc_chttp2_hpack_parser *p,
-                                         const uint8_t *cur,
-                                         const uint8_t *end) {
+static grpc_error* parse_lithdr_nvridx_v(grpc_exec_ctx* exec_ctx,
+                                         grpc_chttp2_hpack_parser* p,
+                                         const uint8_t* cur,
+                                         const uint8_t* end) {
   static const grpc_chttp2_hpack_parser_state and_then[] = {
       parse_key_string, parse_string_prefix,
       parse_value_string_with_literal_key, finish_lithdr_nvridx_v};
@@ -1038,22 +1044,22 @@ static grpc_error *parse_lithdr_nvridx_v(grpc_exec_ctx *exec_ctx,
 }
 
 /* finish parsing a max table size change */
-static grpc_error *finish_max_tbl_size(grpc_exec_ctx *exec_ctx,
-                                       grpc_chttp2_hpack_parser *p,
-                                       const uint8_t *cur, const uint8_t *end) {
-  if (GRPC_TRACER_ON(grpc_http_trace)) {
+static grpc_error* finish_max_tbl_size(grpc_exec_ctx* exec_ctx,
+                                       grpc_chttp2_hpack_parser* p,
+                                       const uint8_t* cur, const uint8_t* end) {
+  if (grpc_http_trace.enabled()) {
     gpr_log(GPR_INFO, "MAX TABLE SIZE: %d", p->index);
   }
-  grpc_error *err =
+  grpc_error* err =
       grpc_chttp2_hptbl_set_current_table_size(exec_ctx, &p->table, p->index);
   if (err != GRPC_ERROR_NONE) return parse_error(exec_ctx, p, cur, end, err);
   return parse_begin(exec_ctx, p, cur, end);
 }
 
 /* parse a max table size change, max size < 15 */
-static grpc_error *parse_max_tbl_size(grpc_exec_ctx *exec_ctx,
-                                      grpc_chttp2_hpack_parser *p,
-                                      const uint8_t *cur, const uint8_t *end) {
+static grpc_error* parse_max_tbl_size(grpc_exec_ctx* exec_ctx,
+                                      grpc_chttp2_hpack_parser* p,
+                                      const uint8_t* cur, const uint8_t* end) {
   if (p->dynamic_table_update_allowed == 0) {
     return parse_error(
         exec_ctx, p, cur, end,
@@ -1066,10 +1072,10 @@ static grpc_error *parse_max_tbl_size(grpc_exec_ctx *exec_ctx,
 }
 
 /* parse a max table size change, max size >= 15 */
-static grpc_error *parse_max_tbl_size_x(grpc_exec_ctx *exec_ctx,
-                                        grpc_chttp2_hpack_parser *p,
-                                        const uint8_t *cur,
-                                        const uint8_t *end) {
+static grpc_error* parse_max_tbl_size_x(grpc_exec_ctx* exec_ctx,
+                                        grpc_chttp2_hpack_parser* p,
+                                        const uint8_t* cur,
+                                        const uint8_t* end) {
   static const grpc_chttp2_hpack_parser_state and_then[] = {
       finish_max_tbl_size};
   if (p->dynamic_table_update_allowed == 0) {
@@ -1086,9 +1092,9 @@ static grpc_error *parse_max_tbl_size_x(grpc_exec_ctx *exec_ctx,
 }
 
 /* a parse error: jam the parse state into parse_error, and return error */
-static grpc_error *parse_error(grpc_exec_ctx *exec_ctx,
-                               grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-                               const uint8_t *end, grpc_error *err) {
+static grpc_error* parse_error(grpc_exec_ctx* exec_ctx,
+                               grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+                               const uint8_t* end, grpc_error* err) {
   GPR_ASSERT(err != GRPC_ERROR_NONE);
   if (p->last_error == GRPC_ERROR_NONE) {
     p->last_error = GRPC_ERROR_REF(err);
@@ -1097,28 +1103,28 @@ static grpc_error *parse_error(grpc_exec_ctx *exec_ctx,
   return err;
 }
 
-static grpc_error *still_parse_error(grpc_exec_ctx *exec_ctx,
-                                     grpc_chttp2_hpack_parser *p,
-                                     const uint8_t *cur, const uint8_t *end) {
+static grpc_error* still_parse_error(grpc_exec_ctx* exec_ctx,
+                                     grpc_chttp2_hpack_parser* p,
+                                     const uint8_t* cur, const uint8_t* end) {
   return GRPC_ERROR_REF(p->last_error);
 }
 
-static grpc_error *parse_illegal_op(grpc_exec_ctx *exec_ctx,
-                                    grpc_chttp2_hpack_parser *p,
-                                    const uint8_t *cur, const uint8_t *end) {
+static grpc_error* parse_illegal_op(grpc_exec_ctx* exec_ctx,
+                                    grpc_chttp2_hpack_parser* p,
+                                    const uint8_t* cur, const uint8_t* end) {
   GPR_ASSERT(cur != end);
-  char *msg;
+  char* msg;
   gpr_asprintf(&msg, "Illegal hpack op code %d", *cur);
-  grpc_error *err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
+  grpc_error* err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
   gpr_free(msg);
   return parse_error(exec_ctx, p, cur, end, err);
 }
 
 /* parse the 1st byte of a varint into p->parsing.value
    no overflow is possible */
-static grpc_error *parse_value0(grpc_exec_ctx *exec_ctx,
-                                grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-                                const uint8_t *end) {
+static grpc_error* parse_value0(grpc_exec_ctx* exec_ctx,
+                                grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+                                const uint8_t* end) {
   if (cur == end) {
     p->state = parse_value0;
     return GRPC_ERROR_NONE;
@@ -1135,9 +1141,9 @@ static grpc_error *parse_value0(grpc_exec_ctx *exec_ctx,
 
 /* parse the 2nd byte of a varint into p->parsing.value
    no overflow is possible */
-static grpc_error *parse_value1(grpc_exec_ctx *exec_ctx,
-                                grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-                                const uint8_t *end) {
+static grpc_error* parse_value1(grpc_exec_ctx* exec_ctx,
+                                grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+                                const uint8_t* end) {
   if (cur == end) {
     p->state = parse_value1;
     return GRPC_ERROR_NONE;
@@ -1154,9 +1160,9 @@ static grpc_error *parse_value1(grpc_exec_ctx *exec_ctx,
 
 /* parse the 3rd byte of a varint into p->parsing.value
    no overflow is possible */
-static grpc_error *parse_value2(grpc_exec_ctx *exec_ctx,
-                                grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-                                const uint8_t *end) {
+static grpc_error* parse_value2(grpc_exec_ctx* exec_ctx,
+                                grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+                                const uint8_t* end) {
   if (cur == end) {
     p->state = parse_value2;
     return GRPC_ERROR_NONE;
@@ -1173,9 +1179,9 @@ static grpc_error *parse_value2(grpc_exec_ctx *exec_ctx,
 
 /* parse the 4th byte of a varint into p->parsing.value
    no overflow is possible */
-static grpc_error *parse_value3(grpc_exec_ctx *exec_ctx,
-                                grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-                                const uint8_t *end) {
+static grpc_error* parse_value3(grpc_exec_ctx* exec_ctx,
+                                grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+                                const uint8_t* end) {
   if (cur == end) {
     p->state = parse_value3;
     return GRPC_ERROR_NONE;
@@ -1192,13 +1198,13 @@ static grpc_error *parse_value3(grpc_exec_ctx *exec_ctx,
 
 /* parse the 5th byte of a varint into p->parsing.value
    depending on the byte, we may overflow, and care must be taken */
-static grpc_error *parse_value4(grpc_exec_ctx *exec_ctx,
-                                grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-                                const uint8_t *end) {
+static grpc_error* parse_value4(grpc_exec_ctx* exec_ctx,
+                                grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+                                const uint8_t* end) {
   uint8_t c;
   uint32_t cur_value;
   uint32_t add_value;
-  char *msg;
+  char* msg;
 
   if (cur == end) {
     p->state = parse_value4;
@@ -1229,7 +1235,7 @@ error:
                "integer overflow in hpack integer decoding: have 0x%08x, "
                "got byte 0x%02x on byte 5",
                *p->parsing.value, *cur);
-  grpc_error *err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
+  grpc_error* err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
   gpr_free(msg);
   return parse_error(exec_ctx, p, cur, end, err);
 }
@@ -1237,9 +1243,9 @@ error:
 /* parse any trailing bytes in a varint: it's possible to append an arbitrary
    number of 0x80's and not affect the value - a zero will terminate - and
    anything else will overflow */
-static grpc_error *parse_value5up(grpc_exec_ctx *exec_ctx,
-                                  grpc_chttp2_hpack_parser *p,
-                                  const uint8_t *cur, const uint8_t *end) {
+static grpc_error* parse_value5up(grpc_exec_ctx* exec_ctx,
+                                  grpc_chttp2_hpack_parser* p,
+                                  const uint8_t* cur, const uint8_t* end) {
   while (cur != end && *cur == 0x80) {
     ++cur;
   }
@@ -1253,20 +1259,20 @@ static grpc_error *parse_value5up(grpc_exec_ctx *exec_ctx,
     return parse_next(exec_ctx, p, cur + 1, end);
   }
 
-  char *msg;
+  char* msg;
   gpr_asprintf(&msg,
                "integer overflow in hpack integer decoding: have 0x%08x, "
                "got byte 0x%02x sometime after byte 5",
                *p->parsing.value, *cur);
-  grpc_error *err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
+  grpc_error* err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
   gpr_free(msg);
   return parse_error(exec_ctx, p, cur, end, err);
 }
 
 /* parse a string prefix */
-static grpc_error *parse_string_prefix(grpc_exec_ctx *exec_ctx,
-                                       grpc_chttp2_hpack_parser *p,
-                                       const uint8_t *cur, const uint8_t *end) {
+static grpc_error* parse_string_prefix(grpc_exec_ctx* exec_ctx,
+                                       grpc_chttp2_hpack_parser* p,
+                                       const uint8_t* cur, const uint8_t* end) {
   if (cur == end) {
     p->state = parse_string_prefix;
     return GRPC_ERROR_NONE;
@@ -1283,24 +1289,24 @@ static grpc_error *parse_string_prefix(grpc_exec_ctx *exec_ctx,
 }
 
 /* append some bytes to a string */
-static void append_bytes(grpc_chttp2_hpack_parser_string *str,
-                         const uint8_t *data, size_t length) {
+static void append_bytes(grpc_chttp2_hpack_parser_string* str,
+                         const uint8_t* data, size_t length) {
   if (length == 0) return;
   if (length + str->data.copied.length > str->data.copied.capacity) {
     GPR_ASSERT(str->data.copied.length + length <= UINT32_MAX);
     str->data.copied.capacity = (uint32_t)(str->data.copied.length + length);
     str->data.copied.str =
-        (char *)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);
   str->data.copied.length += (uint32_t)length;
 }
 
-static grpc_error *append_string(grpc_exec_ctx *exec_ctx,
-                                 grpc_chttp2_hpack_parser *p,
-                                 const uint8_t *cur, const uint8_t *end) {
-  grpc_chttp2_hpack_parser_string *str = p->parsing.str;
+static grpc_error* append_string(grpc_exec_ctx* exec_ctx,
+                                 grpc_chttp2_hpack_parser* p,
+                                 const uint8_t* cur, const uint8_t* end) {
+  grpc_chttp2_hpack_parser_string* str = p->parsing.str;
   uint32_t bits;
   uint8_t decoded[3];
   switch ((binary_state)p->binary) {
@@ -1397,12 +1403,12 @@ static grpc_error *append_string(grpc_exec_ctx *exec_ctx,
       GRPC_ERROR_CREATE_FROM_STATIC_STRING("Should never reach here")));
 }
 
-static grpc_error *finish_str(grpc_exec_ctx *exec_ctx,
-                              grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-                              const uint8_t *end) {
+static grpc_error* finish_str(grpc_exec_ctx* exec_ctx,
+                              grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+                              const uint8_t* end) {
   uint8_t decoded[2];
   uint32_t bits;
-  grpc_chttp2_hpack_parser_string *str = p->parsing.str;
+  grpc_chttp2_hpack_parser_string* str = p->parsing.str;
   switch ((binary_state)p->binary) {
     case NOT_BINARY:
       break;
@@ -1417,10 +1423,10 @@ static grpc_error *finish_str(grpc_exec_ctx *exec_ctx,
     case B64_BYTE2:
       bits = p->base64_buffer;
       if (bits & 0xffff) {
-        char *msg;
+        char* msg;
         gpr_asprintf(&msg, "trailing bits in base64 encoding: 0x%04x",
                      bits & 0xffff);
-        grpc_error *err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
+        grpc_error* err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
         gpr_free(msg);
         return parse_error(exec_ctx, p, cur, end, err);
       }
@@ -1430,10 +1436,10 @@ static grpc_error *finish_str(grpc_exec_ctx *exec_ctx,
     case B64_BYTE3:
       bits = p->base64_buffer;
       if (bits & 0xff) {
-        char *msg;
+        char* msg;
         gpr_asprintf(&msg, "trailing bits in base64 encoding: 0x%02x",
                      bits & 0xff);
-        grpc_error *err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
+        grpc_error* err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
         gpr_free(msg);
         return parse_error(exec_ctx, p, cur, end, err);
       }
@@ -1446,14 +1452,14 @@ static grpc_error *finish_str(grpc_exec_ctx *exec_ctx,
 }
 
 /* decode a nibble from a huffman encoded stream */
-static grpc_error *huff_nibble(grpc_exec_ctx *exec_ctx,
-                               grpc_chttp2_hpack_parser *p, uint8_t nibble) {
+static grpc_error* huff_nibble(grpc_exec_ctx* exec_ctx,
+                               grpc_chttp2_hpack_parser* p, uint8_t nibble) {
   int16_t emit = emit_sub_tbl[16 * emit_tbl[p->huff_state] + nibble];
   int16_t next = next_sub_tbl[16 * next_tbl[p->huff_state] + nibble];
   if (emit != -1) {
     if (emit >= 0 && emit < 256) {
       uint8_t c = (uint8_t)emit;
-      grpc_error *err = append_string(exec_ctx, p, &c, (&c) + 1);
+      grpc_error* err = append_string(exec_ctx, p, &c, (&c) + 1);
       if (err != GRPC_ERROR_NONE) return err;
     } else {
       assert(emit == 256);
@@ -1464,11 +1470,11 @@ static grpc_error *huff_nibble(grpc_exec_ctx *exec_ctx,
 }
 
 /* decode full bytes from a huffman encoded stream */
-static grpc_error *add_huff_bytes(grpc_exec_ctx *exec_ctx,
-                                  grpc_chttp2_hpack_parser *p,
-                                  const uint8_t *cur, const uint8_t *end) {
+static grpc_error* add_huff_bytes(grpc_exec_ctx* exec_ctx,
+                                  grpc_chttp2_hpack_parser* p,
+                                  const uint8_t* cur, const uint8_t* end) {
   for (; cur != end; ++cur) {
-    grpc_error *err = huff_nibble(exec_ctx, p, *cur >> 4);
+    grpc_error* err = huff_nibble(exec_ctx, p, *cur >> 4);
     if (err != GRPC_ERROR_NONE) return parse_error(exec_ctx, p, cur, end, err);
     err = huff_nibble(exec_ctx, p, *cur & 0xf);
     if (err != GRPC_ERROR_NONE) return parse_error(exec_ctx, p, cur, end, err);
@@ -1478,9 +1484,9 @@ static grpc_error *add_huff_bytes(grpc_exec_ctx *exec_ctx,
 
 /* decode some string bytes based on the current decoding mode
    (huffman or not) */
-static grpc_error *add_str_bytes(grpc_exec_ctx *exec_ctx,
-                                 grpc_chttp2_hpack_parser *p,
-                                 const uint8_t *cur, const uint8_t *end) {
+static grpc_error* add_str_bytes(grpc_exec_ctx* exec_ctx,
+                                 grpc_chttp2_hpack_parser* p,
+                                 const uint8_t* cur, const uint8_t* end) {
   if (p->huff) {
     return add_huff_bytes(exec_ctx, p, cur, end);
   } else {
@@ -1489,19 +1495,19 @@ static grpc_error *add_str_bytes(grpc_exec_ctx *exec_ctx,
 }
 
 /* parse a string - tries to do large chunks at a time */
-static grpc_error *parse_string(grpc_exec_ctx *exec_ctx,
-                                grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-                                const uint8_t *end) {
+static grpc_error* parse_string(grpc_exec_ctx* exec_ctx,
+                                grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+                                const uint8_t* end) {
   size_t remaining = p->strlen - p->strgot;
   size_t given = (size_t)(end - cur);
   if (remaining <= given) {
-    grpc_error *err = add_str_bytes(exec_ctx, p, cur, cur + remaining);
+    grpc_error* err = add_str_bytes(exec_ctx, p, cur, cur + remaining);
     if (err != GRPC_ERROR_NONE) return parse_error(exec_ctx, p, cur, end, err);
     err = finish_str(exec_ctx, p, cur + remaining, end);
     if (err != GRPC_ERROR_NONE) return parse_error(exec_ctx, p, cur, end, err);
     return parse_next(exec_ctx, p, cur + remaining, end);
   } else {
-    grpc_error *err = add_str_bytes(exec_ctx, p, cur, cur + given);
+    grpc_error* err = add_str_bytes(exec_ctx, p, cur, cur + given);
     if (err != GRPC_ERROR_NONE) return parse_error(exec_ctx, p, cur, end, err);
     GPR_ASSERT(given <= UINT32_MAX - p->strgot);
     p->strgot += (uint32_t)given;
@@ -1511,17 +1517,17 @@ static grpc_error *parse_string(grpc_exec_ctx *exec_ctx,
 }
 
 /* begin parsing a string - performs setup, calls parse_string */
-static grpc_error *begin_parse_string(grpc_exec_ctx *exec_ctx,
-                                      grpc_chttp2_hpack_parser *p,
-                                      const uint8_t *cur, const uint8_t *end,
+static grpc_error* begin_parse_string(grpc_exec_ctx* exec_ctx,
+                                      grpc_chttp2_hpack_parser* p,
+                                      const uint8_t* cur, const uint8_t* end,
                                       uint8_t binary,
-                                      grpc_chttp2_hpack_parser_string *str) {
+                                      grpc_chttp2_hpack_parser_string* str) {
   if (!p->huff && binary == NOT_BINARY && (end - cur) >= (intptr_t)p->strlen &&
-      p->current_slice_refcount != NULL) {
+      p->current_slice_refcount != nullptr) {
     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;
+    str->data.referenced.data.refcounted.bytes = (uint8_t*)cur;
     str->data.referenced.data.refcounted.length = p->strlen;
     grpc_slice_ref_internal(str->data.referenced);
     return parse_next(exec_ctx, p, cur + p->strlen, end);
@@ -1550,23 +1556,23 @@ static grpc_error *begin_parse_string(grpc_exec_ctx *exec_ctx,
 }
 
 /* parse the key string */
-static grpc_error *parse_key_string(grpc_exec_ctx *exec_ctx,
-                                    grpc_chttp2_hpack_parser *p,
-                                    const uint8_t *cur, const uint8_t *end) {
+static grpc_error* parse_key_string(grpc_exec_ctx* exec_ctx,
+                                    grpc_chttp2_hpack_parser* p,
+                                    const uint8_t* cur, const uint8_t* end) {
   return begin_parse_string(exec_ctx, p, cur, end, NOT_BINARY, &p->key);
 }
 
 /* check if a key represents a binary header or not */
 
-static bool is_binary_literal_header(grpc_chttp2_hpack_parser *p) {
+static bool is_binary_literal_header(grpc_chttp2_hpack_parser* p) {
   return grpc_is_binary_header(
       p->key.copied ? grpc_slice_from_static_buffer(p->key.data.copied.str,
                                                     p->key.data.copied.length)
                     : p->key.data.referenced);
 }
 
-static grpc_error *is_binary_indexed_header(grpc_chttp2_hpack_parser *p,
-                                            bool *is) {
+static grpc_error* is_binary_indexed_header(grpc_chttp2_hpack_parser* p,
+                                            bool* is) {
   grpc_mdelem elem = grpc_chttp2_hptbl_lookup(&p->table, p->index);
   if (GRPC_MDISNULL(elem)) {
     return grpc_error_set_int(
@@ -1580,42 +1586,42 @@ static grpc_error *is_binary_indexed_header(grpc_chttp2_hpack_parser *p,
 }
 
 /* parse the value string */
-static grpc_error *parse_value_string(grpc_exec_ctx *exec_ctx,
-                                      grpc_chttp2_hpack_parser *p,
-                                      const uint8_t *cur, const uint8_t *end,
+static grpc_error* parse_value_string(grpc_exec_ctx* exec_ctx,
+                                      grpc_chttp2_hpack_parser* p,
+                                      const uint8_t* cur, const uint8_t* end,
                                       bool is_binary) {
   return begin_parse_string(exec_ctx, p, cur, end,
                             is_binary ? BINARY_BEGIN : NOT_BINARY, &p->value);
 }
 
-static grpc_error *parse_value_string_with_indexed_key(
-    grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-    const uint8_t *end) {
+static grpc_error* parse_value_string_with_indexed_key(
+    grpc_exec_ctx* exec_ctx, grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+    const uint8_t* end) {
   bool is_binary = false;
-  grpc_error *err = is_binary_indexed_header(p, &is_binary);
+  grpc_error* err = is_binary_indexed_header(p, &is_binary);
   if (err != GRPC_ERROR_NONE) return parse_error(exec_ctx, p, cur, end, err);
   return parse_value_string(exec_ctx, p, cur, end, is_binary);
 }
 
-static grpc_error *parse_value_string_with_literal_key(
-    grpc_exec_ctx *exec_ctx, grpc_chttp2_hpack_parser *p, const uint8_t *cur,
-    const uint8_t *end) {
+static grpc_error* parse_value_string_with_literal_key(
+    grpc_exec_ctx* exec_ctx, grpc_chttp2_hpack_parser* p, const uint8_t* cur,
+    const uint8_t* end) {
   return parse_value_string(exec_ctx, p, cur, end, is_binary_literal_header(p));
 }
 
 /* PUBLIC INTERFACE */
 
-void grpc_chttp2_hpack_parser_init(grpc_exec_ctx *exec_ctx,
-                                   grpc_chttp2_hpack_parser *p) {
-  p->on_header = NULL;
-  p->on_header_user_data = NULL;
+void grpc_chttp2_hpack_parser_init(grpc_exec_ctx* exec_ctx,
+                                   grpc_chttp2_hpack_parser* p) {
+  p->on_header = nullptr;
+  p->on_header_user_data = nullptr;
   p->state = parse_begin;
   p->key.data.referenced = grpc_empty_slice();
-  p->key.data.copied.str = NULL;
+  p->key.data.copied.str = nullptr;
   p->key.data.copied.capacity = 0;
   p->key.data.copied.length = 0;
   p->value.data.referenced = grpc_empty_slice();
-  p->value.data.copied.str = NULL;
+  p->value.data.copied.str = nullptr;
   p->value.data.copied.capacity = 0;
   p->value.data.copied.length = 0;
   p->dynamic_table_update_allowed = 2;
@@ -1623,13 +1629,13 @@ void grpc_chttp2_hpack_parser_init(grpc_exec_ctx *exec_ctx,
   grpc_chttp2_hptbl_init(exec_ctx, &p->table);
 }
 
-void grpc_chttp2_hpack_parser_set_has_priority(grpc_chttp2_hpack_parser *p) {
+void grpc_chttp2_hpack_parser_set_has_priority(grpc_chttp2_hpack_parser* p) {
   p->after_prioritization = p->state;
   p->state = parse_stream_dep0;
 }
 
-void grpc_chttp2_hpack_parser_destroy(grpc_exec_ctx *exec_ctx,
-                                      grpc_chttp2_hpack_parser *p) {
+void grpc_chttp2_hpack_parser_destroy(grpc_exec_ctx* exec_ctx,
+                                      grpc_chttp2_hpack_parser* p) {
   grpc_chttp2_hptbl_destroy(exec_ctx, &p->table);
   GRPC_ERROR_UNREF(p->last_error);
   grpc_slice_unref_internal(exec_ctx, p->key.data.referenced);
@@ -1638,36 +1644,36 @@ void grpc_chttp2_hpack_parser_destroy(grpc_exec_ctx *exec_ctx,
   gpr_free(p->value.data.copied.str);
 }
 
-grpc_error *grpc_chttp2_hpack_parser_parse(grpc_exec_ctx *exec_ctx,
-                                           grpc_chttp2_hpack_parser *p,
+grpc_error* grpc_chttp2_hpack_parser_parse(grpc_exec_ctx* exec_ctx,
+                                           grpc_chttp2_hpack_parser* p,
                                            grpc_slice slice) {
 /* max number of bytes to parse at a time... limits call stack depth on
  * compilers without TCO */
 #define MAX_PARSE_LENGTH 1024
   p->current_slice_refcount = slice.refcount;
-  uint8_t *start = GRPC_SLICE_START_PTR(slice);
-  uint8_t *end = GRPC_SLICE_END_PTR(slice);
-  grpc_error *error = GRPC_ERROR_NONE;
+  uint8_t* start = GRPC_SLICE_START_PTR(slice);
+  uint8_t* end = GRPC_SLICE_END_PTR(slice);
+  grpc_error* error = GRPC_ERROR_NONE;
   while (start != end && error == GRPC_ERROR_NONE) {
-    uint8_t *target = start + GPR_MIN(MAX_PARSE_LENGTH, end - start);
+    uint8_t* target = start + GPR_MIN(MAX_PARSE_LENGTH, end - start);
     error = p->state(exec_ctx, p, start, target);
     start = target;
   }
-  p->current_slice_refcount = NULL;
+  p->current_slice_refcount = nullptr;
   return error;
 }
 
-typedef void (*maybe_complete_func_type)(grpc_exec_ctx *exec_ctx,
-                                         grpc_chttp2_transport *t,
-                                         grpc_chttp2_stream *s);
+typedef void (*maybe_complete_func_type)(grpc_exec_ctx* exec_ctx,
+                                         grpc_chttp2_transport* t,
+                                         grpc_chttp2_stream* s);
 static const maybe_complete_func_type maybe_complete_funcs[] = {
     grpc_chttp2_maybe_complete_recv_initial_metadata,
     grpc_chttp2_maybe_complete_recv_trailing_metadata};
 
-static void force_client_rst_stream(grpc_exec_ctx *exec_ctx, void *sp,
-                                    grpc_error *error) {
-  grpc_chttp2_stream *s = (grpc_chttp2_stream *)sp;
-  grpc_chttp2_transport *t = s->t;
+static void force_client_rst_stream(grpc_exec_ctx* exec_ctx, void* sp,
+                                    grpc_error* error) {
+  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,
@@ -1679,11 +1685,11 @@ static void force_client_rst_stream(grpc_exec_ctx *exec_ctx, void *sp,
   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 ||
+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 == nullptr ||
       grpc_stream_compression_method_parse(
           GRPC_MDVALUE(initial_metadata->idx.named.content_encoding->md), false,
           &s->stream_decompression_method) == 0) {
@@ -1692,17 +1698,17 @@ static void parse_stream_compression_md(grpc_exec_ctx *exec_ctx,
   }
 }
 
-grpc_error *grpc_chttp2_header_parser_parse(grpc_exec_ctx *exec_ctx,
-                                            void *hpack_parser,
-                                            grpc_chttp2_transport *t,
-                                            grpc_chttp2_stream *s,
+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 = (grpc_chttp2_hpack_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) {
+  if (s != nullptr) {
     s->stats.incoming.header_bytes += GRPC_SLICE_LENGTH(slice);
   }
-  grpc_error *error = grpc_chttp2_hpack_parser_parse(exec_ctx, parser, slice);
+  grpc_error* error = grpc_chttp2_hpack_parser_parse(exec_ctx, parser, slice);
   if (error != GRPC_ERROR_NONE) {
     GPR_TIMER_END("grpc_chttp2_hpack_parser_parse", 0);
     return error;
@@ -1715,7 +1721,7 @@ grpc_error *grpc_chttp2_header_parser_parse(grpc_exec_ctx *exec_ctx,
     }
     /* need to check for null stream: this can occur if we receive an invalid
        stream id on a header */
-    if (s != NULL) {
+    if (s != nullptr) {
       if (parser->is_boundary) {
         if (s->header_frames_received == GPR_ARRAY_SIZE(s->metadata_buffer)) {
           GPR_TIMER_END("grpc_chttp2_hpack_parser_parse", 0);
@@ -1750,8 +1756,8 @@ grpc_error *grpc_chttp2_header_parser_parse(grpc_exec_ctx *exec_ctx,
                                        GRPC_ERROR_NONE);
       }
     }
-    parser->on_header = NULL;
-    parser->on_header_user_data = NULL;
+    parser->on_header = nullptr;
+    parser->on_header_user_data = nullptr;
     parser->is_boundary = 0xde;
     parser->is_eof = 0xde;
     parser->dynamic_table_update_allowed = 2;