grpc 1.47.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

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

@@ -20,42 +20,25 @@
 
 #include "src/core/ext/transport/chttp2/transport/frame_data.h"
 
-#include <string.h>
+#include <stdlib.h>
 
-#include "absl/base/attributes.h"
+#include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/slice_buffer.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/transport/chttp2/transport/internal.h"
-#include "src/core/lib/channel/channelz.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/slice/slice_refcount.h"
-#include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/transport/transport.h"
 
-grpc_chttp2_data_parser::~grpc_chttp2_data_parser() {
-  if (parsing_frame != nullptr) {
-    GRPC_ERROR_UNREF(parsing_frame->Finished(
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Parser destroyed"), false));
-  }
-  GRPC_ERROR_UNREF(error);
-}
-
-grpc_error_handle grpc_chttp2_data_parser_begin_frame(
-    grpc_chttp2_data_parser* /*parser*/, uint8_t flags, uint32_t stream_id,
-    grpc_chttp2_stream* s) {
+absl::Status grpc_chttp2_data_parser_begin_frame(uint8_t flags,
+                                                 uint32_t stream_id,
+                                                 grpc_chttp2_stream* s) {
   if (flags & ~GRPC_CHTTP2_DATA_FLAG_END_STREAM) {
-    return grpc_error_set_int(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
-                                  "unsupported data flags: 0x%02x", flags)),
-                              GRPC_ERROR_INT_STREAM_ID,
-                              static_cast<intptr_t>(stream_id));
+    return absl::InternalError(absl::StrFormat(
+        "unsupported data flags: 0x%02x stream: %d", flags, stream_id));
   }
 
   if (flags & GRPC_CHTTP2_DATA_FLAG_END_STREAM) {
@@ -65,7 +48,7 @@ grpc_error_handle grpc_chttp2_data_parser_begin_frame(
     s->received_last_frame = false;
   }
 
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
@@ -96,188 +79,58 @@ void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
   stats->data_bytes += write_bytes;
 }
 
-grpc_error_handle grpc_deframe_unprocessed_incoming_frames(
-    grpc_chttp2_data_parser* p, grpc_chttp2_stream* s,
-    grpc_slice_buffer* slices, grpc_slice* slice_out,
-    grpc_core::OrphanablePtr<grpc_core::ByteStream>* stream_out) {
+grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(
+    grpc_chttp2_stream* s, uint32_t* min_progress_size,
+    grpc_core::SliceBuffer* stream_out, uint32_t* message_flags) {
+  grpc_slice_buffer* slices = &s->frame_storage;
   grpc_error_handle error = GRPC_ERROR_NONE;
-  grpc_chttp2_transport* t = s->t;
 
-  while (slices->count > 0) {
-    uint8_t* beg = nullptr;
-    uint8_t* end = nullptr;
-    uint8_t* cur = nullptr;
-
-    grpc_slice* slice = grpc_slice_buffer_peek_first(slices);
-    beg = GRPC_SLICE_START_PTR(*slice);
-    end = GRPC_SLICE_END_PTR(*slice);
-    cur = beg;
-    uint32_t message_flags;
+  if (slices->length < 5) {
+    if (min_progress_size != nullptr) *min_progress_size = 5 - slices->length;
+    return grpc_core::Pending{};
+  }
 
-    if (cur == end) {
-      grpc_slice_buffer_remove_first(slices);
-      continue;
-    }
+  uint8_t header[5];
+  grpc_slice_buffer_copy_first_into_buffer(slices, 5, header);
 
-    switch (p->state) {
-      case GRPC_CHTTP2_DATA_ERROR:
-        p->state = GRPC_CHTTP2_DATA_ERROR;
-        grpc_slice_buffer_remove_first(slices);
-        return GRPC_ERROR_REF(p->error);
-      case GRPC_CHTTP2_DATA_FH_0:
-        s->stats.incoming.framing_bytes++;
-        p->frame_type = *cur;
-        switch (p->frame_type) {
-          case 0:
-            p->is_frame_compressed = false; /* GPR_FALSE */
-            break;
-          case 1:
-            p->is_frame_compressed = true; /* GPR_TRUE */
-            break;
-          default:
-            p->error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
-                absl::StrFormat("Bad GRPC frame type 0x%02x", p->frame_type));
-            p->error = grpc_error_set_int(p->error, GRPC_ERROR_INT_STREAM_ID,
-                                          static_cast<intptr_t>(s->id));
-            grpc_core::UniquePtr<char> dmp(
-                grpc_dump_slice(*slice, GPR_DUMP_HEX | GPR_DUMP_ASCII));
-            p->error = grpc_error_set_str(p->error, GRPC_ERROR_STR_RAW_BYTES,
-                                          dmp.get());
-            p->error =
-                grpc_error_set_int(p->error, GRPC_ERROR_INT_OFFSET, cur - beg);
-            p->state = GRPC_CHTTP2_DATA_ERROR;
-            grpc_slice_buffer_remove_first(slices);
-            return GRPC_ERROR_REF(p->error);
-        }
-        if (++cur == end) {
-          p->state = GRPC_CHTTP2_DATA_FH_1;
-          grpc_slice_buffer_remove_first(slices);
-          continue;
-        }
-        ABSL_FALLTHROUGH_INTENDED;
-      case GRPC_CHTTP2_DATA_FH_1:
-        s->stats.incoming.framing_bytes++;
-        p->frame_size = (static_cast<uint32_t>(*cur)) << 24;
-        if (++cur == end) {
-          p->state = GRPC_CHTTP2_DATA_FH_2;
-          grpc_slice_buffer_remove_first(slices);
-          continue;
-        }
-        ABSL_FALLTHROUGH_INTENDED;
-      case GRPC_CHTTP2_DATA_FH_2:
-        s->stats.incoming.framing_bytes++;
-        p->frame_size |= (static_cast<uint32_t>(*cur)) << 16;
-        if (++cur == end) {
-          p->state = GRPC_CHTTP2_DATA_FH_3;
-          grpc_slice_buffer_remove_first(slices);
-          continue;
-        }
-        ABSL_FALLTHROUGH_INTENDED;
-      case GRPC_CHTTP2_DATA_FH_3:
-        s->stats.incoming.framing_bytes++;
-        p->frame_size |= (static_cast<uint32_t>(*cur)) << 8;
-        if (++cur == end) {
-          p->state = GRPC_CHTTP2_DATA_FH_4;
-          grpc_slice_buffer_remove_first(slices);
-          continue;
-        }
-        ABSL_FALLTHROUGH_INTENDED;
-      case GRPC_CHTTP2_DATA_FH_4:
-        s->stats.incoming.framing_bytes++;
-        GPR_ASSERT(stream_out != nullptr);
-        GPR_ASSERT(p->parsing_frame == nullptr);
-        p->frame_size |= (static_cast<uint32_t>(*cur));
-        if (t->channelz_socket != nullptr) {
-          t->channelz_socket->RecordMessageReceived();
-        }
-        p->state = GRPC_CHTTP2_DATA_FRAME;
-        ++cur;
-        message_flags = 0;
-        if (p->is_frame_compressed) {
-          message_flags |= GRPC_WRITE_INTERNAL_COMPRESS;
-        }
-        p->parsing_frame = new grpc_core::Chttp2IncomingByteStream(
-            t, s, p->frame_size, message_flags);
-        stream_out->reset(p->parsing_frame);
-        if (p->parsing_frame->remaining_bytes() == 0) {
-          GRPC_ERROR_UNREF(p->parsing_frame->Finished(GRPC_ERROR_NONE, true));
-          p->parsing_frame = nullptr;
-          p->state = GRPC_CHTTP2_DATA_FH_0;
-        }
-        s->pending_byte_stream = true;
-        if (cur != end) {
-          grpc_slice_buffer_sub_first(slices, static_cast<size_t>(cur - beg),
-                                      static_cast<size_t>(end - beg));
-        } else {
-          grpc_slice_buffer_remove_first(slices);
-        }
-        return GRPC_ERROR_NONE;
-      case GRPC_CHTTP2_DATA_FRAME: {
-        GPR_ASSERT(p->parsing_frame != nullptr);
-        GPR_ASSERT(slice_out != nullptr);
-        if (cur == end) {
-          grpc_slice_buffer_remove_first(slices);
-          continue;
-        }
-        uint32_t remaining = static_cast<uint32_t>(end - cur);
-        if (remaining == p->frame_size) {
-          s->stats.incoming.data_bytes += remaining;
-          if (GRPC_ERROR_NONE !=
-              (error = p->parsing_frame->Push(
-                   grpc_slice_sub(*slice, static_cast<size_t>(cur - beg),
-                                  static_cast<size_t>(end - beg)),
-                   slice_out))) {
-            grpc_slice_buffer_remove_first(slices);
-            return error;
-          }
-          if (GRPC_ERROR_NONE !=
-              (error = p->parsing_frame->Finished(GRPC_ERROR_NONE, true))) {
-            grpc_slice_buffer_remove_first(slices);
-            return error;
-          }
-          p->parsing_frame = nullptr;
-          p->state = GRPC_CHTTP2_DATA_FH_0;
-          grpc_slice_buffer_remove_first(slices);
-          return GRPC_ERROR_NONE;
-        } else if (remaining < p->frame_size) {
-          s->stats.incoming.data_bytes += remaining;
-          if (GRPC_ERROR_NONE !=
-              (error = p->parsing_frame->Push(
-                   grpc_slice_sub(*slice, static_cast<size_t>(cur - beg),
-                                  static_cast<size_t>(end - beg)),
-                   slice_out))) {
-            return error;
-          }
-          p->frame_size -= remaining;
-          grpc_slice_buffer_remove_first(slices);
-          return GRPC_ERROR_NONE;
-        } else {
-          GPR_ASSERT(remaining > p->frame_size);
-          s->stats.incoming.data_bytes += p->frame_size;
-          if (GRPC_ERROR_NONE !=
-              p->parsing_frame->Push(
-                  grpc_slice_sub(
-                      *slice, static_cast<size_t>(cur - beg),
-                      static_cast<size_t>(cur + p->frame_size - beg)),
-                  slice_out)) {
-            grpc_slice_buffer_remove_first(slices);
-            return error;
-          }
-          if (GRPC_ERROR_NONE !=
-              (error = p->parsing_frame->Finished(GRPC_ERROR_NONE, true))) {
-            grpc_slice_buffer_remove_first(slices);
-            return error;
-          }
-          p->parsing_frame = nullptr;
-          p->state = GRPC_CHTTP2_DATA_FH_0;
-          cur += p->frame_size;
-          grpc_slice_buffer_sub_first(slices, static_cast<size_t>(cur - beg),
-                                      static_cast<size_t>(end - beg));
-          return GRPC_ERROR_NONE;
-        }
+  switch (header[0]) {
+    case 0:
+      if (message_flags != nullptr) *message_flags = 0;
+      break;
+    case 1:
+      if (message_flags != nullptr) {
+        *message_flags = GRPC_WRITE_INTERNAL_COMPRESS;
       }
+      break;
+    default:
+      error = GRPC_ERROR_CREATE_FROM_CPP_STRING(
+          absl::StrFormat("Bad GRPC frame type 0x%02x", header[0]));
+      error = grpc_error_set_int(error, GRPC_ERROR_INT_STREAM_ID,
+                                 static_cast<intptr_t>(s->id));
+      return error;
+  }
+
+  uint64_t length = (static_cast<uint32_t>(header[1]) << 24) |
+                    (static_cast<uint32_t>(header[2]) << 16) |
+                    (static_cast<uint32_t>(header[3]) << 8) |
+                    static_cast<uint32_t>(header[4]);
+
+  if (slices->length < length + 5) {
+    if (min_progress_size != nullptr) {
+      *min_progress_size = length + 5 - slices->length;
     }
+    return grpc_core::Pending{};
+  }
+
+  if (min_progress_size != nullptr) *min_progress_size = 0;
+
+  if (stream_out != nullptr) {
+    s->stats.incoming.framing_bytes += 5;
+    s->stats.incoming.data_bytes += length;
+    grpc_slice_buffer_move_first_into_buffer(slices, 5, header);
+    grpc_slice_buffer_move_first(slices, length, stream_out->c_slice_buffer());
   }
+
   return GRPC_ERROR_NONE;
 }
 
@@ -286,20 +139,9 @@ grpc_error_handle grpc_chttp2_data_parser_parse(void* /*parser*/,
                                                 grpc_chttp2_stream* s,
                                                 const grpc_slice& slice,
                                                 int is_last) {
-  if (!s->pending_byte_stream) {
-    grpc_slice_ref_internal(slice);
-    grpc_slice_buffer_add(&s->frame_storage, slice);
-    grpc_chttp2_maybe_complete_recv_message(t, s);
-  } else if (s->on_next) {
-    GPR_ASSERT(s->frame_storage.length == 0);
-    grpc_slice_ref_internal(slice);
-    grpc_slice_buffer_add(&s->unprocessed_incoming_frames_buffer, slice);
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, s->on_next, GRPC_ERROR_NONE);
-    s->on_next = nullptr;
-  } else {
-    grpc_slice_ref_internal(slice);
-    grpc_slice_buffer_add(&s->frame_storage, slice);
-  }
+  grpc_slice_ref_internal(slice);
+  grpc_slice_buffer_add(&s->frame_storage, slice);
+  grpc_chttp2_maybe_complete_recv_message(t, s);
 
   if (is_last && s->received_last_frame) {
     grpc_chttp2_mark_stream_closed(

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

@@ -25,45 +25,20 @@
 
 #include <stdint.h>
 
+#include "absl/status/status.h"
+
 #include <grpc/slice.h>
 
 #include "src/core/ext/transport/chttp2/transport/frame.h"
-#include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/transport/byte_stream.h"
+#include "src/core/lib/promise/poll.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/transport.h"
 
-typedef enum {
-  GRPC_CHTTP2_DATA_FH_0,
-  GRPC_CHTTP2_DATA_FH_1,
-  GRPC_CHTTP2_DATA_FH_2,
-  GRPC_CHTTP2_DATA_FH_3,
-  GRPC_CHTTP2_DATA_FH_4,
-  GRPC_CHTTP2_DATA_FRAME,
-  GRPC_CHTTP2_DATA_ERROR
-} grpc_chttp2_stream_state;
-
-namespace grpc_core {
-class Chttp2IncomingByteStream;
-}  // namespace grpc_core
-
-struct grpc_chttp2_data_parser {
-  grpc_chttp2_data_parser() = default;
-  ~grpc_chttp2_data_parser();
-
-  grpc_chttp2_stream_state state = GRPC_CHTTP2_DATA_FH_0;
-  uint8_t frame_type = 0;
-  uint32_t frame_size = 0;
-  grpc_error_handle error = GRPC_ERROR_NONE;
-
-  bool is_frame_compressed = false;
-  grpc_core::Chttp2IncomingByteStream* parsing_frame = nullptr;
-};
-
 /* start processing a new data frame */
-grpc_error_handle grpc_chttp2_data_parser_begin_frame(
-    grpc_chttp2_data_parser* parser, uint8_t flags, uint32_t stream_id,
-    grpc_chttp2_stream* s);
+absl::Status grpc_chttp2_data_parser_begin_frame(uint8_t flags,
+                                                 uint32_t stream_id,
+                                                 grpc_chttp2_stream* s);
 
 /* handle a slice of a data frame - is_last indicates the last slice of a
    frame */
@@ -78,9 +53,8 @@ void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
                              grpc_transport_one_way_stats* stats,
                              grpc_slice_buffer* outbuf);
 
-grpc_error_handle grpc_deframe_unprocessed_incoming_frames(
-    grpc_chttp2_data_parser* p, grpc_chttp2_stream* s,
-    grpc_slice_buffer* slices, grpc_slice* slice_out,
-    grpc_core::OrphanablePtr<grpc_core::ByteStream>* stream_out);
+grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(
+    grpc_chttp2_stream* s, uint32_t* min_progress_size,
+    grpc_core::SliceBuffer* stream_out, uint32_t* message_flags);
 
 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FRAME_DATA_H */

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

@@ -35,11 +35,9 @@
 #include "src/core/ext/transport/chttp2/transport/frame_goaway.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
-#include "src/core/ext/transport/chttp2/transport/stream_map.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 
 static uint8_t* fill_header(uint8_t* out, uint32_t length, uint8_t flags) {
@@ -119,22 +117,6 @@ grpc_error_handle grpc_chttp2_settings_parser_begin_frame(
   }
 }
 
-namespace {
-
-void StreamFlowControlWindowCheck(void* user_data, uint32_t /* key */,
-                                  void* stream) {
-  bool* error = static_cast<bool*>(user_data);
-  grpc_chttp2_stream* s = static_cast<grpc_chttp2_stream*>(stream);
-  if ((s->t->settings[GRPC_PEER_SETTINGS]
-                     [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE] +
-       s->t->initial_window_update + s->flow_control->remote_window_delta()) >
-      ((1u << 31) - 1)) {
-    *error = true;
-  }
-}
-
-}  // namespace
-
 grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
                                                     grpc_chttp2_transport* t,
                                                     grpc_chttp2_stream* /*s*/,
@@ -219,12 +201,6 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
         if (grpc_wire_id_to_setting_id(parser->id, &id)) {
           const grpc_chttp2_setting_parameters* sp =
               &grpc_chttp2_settings_parameters[id];
-          // If flow control is disabled we skip these.
-          if (!t->flow_control->flow_control_enabled() &&
-              (id == GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE ||
-               id == GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE)) {
-            continue;
-          }
           if (parser->value < sp->min_value || parser->value > sp->max_value) {
             switch (sp->invalid_value_behavior) {
               case GRPC_CHTTP2_CLAMP_INVALID_VALUE:
@@ -250,23 +226,6 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
                       t->is_client ? "cli" : "svr",
                       static_cast<int>(t->initial_window_update));
             }
-            if (grpc_core::chttp2::
-                    g_test_only_transport_flow_control_window_check) {
-              bool error = false;
-              if (parser->value > grpc_core::chttp2::kMaxInitialWindowSize ||
-                  parser->value < grpc_core::chttp2::kMinInitialWindowSize) {
-                error = true;
-              } else {
-                grpc_chttp2_stream_map_for_each(
-                    &t->stream_map, StreamFlowControlWindowCheck, &error);
-              }
-              if (error) {
-                grpc_chttp2_goaway_append(
-                    t->last_new_stream_id, sp->error_value,
-                    grpc_slice_from_static_string("HTTP2 settings error"),
-                    &t->qbuf);
-              }
-            }
           }
           parser->incoming_settings[id] = parser->value;
           if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {

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

@@ -29,7 +29,6 @@
 
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
-#include "src/core/lib/gprpp/manual_constructor.h"
 
 grpc_slice grpc_chttp2_window_update_create(
     uint32_t id, uint32_t window_delta, grpc_transport_one_way_stats* stats) {
@@ -98,13 +97,9 @@ grpc_error_handle grpc_chttp2_window_update_parser_parse(
 
     if (t->incoming_stream_id != 0) {
       if (s != nullptr) {
-        s->flow_control->RecvUpdate(received_update);
-        if (grpc_core::chttp2::
-                g_test_only_transport_flow_control_window_check &&
-            s->flow_control->remote_window_delta() >
-                grpc_core::chttp2::kMaxWindowDelta) {
-          GPR_ASSERT(false);
-        }
+        grpc_core::chttp2::StreamFlowControl::OutgoingUpdateContext(
+            &s->flow_control)
+            .RecvUpdate(received_update);
         if (grpc_chttp2_list_remove_stalled_by_stream(t, s)) {
           grpc_chttp2_mark_stream_writable(t, s);
           grpc_chttp2_initiate_write(
@@ -112,10 +107,10 @@ grpc_error_handle grpc_chttp2_window_update_parser_parse(
         }
       }
     } else {
-      bool was_zero = t->flow_control->remote_window() <= 0;
-      t->flow_control->RecvUpdate(received_update);
-      bool is_zero = t->flow_control->remote_window() <= 0;
-      if (was_zero && !is_zero) {
+      grpc_core::chttp2::TransportFlowControl::OutgoingUpdateContext upd(
+          &t->flow_control);
+      upd.RecvUpdate(received_update);
+      if (upd.Finish() == grpc_core::chttp2::StallEdge::kUnstalled) {
         grpc_chttp2_initiate_write(
             t, GRPC_CHTTP2_INITIATE_WRITE_TRANSPORT_FLOW_CONTROL_UNSTALLED);
       }

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

@@ -17,7 +17,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdint.h>
+#include <cstddef>
+#include <cstdint>
 
 namespace grpc_core {
 namespace hpack_constants {
@@ -33,6 +34,11 @@ static constexpr uint32_t EntriesForBytes(uint32_t bytes) noexcept {
   return (bytes + kEntryOverhead - 1) / kEntryOverhead;
 }
 
+static constexpr size_t SizeForEntry(size_t key_length,
+                                     size_t value_length) noexcept {
+  return key_length + value_length + kEntryOverhead;
+}
+
 static constexpr uint32_t kInitialTableEntries =
     EntriesForBytes(kInitialTableSize);
 }  // namespace hpack_constants

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

@@ -431,13 +431,15 @@ void HPackCompressor::Framer::Encode(HttpSchemeMetadata,
 }
 
 void HPackCompressor::Framer::Encode(GrpcTraceBinMetadata, const Slice& slice) {
-  EncodeIndexedKeyWithBinaryValue(&compressor_->grpc_trace_bin_index_,
-                                  "grpc-trace-bin", slice.Ref());
+  EncodeRepeatingSliceValue(GrpcTraceBinMetadata::key(), slice,
+                            &compressor_->grpc_trace_bin_index_,
+                            HPackEncoderTable::MaxEntrySize());
 }
 
 void HPackCompressor::Framer::Encode(GrpcTagsBinMetadata, const Slice& slice) {
-  EncodeIndexedKeyWithBinaryValue(&compressor_->grpc_tags_bin_index_,
-                                  "grpc-tags-bin", slice.Ref());
+  EncodeRepeatingSliceValue(GrpcTagsBinMetadata::key(), slice,
+                            &compressor_->grpc_tags_bin_index_,
+                            HPackEncoderTable::MaxEntrySize());
 }
 
 void HPackCompressor::Framer::Encode(HttpStatusMetadata, uint32_t status) {
@@ -521,6 +523,18 @@ void HPackCompressor::Framer::EncodeIndexedKeyWithBinaryValue(
   }
 }
 
+void HPackCompressor::Framer::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),
+                                        slice.Ref());
+  } else {
+    EncodeIndexedKeyWithBinaryValue(index, key, slice.Ref());
+  }
+}
+
 void HPackCompressor::Framer::Encode(GrpcTimeoutMetadata, Timestamp deadline) {
   Timeout timeout = Timeout::FromDuration(deadline - ExecCtx::Get()->Now());
   for (auto it = compressor_->previous_timeouts_.begin();
@@ -553,7 +567,9 @@ void HPackCompressor::Framer::Encode(GrpcTimeoutMetadata, Timestamp deadline) {
 }
 
 void HPackCompressor::Framer::Encode(UserAgentMetadata, const Slice& slice) {
-  if (slice.length() > HPackEncoderTable::MaxEntrySize()) {
+  if (hpack_constants::SizeForEntry(UserAgentMetadata::key().size(),
+                                    slice.size()) >
+      HPackEncoderTable::MaxEntrySize()) {
     EmitLitHdrWithNonBinaryStringKeyNotIdx(
         Slice::FromStaticString(UserAgentMetadata::key()), slice.Ref());
     return;
@@ -562,9 +578,10 @@ void HPackCompressor::Framer::Encode(UserAgentMetadata, const Slice& slice) {
     compressor_->user_agent_ = slice.Ref();
     compressor_->user_agent_index_ = 0;
   }
-  EncodeAlwaysIndexed(
-      &compressor_->user_agent_index_, "user-agent", slice.Ref(),
-      10 /* user-agent */ + slice.size() + hpack_constants::kEntryOverhead);
+  EncodeAlwaysIndexed(&compressor_->user_agent_index_, UserAgentMetadata::key(),
+                      slice.Ref(),
+                      hpack_constants::SizeForEntry(
+                          UserAgentMetadata::key().size(), slice.size()));
 }
 
 void HPackCompressor::Framer::Encode(GrpcStatusMetadata,

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

@@ -154,6 +154,10 @@ class HPackCompressor {
     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);
+
     size_t CurrentFrameSize() const;
     void Add(Slice slice);
     uint8_t* AddTiny(size_t len);

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

@@ -17,7 +17,6 @@
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder_table.h"
 
 #include <algorithm>
-#include <cstdint>
 
 #include <grpc/support/log.h>
 

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

@@ -20,6 +20,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <limits>
+
 #include "absl/container/inlined_vector.h"
 
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
@@ -30,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
@@ -65,7 +71,7 @@ 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_;
 };