grpc 1.40.0 → 1.41.0.pre2

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

@@ -24,15 +24,30 @@
 #include <stddef.h>
 
 #include "src/core/ext/transport/chttp2/transport/frame.h"
-#include "src/core/ext/transport/chttp2/transport/hpack_table.h"
+#include "src/core/ext/transport/chttp2/transport/hpack_parser_table.h"
 #include "src/core/lib/transport/metadata.h"
 
 namespace grpc_core {
 
+// Top level interface for parsing a sequence of header, continuation frames.
 class HPackParser {
  public:
-  enum class Boundary { None, EndOfHeaders, EndOfStream };
-  enum class Priority { None, Included };
+  // What kind of stream boundary is provided by this frame?
+  enum class Boundary : uint8_t {
+    // More continuations are expected
+    None,
+    // This marks the end of headers, so data frames should follow
+    EndOfHeaders,
+    // This marks the end of headers *and* the end of the stream
+    EndOfStream
+  };
+  // What kind of priority is represented in the next frame
+  enum class Priority : uint8_t {
+    // No priority field
+    None,
+    // Yes there's a priority field
+    Included
+  };
 
   // User specified structure called for each received header.
   using Sink = std::function<grpc_error_handle(grpc_mdelem)>;
@@ -40,189 +55,53 @@ class HPackParser {
   HPackParser();
   ~HPackParser();
 
+  // Non-copyable/movable
   HPackParser(const HPackParser&) = delete;
   HPackParser& operator=(const HPackParser&) = delete;
 
+  // Begin parsing a new frame
+  // Sink receives each parsed header,
   void BeginFrame(Sink sink, Boundary boundary, Priority priority);
+  // Change the header sink mid parse
   void ResetSink(Sink sink) { sink_ = std::move(sink); }
-  grpc_error_handle Parse(const grpc_slice& slice);
+  // Parse one slice worth of data
+  grpc_error_handle Parse(const grpc_slice& slice, bool is_last);
+  // Reset state ready for the next BeginFrame
   void FinishFrame();
 
-  grpc_chttp2_hptbl* hpack_table() { return &table_; }
+  // Retrieve the associated hpack table (for tests, debugging)
+  HPackTable* hpack_table() { return &table_; }
+  // Is the current frame a boundary of some sort
   bool is_boundary() const { return boundary_ != Boundary::None; }
+  // Is the current frame the end of a stream
   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 {
-      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);
+  // Helper classes: see implementation
+  class Parser;
+  class Input;
+  class String;
 
-  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);
+  grpc_error_handle ParseInput(Input input, bool is_last);
+  bool ParseInputInner(Input* input);
 
+  // Callback per header received
   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;
-    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_;
-#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?
-  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
+
+  // Bytes that could not be parsed last parsing round
+  std::vector<uint8_t> unparsed_bytes_;
+  // Buffer kind of boundary
+  // TODO(ctiller): see if we can move this argument to Parse, and avoid
+  // buffering.
   Boundary boundary_;
-  uint32_t base64_buffer_;
+  // Buffer priority
+  // TODO(ctiller): see if we can move this argument to Parse, and avoid
+  // buffering.
+  Priority priority_;
+  uint8_t dynamic_table_updates_allowed_;
 
   // hpack table
-  grpc_chttp2_hptbl table_;
+  HPackTable table_;
 };
 
 }  // namespace grpc_core

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

@@ -0,0 +1,159 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/transport/chttp2/transport/hpack_parser_table.h"
+
+#include <assert.h>
+#include <string.h>
+
+#include "absl/strings/str_format.h"
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gpr/murmur_hash.h"
+#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/surface/validate_metadata.h"
+#include "src/core/lib/transport/static_metadata.h"
+
+extern grpc_core::TraceFlag grpc_http_trace;
+
+namespace grpc_core {
+
+HPackTable::HPackTable() = default;
+
+HPackTable::~HPackTable() {
+  for (size_t i = 0; i < num_entries_; i++) {
+    GRPC_MDELEM_UNREF(entries_[(first_entry_ + i) % entries_.size()]);
+  }
+}
+
+/* Evict one element from the table */
+void HPackTable::EvictOne() {
+  grpc_mdelem first_entry = entries_[first_entry_];
+  size_t elem_bytes = GRPC_SLICE_LENGTH(GRPC_MDKEY(first_entry)) +
+                      GRPC_SLICE_LENGTH(GRPC_MDVALUE(first_entry)) +
+                      hpack_constants::kEntryOverhead;
+  GPR_ASSERT(elem_bytes <= mem_used_);
+  mem_used_ -= static_cast<uint32_t>(elem_bytes);
+  first_entry_ = ((first_entry_ + 1) % entries_.size());
+  num_entries_--;
+  GRPC_MDELEM_UNREF(first_entry);
+}
+
+void HPackTable::Rebuild(uint32_t new_cap) {
+  EntriesVec entries;
+  entries.resize(new_cap);
+  for (size_t i = 0; i < num_entries_; i++) {
+    entries[i] = entries_[(first_entry_ + i) % entries_.size()];
+  }
+  first_entry_ = 0;
+  entries_.swap(entries);
+}
+
+void HPackTable::SetMaxBytes(uint32_t max_bytes) {
+  if (max_bytes_ == max_bytes) {
+    return;
+  }
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
+    gpr_log(GPR_INFO, "Update hpack parser max size to %d", max_bytes);
+  }
+  while (mem_used_ > max_bytes) {
+    EvictOne();
+  }
+  max_bytes_ = max_bytes;
+}
+
+grpc_error_handle HPackTable::SetCurrentTableSize(uint32_t bytes) {
+  if (current_table_bytes_ == bytes) {
+    return GRPC_ERROR_NONE;
+  }
+  if (bytes > max_bytes_) {
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+        "Attempt to make hpack table %d bytes when max is %d bytes", bytes,
+        max_bytes_));
+  }
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
+    gpr_log(GPR_INFO, "Update hpack parser table size to %d", bytes);
+  }
+  while (mem_used_ > bytes) {
+    EvictOne();
+  }
+  current_table_bytes_ = bytes;
+  max_entries_ = hpack_constants::EntriesForBytes(bytes);
+  if (max_entries_ > entries_.size()) {
+    Rebuild(max_entries_);
+  } else if (max_entries_ < entries_.size() / 3) {
+    // TODO(ctiller): move to resource quota system, only shrink under memory
+    // pressure
+    uint32_t new_cap =
+        std::max(max_entries_, static_cast<uint32_t>(kInlineEntries));
+    if (new_cap != entries_.size()) {
+      Rebuild(new_cap);
+    }
+  }
+  return GRPC_ERROR_NONE;
+}
+
+grpc_error_handle HPackTable::Add(grpc_mdelem md) {
+  /* determine how many bytes of buffer this entry represents */
+  size_t elem_bytes = GRPC_SLICE_LENGTH(GRPC_MDKEY(md)) +
+                      GRPC_SLICE_LENGTH(GRPC_MDVALUE(md)) +
+                      hpack_constants::kEntryOverhead;
+
+  if (current_table_bytes_ > max_bytes_) {
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+        "HPACK max table size reduced to %d but not reflected by hpack "
+        "stream (still at %d)",
+        max_bytes_, current_table_bytes_));
+  }
+
+  // we can't add elements bigger than the max table size
+  if (elem_bytes > current_table_bytes_) {
+    // HPACK draft 10 section 4.4 states:
+    // If the size of the new entry is less than or equal to the maximum
+    // size, that entry is added to the table.  It is not an error to
+    // attempt to add an entry that is larger than the maximum size; an
+    // attempt to add an entry larger than the entire table causes
+    // the table to be emptied of all existing entries, and results in an
+    // empty table.
+    while (num_entries_) {
+      EvictOne();
+    }
+    return GRPC_ERROR_NONE;
+  }
+
+  // evict entries to ensure no overflow
+  while (elem_bytes > static_cast<size_t>(current_table_bytes_) - mem_used_) {
+    EvictOne();
+  }
+
+  // copy the finalized entry in
+  entries_[(first_entry_ + num_entries_) % entries_.size()] =
+      GRPC_MDELEM_REF(md);
+
+  // update accounting values
+  num_entries_++;
+  mem_used_ += static_cast<uint32_t>(elem_bytes);
+  return GRPC_ERROR_NONE;
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,130 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_TABLE_H
+#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_TABLE_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/slice.h>
+
+#include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
+#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/transport/metadata.h"
+#include "src/core/lib/transport/static_metadata.h"
+
+namespace grpc_core {
+
+// HPACK header table
+class HPackTable {
+ public:
+  HPackTable();
+  ~HPackTable();
+
+  HPackTable(const HPackTable&);
+  HPackTable& operator=(const HPackTable&);
+
+  void SetMaxBytes(uint32_t max_bytes);
+  grpc_error_handle SetCurrentTableSize(uint32_t bytes);
+
+  // Lookup, but don't ref.
+  grpc_mdelem Peek(uint32_t index) const { return Lookup<false>(index); }
+  // Lookup, taking a ref if found.
+  grpc_mdelem Fetch(uint32_t index) const { return Lookup<true>(index); }
+
+  // add a table entry to the index
+  grpc_error_handle Add(grpc_mdelem md) GRPC_MUST_USE_RESULT;
+
+  // Current entry count in the table.
+  uint32_t num_entries() const { return num_entries_; }
+
+ private:
+  enum { kInlineEntries = hpack_constants::kInitialTableEntries };
+  using EntriesVec = absl::InlinedVector<grpc_mdelem, kInlineEntries>;
+
+  /* lookup a table entry based on its hpack index */
+  template <bool take_ref>
+  grpc_mdelem Lookup(uint32_t index) const {
+    // Static table comes first, just return an entry from it.
+    // NB: This imposes the constraint that the first
+    // GRPC_CHTTP2_LAST_STATIC_ENTRY entries in the core static metadata table
+    // must follow the hpack standard. If that changes, we *must* not rely on
+    // reading the core static metadata table here; at that point we'd need our
+    // own singleton static metadata in the correct order.
+    if (index <= hpack_constants::kLastStaticEntry) {
+      return grpc_static_mdelem_manifested()[index - 1];
+    } else {
+      return LookupDynamic<take_ref>(index);
+    }
+  }
+
+  template <bool take_ref>
+  grpc_mdelem LookupDynamic(uint32_t index) const {
+    // Not static - find the value in the list of valid entries
+    const uint32_t tbl_index = index - (hpack_constants::kLastStaticEntry + 1);
+    if (tbl_index < num_entries_) {
+      uint32_t offset =
+          (num_entries_ - 1u - tbl_index + first_entry_) % entries_.size();
+      grpc_mdelem md = entries_[offset];
+      if (take_ref) {
+        GRPC_MDELEM_REF(md);
+      }
+      return md;
+    }
+    // Invalid entry: return error
+    return GRPC_MDNULL;
+  }
+
+  void EvictOne();
+  void Rebuild(uint32_t new_cap);
+
+  // The first used entry in ents.
+  uint32_t first_entry_ = 0;
+  // How many entries are in the table.
+  uint32_t num_entries_ = 0;
+  // The amount of memory used by the table, according to the hpack algorithm
+  uint32_t mem_used_ = 0;
+  // The max memory allowed to be used by the table, according to the hpack
+  // algorithm.
+  uint32_t max_bytes_ = hpack_constants::kInitialTableSize;
+  // The currently agreed size of the table, according to the hpack algorithm.
+  uint32_t current_table_bytes_ = hpack_constants::kInitialTableSize;
+  // Maximum number of entries we could possibly fit in the table, given defined
+  // overheads.
+  uint32_t max_entries_ = hpack_constants::kInitialTableEntries;
+  // HPack table entries
+  EntriesVec entries_{hpack_constants::kInitialTableEntries};
+};
+
+}  // namespace grpc_core
+
+/* Returns the static hpack table index that corresponds to /a elem. Returns 0
+  if /a elem is not statically stored or if it is not in the static hpack
+  table */
+inline uintptr_t grpc_chttp2_get_static_hpack_table_index(grpc_mdelem md) {
+  uintptr_t index =
+      reinterpret_cast<grpc_core::StaticMetadata*>(GRPC_MDELEM_DATA(md)) -
+      grpc_static_mdelem_table();
+  if (index < grpc_core::hpack_constants::kLastStaticEntry) {
+    return index + 1;  // Hpack static metadata element indices start at 1
+  }
+  return 0;
+}
+
+#endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_TABLE_H */

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

@@ -0,0 +1,46 @@
+// Copyright 2021 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/transport/chttp2/transport/hpack_utils.h"
+
+#include "src/core/lib/surface/validate_metadata.h"
+
+namespace grpc_core {
+
+namespace {
+size_t Base64EncodedSize(size_t raw_length) {
+  static constexpr uint8_t tail_xtra[3] = {0, 2, 3};
+  return raw_length / 3 * 4 + tail_xtra[raw_length % 3];
+}
+}  // namespace
+
+// Return the size occupied by some metadata in the HPACK table.
+size_t MetadataSizeInHPackTable(grpc_mdelem elem,
+                                bool use_true_binary_metadata) {
+  const uint8_t* key_buf = GRPC_SLICE_START_PTR(GRPC_MDKEY(elem));
+  size_t key_len = GRPC_SLICE_LENGTH(GRPC_MDKEY(elem));
+  size_t overhead_and_key = 32 + key_len;
+  size_t value_len = GRPC_SLICE_LENGTH(GRPC_MDVALUE(elem));
+  if (grpc_key_is_binary_header(key_buf, key_len)) {
+    return overhead_and_key + (use_true_binary_metadata
+                                   ? value_len + 1
+                                   : Base64EncodedSize(value_len));
+  } else {
+    return overhead_and_key + value_len;
+  }
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,30 @@
+// Copyright 2021 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_UTILS_H
+#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_UTILS_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/transport/metadata.h"
+
+namespace grpc_core {
+
+// Return the size occupied by some metadata in the HPACK table.
+size_t MetadataSizeInHPackTable(grpc_mdelem elem,
+                                bool use_true_binary_metadata);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_UTILS_H

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

@@ -22,11 +22,11 @@
 
 #include <string.h>
 
-#include "src/core/ext/transport/chttp2/transport/internal.h"
-
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/ext/transport/chttp2/transport/internal.h"
+
 grpc_error_handle grpc_chttp2_incoming_metadata_buffer_add(
     grpc_chttp2_incoming_metadata_buffer* buffer, grpc_mdelem elem) {
   buffer->size += GRPC_MDELEM_LENGTH(elem);

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

@@ -345,7 +345,7 @@ struct grpc_chttp2_transport {
   /** data to write now */
   grpc_slice_buffer outbuf;
   /** hpack encoding */
-  grpc_chttp2_hpack_compressor hpack_compressor;
+  grpc_core::HPackCompressor hpack_compressor;
   /** is this a client? */
   bool is_client;
 
@@ -555,7 +555,7 @@ struct grpc_chttp2_stream {
   grpc_metadata_batch* recv_initial_metadata;
   grpc_closure* recv_initial_metadata_ready = nullptr;
   bool* trailing_metadata_available = nullptr;
-  grpc_core::OrphanablePtr<grpc_core::ByteStream>* recv_message;
+  grpc_core::OrphanablePtr<grpc_core::ByteStream>* recv_message = nullptr;
   bool* call_failed_before_recv_message = nullptr;
   grpc_closure* recv_message_ready = nullptr;
   grpc_metadata_batch* recv_trailing_metadata;