grpc 1.43.1 → 1.48.0

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

@@ -21,63 +21,36 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
+#include <cstdint>
+#include <utility>
+#include <vector>
+
+#include "absl/strings/match.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/impl/codegen/compression_types.h>
 #include <grpc/slice.h>
-#include <grpc/slice_buffer.h>
+#include <grpc/status.h>
 
-#include "src/core/ext/transport/chttp2/transport/frame.h"
-#include "src/core/ext/transport/chttp2/transport/hpack_encoder_index.h"
+#include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder_table.h"
-#include "src/core/ext/transport/chttp2/transport/popularity_count.h"
-#include "src/core/lib/transport/metadata.h"
+#include "src/core/lib/compression/compression_internal.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/timeout_encoding.h"
 #include "src/core/lib/transport/transport.h"
 
 extern grpc_core::TraceFlag grpc_http_trace;
 
 namespace grpc_core {
 
-// Wrapper to take an array of mdelems and make them encodable
-class MetadataArray {
- public:
-  MetadataArray(grpc_mdelem** elems, size_t count)
-      : elems_(elems), count_(count) {}
-
-  template <typename Encoder>
-  void Encode(Encoder* encoder) const {
-    for (size_t i = 0; i < count_; i++) {
-      encoder->Encode(*elems_[i]);
-    }
-  }
-
- private:
-  grpc_mdelem** elems_;
-  size_t count_;
-};
-
-namespace metadata_detail {
-template <typename A, typename B>
-class ConcatMetadata {
- public:
-  ConcatMetadata(const A& a, const B& b) : a_(a), b_(b) {}
-
-  template <typename Encoder>
-  void Encode(Encoder* encoder) const {
-    a_.Encode(encoder);
-    b_.Encode(encoder);
-  }
-
- private:
-  const A& a_;
-  const B& b_;
-};
-}  // namespace metadata_detail
-
-template <typename A, typename B>
-metadata_detail::ConcatMetadata<A, B> ConcatMetadata(const A& a, const B& b) {
-  return metadata_detail::ConcatMetadata<A, B>(a, b);
-}
-
 class HPackCompressor {
+  class SliceIndex;
+
  public:
   HPackCompressor() = default;
   ~HPackCompressor() = default;
@@ -116,30 +89,41 @@ class HPackCompressor {
     Framer(const Framer&) = delete;
     Framer& operator=(const Framer&) = delete;
 
-    void Encode(grpc_mdelem md);
-    void Encode(GrpcTimeoutMetadata, grpc_millis deadline);
+    void Encode(const Slice& key, const Slice& value);
+    void Encode(HttpPathMetadata, const Slice& value);
+    void Encode(HttpAuthorityMetadata, const Slice& value);
+    void Encode(HttpStatusMetadata, uint32_t status);
+    void Encode(GrpcTimeoutMetadata, Timestamp deadline);
     void Encode(TeMetadata, TeMetadata::ValueType value);
+    void Encode(ContentTypeMetadata, ContentTypeMetadata::ValueType value);
+    void Encode(HttpSchemeMetadata, HttpSchemeMetadata::ValueType value);
+    void Encode(HttpMethodMetadata, HttpMethodMetadata::ValueType method);
     void Encode(UserAgentMetadata, const Slice& slice);
+    void Encode(GrpcStatusMetadata, grpc_status_code status);
+    void Encode(GrpcEncodingMetadata, grpc_compression_algorithm value);
+    void Encode(GrpcAcceptEncodingMetadata, CompressionAlgorithmSet value);
+    void Encode(GrpcTagsBinMetadata, const Slice& slice);
+    void Encode(GrpcTraceBinMetadata, const Slice& slice);
     void Encode(GrpcMessageMetadata, const Slice& slice) {
       if (slice.empty()) return;
       EmitLitHdrWithNonBinaryStringKeyNotIdx(
-          StaticSlice::FromStaticString("grpc-message").c_slice(),
-          slice.c_slice());
+          Slice::FromStaticString("grpc-message"), slice.Ref());
     }
     template <typename Which>
-    void Encode(Which, const Slice& slice) {
+    void Encode(Which, const typename Which::ValueType& value) {
+      const Slice& slice = MetadataValueAsSlice<Which>(value);
       if (absl::EndsWith(Which::key(), "-bin")) {
         EmitLitHdrWithBinaryStringKeyNotIdx(
-            StaticSlice::FromStaticString(Which::key()).c_slice(),
-            slice.c_slice());
+            Slice::FromStaticString(Which::key()), slice.Ref());
       } else {
         EmitLitHdrWithNonBinaryStringKeyNotIdx(
-            StaticSlice::FromStaticString(Which::key()).c_slice(),
-            slice.c_slice());
+            Slice::FromStaticString(Which::key()), slice.Ref());
       }
     }
 
    private:
+    friend class SliceIndex;
+
     struct FramePrefix {
       // index (in output_) of the header for the frame
       size_t header_idx;
@@ -154,26 +138,24 @@ class HPackCompressor {
 
     void AdvertiseTableSizeChange();
     void EmitIndexed(uint32_t index);
-    void EncodeDynamic(grpc_mdelem elem);
-    static GPR_ATTRIBUTE_NOINLINE void Log(grpc_mdelem elem);
-
-    void EmitLitHdrIncIdx(uint32_t key_index, grpc_mdelem elem);
-    void EmitLitHdrNotIdx(uint32_t key_index, grpc_mdelem elem);
-    void EmitLitHdrWithStringKeyIncIdx(grpc_mdelem elem);
-    void EmitLitHdrWithNonBinaryStringKeyIncIdx(const grpc_slice& key_slice,
-                                                const grpc_slice& value_slice);
-    void EmitLitHdrWithBinaryStringKeyNotIdx(const grpc_slice& key_slice,
-                                             const grpc_slice& value_slice);
-    void EmitLitHdrWithNonBinaryStringKeyNotIdx(const grpc_slice& key_slice,
-                                                const grpc_slice& value_slice);
-    void EmitLitHdrWithStringKeyNotIdx(grpc_mdelem elem);
-
-    void EncodeAlwaysIndexed(uint32_t* index, const grpc_slice& key,
-                             const grpc_slice& value,
-                             uint32_t transport_length);
+    void EmitLitHdrWithNonBinaryStringKeyIncIdx(Slice key_slice,
+                                                Slice value_slice);
+    void EmitLitHdrWithBinaryStringKeyIncIdx(Slice key_slice,
+                                             Slice value_slice);
+    void EmitLitHdrWithBinaryStringKeyNotIdx(Slice key_slice,
+                                             Slice value_slice);
+    void EmitLitHdrWithBinaryStringKeyNotIdx(uint32_t key_index,
+                                             Slice value_slice);
+    void EmitLitHdrWithNonBinaryStringKeyNotIdx(Slice key_slice,
+                                                Slice value_slice);
+
+    void EncodeAlwaysIndexed(uint32_t* index, absl::string_view key,
+                             Slice value, uint32_t transport_length);
+    void EncodeIndexedKeyWithBinaryValue(uint32_t* index, absl::string_view key,
+                                         Slice value);
 
     size_t CurrentFrameSize() const;
-    void Add(grpc_slice slice);
+    void Add(Slice slice);
     uint8_t* AddTiny(size_t len);
 
     // maximum size of a frame
@@ -183,10 +165,6 @@ class HPackCompressor {
     const bool is_end_of_stream_;
     // output stream id
     const uint32_t stream_id_;
-#ifndef NDEBUG
-    // have we seen a regular (non-colon-prefixed) header yet?
-    bool seen_regular_header_ = false;
-#endif
     grpc_slice_buffer* const output_;
     grpc_transport_one_way_stats* const stats_;
     HPackCompressor* const compressor_;
@@ -195,14 +173,7 @@ class HPackCompressor {
 
  private:
   static constexpr size_t kNumFilterValues = 64;
-
-  void AddKeyWithIndex(grpc_slice_refcount* key_ref, uint32_t new_index,
-                       uint32_t key_hash);
-  void AddElemWithIndex(grpc_mdelem elem, uint32_t new_index,
-                        uint32_t elem_hash, uint32_t key_hash);
-  void AddElem(grpc_mdelem elem, size_t elem_size, uint32_t elem_hash,
-               uint32_t key_hash);
-  void AddKey(grpc_mdelem elem, size_t elem_size, uint32_t key_hash);
+  static constexpr uint32_t kNumCachedGrpcStatusValues = 16;
 
   // maximum number of bytes we'll use for the decode table (to guard against
   // peers ooming us by setting decode table size high)
@@ -212,96 +183,48 @@ class HPackCompressor {
   bool advertise_table_size_change_ = false;
   HPackEncoderTable table_;
 
-  // filter tables for elems: this tables provides an approximate
-  // popularity count for particular hashes, and are used to determine whether
-  // a new literal should be added to the compression table or not.
-  // They track a single integer that counts how often a particular value has
-  // been seen. When that count reaches max (255), all values are halved.
-  PopularityCount<kNumFilterValues> filter_elems_;
-
-  class KeyElem {
+  class SliceIndex {
    public:
-    class Stored {
-     public:
-      Stored() : elem_(GRPC_MDNULL) {}
-      explicit Stored(grpc_mdelem elem) : elem_(GRPC_MDELEM_REF(elem)) {}
-      Stored(const Stored& other) : elem_(GRPC_MDELEM_REF(other.elem_)) {}
-      Stored& operator=(Stored other) {
-        std::swap(elem_, other.elem_);
-        return *this;
-      }
-      ~Stored() { GRPC_MDELEM_UNREF(elem_); }
-
-      const grpc_mdelem& elem() const { return elem_; }
-
-      bool operator==(const Stored& other) const noexcept {
-        return elem_.payload == other.elem_.payload;
-      }
-
-     private:
-      grpc_mdelem elem_;
-    };
-
-    KeyElem(grpc_mdelem elem, uint32_t hash) : elem_(elem), hash_(hash) {}
-    KeyElem(const KeyElem&);
-    KeyElem& operator=(const KeyElem&);
-
-    uint32_t hash() const {
-      // TODO(ctiller): unify this with what's in the cc file when we move this
-      // code to c++
-      return hash_ >> 6;
-    }
-
-    Stored stored() const { return Stored(elem_); }
-
-    bool operator==(const Stored& stored) const noexcept {
-      return elem_.payload == stored.elem().payload;
-    }
+    void EmitTo(absl::string_view key, const Slice& value, Framer* framer);
 
    private:
-    grpc_mdelem elem_;
-    uint32_t hash_;
+    struct ValueIndex {
+      ValueIndex(Slice value, uint32_t index)
+          : value(std::move(value)), index(index) {}
+      Slice value;
+      uint32_t index;
+    };
+    std::vector<ValueIndex> values_;
   };
 
-  class KeySliceRef {
-   public:
-    using Stored = RefCountedPtr<grpc_slice_refcount>;
-
-    KeySliceRef(grpc_slice_refcount* ref, uint32_t hash)
-        : ref_(ref), hash_(hash) {}
-    KeySliceRef(const KeySliceRef&) = delete;
-    KeySliceRef& operator=(const KeySliceRef&) = delete;
-
-    uint32_t hash() const {
-      // TODO(ctiller): unify this with what's in the cc file when we move this
-      // code to c++
-      return hash_ >> 6;
-    }
-
-    Stored stored() const {
-      ref_->Ref();
-      return Stored(ref_);
-    }
-
-    bool operator==(const Stored& stored) const noexcept {
-      return ref_ == stored.get();
-    }
-
-   private:
-    grpc_slice_refcount* ref_;
-    uint32_t hash_;
+  struct PreviousTimeout {
+    Timeout timeout;
+    uint32_t index;
   };
 
-  // entry tables for keys & elems: these tables track values that have been
-  // seen and *may* be in the decompressor table
-  HPackEncoderIndex<KeyElem, kNumFilterValues> elem_index_;
-  HPackEncoderIndex<KeySliceRef, kNumFilterValues> key_index_;
   // Index into table_ for the te:trailers metadata element
   uint32_t te_index_ = 0;
+  // Index into table_ for the content-type metadata element
+  uint32_t content_type_index_ = 0;
   // Index into table_ for the user-agent metadata element
   uint32_t user_agent_index_ = 0;
+  // Cached grpc-status values
+  uint32_t cached_grpc_status_[kNumCachedGrpcStatusValues] = {};
+  // Cached grpc-encoding values
+  uint32_t cached_grpc_encoding_[GRPC_COMPRESS_ALGORITHMS_COUNT] = {};
+  // Cached grpc-accept-encoding value
+  uint32_t grpc_accept_encoding_index_ = 0;
+  // The grpc-accept-encoding string referred to by grpc_accept_encoding_index_
+  CompressionAlgorithmSet grpc_accept_encoding_;
+  // Index of something that was sent with grpc-tags-bin
+  uint32_t grpc_tags_bin_index_ = 0;
+  // Index of something that was sent with grpc-trace-bin
+  uint32_t grpc_trace_bin_index_ = 0;
   // The user-agent string referred to by user_agent_index_
   Slice user_agent_;
+  SliceIndex path_index_;
+  SliceIndex authority_index_;
+  std::vector<PreviousTimeout> previous_timeouts_;
 };
 
 }  // namespace grpc_core

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

@@ -16,13 +16,16 @@
 
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder_table.h"
 
+#include <algorithm>
+#include <cstdint>
+
 #include <grpc/support/log.h>
 
 namespace grpc_core {
 
 uint32_t HPackEncoderTable::AllocateIndex(size_t element_size) {
   uint32_t new_index = tail_remote_index_ + table_elems_ + 1;
-  GPR_DEBUG_ASSERT(element_size < 65536);
+  GPR_DEBUG_ASSERT(element_size <= MaxEntrySize());
 
   if (element_size > max_table_size_) {
     while (table_size_ > 0) {

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

@@ -17,6 +17,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "absl/container/inlined_vector.h"
 
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
@@ -29,6 +32,8 @@ class HPackEncoderTable {
  public:
   HPackEncoderTable() : elem_size_(hpack_constants::kInitialTableEntries) {}
 
+  static constexpr size_t MaxEntrySize() { return 65535; }
+
   // Reserve space in table for the new element, evict entries if needed.
   // Return the new index of the element. Return 0 to indicate not adding to
   // table.

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

@@ -21,24 +21,43 @@
 #include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
 
 #include <assert.h>
+#include <inttypes.h>
 #include <stddef.h>
-#include <string.h>
+#include <stdlib.h>
 
+#include <algorithm>
+#include <cstdint>
+#include <string>
+#include <utility>
+
+#include "absl/base/attributes.h"
+#include "absl/status/status.h"
+#include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "absl/types/span.h"
+#include "absl/types/variant.h"
 
-#include <grpc/support/alloc.h>
+#include <grpc/status.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/transport/chttp2/transport/bin_encoder.h"
+#include "src/core/ext/transport/chttp2/transport/frame_rst_stream.h"
+#include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #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/debug/trace.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/profiling/timers.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_string_helpers.h"
-#include "src/core/lib/surface/validate_metadata.h"
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_refcount_base.h"
 #include "src/core/lib/transport/http2_errors.h"
+#include "src/core/lib/transport/parsed_metadata.h"
+#include "src/core/lib/transport/transport.h"
+
+// IWYU pragma: no_include <type_traits>
 
 #if __cplusplus > 201103L
 #define GRPC_HPACK_CONSTEXPR_FN constexpr
@@ -582,7 +601,7 @@ class HPackParser::Input {
   // Set the current error - allows the rest of the code not to need to pass
   // around StatusOr<> which would be prohibitive here.
   GPR_ATTRIBUTE_NOINLINE void SetError(grpc_error_handle error) {
-    if (error_ != GRPC_ERROR_NONE || eof_error_) {
+    if (!GRPC_ERROR_IS_NONE(error_) || eof_error_) {
       GRPC_ERROR_UNREF(error);
       return;
     }
@@ -595,7 +614,7 @@ class HPackParser::Input {
   template <typename F, typename T>
   GPR_ATTRIBUTE_NOINLINE T MaybeSetErrorAndReturn(F error_factory,
                                                   T return_value) {
-    if (error_ != GRPC_ERROR_NONE || eof_error_) return return_value;
+    if (!GRPC_ERROR_IS_NONE(error_) || eof_error_) return return_value;
     error_ = error_factory();
     begin_ = end_;
     return return_value;
@@ -605,7 +624,7 @@ class HPackParser::Input {
   // is a common case)
   template <typename T>
   T UnexpectedEOF(T return_value) {
-    if (error_ != GRPC_ERROR_NONE) return return_value;
+    if (!GRPC_ERROR_IS_NONE(error_)) return return_value;
     eof_error_ = true;
     return return_value;
   }
@@ -647,17 +666,6 @@ class HPackParser::Input {
 // Helper to parse a string and turn it into a slice with appropriate memory
 // management characteristics
 class HPackParser::String {
- public:
-  // Helper to specify a string should be internalized
-  struct Intern {};
-  // Helper to specify a string should be externalized
-  struct Extern {};
-
- private:
-  // Forward declare take functions... we'll need them in the public interface
-  Slice Take(Extern);
-  Slice Take(Intern);
-
  public:
   String(const String&) = delete;
   String& operator=(const String&) = delete;
@@ -671,11 +679,7 @@ class HPackParser::String {
   }
 
   // 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());
-  }
+  Slice Take();
 
   // Return a reference to the value as a string view
   absl::string_view string_view() const {
@@ -962,13 +966,11 @@ class HPackParser::Parser {
       case 1:
         switch (cur & 0xf) {
           case 0:  // literal key
-            return FinishHeaderOmitFromTable(ParseLiteralKey<String::Extern>());
+            return FinishHeaderOmitFromTable(ParseLiteralKey());
           case 0xf:  // varint encoded key index
-            return FinishHeaderOmitFromTable(
-                ParseVarIdxKey<String::Extern>(0xf));
+            return FinishHeaderOmitFromTable(ParseVarIdxKey(0xf));
           default:  // inline encoded key index
-            return FinishHeaderOmitFromTable(
-                ParseIdxKey<String::Extern>(cur & 0xf));
+            return FinishHeaderOmitFromTable(ParseIdxKey(cur & 0xf));
         }
         // Update max table size.
         // First byte format: 001xxxxx
@@ -995,23 +997,20 @@ class HPackParser::Parser {
       case 4:
         if (cur == 0x40) {
           // literal key
-          return FinishHeaderAndAddToTable(ParseLiteralKey<String::Intern>());
+          return FinishHeaderAndAddToTable(ParseLiteralKey());
         }
         ABSL_FALLTHROUGH_INTENDED;
       case 5:
       case 6:
         // inline encoded key index
-        return FinishHeaderAndAddToTable(
-            ParseIdxKey<String::Intern>(cur & 0x3f));
+        return FinishHeaderAndAddToTable(ParseIdxKey(cur & 0x3f));
       case 7:
         if (cur == 0x7f) {
           // varint encoded key index
-          return FinishHeaderAndAddToTable(
-              ParseVarIdxKey<String::Intern>(0x3f));
+          return FinishHeaderAndAddToTable(ParseVarIdxKey(0x3f));
         } else {
           // inline encoded key index
-          return FinishHeaderAndAddToTable(
-              ParseIdxKey<String::Intern>(cur & 0x3f));
+          return FinishHeaderAndAddToTable(ParseIdxKey(cur & 0x3f));
         }
         // Indexed Header Field Representation
         // First byte format: 1xxxxxxx
@@ -1076,11 +1075,7 @@ class HPackParser::Parser {
       return HandleMetadataSizeLimitExceeded(md);
     }
 
-    grpc_error_handle err = metadata_buffer_->Set(md);
-    if (GPR_UNLIKELY(err != GRPC_ERROR_NONE)) {
-      input_->SetError(err);
-      return false;
-    }
+    metadata_buffer_->Set(md);
     return true;
   }
 
@@ -1095,7 +1090,7 @@ class HPackParser::Parser {
     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)) {
+    if (GPR_UNLIKELY(!GRPC_ERROR_IS_NONE(err))) {
       input_->SetError(err);
       return false;
     };
@@ -1117,7 +1112,6 @@ class HPackParser::Parser {
   }
 
   // Parse a string encoded key and a string encoded value
-  template <typename TakeValueType>
   absl::optional<HPackTable::Memento> ParseLiteralKey() {
     auto key = String::Parse(input_);
     if (!key.has_value()) return {};
@@ -1126,15 +1120,17 @@ class HPackParser::Parser {
       return {};
     }
     auto key_string = key->string_view();
-    auto value_slice = value->Take<TakeValueType>();
+    auto value_slice = value->Take();
     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);
+    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>
   absl::optional<HPackTable::Memento> ParseIdxKey(uint32_t index) {
     const auto* elem = table_->Lookup(index);
     if (GPR_UNLIKELY(elem == nullptr)) {
@@ -1143,15 +1139,17 @@ class HPackParser::Parser {
     }
     auto value = ParseValueString(elem->is_binary_header());
     if (GPR_UNLIKELY(!value.has_value())) return {};
-    return elem->WithNewValue(value->Take<TakeValueType>());
+    return elem->WithNewValue(
+        value->Take(), [=](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>
   absl::optional<HPackTable::Memento> ParseVarIdxKey(uint32_t offset) {
     auto index = input_->ParseVarint(offset);
     if (GPR_UNLIKELY(!index.has_value())) return {};
-    return ParseIdxKey<TakeValueType>(*index);
+    return ParseIdxKey(*index);
   }
 
   // Parse a string, figuring out if it's binary or not by the key name.
@@ -1188,7 +1186,7 @@ class HPackParser::Parser {
     }
     (*dynamic_table_updates_allowed_)--;
     grpc_error_handle err = table_->SetCurrentTableSize(*size);
-    if (err != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(err)) {
       input_->SetError(err);
       return false;
     }
@@ -1230,6 +1228,14 @@ class HPackParser::Parser {
         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* const input_;
   grpc_metadata_batch* const metadata_buffer_;
   HPackTable* const table_;
@@ -1239,7 +1245,7 @@ class HPackParser::Parser {
   const LogInfo log_info_;
 };
 
-Slice HPackParser::String::Take(Extern) {
+Slice HPackParser::String::Take() {
   if (auto* p = absl::get_if<Slice>(&value_)) {
     return p->Copy();
   } else if (auto* p = absl::get_if<absl::Span<const uint8_t>>(&value_)) {
@@ -1250,18 +1256,6 @@ Slice HPackParser::String::Take(Extern) {
   GPR_UNREACHABLE_CODE(return Slice());
 }
 
-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 */
 
 HPackParser::HPackParser() = default;
@@ -1356,25 +1350,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->legacy_index()->named.content_encoding == nullptr ||
-      grpc_stream_compression_method_parse(
-          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;
-  }
-
-  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,
@@ -1386,7 +1361,7 @@ grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
     s->stats.incoming.header_bytes += GRPC_SLICE_LENGTH(slice);
   }
   grpc_error_handle error = parser->Parse(slice, is_last != 0);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     return error;
   }
   if (is_last) {
@@ -1398,11 +1373,6 @@ grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
           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->initial_metadata_buffer);
-        }
         s->published_metadata[s->header_frames_received] =
             GRPC_METADATA_PUBLISHED_FROM_WIRE;
         maybe_complete_funcs[s->header_frames_received](t, s);