grpc 1.42.0 → 1.43.1

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

@@ -46,6 +46,8 @@
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/profiling/timers.h"
+#include "src/core/lib/resource_quota/api.h"
+#include "src/core/lib/resource_quota/trace.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/transport/error_utils.h"
@@ -126,8 +128,6 @@ static void connectivity_state_set(grpc_chttp2_transport* t,
                                    const absl::Status& status,
                                    const char* reason);
 
-static void benign_reclaimer(void* arg, grpc_error_handle error);
-static void destructive_reclaimer(void* arg, grpc_error_handle error);
 static void benign_reclaimer_locked(void* arg, grpc_error_handle error);
 static void destructive_reclaimer_locked(void* arg, grpc_error_handle error);
 
@@ -442,14 +442,18 @@ static void init_keepalive_pings_if_enabled(grpc_chttp2_transport* t) {
 }
 
 grpc_chttp2_transport::grpc_chttp2_transport(
-    const grpc_channel_args* channel_args, grpc_endpoint* ep, bool is_client,
-    grpc_resource_user* resource_user)
+    const grpc_channel_args* channel_args, grpc_endpoint* ep, bool is_client)
     : refs(1, GRPC_TRACE_FLAG_ENABLED(grpc_trace_chttp2_refcount)
                   ? "chttp2_refcount"
                   : nullptr),
       ep(ep),
       peer_string(grpc_endpoint_get_peer(ep)),
-      resource_user(resource_user),
+      memory_owner(grpc_core::ResourceQuotaFromChannelArgs(channel_args)
+                       ->memory_quota()
+                       ->CreateMemoryOwner(absl::StrCat(
+                           grpc_endpoint_get_peer(ep), ":client_transport"))),
+      self_reservation(
+          memory_owner.MakeReservation(sizeof(grpc_chttp2_transport))),
       combiner(grpc_combiner_create()),
       state_tracker(is_client ? "client_transport" : "server_transport",
                     GRPC_CHANNEL_READY),
@@ -535,12 +539,11 @@ grpc_chttp2_transport::grpc_chttp2_transport(
 static void destroy_transport_locked(void* tp, grpc_error_handle /*error*/) {
   grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(tp);
   t->destroying = 1;
-  grpc_resource_user_shutdown(t->resource_user);
-  grpc_resource_user_unref(t->resource_user);
   close_transport_locked(
       t, grpc_error_set_int(
              GRPC_ERROR_CREATE_FROM_STATIC_STRING("Transport destroyed"),
              GRPC_ERROR_INT_OCCURRED_DURING_WRITE, t->write_state));
+  t->memory_owner.Reset();
   // Must be the last line.
   GRPC_CHTTP2_UNREF_TRANSPORT(t, "destroy");
 }
@@ -646,6 +649,10 @@ grpc_chttp2_stream::grpc_chttp2_stream(grpc_chttp2_transport* t,
     : t(t),
       refcount(refcount),
       reffer(this),
+      stream_reservation(t->memory_owner.MakeReservation(
+          grpc_core::kResourceQuotaCallSize)),  // TODO(ctiller): sizeof(*this),
+                                                // or better, move allocation to
+                                                // memory quota.
       initial_metadata_buffer(arena),
       trailing_metadata_buffer(arena) {
   if (server_data) {
@@ -712,9 +719,6 @@ grpc_chttp2_stream::~grpc_chttp2_stream() {
   GRPC_ERROR_UNREF(write_closed_error);
   GRPC_ERROR_UNREF(byte_stream_error);
   flow_control.Destroy();
-  if (!t->is_client) {
-    grpc_resource_user_free(t->resource_user, GRPC_RESOURCE_QUOTA_CALL_SIZE);
-  }
   GRPC_CHTTP2_UNREF_TRANSPORT(t, "stream");
   grpc_core::ExecCtx::Run(DEBUG_LOCATION, destroy_stream_arg, GRPC_ERROR_NONE);
 }
@@ -763,18 +767,6 @@ grpc_chttp2_stream* grpc_chttp2_parsing_accept_stream(grpc_chttp2_transport* t,
   if (t->accept_stream_cb == nullptr) {
     return nullptr;
   }
-  // Don't accept the stream if memory quota doesn't allow. Note that we should
-  // simply refuse the stream here instead of canceling the stream after it's
-  // accepted since the latter will create the call which costs much memory.
-  GPR_ASSERT(t->resource_user != nullptr);
-  if (!grpc_resource_user_safe_alloc(t->resource_user,
-                                     GRPC_RESOURCE_QUOTA_CALL_SIZE)) {
-    gpr_log(GPR_INFO, "Memory exhausted, rejecting the stream.");
-    grpc_chttp2_add_rst_stream_to_next_write(t, id, GRPC_HTTP2_REFUSED_STREAM,
-                                             nullptr);
-    grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
-    return nullptr;
-  }
   grpc_chttp2_stream* accepting = nullptr;
   GPR_ASSERT(t->accepting_stream == nullptr);
   t->accepting_stream = &accepting;
@@ -2110,10 +2102,9 @@ void grpc_chttp2_fake_status(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
                           GRPC_MDSTR_GRPC_STATUS,
                           grpc_core::UnmanagedMemorySlice(status_string)));
     if (!message.empty()) {
-      grpc_slice message_slice = grpc_slice_from_cpp_string(std::move(message));
-      GRPC_LOG_IF_ERROR("add_status_message",
-                        s->trailing_metadata_buffer.ReplaceOrAppend(
-                            GRPC_MDSTR_GRPC_MESSAGE, message_slice));
+      s->trailing_metadata_buffer.Set(
+          grpc_core::GrpcMessageMetadata(),
+          grpc_core::Slice::FromCopiedBuffer(message));
     }
     s->published_metadata[1] = GRPC_METADATA_SYNTHESIZED_FROM_FAKE;
     grpc_chttp2_maybe_complete_recv_trailing_metadata(t, s);
@@ -2999,11 +2990,10 @@ void Chttp2IncomingByteStream::NextLocked(void* arg,
     grpc_slice_buffer_swap(&s->frame_storage,
                            &s->unprocessed_incoming_frames_buffer);
     s->unprocessed_incoming_frames_decompressed = false;
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, bs->next_action_.on_complete,
-                            GRPC_ERROR_NONE);
+    ExecCtx::Run(DEBUG_LOCATION, bs->next_action_.on_complete, GRPC_ERROR_NONE);
   } else if (s->byte_stream_error != GRPC_ERROR_NONE) {
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, bs->next_action_.on_complete,
-                            GRPC_ERROR_REF(s->byte_stream_error));
+    ExecCtx::Run(DEBUG_LOCATION, bs->next_action_.on_complete,
+                 GRPC_ERROR_REF(s->byte_stream_error));
     if (s->data_parser.parsing_frame != nullptr) {
       s->data_parser.parsing_frame->Unref();
       s->data_parser.parsing_frame = nullptr;
@@ -3012,8 +3002,8 @@ void Chttp2IncomingByteStream::NextLocked(void* arg,
     if (bs->remaining_bytes_ != 0) {
       s->byte_stream_error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
           "Truncated message", &s->read_closed_error, 1);
-      grpc_core::ExecCtx::Run(DEBUG_LOCATION, bs->next_action_.on_complete,
-                              GRPC_ERROR_REF(s->byte_stream_error));
+      ExecCtx::Run(DEBUG_LOCATION, bs->next_action_.on_complete,
+                   GRPC_ERROR_REF(s->byte_stream_error));
       if (s->data_parser.parsing_frame != nullptr) {
         s->data_parser.parsing_frame->Unref();
         s->data_parser.parsing_frame = nullptr;
@@ -3101,8 +3091,7 @@ grpc_error_handle Chttp2IncomingByteStream::Pull(grpc_slice* slice) {
 
 void Chttp2IncomingByteStream::PublishError(grpc_error_handle error) {
   GPR_ASSERT(error != GRPC_ERROR_NONE);
-  grpc_core::ExecCtx::Run(DEBUG_LOCATION, stream_->on_next,
-                          GRPC_ERROR_REF(error));
+  ExecCtx::Run(DEBUG_LOCATION, stream_->on_next, GRPC_ERROR_REF(error));
   stream_->on_next = nullptr;
   GRPC_ERROR_UNREF(stream_->byte_stream_error);
   stream_->byte_stream_error = GRPC_ERROR_REF(error);
@@ -3156,10 +3145,19 @@ static void post_benign_reclaimer(grpc_chttp2_transport* t) {
   if (!t->benign_reclaimer_registered) {
     t->benign_reclaimer_registered = true;
     GRPC_CHTTP2_REF_TRANSPORT(t, "benign_reclaimer");
-    GRPC_CLOSURE_INIT(&t->benign_reclaimer_locked, benign_reclaimer, t,
-                      grpc_schedule_on_exec_ctx);
-    grpc_resource_user_post_reclaimer(t->resource_user, false,
-                                      &t->benign_reclaimer_locked);
+    t->memory_owner.PostReclaimer(
+        grpc_core::ReclamationPass::kBenign,
+        [t](absl::optional<grpc_core::ReclamationSweep> sweep) {
+          if (sweep.has_value()) {
+            GRPC_CLOSURE_INIT(&t->benign_reclaimer_locked,
+                              benign_reclaimer_locked, t,
+                              grpc_schedule_on_exec_ctx);
+            t->active_reclamation = std::move(*sweep);
+            t->combiner->Run(&t->benign_reclaimer_locked, GRPC_ERROR_NONE);
+          } else {
+            GRPC_CHTTP2_UNREF_TRANSPORT(t, "benign_reclaimer");
+          }
+        });
   }
 }
 
@@ -3167,20 +3165,22 @@ static void post_destructive_reclaimer(grpc_chttp2_transport* t) {
   if (!t->destructive_reclaimer_registered) {
     t->destructive_reclaimer_registered = true;
     GRPC_CHTTP2_REF_TRANSPORT(t, "destructive_reclaimer");
-    GRPC_CLOSURE_INIT(&t->destructive_reclaimer_locked, destructive_reclaimer,
-                      t, grpc_schedule_on_exec_ctx);
-    grpc_resource_user_post_reclaimer(t->resource_user, true,
-                                      &t->destructive_reclaimer_locked);
+    t->memory_owner.PostReclaimer(
+        grpc_core::ReclamationPass::kDestructive,
+        [t](absl::optional<grpc_core::ReclamationSweep> sweep) {
+          if (sweep.has_value()) {
+            GRPC_CLOSURE_INIT(&t->destructive_reclaimer_locked,
+                              destructive_reclaimer_locked, t,
+                              grpc_schedule_on_exec_ctx);
+            t->active_reclamation = std::move(*sweep);
+            t->combiner->Run(&t->destructive_reclaimer_locked, GRPC_ERROR_NONE);
+          } else {
+            GRPC_CHTTP2_UNREF_TRANSPORT(t, "benign_reclaimer");
+          }
+        });
   }
 }
 
-static void benign_reclaimer(void* arg, grpc_error_handle error) {
-  grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(arg);
-  t->combiner->Run(GRPC_CLOSURE_INIT(&t->benign_reclaimer_locked,
-                                     benign_reclaimer_locked, t, nullptr),
-                   GRPC_ERROR_REF(error));
-}
-
 static void benign_reclaimer_locked(void* arg, grpc_error_handle error) {
   grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(arg);
   if (error == GRPC_ERROR_NONE &&
@@ -3205,18 +3205,11 @@ static void benign_reclaimer_locked(void* arg, grpc_error_handle error) {
   }
   t->benign_reclaimer_registered = false;
   if (error != GRPC_ERROR_CANCELLED) {
-    grpc_resource_user_finish_reclamation(t->resource_user);
+    t->active_reclamation.Finish();
   }
   GRPC_CHTTP2_UNREF_TRANSPORT(t, "benign_reclaimer");
 }
 
-static void destructive_reclaimer(void* arg, grpc_error_handle error) {
-  grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(arg);
-  t->combiner->Run(GRPC_CLOSURE_INIT(&t->destructive_reclaimer_locked,
-                                     destructive_reclaimer_locked, t, nullptr),
-                   GRPC_ERROR_REF(error));
-}
-
 static void destructive_reclaimer_locked(void* arg, grpc_error_handle error) {
   grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(arg);
   size_t n = grpc_chttp2_stream_map_size(&t->stream_map);
@@ -3242,7 +3235,7 @@ static void destructive_reclaimer_locked(void* arg, grpc_error_handle error) {
     }
   }
   if (error != GRPC_ERROR_CANCELLED) {
-    grpc_resource_user_finish_reclamation(t->resource_user);
+    t->active_reclamation.Finish();
   }
   GRPC_CHTTP2_UNREF_TRANSPORT(t, "destructive_reclaimer");
 }
@@ -3325,10 +3318,8 @@ grpc_chttp2_transport_get_socket_node(grpc_transport* transport) {
 }
 
 grpc_transport* grpc_create_chttp2_transport(
-    const grpc_channel_args* channel_args, grpc_endpoint* ep, bool is_client,
-    grpc_resource_user* resource_user) {
-  auto t =
-      new grpc_chttp2_transport(channel_args, ep, is_client, resource_user);
+    const grpc_channel_args* channel_args, grpc_endpoint* ep, bool is_client) {
+  auto t = new grpc_chttp2_transport(channel_args, ep, is_client);
   return &t->base;
 }
 

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

@@ -38,8 +38,7 @@ extern bool g_flow_control_enabled;
 /// from the caller; if the caller still needs the resource_user after creating
 /// a transport, the caller must take another ref.
 grpc_transport* grpc_create_chttp2_transport(
-    const grpc_channel_args* channel_args, grpc_endpoint* ep, bool is_client,
-    grpc_resource_user* resource_user);
+    const grpc_channel_args* channel_args, grpc_endpoint* ep, bool is_client);
 
 grpc_core::RefCountedPtr<grpc_core::channelz::SocketNode>
 grpc_chttp2_transport_get_socket_node(grpc_transport* transport);

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

@@ -40,8 +40,7 @@ void ContextList::Append(ContextList** head, grpc_chttp2_stream* s) {
   *head = elem;
 }
 
-void ContextList::Execute(void* arg, grpc_core::Timestamps* ts,
-                          grpc_error_handle error) {
+void ContextList::Execute(void* arg, Timestamps* ts, grpc_error_handle error) {
   ContextList* head = static_cast<ContextList*>(arg);
   ContextList* to_be_freed;
   while (head != nullptr) {
@@ -58,7 +57,7 @@ void ContextList::Execute(void* arg, grpc_core::Timestamps* ts,
 }
 
 void grpc_http2_set_write_timestamps_callback(
-    void (*fn)(void*, grpc_core::Timestamps*, grpc_error_handle error)) {
+    void (*fn)(void*, Timestamps*, grpc_error_handle error)) {
   write_timestamps_callback_g = fn;
 }
 

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

@@ -35,8 +35,7 @@ class ContextList {
   /* Executes a function \a fn with each context in the list and \a ts. It also
    * frees up the entire list after this operation. It is intended as a callback
    * and hence does not take a ref on \a error */
-  static void Execute(void* arg, grpc_core::Timestamps* ts,
-                      grpc_error_handle error);
+  static void Execute(void* arg, Timestamps* ts, grpc_error_handle error);
 
  private:
   void* trace_context_ = nullptr;
@@ -45,7 +44,7 @@ class ContextList {
 };
 
 void grpc_http2_set_write_timestamps_callback(
-    void (*fn)(void*, grpc_core::Timestamps*, grpc_error_handle error));
+    void (*fn)(void*, Timestamps*, grpc_error_handle error));
 void grpc_http2_set_fn_get_copied_context(void* (*fn)(void*));
 } /* namespace grpc_core */
 

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

@@ -47,10 +47,10 @@ bool g_test_only_transport_flow_control_window_check;
 
 namespace {
 
-static constexpr const int kTracePadding = 30;
-static constexpr const int64_t kMaxWindowUpdateSize = (1u << 31) - 1;
+constexpr const int kTracePadding = 30;
+constexpr const int64_t kMaxWindowUpdateSize = (1u << 31) - 1;
 
-static char* fmt_int64_diff_str(int64_t old_val, int64_t new_val) {
+char* fmt_int64_diff_str(int64_t old_val, int64_t new_val) {
   std::string str;
   if (old_val != new_val) {
     str = absl::StrFormat("%" PRId64 " -> %" PRId64 "", old_val, new_val);
@@ -60,7 +60,7 @@ static char* fmt_int64_diff_str(int64_t old_val, int64_t new_val) {
   return gpr_leftpad(str.c_str(), ' ', kTracePadding);
 }
 
-static char* fmt_uint32_diff_str(uint32_t old_val, uint32_t new_val) {
+char* fmt_uint32_diff_str(uint32_t old_val, uint32_t new_val) {
   std::string str;
   if (old_val != new_val) {
     str = absl::StrFormat("%" PRIu32 " -> %" PRIu32 "", old_val, new_val);
@@ -324,10 +324,8 @@ void StreamFlowControl::IncomingByteStreamUpdate(size_t max_size_hint,
 }
 
 // Take in a target and modifies it based on the memory pressure of the system
-static double AdjustForMemoryPressure(grpc_resource_quota* quota,
-                                      double target) {
+static double AdjustForMemoryPressure(double memory_pressure, double target) {
   // do not increase window under heavy memory pressure.
-  double memory_pressure = grpc_resource_quota_get_memory_pressure(quota);
   static const double kLowMemPressure = 0.1;
   static const double kZeroTarget = 22;
   static const double kHighMemPressure = 0.8;
@@ -343,7 +341,9 @@ static double AdjustForMemoryPressure(grpc_resource_quota* quota,
 }
 
 double TransportFlowControl::TargetLogBdp() {
-  return AdjustForMemoryPressure(grpc_resource_user_quota(t_->resource_user),
+  return AdjustForMemoryPressure(t_->memory_owner.is_valid()
+                                     ? t_->memory_owner.InstantaneousPressure()
+                                     : 0.0,
                                  1 + log2(bdp_estimator_.EstimateBdp()));
 }
 

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

@@ -331,10 +331,10 @@ class TransportFlowControl final : public TransportFlowControlBase {
   const bool enable_bdp_probe_;
 
   /* bdp estimation */
-  grpc_core::BdpEstimator bdp_estimator_;
+  BdpEstimator bdp_estimator_;
 
   /* pid controller */
-  grpc_core::PidController pid_controller_;
+  PidController pid_controller_;
   grpc_millis last_pid_update_ = 0;
 };
 

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

@@ -265,6 +265,32 @@ class StringValue {
   VarintWriter<1> len_val_;
 };
 
+class BinaryStringValue {
+ public:
+  explicit BinaryStringValue(const grpc_slice& value,
+                             bool use_true_binary_metadata)
+      : wire_value_(GetWireValue(value, use_true_binary_metadata, true)),
+        len_val_(wire_value_.length) {}
+
+  size_t prefix_length() const {
+    return len_val_.length() +
+           (wire_value_.insert_null_before_wire_value ? 1 : 0);
+  }
+
+  void WritePrefix(uint8_t* prefix_data) {
+    len_val_.Write(wire_value_.huffman_prefix, prefix_data);
+    if (wire_value_.insert_null_before_wire_value) {
+      prefix_data[len_val_.length()] = 0;
+    }
+  }
+
+  const grpc_slice& data() { return wire_value_.data; }
+
+ private:
+  WireValue wire_value_;
+  VarintWriter<1> len_val_;
+};
+
 class NonBinaryStringValue {
  public:
   explicit NonBinaryStringValue(const grpc_slice& value)
@@ -356,6 +382,30 @@ void HPackCompressor::Framer::EmitLitHdrWithStringKeyNotIdx(grpc_mdelem elem) {
   Add(emit.data());
 }
 
+void HPackCompressor::Framer::EmitLitHdrWithBinaryStringKeyNotIdx(
+    const grpc_slice& key_slice, const grpc_slice& value_slice) {
+  GRPC_STATS_INC_HPACK_SEND_LITHDR_NOTIDX_V();
+  GRPC_STATS_INC_HPACK_SEND_UNCOMPRESSED();
+  StringKey key(key_slice);
+  key.WritePrefix(0x00, AddTiny(key.prefix_length()));
+  Add(grpc_slice_ref_internal(key.key()));
+  BinaryStringValue emit(value_slice, use_true_binary_metadata_);
+  emit.WritePrefix(AddTiny(emit.prefix_length()));
+  Add(emit.data());
+}
+
+void HPackCompressor::Framer::EmitLitHdrWithNonBinaryStringKeyNotIdx(
+    const grpc_slice& key_slice, const grpc_slice& value_slice) {
+  GRPC_STATS_INC_HPACK_SEND_LITHDR_NOTIDX_V();
+  GRPC_STATS_INC_HPACK_SEND_UNCOMPRESSED();
+  StringKey key(key_slice);
+  key.WritePrefix(0x00, AddTiny(key.prefix_length()));
+  Add(grpc_slice_ref_internal(key.key()));
+  NonBinaryStringValue emit(value_slice);
+  emit.WritePrefix(AddTiny(emit.prefix_length()));
+  Add(grpc_slice_ref_internal(emit.data()));
+}
+
 void HPackCompressor::Framer::AdvertiseTableSizeChange() {
   VarintWriter<3> w(compressor_->table_.max_size());
   w.Write(0x20, AddTiny(w.length()));
@@ -420,13 +470,11 @@ void HPackCompressor::Framer::EncodeDynamic(grpc_mdelem elem) {
   uint32_t elem_hash = 0;
   if (elem_interned) {
     // Update filter to see if we can perhaps add this elem.
-    elem_hash = GRPC_MDELEM_STORAGE(elem) == GRPC_MDELEM_STORAGE_INTERNED
-                    ? reinterpret_cast<grpc_core::InternedMetadata*>(
-                          GRPC_MDELEM_DATA(elem))
-                          ->hash()
-                    : reinterpret_cast<grpc_core::StaticMetadata*>(
-                          GRPC_MDELEM_DATA(elem))
-                          ->hash();
+    elem_hash =
+        GRPC_MDELEM_STORAGE(elem) == GRPC_MDELEM_STORAGE_INTERNED
+            ? reinterpret_cast<InternedMetadata*>(GRPC_MDELEM_DATA(elem))
+                  ->hash()
+            : reinterpret_cast<StaticMetadata*>(GRPC_MDELEM_DATA(elem))->hash();
     bool can_add_to_hashtable =
         compressor_->filter_elems_.AddElement(elem_hash % kNumFilterValues);
     /* is this elem currently in the decoders table? */
@@ -443,7 +491,7 @@ void HPackCompressor::Framer::EncodeDynamic(grpc_mdelem elem) {
 
   /* should this elem be in the table? */
   const size_t decoder_space_usage =
-      grpc_core::MetadataSizeInHPackTable(elem, use_true_binary_metadata_);
+      MetadataSizeInHPackTable(elem, use_true_binary_metadata_);
   const bool decoder_space_available =
       decoder_space_usage < kMaxDecoderSpaceUsage;
   const bool should_add_elem =
@@ -478,12 +526,20 @@ void HPackCompressor::Framer::EncodeDynamic(grpc_mdelem elem) {
 
 void HPackCompressor::Framer::Encode(TeMetadata, TeMetadata::ValueType value) {
   GPR_ASSERT(value == TeMetadata::ValueType::kTrailers);
-  if (compressor_->table_.ConvertableToDynamicIndex(compressor_->te_index_)) {
-    EmitIndexed(compressor_->table_.DynamicIndex(compressor_->te_index_));
+  EncodeAlwaysIndexed(
+      &compressor_->te_index_, GRPC_MDSTR_TE, GRPC_MDSTR_TRAILERS,
+      2 /* te */ + 8 /* trailers */ + hpack_constants::kEntryOverhead);
+}
+
+void HPackCompressor::Framer::EncodeAlwaysIndexed(uint32_t* index,
+                                                  const grpc_slice& key,
+                                                  const grpc_slice& value,
+                                                  uint32_t transport_length) {
+  if (compressor_->table_.ConvertableToDynamicIndex(*index)) {
+    EmitIndexed(compressor_->table_.DynamicIndex(*index));
   } else {
-    compressor_->te_index_ = compressor_->table_.AllocateIndex(
-        2 /* te */ + 8 /* trailers */ + hpack_constants::kEntryOverhead);
-    EmitLitHdrWithNonBinaryStringKeyIncIdx(GRPC_MDSTR_TE, GRPC_MDSTR_TRAILERS);
+    *index = compressor_->table_.AllocateIndex(transport_length);
+    EmitLitHdrWithNonBinaryStringKeyIncIdx(key, value);
   }
 }
 
@@ -491,14 +547,23 @@ void HPackCompressor::Framer::Encode(GrpcTimeoutMetadata,
                                      grpc_millis deadline) {
   char timeout_str[GRPC_HTTP2_TIMEOUT_ENCODE_MIN_BUFSIZE];
   grpc_mdelem mdelem;
-  grpc_http2_encode_timeout(deadline - grpc_core::ExecCtx::Get()->Now(),
-                            timeout_str);
-  mdelem = grpc_mdelem_from_slices(
-      GRPC_MDSTR_GRPC_TIMEOUT, grpc_core::UnmanagedMemorySlice(timeout_str));
+  grpc_http2_encode_timeout(deadline - ExecCtx::Get()->Now(), timeout_str);
+  mdelem = grpc_mdelem_from_slices(GRPC_MDSTR_GRPC_TIMEOUT,
+                                   UnmanagedMemorySlice(timeout_str));
   EncodeDynamic(mdelem);
   GRPC_MDELEM_UNREF(mdelem);
 }
 
+void HPackCompressor::Framer::Encode(UserAgentMetadata, const Slice& slice) {
+  if (!slice.is_equivalent(compressor_->user_agent_)) {
+    compressor_->user_agent_ = slice.Ref();
+    compressor_->user_agent_index_ = 0;
+  }
+  EncodeAlwaysIndexed(
+      &compressor_->user_agent_index_, GRPC_MDSTR_USER_AGENT, slice.c_slice(),
+      10 /* user-agent */ + slice.size() + hpack_constants::kEntryOverhead);
+}
+
 void HPackCompressor::SetMaxUsableSize(uint32_t max_table_size) {
   max_usable_size_ = max_table_size;
   SetMaxTableSize(std::min(table_.max_size(), max_table_size));
@@ -533,8 +598,7 @@ HPackCompressor::Framer::Framer(const EncodeHeaderOptions& options,
 void HPackCompressor::Framer::Encode(grpc_mdelem md) {
   if (GRPC_MDELEM_STORAGE(md) == GRPC_MDELEM_STORAGE_STATIC) {
     const uintptr_t static_index =
-        reinterpret_cast<grpc_core::StaticMetadata*>(GRPC_MDELEM_DATA(md))
-            ->StaticIndex();
+        reinterpret_cast<StaticMetadata*>(GRPC_MDELEM_DATA(md))->StaticIndex();
     if (static_index < hpack_constants::kLastStaticEntry) {
       EmitIndexed(static_cast<uint32_t>(static_index + 1));
       return;

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

@@ -119,6 +119,25 @@ class HPackCompressor {
     void Encode(grpc_mdelem md);
     void Encode(GrpcTimeoutMetadata, grpc_millis deadline);
     void Encode(TeMetadata, TeMetadata::ValueType value);
+    void Encode(UserAgentMetadata, const Slice& slice);
+    void Encode(GrpcMessageMetadata, const Slice& slice) {
+      if (slice.empty()) return;
+      EmitLitHdrWithNonBinaryStringKeyNotIdx(
+          StaticSlice::FromStaticString("grpc-message").c_slice(),
+          slice.c_slice());
+    }
+    template <typename Which>
+    void Encode(Which, const Slice& slice) {
+      if (absl::EndsWith(Which::key(), "-bin")) {
+        EmitLitHdrWithBinaryStringKeyNotIdx(
+            StaticSlice::FromStaticString(Which::key()).c_slice(),
+            slice.c_slice());
+      } else {
+        EmitLitHdrWithNonBinaryStringKeyNotIdx(
+            StaticSlice::FromStaticString(Which::key()).c_slice(),
+            slice.c_slice());
+      }
+    }
 
    private:
     struct FramePrefix {
@@ -143,8 +162,16 @@ class HPackCompressor {
     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);
+
     size_t CurrentFrameSize() const;
     void Add(grpc_slice slice);
     uint8_t* AddTiny(size_t len);
@@ -238,7 +265,7 @@ class HPackCompressor {
 
   class KeySliceRef {
    public:
-    using Stored = grpc_core::RefCountedPtr<grpc_slice_refcount>;
+    using Stored = RefCountedPtr<grpc_slice_refcount>;
 
     KeySliceRef(grpc_slice_refcount* ref, uint32_t hash)
         : ref_(ref), hash_(hash) {}
@@ -269,7 +296,12 @@ class HPackCompressor {
   // 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 user-agent metadata element
+  uint32_t user_agent_index_ = 0;
+  // The user-agent string referred to by user_agent_index_
+  Slice user_agent_;
 };
 
 }  // namespace grpc_core