grpc 1.39.0.pre1 → 1.40.0.pre1

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

@@ -27,84 +27,205 @@
 #include "src/core/ext/transport/chttp2/transport/hpack_table.h"
 #include "src/core/lib/transport/metadata.h"
 
-typedef struct grpc_chttp2_hpack_parser grpc_chttp2_hpack_parser;
+namespace grpc_core {
 
-typedef grpc_error_handle (*grpc_chttp2_hpack_parser_state)(
-    grpc_chttp2_hpack_parser* p, const uint8_t* beg, const uint8_t* end);
+class HPackParser {
+ public:
+  enum class Boundary { None, EndOfHeaders, EndOfStream };
+  enum class Priority { None, Included };
 
-struct grpc_chttp2_hpack_parser_string {
-  bool copied;
-  struct {
-    grpc_slice referenced;
+  // User specified structure called for each received header.
+  using Sink = std::function<grpc_error_handle(grpc_mdelem)>;
+
+  HPackParser();
+  ~HPackParser();
+
+  HPackParser(const HPackParser&) = delete;
+  HPackParser& operator=(const HPackParser&) = delete;
+
+  void BeginFrame(Sink sink, Boundary boundary, Priority priority);
+  void ResetSink(Sink sink) { sink_ = std::move(sink); }
+  grpc_error_handle Parse(const grpc_slice& slice);
+  void FinishFrame();
+
+  grpc_chttp2_hptbl* hpack_table() { return &table_; }
+  bool is_boundary() const { return boundary_ != Boundary::None; }
+  bool is_eof() const { return boundary_ == Boundary::EndOfStream; }
+  bool is_in_begin_state() const { return state_ == &HPackParser::parse_begin; }
+
+ private:
+  enum class BinaryState {
+    kNotBinary,
+    kBinaryBegin,
+    kBase64Byte0,
+    kBase64Byte1,
+    kBase64Byte2,
+    kBase64Byte3,
+  };
+
+  struct String {
+    bool copied_;
     struct {
-      char* str;
-      uint32_t length;
-      uint32_t capacity;
-    } copied;
-  } data;
-};
-struct grpc_chttp2_hpack_parser {
-  /* user specified callback for each header output */
-  grpc_error_handle (*on_header)(void* user_data, grpc_mdelem md);
-  void* on_header_user_data;
-
-  grpc_error_handle last_error;
-
-  /* current parse state - or a function that implements it */
-  grpc_chttp2_hpack_parser_state state;
-  /* future states dependent on the opening op code */
-  const grpc_chttp2_hpack_parser_state* next_state;
-  /* what to do after skipping prioritization data */
-  grpc_chttp2_hpack_parser_state after_prioritization;
-  /* the refcount of the slice that we're currently parsing */
-  grpc_slice_refcount* current_slice_refcount;
-  /* the value we're currently parsing */
+      grpc_slice referenced;
+      struct {
+        char* str;
+        uint32_t length;
+        uint32_t capacity;
+      } copied;
+    } data_;
+
+    UnmanagedMemorySlice TakeExtern();
+    ManagedMemorySlice TakeIntern();
+    void AppendBytes(const uint8_t* data, size_t length);
+  };
+
+  using State = grpc_error_handle (HPackParser::*)(const uint8_t* beg,
+                                                   const uint8_t* end);
+
+  // Forward declarations for parsing states.
+  // These are keeping their old (C-style) names until a future refactor where
+  // they will be eliminated.
+  grpc_error_handle parse_next(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_begin(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_error(const uint8_t* cur, const uint8_t* end,
+                                grpc_error_handle error);
+  grpc_error_handle still_parse_error(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_illegal_op(const uint8_t* cur, const uint8_t* end);
+
+  grpc_error_handle parse_string_prefix(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_key_string(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_value_string(const uint8_t* cur, const uint8_t* end,
+                                       bool is_binary);
+  grpc_error_handle parse_value_string_with_indexed_key(const uint8_t* cur,
+                                                        const uint8_t* end);
+  grpc_error_handle parse_value_string_with_literal_key(const uint8_t* cur,
+                                                        const uint8_t* end);
+  grpc_error_handle parse_stream_weight(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_value0(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_value1(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_value2(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_value3(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_value4(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_value5up(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_stream_dep0(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_stream_dep1(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_stream_dep2(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_stream_dep3(const uint8_t* cur, const uint8_t* end);
+
+  grpc_error_handle parse_indexed_field(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_indexed_field_x(const uint8_t* cur,
+                                          const uint8_t* end);
+  grpc_error_handle parse_lithdr_incidx(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_lithdr_incidx_x(const uint8_t* cur,
+                                          const uint8_t* end);
+  grpc_error_handle parse_lithdr_incidx_v(const uint8_t* cur,
+                                          const uint8_t* end);
+  grpc_error_handle parse_lithdr_notidx(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_lithdr_notidx_x(const uint8_t* cur,
+                                          const uint8_t* end);
+  grpc_error_handle parse_lithdr_notidx_v(const uint8_t* cur,
+                                          const uint8_t* end);
+  grpc_error_handle parse_lithdr_nvridx(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_lithdr_nvridx_x(const uint8_t* cur,
+                                          const uint8_t* end);
+  grpc_error_handle parse_lithdr_nvridx_v(const uint8_t* cur,
+                                          const uint8_t* end);
+  grpc_error_handle parse_max_tbl_size(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle parse_max_tbl_size_x(const uint8_t* cur,
+                                         const uint8_t* end);
+  grpc_error_handle parse_string(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle begin_parse_string(const uint8_t* cur, const uint8_t* end,
+                                       BinaryState binary, String* str);
+
+  grpc_error_handle finish_indexed_field(const uint8_t* cur,
+                                         const uint8_t* end);
+  grpc_error_handle finish_lithdr_incidx(const uint8_t* cur,
+                                         const uint8_t* end);
+  grpc_error_handle finish_lithdr_incidx_v(const uint8_t* cur,
+                                           const uint8_t* end);
+  grpc_error_handle finish_lithdr_notidx(const uint8_t* cur,
+                                         const uint8_t* end);
+  grpc_error_handle finish_lithdr_notidx_v(const uint8_t* cur,
+                                           const uint8_t* end);
+  grpc_error_handle finish_lithdr_nvridx(const uint8_t* cur,
+                                         const uint8_t* end);
+  grpc_error_handle finish_lithdr_nvridx_v(const uint8_t* cur,
+                                           const uint8_t* end);
+  grpc_error_handle finish_max_tbl_size(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle finish_str(const uint8_t* cur, const uint8_t* end);
+
+  enum class TableAction {
+    kAddToTable,
+    kOmitFromTable,
+  };
+
+  GPR_ATTRIBUTE_NOINLINE grpc_error_handle InvalidHPackIndexError();
+  GPR_ATTRIBUTE_NOINLINE void LogHeader(grpc_mdelem md);
+  grpc_error_handle AddHeaderToTable(grpc_mdelem md);
+  template <TableAction table_action>
+  grpc_error_handle FinishHeader(grpc_mdelem md);
+
+  grpc_mdelem GetPrecomputedMDForIndex();
+  void SetPrecomputedMDIndex(grpc_mdelem md);
+  bool IsBinaryLiteralHeader();
+  grpc_error_handle IsBinaryIndexedHeader(bool* is);
+
+  grpc_error_handle AppendString(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle AppendHuffNibble(uint8_t nibble);
+  grpc_error_handle AppendHuffBytes(const uint8_t* cur, const uint8_t* end);
+  grpc_error_handle AppendStrBytes(const uint8_t* cur, const uint8_t* end);
+
+  Sink sink_;
+  grpc_error_handle last_error_;
+
+  // current parse state - or a function that implements it
+  State state_;
+  // future states dependent on the opening op code
+  const State* next_state_;
+  // what to do after skipping prioritization data
+  State after_prioritization_;
+  // the refcount of the slice that we're currently parsing
+  grpc_slice_refcount* current_slice_refcount_;
+  // the value we're currently parsing
   union {
     uint32_t* value;
-    grpc_chttp2_hpack_parser_string* str;
-  } parsing;
-  /* string parameters for each chunk */
-  grpc_chttp2_hpack_parser_string key;
-  grpc_chttp2_hpack_parser_string value;
-  /* parsed index */
-  uint32_t index;
-  /* When we parse a value string, we determine the metadata element for a
-     specific index, which we need again when we're finishing up with that
-     header. To avoid calculating the metadata element for that index a second
-     time at that stage, we cache (and invalidate) the element here. */
-  grpc_mdelem md_for_index;
+    String* str;
+  } parsing_;
+  // string parameters for each chunk
+  String key_;
+  String value_;
+  // parsed index
+  uint32_t index_;
+  // When we parse a value string, we determine the metadata element for a
+  // specific index, which we need again when we're finishing up with that
+  // header. To avoid calculating the metadata element for that index a second
+  // time at that stage, we cache (and invalidate) the element here.
+  grpc_mdelem md_for_index_;
 #ifndef NDEBUG
-  int64_t precomputed_md_index;
+  int64_t precomputed_md_index_;
 #endif
-  /* length of source bytes for the currently parsing string */
-  uint32_t strlen;
-  /* number of source bytes read for the currently parsing string */
-  uint32_t strgot;
-  /* huffman decoding state */
-  int16_t huff_state;
-  /* is the string being decoded binary? */
-  uint8_t binary;
-  /* is the current string huffman encoded? */
-  uint8_t huff;
-  /* is a dynamic table update allowed? */
-  uint8_t dynamic_table_update_allowed;
-  /* set by higher layers, used by grpc_chttp2_header_parser_parse to signal
-     it should append a metadata boundary at the end of frame */
-  uint8_t is_boundary;
-  uint8_t is_eof;
-  uint32_t base64_buffer;
-
-  /* hpack table */
-  grpc_chttp2_hptbl table;
-};
+  // length of source bytes for the currently parsing string
+  uint32_t strlen_;
+  // number of source bytes read for the currently parsing string
+  uint32_t strgot_;
+  // huffman decoding state
+  int16_t huff_state_;
+  // is the string being decoded binary?
+  BinaryState binary_;
+  // is the current string huffman encoded?
+  bool huff_;
+  // is a dynamic table update allowed?
+  uint8_t dynamic_table_updates_allowed_;
+  // set by higher layers, used by grpc_chttp2_header_parser_parse to signal
+  // it should append a metadata boundary at the end of frame
+  Boundary boundary_;
+  uint32_t base64_buffer_;
 
-void grpc_chttp2_hpack_parser_init(grpc_chttp2_hpack_parser* p);
-void grpc_chttp2_hpack_parser_destroy(grpc_chttp2_hpack_parser* p);
-
-void grpc_chttp2_hpack_parser_set_has_priority(grpc_chttp2_hpack_parser* p);
+  // hpack table
+  grpc_chttp2_hptbl table_;
+};
 
-grpc_error_handle grpc_chttp2_hpack_parser_parse(grpc_chttp2_hpack_parser* p,
-                                                 const grpc_slice& slice);
+}  // namespace grpc_core
 
 /* wraps grpc_chttp2_hpack_parser_parse to provide a frame level parser for
    the transport */

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

@@ -394,7 +394,7 @@ struct grpc_chttp2_transport {
   grpc_chttp2_server_ping_recv_state ping_recv_state;
 
   /** parser for headers */
-  grpc_chttp2_hpack_parser hpack_parser;
+  grpc_core::HPackParser hpack_parser;
   /** simple one shot parsers */
   union {
     grpc_chttp2_window_update_parser window_update;

data/src/core/ext/transport/chttp2/transport/parsing.cc

@@ -36,6 +36,8 @@
 #include "src/core/lib/transport/status_conversion.h"
 #include "src/core/lib/transport/timeout_encoding.h"
 
+using grpc_core::HPackParser;
+
 static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t);
 static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                                                   int is_continuation);
@@ -46,8 +48,8 @@ static grpc_error_handle init_window_update_frame_parser(
     grpc_chttp2_transport* t);
 static grpc_error_handle init_ping_parser(grpc_chttp2_transport* t);
 static grpc_error_handle init_goaway_parser(grpc_chttp2_transport* t);
-static grpc_error_handle init_skip_frame_parser(grpc_chttp2_transport* t,
-                                                int is_header);
+static grpc_error_handle init_non_header_skip_frame_parser(
+    grpc_chttp2_transport* t);
 
 static grpc_error_handle parse_frame_slice(grpc_chttp2_transport* t,
                                            const grpc_slice& slice,
@@ -107,8 +109,8 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
       if (cur == end) {
         return GRPC_ERROR_NONE;
       }
-    /* fallthrough */
     dts_fh_0:
+      ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_0:
       GPR_DEBUG_ASSERT(cur < end);
       t->incoming_frame_size = (static_cast<uint32_t>(*cur)) << 16;
@@ -116,7 +118,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
         t->deframe_state = GRPC_DTS_FH_1;
         return GRPC_ERROR_NONE;
       }
-    /* fallthrough */
+      ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_1:
       GPR_DEBUG_ASSERT(cur < end);
       t->incoming_frame_size |= (static_cast<uint32_t>(*cur)) << 8;
@@ -124,7 +126,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
         t->deframe_state = GRPC_DTS_FH_2;
         return GRPC_ERROR_NONE;
       }
-    /* fallthrough */
+      ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_2:
       GPR_DEBUG_ASSERT(cur < end);
       t->incoming_frame_size |= *cur;
@@ -132,7 +134,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
         t->deframe_state = GRPC_DTS_FH_3;
         return GRPC_ERROR_NONE;
       }
-    /* fallthrough */
+      ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_3:
       GPR_DEBUG_ASSERT(cur < end);
       t->incoming_frame_type = *cur;
@@ -140,7 +142,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
         t->deframe_state = GRPC_DTS_FH_4;
         return GRPC_ERROR_NONE;
       }
-    /* fallthrough */
+      ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_4:
       GPR_DEBUG_ASSERT(cur < end);
       t->incoming_frame_flags = *cur;
@@ -148,7 +150,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
         t->deframe_state = GRPC_DTS_FH_5;
         return GRPC_ERROR_NONE;
       }
-    /* fallthrough */
+      ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_5:
       GPR_DEBUG_ASSERT(cur < end);
       t->incoming_stream_id = ((static_cast<uint32_t>(*cur)) & 0x7f) << 24;
@@ -156,7 +158,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
         t->deframe_state = GRPC_DTS_FH_6;
         return GRPC_ERROR_NONE;
       }
-    /* fallthrough */
+      ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_6:
       GPR_DEBUG_ASSERT(cur < end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur)) << 16;
@@ -164,7 +166,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
         t->deframe_state = GRPC_DTS_FH_7;
         return GRPC_ERROR_NONE;
       }
-    /* fallthrough */
+      ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_7:
       GPR_DEBUG_ASSERT(cur < end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur)) << 8;
@@ -172,7 +174,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
         t->deframe_state = GRPC_DTS_FH_8;
         return GRPC_ERROR_NONE;
       }
-    /* fallthrough */
+      ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_8:
       GPR_DEBUG_ASSERT(cur < end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur));
@@ -206,7 +208,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
       if (++cur == end) {
         return GRPC_ERROR_NONE;
       }
-    /* fallthrough */
+      ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FRAME:
       GPR_DEBUG_ASSERT(cur < end);
       if (static_cast<uint32_t>(end - cur) == t->incoming_frame_size) {
@@ -301,7 +303,7 @@ static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
         gpr_log(GPR_ERROR, "Unknown frame type %02x", t->incoming_frame_type);
       }
-      return init_skip_frame_parser(t, 0);
+      return init_non_header_skip_frame_parser(t);
   }
 }
 
@@ -313,29 +315,46 @@ static grpc_error_handle skip_parser(void* /*parser*/,
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error_handle skip_header(void* /*tp*/, grpc_mdelem md) {
+grpc_error_handle skip_header(grpc_mdelem md) {
   GRPC_MDELEM_UNREF(md);
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error_handle init_skip_frame_parser(grpc_chttp2_transport* t,
-                                                int is_header) {
-  if (is_header) {
-    uint8_t is_eoh = t->expect_continuation_stream_id != 0;
-    t->parser = grpc_chttp2_header_parser_parse;
-    t->parser_data = &t->hpack_parser;
-    t->hpack_parser.on_header = skip_header;
-    t->hpack_parser.on_header_user_data = nullptr;
-    t->hpack_parser.is_boundary = is_eoh;
-    t->hpack_parser.is_eof = static_cast<uint8_t>(is_eoh ? t->header_eof : 0);
+static HPackParser::Boundary hpack_boundary_type(grpc_chttp2_transport* t,
+                                                 bool is_eoh) {
+  if (is_eoh) {
+    if (t->header_eof) {
+      return HPackParser::Boundary::EndOfStream;
+    } else {
+      return HPackParser::Boundary::EndOfHeaders;
+    }
   } else {
-    t->parser = skip_parser;
+    return HPackParser::Boundary::None;
   }
+}
+
+static grpc_error_handle init_header_skip_frame_parser(
+    grpc_chttp2_transport* t, HPackParser::Priority priority_type) {
+  bool is_eoh = t->expect_continuation_stream_id != 0;
+  t->parser = grpc_chttp2_header_parser_parse;
+  t->parser_data = &t->hpack_parser;
+  t->hpack_parser.BeginFrame(skip_header, hpack_boundary_type(t, is_eoh),
+                             priority_type);
+  return GRPC_ERROR_NONE;
+}
+
+static grpc_error_handle init_non_header_skip_frame_parser(
+    grpc_chttp2_transport* t) {
+  t->parser = skip_parser;
   return GRPC_ERROR_NONE;
 }
 
 void grpc_chttp2_parsing_become_skip_parser(grpc_chttp2_transport* t) {
-  init_skip_frame_parser(t, t->parser == grpc_chttp2_header_parser_parse);
+  if (t->parser == grpc_chttp2_header_parser_parse) {
+    t->hpack_parser.ResetSink(skip_header);
+  } else {
+    t->parser = skip_parser;
+  }
 }
 
 static grpc_error_handle init_data_frame_parser(grpc_chttp2_transport* t) {
@@ -365,12 +384,12 @@ static grpc_error_handle init_data_frame_parser(grpc_chttp2_transport* t) {
     goto error_handler;
   }
   if (s == nullptr) {
-    return init_skip_frame_parser(t, 0);
+    return init_non_header_skip_frame_parser(t);
   }
   s->received_bytes += t->incoming_frame_size;
   s->stats.incoming.framing_bytes += 9;
   if (err == GRPC_ERROR_NONE && s->read_closed) {
-    return init_skip_frame_parser(t, 0);
+    return init_non_header_skip_frame_parser(t);
   }
   if (err == GRPC_ERROR_NONE) {
     err = grpc_chttp2_data_parser_begin_frame(
@@ -393,7 +412,7 @@ error_handler:
     grpc_chttp2_add_rst_stream_to_next_write(t, t->incoming_stream_id,
                                              GRPC_HTTP2_PROTOCOL_ERROR,
                                              &s->stats.outgoing);
-    return init_skip_frame_parser(t, 0);
+    return init_non_header_skip_frame_parser(t);
   } else {
     return err;
   }
@@ -565,7 +584,7 @@ static grpc_error_handle on_trailing_header(void* tp, grpc_mdelem md) {
 
 static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                                                   int is_continuation) {
-  uint8_t is_eoh =
+  const bool is_eoh =
       (t->incoming_frame_flags & GRPC_CHTTP2_DATA_FLAG_END_HEADERS) != 0;
   grpc_chttp2_stream* s;
 
@@ -582,6 +601,11 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
         (t->incoming_frame_flags & GRPC_CHTTP2_DATA_FLAG_END_STREAM) != 0;
   }
 
+  const auto priority_type = !is_continuation && (t->incoming_frame_flags &
+                                                  GRPC_CHTTP2_FLAG_HAS_PRIORITY)
+                                 ? HPackParser::Priority::Included
+                                 : HPackParser::Priority::None;
+
   t->ping_state.last_ping_sent_time = GRPC_MILLIS_INF_PAST;
 
   /* could be a new grpc_chttp2_stream or an existing grpc_chttp2_stream */
@@ -591,7 +615,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
       GRPC_CHTTP2_IF_TRACING(
           gpr_log(GPR_ERROR,
                   "grpc_chttp2_stream disbanded before CONTINUATION received"));
-      return init_skip_frame_parser(t, 1);
+      return init_header_skip_frame_parser(t, priority_type);
     }
     if (t->is_client) {
       if (GPR_LIKELY((t->incoming_stream_id & 1) &&
@@ -601,11 +625,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
         GRPC_CHTTP2_IF_TRACING(gpr_log(
             GPR_ERROR, "ignoring new grpc_chttp2_stream creation on client"));
       }
-      grpc_error_handle err = init_skip_frame_parser(t, 1);
-      if (t->incoming_frame_flags & GRPC_CHTTP2_FLAG_HAS_PRIORITY) {
-        grpc_chttp2_hpack_parser_set_has_priority(&t->hpack_parser);
-      }
-      return err;
+      return init_header_skip_frame_parser(t, priority_type);
     } else if (GPR_UNLIKELY(t->last_new_stream_id >= t->incoming_stream_id)) {
       GRPC_CHTTP2_IF_TRACING(gpr_log(
           GPR_ERROR,
@@ -613,13 +633,13 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
           "last grpc_chttp2_stream "
           "id=%d, new grpc_chttp2_stream id=%d",
           t->last_new_stream_id, t->incoming_stream_id));
-      return init_skip_frame_parser(t, 1);
+      return init_header_skip_frame_parser(t, priority_type);
     } else if (GPR_UNLIKELY((t->incoming_stream_id & 1) == 0)) {
       GRPC_CHTTP2_IF_TRACING(gpr_log(
           GPR_ERROR,
           "ignoring grpc_chttp2_stream with non-client generated index %d",
           t->incoming_stream_id));
-      return init_skip_frame_parser(t, 1);
+      return init_header_skip_frame_parser(t, priority_type);
     } else if (GPR_UNLIKELY(
                    grpc_chttp2_stream_map_size(&t->stream_map) >=
                    t->settings[GRPC_ACKED_SETTINGS]
@@ -632,7 +652,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
     if (GPR_UNLIKELY(s == nullptr)) {
       GRPC_CHTTP2_IF_TRACING(
           gpr_log(GPR_ERROR, "grpc_chttp2_stream not accepted"));
-      return init_skip_frame_parser(t, 1);
+      return init_header_skip_frame_parser(t, priority_type);
     }
     if (t->channelz_socket != nullptr) {
       t->channelz_socket->RecordStreamStartedFromRemote();
@@ -646,13 +666,14 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
     GRPC_CHTTP2_IF_TRACING(gpr_log(
         GPR_ERROR, "skipping already closed grpc_chttp2_stream header"));
     t->incoming_stream = nullptr;
-    return init_skip_frame_parser(t, 1);
+    return init_header_skip_frame_parser(t, priority_type);
   }
   t->parser = grpc_chttp2_header_parser_parse;
   t->parser_data = &t->hpack_parser;
   if (t->header_eof) {
     s->eos_received = true;
   }
+  HPackParser::Sink on_header;
   switch (s->header_frames_received) {
     case 0:
       if (t->is_client && t->header_eof) {
@@ -660,27 +681,22 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
         if (s->trailing_metadata_available != nullptr) {
           *s->trailing_metadata_available = true;
         }
-        t->hpack_parser.on_header = on_trailing_header;
+        on_header = [t](grpc_mdelem md) { return on_trailing_header(t, md); };
       } else {
         GRPC_CHTTP2_IF_TRACING(gpr_log(GPR_INFO, "parsing initial_metadata"));
-        t->hpack_parser.on_header = on_initial_header;
+        on_header = [t](grpc_mdelem md) { return on_initial_header(t, md); };
       }
       break;
     case 1:
       GRPC_CHTTP2_IF_TRACING(gpr_log(GPR_INFO, "parsing trailing_metadata"));
-      t->hpack_parser.on_header = on_trailing_header;
+      on_header = [t](grpc_mdelem md) { return on_trailing_header(t, md); };
       break;
     case 2:
       gpr_log(GPR_ERROR, "too many header frames received");
-      return init_skip_frame_parser(t, 1);
-  }
-  t->hpack_parser.on_header_user_data = t;
-  t->hpack_parser.is_boundary = is_eoh;
-  t->hpack_parser.is_eof = static_cast<uint8_t>(is_eoh ? t->header_eof : 0);
-  if (!is_continuation &&
-      (t->incoming_frame_flags & GRPC_CHTTP2_FLAG_HAS_PRIORITY)) {
-    grpc_chttp2_hpack_parser_set_has_priority(&t->hpack_parser);
+      return init_header_skip_frame_parser(t, priority_type);
   }
+  t->hpack_parser.BeginFrame(std::move(on_header),
+                             hpack_boundary_type(t, is_eoh), priority_type);
   return GRPC_ERROR_NONE;
 }
 
@@ -694,7 +710,7 @@ static grpc_error_handle init_window_update_frame_parser(
     grpc_chttp2_stream* s = t->incoming_stream =
         grpc_chttp2_parsing_lookup_stream(t, t->incoming_stream_id);
     if (s == nullptr) {
-      return init_skip_frame_parser(t, 0);
+      return init_non_header_skip_frame_parser(t);
     }
     s->stats.incoming.framing_bytes += 9;
   }
@@ -719,7 +735,7 @@ static grpc_error_handle init_rst_stream_parser(grpc_chttp2_transport* t) {
   grpc_chttp2_stream* s = t->incoming_stream =
       grpc_chttp2_parsing_lookup_stream(t, t->incoming_stream_id);
   if (!t->incoming_stream) {
-    return init_skip_frame_parser(t, 0);
+    return init_non_header_skip_frame_parser(t);
   }
   s->stats.incoming.framing_bytes += 9;
   t->parser = grpc_chttp2_rst_stream_parser_parse;
@@ -752,7 +768,7 @@ static grpc_error_handle init_settings_frame_parser(grpc_chttp2_transport* t) {
     memcpy(t->settings[GRPC_ACKED_SETTINGS], t->settings[GRPC_SENT_SETTINGS],
            GRPC_CHTTP2_NUM_SETTINGS * sizeof(uint32_t));
     grpc_chttp2_hptbl_set_max_bytes(
-        &t->hpack_parser.table,
+        t->hpack_parser.hpack_table(),
         t->settings[GRPC_ACKED_SETTINGS]
                    [GRPC_CHTTP2_SETTINGS_HEADER_TABLE_SIZE]);
     t->sent_local_settings = false;