grpc 1.46.3 → 1.53.1

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

@@ -1,40 +1,324 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_H
-#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_H
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_H
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
 #include <cstdint>
+#include <utility>
+#include <vector>
+
+#include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
-#include <grpc/slice_buffer.h>
+#include <grpc/support/log.h>
 
-#include "src/core/ext/transport/chttp2/transport/frame.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/lib/gprpp/time.h"
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_buffer.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 {
 
+// Forward decl for encoder
+class HPackCompressor;
+
+namespace hpack_encoder_detail {
+
+class Encoder {
+ public:
+  Encoder(HPackCompressor* compressor, bool use_true_binary_metadata,
+          SliceBuffer& output);
+
+  void Encode(const Slice& key, const Slice& value);
+  template <typename MetadataTrait>
+  void Encode(MetadataTrait, const typename MetadataTrait::ValueType& value);
+
+  void AdvertiseTableSizeChange();
+  void EmitIndexed(uint32_t index);
+  GRPC_MUST_USE_RESULT
+  uint32_t EmitLitHdrWithNonBinaryStringKeyIncIdx(Slice key_slice,
+                                                  Slice value_slice);
+  GRPC_MUST_USE_RESULT
+  uint32_t 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,
+                           size_t transport_length);
+  void EncodeIndexedKeyWithBinaryValue(uint32_t* index, absl::string_view key,
+                                       Slice value);
+
+  void EncodeRepeatingSliceValue(const absl::string_view& key,
+                                 const Slice& slice, uint32_t* index,
+                                 size_t max_compression_size);
+
+  HPackEncoderTable& hpack_table();
+
+ private:
+  const bool use_true_binary_metadata_;
+  HPackCompressor* const compressor_;
+  SliceBuffer& output_;
+};
+
+// Compressor is partially specialized on CompressionTraits, but leaves
+// MetadataTrait as variable.
+// Via MetadataMap::StatefulCompressor it builds compression state for
+// HPackCompressor.
+// Each trait compressor gets to have some persistent state across the channel
+// (declared as Compressor member variables).
+// The compressors expose a single method:
+// void EncodeWith(MetadataTrait, const MetadataTrait::ValueType, Encoder*);
+// This method figures out how to encode the value, and then delegates to
+// Encoder to perform the encoding.
+template <typename MetadataTrait, typename CompressonTraits>
+class Compressor;
+
+// No compression encoder: just emit the key and value as literals.
+template <typename MetadataTrait>
+class Compressor<MetadataTrait, NoCompressionCompressor> {
+ public:
+  void EncodeWith(MetadataTrait, const typename MetadataTrait::ValueType& value,
+                  Encoder* encoder) {
+    const Slice& slice = MetadataValueAsSlice<MetadataTrait>(value);
+    if (absl::EndsWith(MetadataTrait::key(), "-bin")) {
+      encoder->EmitLitHdrWithBinaryStringKeyNotIdx(
+          Slice::FromStaticString(MetadataTrait::key()), slice.Ref());
+    } else {
+      encoder->EmitLitHdrWithNonBinaryStringKeyNotIdx(
+          Slice::FromStaticString(MetadataTrait::key()), slice.Ref());
+    }
+  }
+};
+
+// Frequent key with no value compression encoder
+template <typename MetadataTrait>
+class Compressor<MetadataTrait, FrequentKeyWithNoValueCompressionCompressor> {
+ public:
+  void EncodeWith(MetadataTrait, const typename MetadataTrait::ValueType& value,
+                  Encoder* encoder) {
+    const Slice& slice = MetadataValueAsSlice<MetadataTrait>(value);
+    encoder->EncodeRepeatingSliceValue(MetadataTrait::key(), slice,
+                                       &some_sent_value_,
+                                       HPackEncoderTable::MaxEntrySize());
+  }
+
+ private:
+  // Some previously sent value with this tag.
+  uint32_t some_sent_value_ = 0;
+};
+
+// Helper to determine if two objects have the same identity.
+// Equivalent here => equality, but equality does not imply equivalency.
+// For example, two slices with the same contents are equal, but not
+// equivalent.
+// Used as a much faster check for equality than the full equality check,
+// since many metadatum that are stable have the same root object in metadata
+// maps.
+template <typename T>
+static bool IsEquivalent(T a, T b) {
+  return a == b;
+}
+
+template <typename T>
+static bool IsEquivalent(const Slice& a, const Slice& b) {
+  return a.is_equivalent(b);
+}
+
+template <typename T>
+static void SaveCopyTo(const T& value, T& copy) {
+  copy = value;
+}
+
+static inline void SaveCopyTo(const Slice& value, Slice& copy) {
+  copy = value.Ref();
+}
+
+template <typename MetadataTrait>
+class Compressor<MetadataTrait, StableValueCompressor> {
+ public:
+  void EncodeWith(MetadataTrait, const typename MetadataTrait::ValueType& value,
+                  Encoder* encoder) {
+    auto& table = encoder->hpack_table();
+    if (previously_sent_value_ == value &&
+        table.ConvertableToDynamicIndex(previously_sent_index_)) {
+      encoder->EmitIndexed(table.DynamicIndex(previously_sent_index_));
+      return;
+    }
+    previously_sent_index_ = 0;
+    auto key = MetadataTrait::key();
+    const Slice& value_slice = MetadataValueAsSlice<MetadataTrait>(value);
+    if (hpack_constants::SizeForEntry(key.size(), value_slice.size()) >
+        HPackEncoderTable::MaxEntrySize()) {
+      encoder->EmitLitHdrWithNonBinaryStringKeyNotIdx(
+          Slice::FromStaticString(key), value_slice.Ref());
+      return;
+    }
+    encoder->EncodeAlwaysIndexed(
+        &previously_sent_index_, key, value_slice.Ref(),
+        hpack_constants::SizeForEntry(key.size(), value_slice.size()));
+    SaveCopyTo(value, previously_sent_value_);
+  }
+
+ private:
+  // Previously sent value
+  typename MetadataTrait::ValueType previously_sent_value_{};
+  // And its index in the table
+  uint32_t previously_sent_index_ = 0;
+};
+
+template <typename MetadataTrait, typename MetadataTrait::ValueType known_value>
+class Compressor<
+    MetadataTrait,
+    KnownValueCompressor<typename MetadataTrait::ValueType, known_value>> {
+ public:
+  void EncodeWith(MetadataTrait, const typename MetadataTrait::ValueType& value,
+                  Encoder* encoder) {
+    if (value != known_value) {
+      gpr_log(GPR_ERROR, "%s",
+              absl::StrCat("Not encoding bad ", MetadataTrait::key(), " header")
+                  .c_str());
+      return;
+    }
+    Slice encoded(MetadataTrait::Encode(known_value));
+    const auto encoded_length = encoded.length();
+    encoder->EncodeAlwaysIndexed(&previously_sent_index_, MetadataTrait::key(),
+                                 std::move(encoded),
+                                 MetadataTrait::key().size() + encoded_length +
+                                     hpack_constants::kEntryOverhead);
+  }
+
+ private:
+  uint32_t previously_sent_index_ = 0;
+};
+template <typename MetadataTrait, size_t N>
+class Compressor<MetadataTrait, SmallIntegralValuesCompressor<N>> {
+ public:
+  void EncodeWith(MetadataTrait, const typename MetadataTrait::ValueType& value,
+                  Encoder* encoder) {
+    uint32_t* index = nullptr;
+    auto& table = encoder->hpack_table();
+    if (static_cast<size_t>(value) < N) {
+      index = &previously_sent_[static_cast<uint32_t>(value)];
+      if (table.ConvertableToDynamicIndex(*index)) {
+        encoder->EmitIndexed(table.DynamicIndex(*index));
+        return;
+      }
+    }
+    auto key = Slice::FromStaticString(MetadataTrait::key());
+    auto encoded_value = MetadataTrait::Encode(value);
+    if (index != nullptr) {
+      *index = encoder->EmitLitHdrWithNonBinaryStringKeyIncIdx(
+          std::move(key), std::move(encoded_value));
+    } else {
+      encoder->EmitLitHdrWithNonBinaryStringKeyNotIdx(std::move(key),
+                                                      std::move(encoded_value));
+    }
+  }
+
+ private:
+  uint32_t previously_sent_[N] = {};
+};
+
+class SliceIndex {
+ public:
+  void EmitTo(absl::string_view key, const Slice& value, Encoder* encoder);
+
+ private:
+  struct ValueIndex {
+    ValueIndex(Slice value, uint32_t index)
+        : value(std::move(value)), index(index) {}
+    Slice value;
+    uint32_t index;
+  };
+  std::vector<ValueIndex> values_;
+};
+
+template <typename MetadataTrait>
+class Compressor<MetadataTrait, SmallSetOfValuesCompressor> {
+ public:
+  void EncodeWith(MetadataTrait, const Slice& value, Encoder* encoder) {
+    index_.EmitTo(MetadataTrait::key(), value, encoder);
+  }
+
+ private:
+  SliceIndex index_;
+};
+
+struct PreviousTimeout {
+  Timeout timeout;
+  uint32_t index;
+};
+
+class TimeoutCompressorImpl {
+ public:
+  void EncodeWith(absl::string_view key, Timestamp deadline, Encoder* encoder);
+
+ private:
+  std::vector<PreviousTimeout> previous_timeouts_;
+};
+
+template <typename MetadataTrait>
+class Compressor<MetadataTrait, TimeoutCompressor>
+    : public TimeoutCompressorImpl {
+ public:
+  void EncodeWith(MetadataTrait, const typename MetadataTrait::ValueType& value,
+                  Encoder* encoder) {
+    TimeoutCompressorImpl::EncodeWith(MetadataTrait::key(), value, encoder);
+  }
+};
+
+template <>
+class Compressor<HttpStatusMetadata, HttpStatusCompressor> {
+ public:
+  void EncodeWith(HttpStatusMetadata, uint32_t status, Encoder* encoder);
+};
+
+template <>
+class Compressor<HttpMethodMetadata, HttpMethodCompressor> {
+ public:
+  void EncodeWith(HttpMethodMetadata, HttpMethodMetadata::ValueType method,
+                  Encoder* encoder);
+};
+
+template <>
+class Compressor<HttpSchemeMetadata, HttpSchemeCompressor> {
+ public:
+  void EncodeWith(HttpSchemeMetadata, HttpSchemeMetadata::ValueType value,
+                  Encoder* encoder);
+};
+
+}  // namespace hpack_encoder_detail
+
 class HPackCompressor {
   class SliceIndex;
 
@@ -63,104 +347,26 @@ class HPackCompressor {
   template <typename HeaderSet>
   void EncodeHeaders(const EncodeHeaderOptions& options,
                      const HeaderSet& headers, grpc_slice_buffer* output) {
-    Framer framer(options, this, output);
-    headers.Encode(&framer);
+    SliceBuffer raw;
+    hpack_encoder_detail::Encoder encoder(
+        this, options.use_true_binary_metadata, raw);
+    headers.Encode(&encoder);
+    Frame(options, raw, output);
   }
 
-  class Framer {
-   public:
-    Framer(const EncodeHeaderOptions& options, HPackCompressor* compressor,
-           grpc_slice_buffer* output);
-    ~Framer() { FinishFrame(true); }
-
-    Framer(const Framer&) = delete;
-    Framer& operator=(const Framer&) = delete;
-
-    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(
-          Slice::FromStaticString("grpc-message"), slice.Ref());
-    }
-    template <typename Which>
-    void Encode(Which, const typename Which::ValueType& value) {
-      const Slice& slice = MetadataValueAsSlice<Which>(value);
-      if (absl::EndsWith(Which::key(), "-bin")) {
-        EmitLitHdrWithBinaryStringKeyNotIdx(
-            Slice::FromStaticString(Which::key()), slice.Ref());
-      } else {
-        EmitLitHdrWithNonBinaryStringKeyNotIdx(
-            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;
-      // number of bytes in 'output' when we started the frame - used to
-      // calculate frame length
-      size_t output_length_at_start_of_frame;
-    };
-
-    FramePrefix BeginFrame();
-    void FinishFrame(bool is_header_boundary);
-    void EnsureSpace(size_t need_bytes);
-
-    void AdvertiseTableSizeChange();
-    void EmitIndexed(uint32_t index);
-    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(Slice slice);
-    uint8_t* AddTiny(size_t len);
-
-    // maximum size of a frame
-    const size_t max_frame_size_;
-    bool is_first_frame_ = true;
-    const bool use_true_binary_metadata_;
-    const bool is_end_of_stream_;
-    // output stream id
-    const uint32_t stream_id_;
-    grpc_slice_buffer* const output_;
-    grpc_transport_one_way_stats* const stats_;
-    HPackCompressor* const compressor_;
-    FramePrefix prefix_;
-  };
+  template <typename HeaderSet>
+  void EncodeRawHeaders(const HeaderSet& headers, SliceBuffer& output) {
+    hpack_encoder_detail::Encoder encoder(this, true, output);
+    headers.Encode(&encoder);
+  }
 
  private:
   static constexpr size_t kNumFilterValues = 64;
   static constexpr uint32_t kNumCachedGrpcStatusValues = 16;
+  friend class hpack_encoder_detail::Encoder;
+
+  void Frame(const EncodeHeaderOptions& options, SliceBuffer& raw,
+             grpc_slice_buffer* output);
 
   // maximum number of bytes we'll use for the decode table (to guard against
   // peers ooming us by setting decode table size high)
@@ -170,50 +376,24 @@ class HPackCompressor {
   bool advertise_table_size_change_ = false;
   HPackEncoderTable table_;
 
-  class SliceIndex {
-   public:
-    void EmitTo(absl::string_view key, const Slice& value, Framer* framer);
-
-   private:
-    struct ValueIndex {
-      ValueIndex(Slice value, uint32_t index)
-          : value(std::move(value)), index(index) {}
-      Slice value;
-      uint32_t index;
-    };
-    std::vector<ValueIndex> values_;
-  };
+  grpc_metadata_batch::StatefulCompressor<hpack_encoder_detail::Compressor>
+      compression_state_;
+};
 
-  struct PreviousTimeout {
-    Timeout timeout;
-    uint32_t index;
-  };
+namespace hpack_encoder_detail {
 
-  // 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_;
-};
+template <typename MetadataTrait>
+void Encoder::Encode(MetadataTrait,
+                     const typename MetadataTrait::ValueType& value) {
+  compressor_->compression_state_
+      .Compressor<MetadataTrait, typename MetadataTrait::CompressionTraits>::
+          EncodeWith(MetadataTrait(), value, this);
+}
+
+inline HPackEncoderTable& Encoder::hpack_table() { return compressor_->table_; }
+
+}  // namespace hpack_encoder_detail
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_H */
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_H

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

@@ -16,11 +16,15 @@
 
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder_table.h"
 
+#include <algorithm>
+
 #include <grpc/support/log.h>
 
 namespace grpc_core {
 
 uint32_t HPackEncoderTable::AllocateIndex(size_t element_size) {
+  GPR_DEBUG_ASSERT(element_size >= 32);
+
   uint32_t new_index = tail_remote_index_ + table_elems_ + 1;
   GPR_DEBUG_ASSERT(element_size <= MaxEntrySize());
 
@@ -58,7 +62,8 @@ bool HPackEncoderTable::SetMaxSize(uint32_t max_table_size) {
       hpack_constants::EntriesForBytes(max_table_size);
   // TODO(ctiller): integrate with ResourceQuota to rebuild smaller when we can.
   if (max_table_elems > elem_size_.size()) {
-    Rebuild(std::max(max_table_elems, 2 * elem_size_.size()));
+    Rebuild(static_cast<uint32_t>(
+        std::max(max_table_elems, 2 * elem_size_.size())));
   }
   return true;
 }

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

@@ -12,11 +12,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_TABLE_H
-#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_TABLE_H
+#ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_TABLE_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_TABLE_H
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+#include <stdint.h>
+
+#include <limits>
+
 #include "absl/container/inlined_vector.h"
 
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
@@ -27,9 +32,13 @@ namespace grpc_core {
 // sizes.
 class HPackEncoderTable {
  public:
+  using EntrySize = uint16_t;
+
   HPackEncoderTable() : elem_size_(hpack_constants::kInitialTableEntries) {}
 
-  static constexpr size_t MaxEntrySize() { return 65535; }
+  static constexpr size_t MaxEntrySize() {
+    return std::numeric_limits<EntrySize>::max();
+  }
 
   // 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
@@ -41,6 +50,8 @@ class HPackEncoderTable {
   uint32_t max_size() const { return max_table_size_; }
   // Get the current table size
   uint32_t test_only_table_size() const { return table_size_; }
+  // Get the number of entries in the table
+  uint32_t test_only_table_elems() const { return table_elems_; }
 
   // Convert an element index into a dynamic index
   uint32_t DynamicIndex(uint32_t index) const {
@@ -62,10 +73,10 @@ class HPackEncoderTable {
   uint32_t table_elems_ = 0;
   uint32_t table_size_ = 0;
   // The size of each element in the HPACK table.
-  absl::InlinedVector<uint16_t, hpack_constants::kInitialTableEntries>
+  absl::InlinedVector<EntrySize, hpack_constants::kInitialTableEntries>
       elem_size_;
 };
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_TABLE_H
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_TABLE_H