grpc 1.53.2 → 1.54.0

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

@@ -109,56 +109,33 @@ void HPackCompressor::Frame(const EncodeHeaderOptions& options,
   }
 }
 
-void HPackCompressor::SetMaxUsableSize(uint32_t max_table_size) {
-  max_usable_size_ = max_table_size;
-  SetMaxTableSize(std::min(table_.max_size(), max_table_size));
-}
-
-void HPackCompressor::SetMaxTableSize(uint32_t max_table_size) {
-  if (table_.SetMaxSize(std::min(max_usable_size_, max_table_size))) {
-    advertise_table_size_change_ = true;
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
-      gpr_log(GPR_INFO, "set max table size from encoder to %d",
-              max_table_size);
-    }
-  }
+void HPackCompressor::Encoder::EmitIndexed(uint32_t elem_index) {
+  VarintWriter<1> w(elem_index);
+  w.Write(0x80, output_.AddTiny(w.length()));
 }
 
-namespace {
 struct WireValue {
   WireValue(uint8_t huffman_prefix, bool insert_null_before_wire_value,
             Slice slice)
       : data(std::move(slice)),
         huffman_prefix(huffman_prefix),
         insert_null_before_wire_value(insert_null_before_wire_value),
-        length(data.length() + (insert_null_before_wire_value ? 1 : 0)),
-        hpack_length(length) {}
-  WireValue(uint8_t huffman_prefix, bool insert_null_before_wire_value,
-            Slice slice, size_t hpack_length)
-      : data(std::move(slice)),
-        huffman_prefix(huffman_prefix),
-        insert_null_before_wire_value(insert_null_before_wire_value),
-        length(data.length() + (insert_null_before_wire_value ? 1 : 0)),
-        hpack_length(hpack_length + (insert_null_before_wire_value ? 1 : 0)) {}
+        length(data.length() + (insert_null_before_wire_value ? 1 : 0)) {}
   Slice data;
   const uint8_t huffman_prefix;
   const bool insert_null_before_wire_value;
   const size_t length;
-  const size_t hpack_length;
 };
 
-// Construct a wire value from a slice.
-// true_binary_enabled => use the true binary system
-// is_bin_hdr => the header is -bin suffixed
-WireValue GetWireValue(Slice value, bool true_binary_enabled, bool is_bin_hdr) {
+static WireValue GetWireValue(Slice value, bool true_binary_enabled,
+                              bool is_bin_hdr) {
   if (is_bin_hdr) {
     if (true_binary_enabled) {
       return WireValue(0x00, true, std::move(value));
     } else {
-      uint32_t hpack_length;
-      Slice output(grpc_chttp2_base64_encode_and_huffman_compress(
-          value.c_slice(), &hpack_length));
-      return WireValue(0x80, false, std::move(output), hpack_length);
+      return WireValue(0x80, false,
+                       Slice(grpc_chttp2_base64_encode_and_huffman_compress(
+                           value.c_slice())));
     }
   } else {
     // TODO(ctiller): opportunistically compress non-binary headers
@@ -198,8 +175,6 @@ class BinaryStringValue {
 
   Slice data() { return std::move(wire_value_.data); }
 
-  uint32_t hpack_length() { return wire_value_.hpack_length; }
-
  private:
   WireValue wire_value_;
   VarintWriter<1> len_val_;
@@ -239,33 +214,19 @@ class StringKey {
   Slice key_;
   VarintWriter<1> len_key_;
 };
-}  // namespace
 
-namespace hpack_encoder_detail {
-void Encoder::EmitIndexed(uint32_t elem_index) {
-  VarintWriter<1> w(elem_index);
-  w.Write(0x80, output_.AddTiny(w.length()));
-}
-
-uint32_t Encoder::EmitLitHdrWithNonBinaryStringKeyIncIdx(Slice key_slice,
-                                                         Slice value_slice) {
-  auto key_len = key_slice.length();
-  auto value_len = value_slice.length();
+void HPackCompressor::Encoder::EmitLitHdrWithNonBinaryStringKeyIncIdx(
+    Slice key_slice, Slice value_slice) {
   StringKey key(std::move(key_slice));
   key.WritePrefix(0x40, output_.AddTiny(key.prefix_length()));
   output_.Append(key.key());
   NonBinaryStringValue emit(std::move(value_slice));
   emit.WritePrefix(output_.AddTiny(emit.prefix_length()));
-  // Allocate an index in the hpack table for this newly emitted entry.
-  // (we do so here because we know the length of the key and value)
-  uint32_t index = compressor_->table_.AllocateIndex(
-      key_len + value_len + hpack_constants::kEntryOverhead);
   output_.Append(emit.data());
-  return index;
 }
 
-void Encoder::EmitLitHdrWithBinaryStringKeyNotIdx(Slice key_slice,
-                                                  Slice value_slice) {
+void HPackCompressor::Encoder::EmitLitHdrWithBinaryStringKeyNotIdx(
+    Slice key_slice, Slice value_slice) {
   StringKey key(std::move(key_slice));
   key.WritePrefix(0x00, output_.AddTiny(key.prefix_length()));
   output_.Append(key.key());
@@ -274,24 +235,18 @@ void Encoder::EmitLitHdrWithBinaryStringKeyNotIdx(Slice key_slice,
   output_.Append(emit.data());
 }
 
-uint32_t Encoder::EmitLitHdrWithBinaryStringKeyIncIdx(Slice key_slice,
-                                                      Slice value_slice) {
-  auto key_len = key_slice.length();
+void HPackCompressor::Encoder::EmitLitHdrWithBinaryStringKeyIncIdx(
+    Slice key_slice, Slice value_slice) {
   StringKey key(std::move(key_slice));
   key.WritePrefix(0x40, output_.AddTiny(key.prefix_length()));
   output_.Append(key.key());
   BinaryStringValue emit(std::move(value_slice), use_true_binary_metadata_);
   emit.WritePrefix(output_.AddTiny(emit.prefix_length()));
-  // Allocate an index in the hpack table for this newly emitted entry.
-  // (we do so here because we know the length of the key and value)
-  uint32_t index = compressor_->table_.AllocateIndex(
-      key_len + emit.hpack_length() + hpack_constants::kEntryOverhead);
   output_.Append(emit.data());
-  return index;
 }
 
-void Encoder::EmitLitHdrWithBinaryStringKeyNotIdx(uint32_t key_index,
-                                                  Slice value_slice) {
+void HPackCompressor::Encoder::EmitLitHdrWithBinaryStringKeyNotIdx(
+    uint32_t key_index, Slice value_slice) {
   BinaryStringValue emit(std::move(value_slice), use_true_binary_metadata_);
   VarintWriter<4> key(key_index);
   uint8_t* data = output_.AddTiny(key.length() + emit.prefix_length());
@@ -300,8 +255,8 @@ void Encoder::EmitLitHdrWithBinaryStringKeyNotIdx(uint32_t key_index,
   output_.Append(emit.data());
 }
 
-void Encoder::EmitLitHdrWithNonBinaryStringKeyNotIdx(Slice key_slice,
-                                                     Slice value_slice) {
+void HPackCompressor::Encoder::EmitLitHdrWithNonBinaryStringKeyNotIdx(
+    Slice key_slice, Slice value_slice) {
   StringKey key(std::move(key_slice));
   key.WritePrefix(0x00, output_.AddTiny(key.prefix_length()));
   output_.Append(key.key());
@@ -310,14 +265,14 @@ void Encoder::EmitLitHdrWithNonBinaryStringKeyNotIdx(Slice key_slice,
   output_.Append(emit.data());
 }
 
-void Encoder::AdvertiseTableSizeChange() {
+void HPackCompressor::Encoder::AdvertiseTableSizeChange() {
   VarintWriter<3> w(compressor_->table_.max_size());
   w.Write(0x20, output_.AddTiny(w.length()));
 }
 
-void SliceIndex::EmitTo(absl::string_view key, const Slice& value,
-                        Encoder* encoder) {
-  auto& table = encoder->hpack_table();
+void HPackCompressor::SliceIndex::EmitTo(absl::string_view key,
+                                         const Slice& value, Encoder* encoder) {
+  auto& table = encoder->compressor_->table_;
   using It = std::vector<ValueIndex>::iterator;
   It prev = values_.end();
   size_t transport_length =
@@ -336,7 +291,8 @@ void SliceIndex::EmitTo(absl::string_view key, const Slice& value,
         encoder->EmitIndexed(table.DynamicIndex(it->index));
       } else {
         // Not current, emit a new literal and update the index.
-        it->index = encoder->EmitLitHdrWithNonBinaryStringKeyIncIdx(
+        it->index = table.AllocateIndex(transport_length);
+        encoder->EmitLitHdrWithNonBinaryStringKeyIncIdx(
             Slice::FromStaticString(key), value.Ref());
       }
       // Bubble this entry up if we can - ensures that the most used values end
@@ -354,12 +310,13 @@ void SliceIndex::EmitTo(absl::string_view key, const Slice& value,
     prev = it;
   }
   // No hit, emit a new literal and add it to the index.
-  uint32_t index = encoder->EmitLitHdrWithNonBinaryStringKeyIncIdx(
-      Slice::FromStaticString(key), value.Ref());
+  uint32_t index = table.AllocateIndex(transport_length);
+  encoder->EmitLitHdrWithNonBinaryStringKeyIncIdx(Slice::FromStaticString(key),
+                                                  value.Ref());
   values_.emplace_back(value.Ref(), index);
 }
 
-void Encoder::Encode(const Slice& key, const Slice& value) {
+void HPackCompressor::Encoder::Encode(const Slice& key, const Slice& value) {
   if (absl::EndsWith(key.as_string_view(), "-bin")) {
     EmitLitHdrWithBinaryStringKeyNotIdx(key.Ref(), value.Ref());
   } else {
@@ -367,14 +324,43 @@ void Encoder::Encode(const Slice& key, const Slice& value) {
   }
 }
 
-void Compressor<HttpSchemeMetadata, HttpSchemeCompressor>::EncodeWith(
-    HttpSchemeMetadata, HttpSchemeMetadata::ValueType value, Encoder* encoder) {
+void HPackCompressor::Encoder::Encode(HttpPathMetadata, const Slice& value) {
+  compressor_->path_index_.EmitTo(HttpPathMetadata::key(), value, this);
+}
+
+void HPackCompressor::Encoder::Encode(HttpAuthorityMetadata,
+                                      const Slice& value) {
+  compressor_->authority_index_.EmitTo(HttpAuthorityMetadata::key(), value,
+                                       this);
+}
+
+void HPackCompressor::Encoder::Encode(TeMetadata, TeMetadata::ValueType value) {
+  GPR_ASSERT(value == TeMetadata::ValueType::kTrailers);
+  EncodeAlwaysIndexed(
+      &compressor_->te_index_, "te", Slice::FromStaticString("trailers"),
+      2 /* te */ + 8 /* trailers */ + hpack_constants::kEntryOverhead);
+}
+
+void HPackCompressor::Encoder::Encode(ContentTypeMetadata,
+                                      ContentTypeMetadata::ValueType value) {
+  if (value != ContentTypeMetadata::ValueType::kApplicationGrpc) {
+    gpr_log(GPR_ERROR, "Not encoding bad content-type header");
+    return;
+  }
+  EncodeAlwaysIndexed(&compressor_->content_type_index_, "content-type",
+                      Slice::FromStaticString("application/grpc"),
+                      12 /* content-type */ + 16 /* application/grpc */ +
+                          hpack_constants::kEntryOverhead);
+}
+
+void HPackCompressor::Encoder::Encode(HttpSchemeMetadata,
+                                      HttpSchemeMetadata::ValueType value) {
   switch (value) {
     case HttpSchemeMetadata::ValueType::kHttp:
-      encoder->EmitIndexed(6);  // :scheme: http
+      EmitIndexed(6);  // :scheme: http
       break;
     case HttpSchemeMetadata::ValueType::kHttps:
-      encoder->EmitIndexed(7);  // :scheme: https
+      EmitIndexed(7);  // :scheme: https
       break;
     case HttpSchemeMetadata::ValueType::kInvalid:
       Crash("invalid http scheme encoding");
@@ -382,10 +368,22 @@ void Compressor<HttpSchemeMetadata, HttpSchemeCompressor>::EncodeWith(
   }
 }
 
-void Compressor<HttpStatusMetadata, HttpStatusCompressor>::EncodeWith(
-    HttpStatusMetadata, uint32_t status, Encoder* encoder) {
+void HPackCompressor::Encoder::Encode(GrpcTraceBinMetadata,
+                                      const Slice& slice) {
+  EncodeRepeatingSliceValue(GrpcTraceBinMetadata::key(), slice,
+                            &compressor_->grpc_trace_bin_index_,
+                            HPackEncoderTable::MaxEntrySize());
+}
+
+void HPackCompressor::Encoder::Encode(GrpcTagsBinMetadata, const Slice& slice) {
+  EncodeRepeatingSliceValue(GrpcTagsBinMetadata::key(), slice,
+                            &compressor_->grpc_tags_bin_index_,
+                            HPackEncoderTable::MaxEntrySize());
+}
+
+void HPackCompressor::Encoder::Encode(HttpStatusMetadata, uint32_t status) {
   if (status == 200) {
-    encoder->EmitIndexed(8);  // :status: 200
+    EmitIndexed(8);  // :status: 200
     return;
   }
   uint8_t index = 0;
@@ -410,28 +408,27 @@ void Compressor<HttpStatusMetadata, HttpStatusCompressor>::EncodeWith(
       break;
   }
   if (GPR_LIKELY(index != 0)) {
-    encoder->EmitIndexed(index);
+    EmitIndexed(index);
   } else {
-    encoder->EmitLitHdrWithNonBinaryStringKeyNotIdx(
-        Slice::FromStaticString(":status"), Slice::FromInt64(status));
+    EmitLitHdrWithNonBinaryStringKeyIncIdx(Slice::FromStaticString(":status"),
+                                           Slice::FromInt64(status));
   }
 }
 
-void Compressor<HttpMethodMetadata, HttpMethodCompressor>::EncodeWith(
-    HttpMethodMetadata, HttpMethodMetadata::ValueType method,
-    Encoder* encoder) {
+void HPackCompressor::Encoder::Encode(HttpMethodMetadata,
+                                      HttpMethodMetadata::ValueType method) {
   switch (method) {
     case HttpMethodMetadata::ValueType::kPost:
-      encoder->EmitIndexed(3);  // :method: POST
+      EmitIndexed(3);  // :method: POST
       break;
     case HttpMethodMetadata::ValueType::kGet:
-      encoder->EmitIndexed(2);  // :method: GET
+      EmitIndexed(2);  // :method: GET
       break;
     case HttpMethodMetadata::ValueType::kPut:
       // Right now, we only emit PUT as a method for testing purposes, so it's
       // fine to not index it.
-      encoder->EmitLitHdrWithNonBinaryStringKeyNotIdx(
-          Slice::FromStaticString(":method"), Slice::FromStaticString("PUT"));
+      EmitLitHdrWithNonBinaryStringKeyNotIdx(Slice::FromStaticString(":method"),
+                                             Slice::FromStaticString("PUT"));
       break;
     case HttpMethodMetadata::ValueType::kInvalid:
       Crash("invalid http method encoding");
@@ -439,31 +436,35 @@ void Compressor<HttpMethodMetadata, HttpMethodCompressor>::EncodeWith(
   }
 }
 
-void Encoder::EncodeAlwaysIndexed(uint32_t* index, absl::string_view key,
-                                  Slice value, size_t) {
+void HPackCompressor::Encoder::EncodeAlwaysIndexed(uint32_t* index,
+                                                   absl::string_view key,
+                                                   Slice value,
+                                                   size_t transport_length) {
   if (compressor_->table_.ConvertableToDynamicIndex(*index)) {
     EmitIndexed(compressor_->table_.DynamicIndex(*index));
   } else {
-    *index = EmitLitHdrWithNonBinaryStringKeyIncIdx(
-        Slice::FromStaticString(key), std::move(value));
+    *index = compressor_->table_.AllocateIndex(transport_length);
+    EmitLitHdrWithNonBinaryStringKeyIncIdx(Slice::FromStaticString(key),
+                                           std::move(value));
   }
 }
 
-void Encoder::EncodeIndexedKeyWithBinaryValue(uint32_t* index,
-                                              absl::string_view key,
-                                              Slice value) {
+void HPackCompressor::Encoder::EncodeIndexedKeyWithBinaryValue(
+    uint32_t* index, absl::string_view key, Slice value) {
   if (compressor_->table_.ConvertableToDynamicIndex(*index)) {
     EmitLitHdrWithBinaryStringKeyNotIdx(
         compressor_->table_.DynamicIndex(*index), std::move(value));
   } else {
-    *index = EmitLitHdrWithBinaryStringKeyIncIdx(Slice::FromStaticString(key),
-                                                 std::move(value));
+    *index = compressor_->table_.AllocateIndex(key.length() + value.length() +
+                                               hpack_constants::kEntryOverhead);
+    EmitLitHdrWithBinaryStringKeyIncIdx(Slice::FromStaticString(key),
+                                        std::move(value));
   }
 }
 
-void Encoder::EncodeRepeatingSliceValue(const absl::string_view& key,
-                                        const Slice& slice, uint32_t* index,
-                                        size_t max_compression_size) {
+void HPackCompressor::Encoder::EncodeRepeatingSliceValue(
+    const absl::string_view& key, const Slice& slice, uint32_t* index,
+    size_t max_compression_size) {
   if (hpack_constants::SizeForEntry(key.size(), slice.size()) >
       max_compression_size) {
     EmitLitHdrWithBinaryStringKeyNotIdx(Slice::FromStaticString(key),
@@ -473,37 +474,141 @@ void Encoder::EncodeRepeatingSliceValue(const absl::string_view& key,
   }
 }
 
-void TimeoutCompressorImpl::EncodeWith(absl::string_view key,
-                                       Timestamp deadline, Encoder* encoder) {
+void HPackCompressor::Encoder::Encode(GrpcTimeoutMetadata, Timestamp deadline) {
   Timeout timeout = Timeout::FromDuration(deadline - Timestamp::Now());
-  auto& table = encoder->hpack_table();
-  for (auto it = previous_timeouts_.begin(); it != previous_timeouts_.end();
-       ++it) {
+  for (auto it = compressor_->previous_timeouts_.begin();
+       it != compressor_->previous_timeouts_.end(); ++it) {
     double ratio = timeout.RatioVersus(it->timeout);
     // If the timeout we're sending is shorter than a previous timeout, but
     // within 3% of it, we'll consider sending it.
     if (ratio > -3 && ratio <= 0 &&
-        table.ConvertableToDynamicIndex(it->index)) {
-      encoder->EmitIndexed(table.DynamicIndex(it->index));
+        compressor_->table_.ConvertableToDynamicIndex(it->index)) {
+      EmitIndexed(compressor_->table_.DynamicIndex(it->index));
       // Put this timeout to the front of the queue - forces common timeouts to
       // be considered earlier.
-      std::swap(*it, *previous_timeouts_.begin());
+      std::swap(*it, *compressor_->previous_timeouts_.begin());
       return;
     }
   }
   // Clean out some expired timeouts.
-  while (!previous_timeouts_.empty() &&
-         !table.ConvertableToDynamicIndex(previous_timeouts_.back().index)) {
-    previous_timeouts_.pop_back();
+  while (!compressor_->previous_timeouts_.empty() &&
+         !compressor_->table_.ConvertableToDynamicIndex(
+             compressor_->previous_timeouts_.back().index)) {
+    compressor_->previous_timeouts_.pop_back();
   }
   Slice encoded = timeout.Encode();
-  uint32_t index = encoder->EmitLitHdrWithNonBinaryStringKeyIncIdx(
-      Slice::FromStaticString(key), std::move(encoded));
-  previous_timeouts_.push_back(PreviousTimeout{timeout, index});
+  uint32_t index = compressor_->table_.AllocateIndex(
+      GrpcTimeoutMetadata::key().length() + encoded.length() +
+      hpack_constants::kEntryOverhead);
+  compressor_->previous_timeouts_.push_back(PreviousTimeout{timeout, index});
+  EmitLitHdrWithNonBinaryStringKeyIncIdx(
+      Slice::FromStaticString(GrpcTimeoutMetadata::key()), std::move(encoded));
+}
+
+void HPackCompressor::Encoder::Encode(UserAgentMetadata, const Slice& slice) {
+  if (hpack_constants::SizeForEntry(UserAgentMetadata::key().size(),
+                                    slice.size()) >
+      HPackEncoderTable::MaxEntrySize()) {
+    EmitLitHdrWithNonBinaryStringKeyNotIdx(
+        Slice::FromStaticString(UserAgentMetadata::key()), slice.Ref());
+    return;
+  }
+  if (!slice.is_equivalent(compressor_->user_agent_)) {
+    compressor_->user_agent_ = slice.Ref();
+    compressor_->user_agent_index_ = 0;
+  }
+  EncodeAlwaysIndexed(&compressor_->user_agent_index_, UserAgentMetadata::key(),
+                      slice.Ref(),
+                      hpack_constants::SizeForEntry(
+                          UserAgentMetadata::key().size(), slice.size()));
+}
+
+void HPackCompressor::Encoder::Encode(GrpcStatusMetadata,
+                                      grpc_status_code status) {
+  const uint32_t code = static_cast<uint32_t>(status);
+  uint32_t* index = nullptr;
+  if (code < kNumCachedGrpcStatusValues) {
+    index = &compressor_->cached_grpc_status_[code];
+    if (compressor_->table_.ConvertableToDynamicIndex(*index)) {
+      EmitIndexed(compressor_->table_.DynamicIndex(*index));
+      return;
+    }
+  }
+  Slice key = Slice::FromStaticString(GrpcStatusMetadata::key());
+  Slice value = Slice::FromInt64(code);
+  const size_t transport_length =
+      key.length() + value.length() + hpack_constants::kEntryOverhead;
+  if (index != nullptr) {
+    *index = compressor_->table_.AllocateIndex(transport_length);
+    EmitLitHdrWithNonBinaryStringKeyIncIdx(std::move(key), std::move(value));
+  } else {
+    EmitLitHdrWithNonBinaryStringKeyNotIdx(std::move(key), std::move(value));
+  }
+}
+
+void HPackCompressor::Encoder::Encode(GrpcEncodingMetadata,
+                                      grpc_compression_algorithm value) {
+  uint32_t* index = nullptr;
+  if (value < GRPC_COMPRESS_ALGORITHMS_COUNT) {
+    index = &compressor_->cached_grpc_encoding_[static_cast<uint32_t>(value)];
+    if (compressor_->table_.ConvertableToDynamicIndex(*index)) {
+      EmitIndexed(compressor_->table_.DynamicIndex(*index));
+      return;
+    }
+  }
+  auto key = Slice::FromStaticString(GrpcEncodingMetadata::key());
+  auto encoded_value = GrpcEncodingMetadata::Encode(value);
+  size_t transport_length =
+      key.length() + encoded_value.length() + hpack_constants::kEntryOverhead;
+  if (index != nullptr) {
+    *index = compressor_->table_.AllocateIndex(transport_length);
+    EmitLitHdrWithNonBinaryStringKeyIncIdx(std::move(key),
+                                           std::move(encoded_value));
+  } else {
+    EmitLitHdrWithNonBinaryStringKeyNotIdx(std::move(key),
+                                           std::move(encoded_value));
+  }
+}
+
+void HPackCompressor::Encoder::Encode(GrpcAcceptEncodingMetadata,
+                                      CompressionAlgorithmSet value) {
+  if (compressor_->grpc_accept_encoding_index_ != 0 &&
+      value == compressor_->grpc_accept_encoding_ &&
+      compressor_->table_.ConvertableToDynamicIndex(
+          compressor_->grpc_accept_encoding_index_)) {
+    EmitIndexed(compressor_->table_.DynamicIndex(
+        compressor_->grpc_accept_encoding_index_));
+    return;
+  }
+  auto key = Slice::FromStaticString(GrpcAcceptEncodingMetadata::key());
+  auto encoded_value = GrpcAcceptEncodingMetadata::Encode(value);
+  size_t transport_length =
+      key.length() + encoded_value.length() + hpack_constants::kEntryOverhead;
+  compressor_->grpc_accept_encoding_index_ =
+      compressor_->table_.AllocateIndex(transport_length);
+  compressor_->grpc_accept_encoding_ = value;
+  EmitLitHdrWithNonBinaryStringKeyIncIdx(std::move(key),
+                                         std::move(encoded_value));
+}
+
+void HPackCompressor::SetMaxUsableSize(uint32_t max_table_size) {
+  max_usable_size_ = max_table_size;
+  SetMaxTableSize(std::min(table_.max_size(), max_table_size));
+}
+
+void HPackCompressor::SetMaxTableSize(uint32_t max_table_size) {
+  if (table_.SetMaxSize(std::min(max_usable_size_, max_table_size))) {
+    advertise_table_size_change_ = true;
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
+      gpr_log(GPR_INFO, "set max table size from encoder to %d",
+              max_table_size);
+    }
+  }
 }
 
-Encoder::Encoder(HPackCompressor* compressor, bool use_true_binary_metadata,
-                 SliceBuffer& output)
+HPackCompressor::Encoder::Encoder(HPackCompressor* compressor,
+                                  bool use_true_binary_metadata,
+                                  SliceBuffer& output)
     : use_true_binary_metadata_(use_true_binary_metadata),
       compressor_(compressor),
       output_(output) {
@@ -512,5 +617,4 @@ Encoder::Encoder(HPackCompressor* compressor, bool use_true_binary_metadata,
   }
 }
 
-}  // namespace hpack_encoder_detail
 }  // namespace grpc_core