grpc 1.41.1 → 1.44.0.pre2

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

@@ -34,7 +34,6 @@
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/match.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"
@@ -51,7 +50,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
@@ -428,7 +427,7 @@ static const int16_t emit_sub_tbl[249 * 16] = {
 
 namespace {
 // The alphabet used for base64 encoding binary metadata.
-static constexpr char kBase64Alphabet[] =
+constexpr char kBase64Alphabet[] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
 
 // An inverted table: for each value in kBase64Alphabet, table contains the
@@ -448,7 +447,7 @@ struct Base64InverseTable {
   }
 };
 
-static GRPC_HPACK_CONSTEXPR_VALUE Base64InverseTable kBase64InverseTable;
+GRPC_HPACK_CONSTEXPR_VALUE Base64InverseTable kBase64InverseTable;
 }  // namespace
 
 // Input tracks the current byte through the input data and provides it
@@ -656,24 +655,10 @@ class HPackParser::String {
 
  private:
   // Forward declare take functions... we'll need them in the public interface
-  UnmanagedMemorySlice Take(Extern);
-  ManagedMemorySlice Take(Intern);
+  Slice Take(Extern);
+  Slice Take(Intern);
 
  public:
-  // If a String is a Slice then unref
-  ~String() {
-    if (auto* p = absl::get_if<grpc_slice>(&value_)) {
-      grpc_slice_unref_internal(*p);
-    }
-  }
-
-  // Take the value and leave this empty
-  // Use Intern/Extern to choose memory management
-  template <typename T>
-  auto Take() -> decltype(this->Take(T())) {
-    return Take(T());
-  }
-
   String(const String&) = delete;
   String& operator=(const String&) = delete;
   String(String&& other) noexcept : value_(std::move(other.value_)) {
@@ -685,6 +670,27 @@ class HPackParser::String {
     return *this;
   }
 
+  // Take the value and leave this empty
+  // Use Intern/Extern to choose memory management
+  template <typename T>
+  auto Take() -> decltype(this->Take(T())) {
+    return Take(T());
+  }
+
+  // Return a reference to the value as a string view
+  absl::string_view string_view() const {
+    if (auto* p = absl::get_if<Slice>(&value_)) {
+      return p->as_string_view();
+    } else if (auto* p = absl::get_if<absl::Span<const uint8_t>>(&value_)) {
+      return absl::string_view(reinterpret_cast<const char*>(p->data()),
+                               p->size());
+    } else if (auto* p = absl::get_if<std::vector<uint8_t>>(&value_)) {
+      return absl::string_view(reinterpret_cast<const char*>(p->data()),
+                               p->size());
+    }
+    GPR_UNREACHABLE_CODE(return absl::string_view());
+  }
+
   // Parse a non-binary string
   static absl::optional<String> Parse(Input* input) {
     auto pfx = input->ParseStringPrefix();
@@ -758,18 +764,7 @@ class HPackParser::String {
   explicit String(std::vector<uint8_t> v) : value_(std::move(v)) {}
   explicit String(absl::Span<const uint8_t> v) : value_(v) {}
   String(grpc_slice_refcount* r, const uint8_t* begin, const uint8_t* end)
-      : value_(MakeSlice(r, begin, end)) {}
-
-  // Given a refcount and a byte range, make a slice
-  static grpc_slice MakeSlice(grpc_slice_refcount* r, const uint8_t* begin,
-                              const uint8_t* end) {
-    grpc_slice out;
-    out.refcount = r;
-    r->Ref();
-    out.data.refcounted.bytes = const_cast<uint8_t*>(begin);
-    out.data.refcounted.length = end - begin;
-    return out;
-  }
+      : value_(Slice::FromRefcountAndBytes(r, begin, end)) {}
 
   // Parse some huffman encoded bytes, using output(uint8_t b) to emit each
   // decoded byte.
@@ -826,19 +821,17 @@ class HPackParser::String {
   // Turn base64 encoded bytes into not base64 encoded bytes.
   // Only takes input to set an error on failure.
   static absl::optional<String> Unbase64(Input* input, String s) {
-    auto v = Match(
-        s.value_,
-        [](const grpc_slice& slice) {
-          return Unbase64Loop(GRPC_SLICE_START_PTR(slice),
-                              GRPC_SLICE_END_PTR(slice));
-        },
-        [](absl::Span<const uint8_t> span) {
-          return Unbase64Loop(span.begin(), span.end());
-        },
-        [](const std::vector<uint8_t>& vec) {
-          return Unbase64Loop(vec.data(), vec.data() + vec.size());
-        });
-    if (!v.has_value()) {
+    absl::optional<std::vector<uint8_t>> result;
+    if (auto* p = absl::get_if<Slice>(&s.value_)) {
+      result = Unbase64Loop(p->begin(), p->end());
+    }
+    if (auto* p = absl::get_if<absl::Span<const uint8_t>>(&s.value_)) {
+      result = Unbase64Loop(p->begin(), p->end());
+    }
+    if (auto* p = absl::get_if<std::vector<uint8_t>>(&s.value_)) {
+      result = Unbase64Loop(p->data(), p->data() + p->size());
+    }
+    if (!result.has_value()) {
       return input->MaybeSetErrorAndReturn(
           [] {
             return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
@@ -846,7 +839,7 @@ class HPackParser::String {
           },
           absl::optional<String>());
     }
-    return String(std::move(*v));
+    return String(std::move(*result));
   }
 
   // Main loop for Unbase64
@@ -931,19 +924,23 @@ class HPackParser::String {
     GPR_UNREACHABLE_CODE(return out;);
   }
 
-  absl::variant<grpc_slice, absl::Span<const uint8_t>, std::vector<uint8_t>>
-      value_;
+  absl::variant<Slice, absl::Span<const uint8_t>, std::vector<uint8_t>> 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 +962,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 +995,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 +1051,115 @@ 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) {
+    metadata_buffer_->Set(md);
+    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;
-    auto key_slice = key->Take<String::Intern>();
-    auto value = ParseValueString(key_slice);
+    if (!key.has_value()) return {};
+    auto value = ParseValueString(absl::EndsWith(key->string_view(), "-bin"));
     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>());
+    auto key_string = key->string_view();
+    auto value_slice = value->Take<TakeValueType>();
+    const auto transport_size = key_string.size() + value_slice.size() +
+                                hpack_constants::kEntryOverhead;
+    return grpc_metadata_batch::Parse(
+        key->string_view(), std::move(value_slice), transport_size,
+        [key_string](absl::string_view error, const Slice& value) {
+          ReportMetadataParseError(key_string, error, value.as_string_view());
+        });
   }
 
   // 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>(),
+                              [=](absl::string_view error, const Slice& value) {
+                                ReportMetadataParseError(
+                                    elem->key(), error, value.as_string_view());
+                              });
   }
 
   // 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 +1170,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 +1190,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,54 +1212,65 @@ 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_);
+    if (metadata_buffer_ != nullptr) metadata_buffer_->Clear();
+    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);
+  }
+
+  static void ReportMetadataParseError(absl::string_view key,
+                                       absl::string_view error,
+                                       absl::string_view value) {
+    gpr_log(
+        GPR_ERROR, "Error parsing metadata: %s",
+        absl::StrCat("error=", error, " key=", key, " value=", value).c_str());
   }
 
-  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) {
-        GPR_DEBUG_ASSERT(!grpc_slice_is_interned(slice));
-        return static_cast<const UnmanagedMemorySlice&>(slice);
-      },
-      [](absl::Span<const uint8_t> span) {
-        return UnmanagedMemorySlice(
-            reinterpret_cast<char*>(const_cast<uint8_t*>(span.begin())),
-            span.size());
-      },
-      [](const std::vector<uint8_t>& v) {
-        return UnmanagedMemorySlice(reinterpret_cast<const char*>(v.data()),
-                                    v.size());
-      });
-  value_ = absl::Span<const uint8_t>();
-  return s;
+Slice HPackParser::String::Take(Extern) {
+  if (auto* p = absl::get_if<Slice>(&value_)) {
+    return p->Copy();
+  } else if (auto* p = absl::get_if<absl::Span<const uint8_t>>(&value_)) {
+    return Slice::FromCopiedBuffer(*p);
+  } else if (auto* p = absl::get_if<std::vector<uint8_t>>(&value_)) {
+    return Slice::FromCopiedBuffer(*p);
+  }
+  GPR_UNREACHABLE_CODE(return Slice());
 }
 
-ManagedMemorySlice HPackParser::String::Take(Intern) {
-  auto s = Match(
-      value_,
-      [](const grpc_slice& slice) {
-        ManagedMemorySlice s(&slice);
-        grpc_slice_unref_internal(slice);
-        return s;
-      },
-      [](absl::Span<const uint8_t> span) {
-        return ManagedMemorySlice(
-            reinterpret_cast<char*>(const_cast<uint8_t*>(span.data())),
-            span.size());
-      },
-      [](const std::vector<uint8_t>& v) {
-        return ManagedMemorySlice(reinterpret_cast<const char*>(v.data()),
-                                  v.size());
-      });
-  value_ = absl::Span<const uint8_t>();
-  return s;
+Slice HPackParser::String::Take(Intern) {
+  ManagedMemorySlice m;
+  if (auto* p = absl::get_if<Slice>(&value_)) {
+    m = ManagedMemorySlice(&p->c_slice());
+  } else if (auto* p = absl::get_if<absl::Span<const uint8_t>>(&value_)) {
+    m = ManagedMemorySlice(reinterpret_cast<const char*>(p->data()), p->size());
+  } else if (auto* p = absl::get_if<std::vector<uint8_t>>(&value_)) {
+    m = ManagedMemorySlice(reinterpret_cast<const char*>(p->data()), p->size());
+  }
+  return Slice(m);
 }
 
 /* PUBLIC INTERFACE */
@@ -1263,11 +1279,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 +1331,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 +1342,7 @@ bool HPackParser::ParseInputInner(Input* input) {
   return true;
 }
 
-void HPackParser::FinishFrame() { sink_ = Sink(); }
+void HPackParser::FinishFrame() { metadata_buffer_ = nullptr; }
 
 }  // namespace grpc_core
 
@@ -1345,24 +1367,6 @@ static void force_client_rst_stream(void* sp, grpc_error_handle /*error*/) {
   GRPC_CHTTP2_STREAM_UNREF(s, "final_rst");
 }
 
-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 ||
-      grpc_stream_compression_method_parse(
-          GRPC_MDVALUE(initial_metadata->idx.named.content_encoding->md), false,
-          &s->stream_decompression_method) == 0) {
-    s->stream_decompression_method =
-        GRPC_STREAM_COMPRESSION_IDENTITY_DECOMPRESS;
-  }
-
-  if (s->stream_decompression_method !=
-      GRPC_STREAM_COMPRESSION_IDENTITY_DECOMPRESS) {
-    s->stream_decompression_ctx = nullptr;
-    grpc_slice_buffer_init(&s->decompressed_data_buffer);
-  }
-}
-
 grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
                                                   grpc_chttp2_transport* t,
                                                   grpc_chttp2_stream* s,
@@ -1382,15 +1386,10 @@ 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);
-        }
         s->published_metadata[s->header_frames_received] =
             GRPC_METADATA_PUBLISHED_FROM_WIRE;
         maybe_complete_funcs[s->header_frames_received](t, s);