grpc 1.41.0 → 1.42.0

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

@@ -51,7 +51,7 @@
 
 namespace grpc_core {
 
-DebugOnlyTraceFlag grpc_trace_chttp2_hpack_parser(false, "chttp2_hpack_parser");
+TraceFlag grpc_trace_chttp2_hpack_parser(false, "chttp2_hpack_parser");
 
 /* state table for huffman decoding: given a state, gives an index/16 into
    next_sub_tbl. Taking that index and adding the value of the nibble being
@@ -935,15 +935,20 @@ class HPackParser::String {
       value_;
 };
 
-// Parser parses one frame + continuations worth of headers.
+// Parser parses one key/value pair from a byte stream.
 class HPackParser::Parser {
  public:
-  Parser(Input* input, HPackParser::Sink* sink, HPackTable* table,
-         uint8_t* dynamic_table_updates_allowed)
+  Parser(Input* input, grpc_metadata_batch* metadata_buffer,
+         uint32_t metadata_size_limit, HPackTable* table,
+         uint8_t* dynamic_table_updates_allowed, uint32_t* frame_length,
+         LogInfo log_info)
       : input_(input),
-        sink_(sink),
+        metadata_buffer_(metadata_buffer),
         table_(table),
-        dynamic_table_updates_allowed_(dynamic_table_updates_allowed) {}
+        dynamic_table_updates_allowed_(dynamic_table_updates_allowed),
+        frame_length_(frame_length),
+        metadata_size_limit_(metadata_size_limit),
+        log_info_(log_info) {}
 
   // Skip any priority bits, or return false on failure
   bool SkipPriority() {
@@ -965,13 +970,12 @@ class HPackParser::Parser {
       case 1:
         switch (cur & 0xf) {
           case 0:  // literal key
-            return FinishHeader<TableAction::kOmitFromTable>(
-                ParseLiteralKey<String::Extern>());
+            return FinishHeaderOmitFromTable(ParseLiteralKey<String::Extern>());
           case 0xf:  // varint encoded key index
-            return FinishHeader<TableAction::kOmitFromTable>(
+            return FinishHeaderOmitFromTable(
                 ParseVarIdxKey<String::Extern>(0xf));
           default:  // inline encoded key index
-            return FinishHeader<TableAction::kOmitFromTable>(
+            return FinishHeaderOmitFromTable(
                 ParseIdxKey<String::Extern>(cur & 0xf));
         }
         // Update max table size.
@@ -999,23 +1003,22 @@ class HPackParser::Parser {
       case 4:
         if (cur == 0x40) {
           // literal key
-          return FinishHeader<TableAction::kAddToTable>(
-              ParseLiteralKey<String::Intern>());
+          return FinishHeaderAndAddToTable(ParseLiteralKey<String::Intern>());
         }
         ABSL_FALLTHROUGH_INTENDED;
       case 5:
       case 6:
         // inline encoded key index
-        return FinishHeader<TableAction::kAddToTable>(
+        return FinishHeaderAndAddToTable(
             ParseIdxKey<String::Intern>(cur & 0x3f));
       case 7:
         if (cur == 0x7f) {
           // varint encoded key index
-          return FinishHeader<TableAction::kAddToTable>(
+          return FinishHeaderAndAddToTable(
               ParseVarIdxKey<String::Intern>(0x3f));
         } else {
           // inline encoded key index
-          return FinishHeader<TableAction::kAddToTable>(
+          return FinishHeaderAndAddToTable(
               ParseIdxKey<String::Intern>(cur & 0x3f));
         }
         // Indexed Header Field Representation
@@ -1056,102 +1059,110 @@ class HPackParser::Parser {
   }
 
  private:
-  void GPR_ATTRIBUTE_NOINLINE LogHeader(grpc_mdelem md) {
-    char* k = grpc_slice_to_c_string(GRPC_MDKEY(md));
-    char* v = nullptr;
-    if (grpc_is_binary_header_internal(GRPC_MDKEY(md))) {
-      v = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX);
-    } else {
-      v = grpc_slice_to_c_string(GRPC_MDVALUE(md));
+  void GPR_ATTRIBUTE_NOINLINE LogHeader(const HPackTable::Memento& memento) {
+    const char* type;
+    switch (log_info_.type) {
+      case LogInfo::kHeaders:
+        type = "HDR";
+        break;
+      case LogInfo::kTrailers:
+        type = "TRL";
+        break;
+      case LogInfo::kDontKnow:
+        type = "???";
+        break;
     }
-    gpr_log(
-        GPR_INFO,
-        "Decode: '%s: %s', elem_interned=%d [%d], k_interned=%d, v_interned=%d",
-        k, v, GRPC_MDELEM_IS_INTERNED(md), GRPC_MDELEM_STORAGE(md),
-        grpc_slice_is_interned(GRPC_MDKEY(md)),
-        grpc_slice_is_interned(GRPC_MDVALUE(md)));
-    gpr_free(k);
-    gpr_free(v);
+    gpr_log(GPR_DEBUG, "HTTP:%d:%s:%s: %s", log_info_.stream_id, type,
+            log_info_.is_client ? "CLI" : "SVR", memento.DebugString().c_str());
   }
 
-  // During FinishHeader, how should the header be treated in the hpack table
-  enum class TableAction {
-    // Add to the table
-    kAddToTable,
-    // Do not add to the table
-    kOmitFromTable,
-  };
+  bool EmitHeader(const HPackTable::Memento& md) {
+    // Pass up to the transport
+    if (GPR_UNLIKELY(metadata_buffer_ == nullptr)) return true;
+    *frame_length_ += md.transport_size();
+    if (GPR_UNLIKELY(*frame_length_ > metadata_size_limit_)) {
+      return HandleMetadataSizeLimitExceeded(md);
+    }
 
-  template <TableAction action>
-  bool FinishHeader(grpc_mdelem md) {
+    grpc_error_handle err = metadata_buffer_->Set(md);
+    if (GPR_UNLIKELY(err != GRPC_ERROR_NONE)) {
+      input_->SetError(err);
+      return false;
+    }
+    return true;
+  }
+
+  bool FinishHeaderAndAddToTable(absl::optional<HPackTable::Memento> md) {
     // Allow higher code to just pass in failures ... simplifies things a bit.
-    if (GRPC_MDISNULL(md)) return false;
+    if (!md.has_value()) return false;
     // Log if desired
     if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_chttp2_hpack_parser)) {
-      LogHeader(md);
-    }
-    // Add to the hpack table if needed
-    if (action == TableAction::kAddToTable) {
-      GPR_DEBUG_ASSERT(GRPC_MDELEM_STORAGE(md) ==
-                           GRPC_MDELEM_STORAGE_INTERNED ||
-                       GRPC_MDELEM_STORAGE(md) == GRPC_MDELEM_STORAGE_STATIC);
-      grpc_error_handle err = table_->Add(md);
-      if (GPR_UNLIKELY(err != GRPC_ERROR_NONE)) {
-        input_->SetError(err);
-        return false;
-      };
+      LogHeader(*md);
     }
-    // Pass up to the transport
-    grpc_error_handle err = (*sink_)(md);
+    // Emit whilst we own the metadata.
+    auto r = EmitHeader(*md);
+    // Add to the hpack table
+    grpc_error_handle err = table_->Add(std::move(*md));
     if (GPR_UNLIKELY(err != GRPC_ERROR_NONE)) {
       input_->SetError(err);
       return false;
+    };
+    return r;
+  }
+
+  bool FinishHeaderOmitFromTable(absl::optional<HPackTable::Memento> md) {
+    // Allow higher code to just pass in failures ... simplifies things a bit.
+    if (!md.has_value()) return false;
+    return FinishHeaderOmitFromTable(*md);
+  }
+
+  bool FinishHeaderOmitFromTable(const HPackTable::Memento& md) {
+    // Log if desired
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_chttp2_hpack_parser)) {
+      LogHeader(md);
     }
-    return true;
+    return EmitHeader(md);
   }
 
   // Parse a string encoded key and a string encoded value
   template <typename TakeValueType>
-  grpc_mdelem ParseLiteralKey() {
+  absl::optional<HPackTable::Memento> ParseLiteralKey() {
     auto key = String::Parse(input_);
-    if (!key.has_value()) return GRPC_MDNULL;
+    if (!key.has_value()) return {};
     auto key_slice = key->Take<String::Intern>();
-    auto value = ParseValueString(key_slice);
+    auto value =
+        ParseValueString(grpc_is_refcounted_slice_binary_header(key_slice));
     if (GPR_UNLIKELY(!value.has_value())) {
       grpc_slice_unref_internal(key_slice);
-      return GRPC_MDNULL;
+      return {};
     }
-    return grpc_mdelem_from_slices(key_slice, value->Take<TakeValueType>());
+    return grpc_metadata_batch::Parse(key_slice, value->Take<TakeValueType>());
   }
 
   // Parse an index encoded key and a string encoded value
   template <typename TakeValueType>
-  grpc_mdelem ParseIdxKey(uint32_t index) {
-    auto elem = table_->Peek(index);
-    if (GPR_UNLIKELY(GRPC_MDISNULL(elem))) {
-      return InvalidHPackIndexError(index, elem);
+  absl::optional<HPackTable::Memento> ParseIdxKey(uint32_t index) {
+    const auto* elem = table_->Lookup(index);
+    if (GPR_UNLIKELY(elem == nullptr)) {
+      return InvalidHPackIndexError(index,
+                                    absl::optional<HPackTable::Memento>());
     }
-    GPR_DEBUG_ASSERT(GRPC_MDELEM_IS_INTERNED(elem));
-    auto value = ParseValueString(GRPC_MDKEY(elem));
-    if (GPR_UNLIKELY(!value.has_value())) return GRPC_MDNULL;
-    return grpc_mdelem_from_slices(
-        static_cast<const ManagedMemorySlice&>(
-            grpc_slice_ref_internal(GRPC_MDKEY(elem))),
-        value->Take<TakeValueType>());
+    auto value = ParseValueString(elem->is_binary_header());
+    if (GPR_UNLIKELY(!value.has_value())) return {};
+    return elem->WithNewValue(value->Take<TakeValueType>());
   }
 
   // Parse a varint index encoded key and a string encoded value
   template <typename TakeValueType>
-  grpc_mdelem ParseVarIdxKey(uint32_t offset) {
+  absl::optional<HPackTable::Memento> ParseVarIdxKey(uint32_t offset) {
     auto index = input_->ParseVarint(offset);
-    if (GPR_UNLIKELY(!index.has_value())) return GRPC_MDNULL;
+    if (GPR_UNLIKELY(!index.has_value())) return {};
     return ParseIdxKey<TakeValueType>(*index);
   }
 
   // Parse a string, figuring out if it's binary or not by the key name.
-  template <typename SliceType>
-  absl::optional<String> ParseValueString(const SliceType& key) {
-    if (grpc_is_refcounted_slice_binary_header(key)) {
+  absl::optional<String> ParseValueString(bool is_binary) {
+    if (is_binary) {
       return String::ParseBinary(input_);
     } else {
       return String::Parse(input_);
@@ -1162,12 +1173,12 @@ class HPackParser::Parser {
   bool FinishIndexed(absl::optional<uint32_t> index) {
     *dynamic_table_updates_allowed_ = 0;
     if (!index.has_value()) return false;
-    grpc_mdelem md = table_->Fetch(*index);
-    if (GPR_UNLIKELY(GRPC_MDISNULL(md))) {
+    const auto* elem = table_->Lookup(*index);
+    if (GPR_UNLIKELY(elem == nullptr)) {
       return InvalidHPackIndexError(*index, false);
     }
     GRPC_STATS_INC_HPACK_RECV_INDEXED();
-    return FinishHeader<TableAction::kOmitFromTable>(md);
+    return FinishHeaderOmitFromTable(*elem);
   }
 
   // finish parsing a max table size change
@@ -1182,9 +1193,6 @@ class HPackParser::Parser {
           false);
     }
     (*dynamic_table_updates_allowed_)--;
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_chttp2_hpack_parser)) {
-      gpr_log(GPR_INFO, "MAX TABLE SIZE: %d", *size);
-    }
     grpc_error_handle err = table_->SetCurrentTableSize(*size);
     if (err != GRPC_ERROR_NONE) {
       input_->SetError(err);
@@ -1207,21 +1215,44 @@ class HPackParser::Parser {
               GRPC_ERROR_INT_SIZE,
               static_cast<intptr_t>(this->table_->num_entries()));
         },
-        result);
+        std::move(result));
+  }
+
+  GPR_ATTRIBUTE_NOINLINE
+  bool HandleMetadataSizeLimitExceeded(const HPackTable::Memento&) {
+    gpr_log(GPR_DEBUG,
+            "received initial metadata size exceeds limit (%" PRIu32
+            " vs. %" PRIu32
+            "). GRPC_ARG_MAX_METADATA_SIZE can be set to increase this limit.",
+            *frame_length_, metadata_size_limit_);
+    return input_->MaybeSetErrorAndReturn(
+        [] {
+          return grpc_error_set_int(
+              GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                  "received initial metadata size exceeds limit"),
+              GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED);
+        },
+        false);
   }
 
-  Input* input_;
-  HPackParser::Sink* sink_;
+  Input* const input_;
+  grpc_metadata_batch* const metadata_buffer_;
   HPackTable* const table_;
-  uint8_t* dynamic_table_updates_allowed_;
+  uint8_t* const dynamic_table_updates_allowed_;
+  uint32_t* const frame_length_;
+  const uint32_t metadata_size_limit_;
+  const LogInfo log_info_;
 };
 
 UnmanagedMemorySlice HPackParser::String::Take(Extern) {
   auto s = Match(
       value_,
       [](const grpc_slice& slice) {
+        // TODO(ctiller): Think about this before submission.
         GPR_DEBUG_ASSERT(!grpc_slice_is_interned(slice));
-        return static_cast<const UnmanagedMemorySlice&>(slice);
+        auto out_slice = grpc_slice_copy(slice);
+        grpc_slice_unref_internal(slice);
+        return static_cast<const UnmanagedMemorySlice&>(out_slice);
       },
       [](absl::Span<const uint8_t> span) {
         return UnmanagedMemorySlice(
@@ -1263,11 +1294,16 @@ HPackParser::HPackParser() = default;
 
 HPackParser::~HPackParser() = default;
 
-void HPackParser::BeginFrame(Sink sink, Boundary boundary, Priority priority) {
-  sink_ = std::move(sink);
+void HPackParser::BeginFrame(grpc_metadata_batch* metadata_buffer,
+                             uint32_t metadata_size_limit, Boundary boundary,
+                             Priority priority, LogInfo log_info) {
+  metadata_buffer_ = metadata_buffer;
   boundary_ = boundary;
   priority_ = priority;
   dynamic_table_updates_allowed_ = 2;
+  frame_length_ = 0;
+  metadata_size_limit_ = metadata_size_limit;
+  log_info_ = log_info;
 }
 
 grpc_error_handle HPackParser::Parse(const grpc_slice& slice, bool is_last) {
@@ -1310,9 +1346,10 @@ bool HPackParser::ParseInputInner(Input* input) {
     }
   }
   while (!input->end_of_stream()) {
-    if (GPR_UNLIKELY(
-            !Parser(input, &sink_, &table_, &dynamic_table_updates_allowed_)
-                 .Parse())) {
+    if (GPR_UNLIKELY(!Parser(input, metadata_buffer_, metadata_size_limit_,
+                             &table_, &dynamic_table_updates_allowed_,
+                             &frame_length_, log_info_)
+                          .Parse())) {
       return false;
     }
     input->UpdateFrontier();
@@ -1320,7 +1357,7 @@ bool HPackParser::ParseInputInner(Input* input) {
   return true;
 }
 
-void HPackParser::FinishFrame() { sink_ = Sink(); }
+void HPackParser::FinishFrame() { metadata_buffer_ = nullptr; }
 
 }  // namespace grpc_core
 
@@ -1348,10 +1385,11 @@ static void force_client_rst_stream(void* sp, grpc_error_handle /*error*/) {
 static void parse_stream_compression_md(grpc_chttp2_transport* /*t*/,
                                         grpc_chttp2_stream* s,
                                         grpc_metadata_batch* initial_metadata) {
-  if (initial_metadata->idx.named.content_encoding == nullptr ||
+  if (initial_metadata->legacy_index()->named.content_encoding == nullptr ||
       grpc_stream_compression_method_parse(
-          GRPC_MDVALUE(initial_metadata->idx.named.content_encoding->md), false,
-          &s->stream_decompression_method) == 0) {
+          GRPC_MDVALUE(
+              initial_metadata->legacy_index()->named.content_encoding->md),
+          false, &s->stream_decompression_method) == 0) {
     s->stream_decompression_method =
         GRPC_STREAM_COMPRESSION_IDENTITY_DECOMPRESS;
   }
@@ -1382,14 +1420,14 @@ grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
        stream id on a header */
     if (s != nullptr) {
       if (parser->is_boundary()) {
-        if (s->header_frames_received == GPR_ARRAY_SIZE(s->metadata_buffer)) {
+        if (s->header_frames_received == 2) {
           return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
               "Too many trailer frames");
         }
         /* Process stream compression md element if it exists */
         if (s->header_frames_received ==
             0) { /* Only acts on initial metadata */
-          parse_stream_compression_md(t, s, &s->metadata_buffer[0].batch);
+          parse_stream_compression_md(t, s, &s->initial_metadata_buffer);
         }
         s->published_metadata[s->header_frames_received] =
             GRPC_METADATA_PUBLISHED_FROM_WIRE;

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

@@ -26,6 +26,7 @@
 #include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser_table.h"
 #include "src/core/lib/transport/metadata.h"
+#include "src/core/lib/transport/metadata_batch.h"
 
 namespace grpc_core {
 
@@ -48,9 +49,20 @@ class HPackParser {
     // Yes there's a priority field
     Included
   };
-
-  // User specified structure called for each received header.
-  using Sink = std::function<grpc_error_handle(grpc_mdelem)>;
+  // Details about a frame we only need to know for logging
+  struct LogInfo {
+    // The stream ID
+    uint32_t stream_id;
+    // Headers or trailers?
+    enum Type : uint8_t {
+      kHeaders,
+      kTrailers,
+      kDontKnow,
+    };
+    Type type;
+    // Client or server?
+    bool is_client;
+  };
 
   HPackParser();
   ~HPackParser();
@@ -61,9 +73,11 @@ class HPackParser {
 
   // 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); }
+  void BeginFrame(grpc_metadata_batch* metadata_buffer,
+                  uint32_t metadata_size_limit, Boundary boundary,
+                  Priority priority, LogInfo log_info);
+  // Start throwing away any received headers after parsing them.
+  void StopBufferingFrame() { metadata_buffer_ = nullptr; }
   // Parse one slice worth of data
   grpc_error_handle Parse(const grpc_slice& slice, bool is_last);
   // Reset state ready for the next BeginFrame
@@ -85,8 +99,8 @@ class HPackParser {
   grpc_error_handle ParseInput(Input input, bool is_last);
   bool ParseInputInner(Input* input);
 
-  // Callback per header received
-  Sink sink_;
+  // Target metadata buffer
+  grpc_metadata_batch* metadata_buffer_ = nullptr;
 
   // Bytes that could not be parsed last parsing round
   std::vector<uint8_t> unparsed_bytes_;
@@ -99,6 +113,11 @@ class HPackParser {
   // buffering.
   Priority priority_;
   uint8_t dynamic_table_updates_allowed_;
+  // Length of frame so far.
+  uint32_t frame_length_;
+  uint32_t metadata_size_limit_;
+  // Information for logging
+  LogInfo log_info_;
 
   // hpack table
   HPackTable table_;

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

@@ -38,32 +38,24 @@ extern grpc_core::TraceFlag grpc_http_trace;
 
 namespace grpc_core {
 
-HPackTable::HPackTable() = default;
+HPackTable::HPackTable() : static_metadata_(GetStaticMementos()) {}
 
-HPackTable::~HPackTable() {
-  for (size_t i = 0; i < num_entries_; i++) {
-    GRPC_MDELEM_UNREF(entries_[(first_entry_ + i) % entries_.size()]);
-  }
-}
+HPackTable::~HPackTable() = default;
 
 /* 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);
+  auto first_entry = std::move(entries_[first_entry_]);
+  GPR_ASSERT(first_entry.transport_size() <= mem_used_);
+  mem_used_ -= first_entry.transport_size();
   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()];
+    entries[i] = std::move(entries_[(first_entry_ + i) % entries_.size()]);
   }
   first_entry_ = 0;
   entries_.swap(entries);
@@ -113,12 +105,7 @@ grpc_error_handle HPackTable::SetCurrentTableSize(uint32_t bytes) {
   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;
-
+grpc_error_handle HPackTable::Add(Memento md) {
   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 "
@@ -127,7 +114,7 @@ grpc_error_handle HPackTable::Add(grpc_mdelem md) {
   }
 
   // we can't add elements bigger than the max table size
-  if (elem_bytes > current_table_bytes_) {
+  if (md.transport_size() > 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
@@ -142,17 +129,17 @@ grpc_error_handle HPackTable::Add(grpc_mdelem md) {
   }
 
   // evict entries to ensure no overflow
-  while (elem_bytes > static_cast<size_t>(current_table_bytes_) - mem_used_) {
+  while (md.transport_size() >
+         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);
+  mem_used_ += md.transport_size();
+  entries_[(first_entry_ + num_entries_) % entries_.size()] = std::move(md);
 
   // update accounting values
   num_entries_++;
-  mem_used_ += static_cast<uint32_t>(elem_bytes);
   return GRPC_ERROR_NONE;
 }
 

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

@@ -27,6 +27,7 @@
 #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/metadata_batch.h"
 #include "src/core/lib/transport/static_metadata.h"
 
 namespace grpc_core {
@@ -37,30 +38,16 @@ class HPackTable {
   HPackTable();
   ~HPackTable();
 
-  HPackTable(const HPackTable&);
-  HPackTable& operator=(const HPackTable&);
+  HPackTable(const HPackTable&) = delete;
+  HPackTable& operator=(const HPackTable&) = delete;
 
   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_; }
+  using Memento = ParsedMetadata<grpc_metadata_batch>;
 
- 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 {
+  // Lookup, but don't ref.
+  const Memento* 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
@@ -68,27 +55,45 @@ class HPackTable {
     // 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];
+      return &static_metadata_.memento[index - 1];
     } else {
-      return LookupDynamic<take_ref>(index);
+      return LookupDynamic(index);
     }
   }
 
-  template <bool take_ref>
-  grpc_mdelem LookupDynamic(uint32_t index) const {
+  // add a table entry to the index
+  grpc_error_handle Add(Memento md) GRPC_MUST_USE_RESULT;
+
+  // Current entry count in the table.
+  uint32_t num_entries() const { return num_entries_; }
+
+ private:
+  struct StaticMementos {
+    StaticMementos() {
+      for (uint32_t i = 0; i < hpack_constants::kLastStaticEntry; i++) {
+        memento[i] = Memento(g_static_mdelem_manifested[i]);
+      }
+    }
+    Memento memento[hpack_constants::kLastStaticEntry];
+  };
+  static const StaticMementos& GetStaticMementos() {
+    static const StaticMementos static_mementos;
+    return static_mementos;
+  }
+
+  enum { kInlineEntries = hpack_constants::kInitialTableEntries };
+  using EntriesVec = absl::InlinedVector<Memento, kInlineEntries>;
+
+  const Memento* 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;
+      return &entries_[offset];
     }
     // Invalid entry: return error
-    return GRPC_MDNULL;
+    return nullptr;
   }
 
   void EvictOne();
@@ -110,6 +115,8 @@ class HPackTable {
   uint32_t max_entries_ = hpack_constants::kInitialTableEntries;
   // HPack table entries
   EntriesVec entries_{hpack_constants::kInitialTableEntries};
+  // Mementos for static data
+  const StaticMementos& static_metadata_;
 };
 
 }  // namespace grpc_core
@@ -120,7 +127,7 @@ class HPackTable {
 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();
+      grpc_core::g_static_mdelem_table;
   if (index < grpc_core::hpack_constants::kLastStaticEntry) {
     return index + 1;  // Hpack static metadata element indices start at 1
   }