grpc 1.42.0 → 1.45.0

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"
@@ -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
@@ -649,31 +648,6 @@ class HPackParser::Input {
 // 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
-  UnmanagedMemorySlice Take(Extern);
-  ManagedMemorySlice 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 +659,23 @@ class HPackParser::String {
     return *this;
   }
 
+  // Take the value and leave this empty
+  Slice Take();
+
+  // 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 +749,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 +806,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 +824,7 @@ class HPackParser::String {
           },
           absl::optional<String>());
     }
-    return String(std::move(*v));
+    return String(std::move(*result));
   }
 
   // Main loop for Unbase64
@@ -931,8 +909,7 @@ 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 key/value pair from a byte stream.
@@ -970,13 +947,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
@@ -1003,23 +978,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
@@ -1084,11 +1056,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;
   }
 
@@ -1125,22 +1093,25 @@ 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 {};
-    auto key_slice = key->Take<String::Intern>();
-    auto value =
-        ParseValueString(grpc_is_refcounted_slice_binary_header(key_slice));
+    auto value = ParseValueString(absl::EndsWith(key->string_view(), "-bin"));
     if (GPR_UNLIKELY(!value.has_value())) {
-      grpc_slice_unref_internal(key_slice);
       return {};
     }
-    return grpc_metadata_batch::Parse(key_slice, value->Take<TakeValueType>());
+    auto key_string = key->string_view();
+    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,
+        [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)) {
@@ -1149,15 +1120,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.
@@ -1225,6 +1198,7 @@ class HPackParser::Parser {
             " 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(
@@ -1235,6 +1209,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_;
@@ -1244,48 +1226,15 @@ class HPackParser::Parser {
   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));
-        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(
-            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;
-}
-
-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() {
+  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());
 }
 
 /* PUBLIC INTERFACE */
@@ -1382,25 +1331,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,
@@ -1424,11 +1354,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);

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

@@ -25,7 +25,6 @@
 
 #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 {

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

@@ -28,11 +28,11 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/ext/transport/chttp2/transport/hpack_constants.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;
 
@@ -143,4 +143,97 @@ grpc_error_handle HPackTable::Add(Memento md) {
   return GRPC_ERROR_NONE;
 }
 
+namespace {
+struct StaticTableEntry {
+  const char* key;
+  const char* value;
+};
+
+const StaticTableEntry kStaticTable[hpack_constants::kLastStaticEntry] = {
+    {":authority", ""},
+    {":method", "GET"},
+    {":method", "POST"},
+    {":path", "/"},
+    {":path", "/index.html"},
+    {":scheme", "http"},
+    {":scheme", "https"},
+    {":status", "200"},
+    {":status", "204"},
+    {":status", "206"},
+    {":status", "304"},
+    {":status", "400"},
+    {":status", "404"},
+    {":status", "500"},
+    {"accept-charset", ""},
+    {"accept-encoding", "gzip, deflate"},
+    {"accept-language", ""},
+    {"accept-ranges", ""},
+    {"accept", ""},
+    {"access-control-allow-origin", ""},
+    {"age", ""},
+    {"allow", ""},
+    {"authorization", ""},
+    {"cache-control", ""},
+    {"content-disposition", ""},
+    {"content-encoding", ""},
+    {"content-language", ""},
+    {"content-length", ""},
+    {"content-location", ""},
+    {"content-range", ""},
+    {"content-type", ""},
+    {"cookie", ""},
+    {"date", ""},
+    {"etag", ""},
+    {"expect", ""},
+    {"expires", ""},
+    {"from", ""},
+    {"host", ""},
+    {"if-match", ""},
+    {"if-modified-since", ""},
+    {"if-none-match", ""},
+    {"if-range", ""},
+    {"if-unmodified-since", ""},
+    {"last-modified", ""},
+    {"link", ""},
+    {"location", ""},
+    {"max-forwards", ""},
+    {"proxy-authenticate", ""},
+    {"proxy-authorization", ""},
+    {"range", ""},
+    {"referer", ""},
+    {"refresh", ""},
+    {"retry-after", ""},
+    {"server", ""},
+    {"set-cookie", ""},
+    {"strict-transport-security", ""},
+    {"transfer-encoding", ""},
+    {"user-agent", ""},
+    {"vary", ""},
+    {"via", ""},
+    {"www-authenticate", ""},
+};
+
+GPR_ATTRIBUTE_NOINLINE HPackTable::Memento MakeMemento(size_t i) {
+  auto sm = kStaticTable[i];
+  return grpc_metadata_batch::Parse(
+      sm.key, Slice::FromStaticString(sm.value),
+      strlen(sm.key) + strlen(sm.value) + hpack_constants::kEntryOverhead,
+      [](absl::string_view, const Slice&) {
+        abort();  // not expecting to see this
+      });
+}
+
+}  // namespace
+
+const HPackTable::StaticMementos& HPackTable::GetStaticMementos() {
+  static const StaticMementos* const static_mementos = new StaticMementos();
+  return *static_mementos;
+}
+
+HPackTable::StaticMementos::StaticMementos() {
+  for (uint32_t i = 0; i < hpack_constants::kLastStaticEntry; i++) {
+    memento[i] = MakeMemento(i);
+  }
+}
+
 }  // namespace grpc_core

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

@@ -26,9 +26,7 @@
 #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/metadata_batch.h"
-#include "src/core/lib/transport/static_metadata.h"
 
 namespace grpc_core {
 
@@ -69,17 +67,10 @@ class HPackTable {
 
  private:
   struct StaticMementos {
-    StaticMementos() {
-      for (uint32_t i = 0; i < hpack_constants::kLastStaticEntry; i++) {
-        memento[i] = Memento(g_static_mdelem_manifested[i]);
-      }
-    }
+    StaticMementos();
     Memento memento[hpack_constants::kLastStaticEntry];
   };
-  static const StaticMementos& GetStaticMementos() {
-    static const StaticMementos static_mementos;
-    return static_mementos;
-  }
+  static const StaticMementos& GetStaticMementos() GPR_ATTRIBUTE_NOINLINE;
 
   enum { kInlineEntries = hpack_constants::kInitialTableEntries };
   using EntriesVec = absl::InlinedVector<Memento, kInlineEntries>;
@@ -121,17 +112,4 @@ class HPackTable {
 
 }  // 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_core::g_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/internal.h

@@ -36,11 +36,11 @@
 #include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
 #include "src/core/ext/transport/chttp2/transport/stream_map.h"
 #include "src/core/lib/channel/channelz.h"
-#include "src/core/lib/compression/stream_compression.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport_impl.h"
@@ -118,16 +118,16 @@ struct grpc_chttp2_ping_queue {
 struct grpc_chttp2_repeated_ping_policy {
   int max_pings_without_data;
   int max_ping_strikes;
-  grpc_millis min_recv_ping_interval_without_data;
+  grpc_core::Duration min_recv_ping_interval_without_data;
 };
 struct grpc_chttp2_repeated_ping_state {
-  grpc_millis last_ping_sent_time;
+  grpc_core::Timestamp last_ping_sent_time;
   int pings_before_data_required;
   grpc_timer delayed_ping_timer;
   bool is_delayed_ping_timer_set;
 };
 struct grpc_chttp2_server_ping_recv_state {
-  grpc_millis last_ping_recv_time;
+  grpc_core::Timestamp last_ping_recv_time;
   int ping_strikes;
 };
 /* deframer state for the overall http2 stream of bytes */
@@ -253,12 +253,10 @@ class Chttp2IncomingByteStream : public ByteStream {
   static void NextLocked(void* arg, grpc_error_handle error_ignored);
   static void OrphanLocked(void* arg, grpc_error_handle error_ignored);
 
-  void MaybeCreateStreamDecompressionCtx();
-
   grpc_chttp2_transport* transport_;  // Immutable.
   grpc_chttp2_stream* stream_;        // Immutable.
 
-  grpc_core::RefCount refs_;
+  RefCount refs_;
 
   /* Accessed only by transport thread when stream->pending_byte_stream == false
    * Accessed only by application thread when stream->pending_byte_stream ==
@@ -287,8 +285,7 @@ typedef enum {
 
 struct grpc_chttp2_transport {
   grpc_chttp2_transport(const grpc_channel_args* channel_args,
-                        grpc_endpoint* ep, bool is_client,
-                        grpc_resource_user* resource_user);
+                        grpc_endpoint* ep, bool is_client);
   ~grpc_chttp2_transport();
 
   grpc_transport base; /* must be first */
@@ -296,7 +293,9 @@ struct grpc_chttp2_transport {
   grpc_endpoint* ep;
   std::string peer_string;
 
-  grpc_resource_user* resource_user;
+  grpc_core::MemoryOwner memory_owner;
+  const grpc_core::MemoryAllocator::Reservation self_reservation;
+  grpc_core::ReclamationSweep active_reclamation;
 
   grpc_core::Combiner* combiner;
 
@@ -478,9 +477,9 @@ struct grpc_chttp2_transport {
   /** watchdog to kill the transport when waiting for the keepalive ping */
   grpc_timer keepalive_watchdog_timer;
   /** time duration in between pings */
-  grpc_millis keepalive_time;
+  grpc_core::Duration keepalive_time;
   /** grace period for a ping to complete before watchdog kicks in */
-  grpc_millis keepalive_timeout;
+  grpc_core::Duration keepalive_timeout;
   /** if keepalive pings are allowed when there's no outstanding streams */
   bool keepalive_permit_without_calls = false;
   /** If start_keepalive_ping_locked has been called */
@@ -610,7 +609,7 @@ struct grpc_chttp2_stream {
       GRPC_ERROR_NONE;              /* protected by t combiner */
   bool received_last_frame = false; /* protected by t combiner */
 
-  grpc_millis deadline = GRPC_MILLIS_INF_FUTURE;
+  grpc_core::Timestamp deadline = grpc_core::Timestamp::InfFuture();
 
   /** saw some stream level error */
   grpc_error_handle forced_close_error = GRPC_ERROR_NONE;
@@ -640,38 +639,10 @@ struct grpc_chttp2_stream {
   grpc_chttp2_write_cb* finish_after_write = nullptr;
   size_t sending_bytes = 0;
 
-  /* Stream compression method to be used. */
-  grpc_stream_compression_method stream_compression_method =
-      GRPC_STREAM_COMPRESSION_IDENTITY_COMPRESS;
-  /* Stream decompression method to be used. */
-  grpc_stream_compression_method stream_decompression_method =
-      GRPC_STREAM_COMPRESSION_IDENTITY_DECOMPRESS;
-
-  /** Whether bytes stored in unprocessed_incoming_byte_stream is decompressed
-   */
-  bool unprocessed_incoming_frames_decompressed = false;
   /** Whether the bytes needs to be traced using Fathom */
   bool traced = false;
-  /** gRPC header bytes that are already decompressed */
-  size_t decompressed_header_bytes = 0;
   /** Byte counter for number of bytes written */
   size_t byte_counter = 0;
-
-  /** Amount of uncompressed bytes sent out when compressed_data_buffer is
-   * emptied */
-  size_t uncompressed_data_size;
-  /** Stream compression compress context */
-  grpc_stream_compression_context* stream_compression_ctx;
-  /** Buffer storing data that is compressed but not sent */
-  grpc_slice_buffer compressed_data_buffer;
-
-  /** Stream compression decompress context */
-  grpc_stream_compression_context* stream_decompression_ctx;
-  /** Temporary buffer storing decompressed data.
-   * Initialized, used, and destroyed only when stream uses (non-identity)
-   * compression.
-   */
-  grpc_slice_buffer decompressed_data_buffer;
 };
 
 /** Transport writing call flow: