grpc 1.62.0 → 1.63.2

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

@@ -106,6 +106,7 @@
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/transport/http2_errors.h"
 #include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/metadata_info.h"
 #include "src/core/lib/transport/status_conversion.h"
 #include "src/core/lib/transport/transport.h"
 
@@ -116,8 +117,6 @@
 #define DEFAULT_CONNECTION_WINDOW_TARGET (1024 * 1024)
 #define MAX_WINDOW 0x7fffffffu
 #define MAX_WRITE_BUFFER_SIZE (64 * 1024 * 1024)
-#define DEFAULT_MAX_HEADER_LIST_SIZE (16 * 1024)
-#define DEFAULT_MAX_HEADER_LIST_SIZE_SOFT_LIMIT (8 * 1024)
 
 #define KEEPALIVE_TIME_BACKOFF_MULTIPLIER 2
 
@@ -338,16 +337,11 @@ void ForEachContextListEntryExecute(void* arg, Timestamps* ts,
   delete context_list;
 }
 
-HttpAnnotation::HttpAnnotation(
-    Type type, gpr_timespec time,
-    absl::optional<chttp2::TransportFlowControl::Stats> transport_stats,
-    absl::optional<chttp2::StreamFlowControl::Stats> stream_stats)
+HttpAnnotation::HttpAnnotation(Type type, gpr_timespec time)
     : CallTracerAnnotationInterface::Annotation(
           CallTracerAnnotationInterface::AnnotationType::kHttpTransport),
       type_(type),
-      time_(time),
-      transport_stats_(transport_stats),
-      stream_stats_(stream_stats) {}
+      time_(time) {}
 
 std::string HttpAnnotation::ToString() const {
   std::string s = "HttpAnnotation type: ";
@@ -530,21 +524,8 @@ static void read_channel_args(grpc_chttp2_transport* t,
           .GetDurationFromIntMillis(GRPC_ARG_HTTP_TARPIT_MAX_DURATION_MS)
           .value_or(grpc_core::Duration::Seconds(1))
           .millis();
-
-  const int soft_limit =
-      channel_args.GetInt(GRPC_ARG_MAX_METADATA_SIZE).value_or(-1);
-  if (soft_limit < 0) {
-    // Set soft limit to 0.8 * hard limit if this is larger than
-    // `DEFAULT_MAX_HEADER_LIST_SIZE_SOFT_LIMIT` and
-    // `GRPC_ARG_MAX_METADATA_SIZE` is not set.
-    t->max_header_list_size_soft_limit = std::max(
-        DEFAULT_MAX_HEADER_LIST_SIZE_SOFT_LIMIT,
-        static_cast<int>(
-            0.8 * channel_args.GetInt(GRPC_ARG_ABSOLUTE_MAX_METADATA_SIZE)
-                      .value_or(-1)));
-  } else {
-    t->max_header_list_size_soft_limit = soft_limit;
-  }
+  t->max_header_list_size_soft_limit =
+      grpc_core::GetSoftLimitFromChannelArgs(channel_args);
 
   int value;
   if (!is_client) {
@@ -562,22 +543,8 @@ static void read_channel_args(grpc_chttp2_transport* t,
   if (value >= 0) {
     t->settings.mutable_local().SetHeaderTableSize(value);
   }
-  value = channel_args.GetInt(GRPC_ARG_ABSOLUTE_MAX_METADATA_SIZE).value_or(-1);
-  if (value >= 0) {
-    t->settings.mutable_local().SetMaxHeaderListSize(value);
-  } else {
-    // Set value to 1.25 * soft limit if this is larger than
-    // `DEFAULT_MAX_HEADER_LIST_SIZE` and
-    // `GRPC_ARG_ABSOLUTE_MAX_METADATA_SIZE` is not set.
-    const int soft_limit =
-        channel_args.GetInt(GRPC_ARG_MAX_METADATA_SIZE).value_or(-1);
-    const int value = (soft_limit >= 0 && soft_limit < (INT_MAX / 1.25))
-                          ? static_cast<int>(soft_limit * 1.25)
-                          : soft_limit;
-    if (value > DEFAULT_MAX_HEADER_LIST_SIZE) {
-      t->settings.mutable_local().SetMaxHeaderListSize(value);
-    }
-  }
+  t->settings.mutable_local().SetMaxHeaderListSize(
+      grpc_core::GetHardLimitFromChannelArgs(channel_args));
   value = channel_args.GetInt(GRPC_ARG_HTTP2_MAX_FRAME_SIZE).value_or(-1);
   if (value >= 0) {
     t->settings.mutable_local().SetMaxFrameSize(value);
@@ -823,8 +790,7 @@ void grpc_chttp2_stream_unref(grpc_chttp2_stream* s) {
 
 grpc_chttp2_stream::grpc_chttp2_stream(grpc_chttp2_transport* t,
                                        grpc_stream_refcount* refcount,
-                                       const void* server_data,
-                                       grpc_core::Arena* arena)
+                                       const void* server_data)
     : t(t->Ref()),
       refcount([refcount]() {
 // We reserve one 'active stream' that's dropped when the stream is
@@ -838,8 +804,6 @@ grpc_chttp2_stream::grpc_chttp2_stream(grpc_chttp2_transport* t,
 #endif
         return refcount;
       }()),
-      initial_metadata_buffer(arena),
-      trailing_metadata_buffer(arena),
       flow_control(&t->flow_control) {
   t->streams_allocated.fetch_add(1, std::memory_order_relaxed);
   if (server_data) {
@@ -897,8 +861,8 @@ grpc_chttp2_stream::~grpc_chttp2_stream() {
 void grpc_chttp2_transport::InitStream(grpc_stream* gs,
                                        grpc_stream_refcount* refcount,
                                        const void* server_data,
-                                       grpc_core::Arena* arena) {
-  new (gs) grpc_chttp2_stream(this, refcount, server_data, arena);
+                                       grpc_core::Arena*) {
+  new (gs) grpc_chttp2_stream(this, refcount, server_data);
 }
 
 static void destroy_stream_locked(void* sp, grpc_error_handle /*error*/) {
@@ -1305,7 +1269,6 @@ static void null_then_sched_closure(grpc_closure** closure) {
 }
 
 void grpc_chttp2_complete_closure_step(grpc_chttp2_transport* t,
-                                       grpc_chttp2_stream* s,
                                        grpc_closure** pclosure,
                                        grpc_error_handle error,
                                        const char* desc,
@@ -1330,12 +1293,6 @@ void grpc_chttp2_complete_closure_step(grpc_chttp2_transport* t,
         write_state_name(t->write_state), whence.file(), whence.line());
   }
 
-  if (s->call_tracer) {
-    s->call_tracer->RecordAnnotation(
-        absl::StrFormat("on_complete: s=%p %p desc=%s err=%s", s, closure, desc,
-                        grpc_core::StatusToString(error).c_str()));
-  }
-
   if (!error.ok()) {
     grpc_error_handle cl_err =
         grpc_core::internal::StatusMoveFromHeapPtr(closure->error_data.error);
@@ -1410,13 +1367,6 @@ static void perform_stream_op_locked(void* stream_op,
     }
   }
 
-  if (s->call_tracer) {
-    s->call_tracer->RecordAnnotation(absl::StrFormat(
-        "perform_stream_op_locked[s=%p; op=%p]: %s; on_complete = %p", s, op,
-        grpc_transport_stream_op_batch_string(op, true).c_str(),
-        op->on_complete));
-  }
-
   grpc_closure* on_complete = op->on_complete;
   // on_complete will be null if and only if there are no send ops in the batch.
   if (on_complete != nullptr) {
@@ -1433,9 +1383,11 @@ static void perform_stream_op_locked(void* stream_op,
 
   if (op->send_initial_metadata) {
     if (s->call_tracer) {
-      s->call_tracer->RecordAnnotation(grpc_core::HttpAnnotation(
-          grpc_core::HttpAnnotation::Type::kStart, gpr_now(GPR_CLOCK_REALTIME),
-          s->t->flow_control.stats(), s->flow_control.stats()));
+      s->call_tracer->RecordAnnotation(
+          grpc_core::HttpAnnotation(grpc_core::HttpAnnotation::Type::kStart,
+                                    gpr_now(GPR_CLOCK_REALTIME))
+              .Add(s->t->flow_control.stats())
+              .Add(s->flow_control.stats()));
     }
     if (t->is_client && t->channelz_socket != nullptr) {
       t->channelz_socket->RecordStreamStartedFromLocal();
@@ -1486,7 +1438,7 @@ static void perform_stream_op_locked(void* stream_op,
     } else {
       s->send_initial_metadata = nullptr;
       grpc_chttp2_complete_closure_step(
-          t, s, &s->send_initial_metadata_finished,
+          t, &s->send_initial_metadata_finished,
           GRPC_ERROR_CREATE_REFERENCING(
               "Attempt to send initial metadata after stream was closed",
               &s->write_closed_error, 1),
@@ -1506,7 +1458,7 @@ static void perform_stream_op_locked(void* stream_op,
       // We should NOT return an error here, so as to avoid a cancel OP being
       // started. The surface layer will notice that the stream has been closed
       // for writes and fail the send message op.
-      grpc_chttp2_complete_closure_step(t, s, &s->send_message_finished,
+      grpc_chttp2_complete_closure_step(t, &s->send_message_finished,
                                         absl::OkStatus(),
                                         "fetching_send_message_finished");
     } else {
@@ -1546,7 +1498,7 @@ static void perform_stream_op_locked(void* stream_op,
 
       int64_t notify_offset = s->next_message_end_offset;
       if (notify_offset <= s->flow_controlled_bytes_written) {
-        grpc_chttp2_complete_closure_step(t, s, &s->send_message_finished,
+        grpc_chttp2_complete_closure_step(t, &s->send_message_finished,
                                           absl::OkStatus(),
                                           "fetching_send_message_finished");
       } else {
@@ -1590,7 +1542,7 @@ static void perform_stream_op_locked(void* stream_op,
       s->send_trailing_metadata = nullptr;
       s->sent_trailing_metadata_op = nullptr;
       grpc_chttp2_complete_closure_step(
-          t, s, &s->send_trailing_metadata_finished,
+          t, &s->send_trailing_metadata_finished,
           op->payload->send_trailing_metadata.send_trailing_metadata->empty()
               ? absl::OkStatus()
               : GRPC_ERROR_CREATE("Attempt to send trailing metadata after "
@@ -1643,7 +1595,7 @@ static void perform_stream_op_locked(void* stream_op,
   }
 
   if (on_complete != nullptr) {
-    grpc_chttp2_complete_closure_step(t, s, &on_complete, absl::OkStatus(),
+    grpc_chttp2_complete_closure_step(t, &on_complete, absl::OkStatus(),
                                       "op->on_complete");
   }
 
@@ -2310,13 +2262,13 @@ static grpc_error_handle removal_error(grpc_error_handle extra_error,
   return error;
 }
 
-static void flush_write_list(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
+static void flush_write_list(grpc_chttp2_transport* t,
                              grpc_chttp2_write_cb** list,
                              grpc_error_handle error) {
   while (*list) {
     grpc_chttp2_write_cb* cb = *list;
     *list = cb->next;
-    grpc_chttp2_complete_closure_step(t, s, &cb->closure, error,
+    grpc_chttp2_complete_closure_step(t, &cb->closure, error,
                                       "on_write_finished_cb");
     cb->next = t->write_cb_pool;
     t->write_cb_pool = cb;
@@ -2329,18 +2281,18 @@ void grpc_chttp2_fail_pending_writes(grpc_chttp2_transport* t,
   error =
       removal_error(error, s, "Pending writes failed due to stream closure");
   s->send_initial_metadata = nullptr;
-  grpc_chttp2_complete_closure_step(t, s, &s->send_initial_metadata_finished,
+  grpc_chttp2_complete_closure_step(t, &s->send_initial_metadata_finished,
                                     error, "send_initial_metadata_finished");
 
   s->send_trailing_metadata = nullptr;
   s->sent_trailing_metadata_op = nullptr;
-  grpc_chttp2_complete_closure_step(t, s, &s->send_trailing_metadata_finished,
+  grpc_chttp2_complete_closure_step(t, &s->send_trailing_metadata_finished,
                                     error, "send_trailing_metadata_finished");
 
-  grpc_chttp2_complete_closure_step(t, s, &s->send_message_finished, error,
+  grpc_chttp2_complete_closure_step(t, &s->send_message_finished, error,
                                     "fetching_send_message_finished");
-  flush_write_list(t, s, &s->on_write_finished_cbs, error);
-  flush_write_list(t, s, &s->on_flow_controlled_cbs, error);
+  flush_write_list(t, &s->on_write_finished_cbs, error);
+  flush_write_list(t, &s->on_flow_controlled_cbs, error);
 }
 
 grpc_chttp2_transport::RemovedStreamHandle grpc_chttp2_mark_stream_closed(
@@ -2897,7 +2849,6 @@ static void next_bdp_ping_timer_expired_locked(
     grpc_core::RefCountedPtr<grpc_chttp2_transport> t,
     GRPC_UNUSED grpc_error_handle error) {
   GPR_DEBUG_ASSERT(error.ok());
-  GPR_ASSERT(t->next_bdp_ping_timer_handle != TaskHandle::kInvalid);
   t->next_bdp_ping_timer_handle = TaskHandle::kInvalid;
   if (t->flow_control.bdp_estimator()->accumulator() == 0) {
     // Block the bdp ping till we receive more data.

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

@@ -112,10 +112,27 @@ class HttpAnnotation : public CallTracerAnnotationInterface::Annotation {
     kEnd,
   };
 
-  HttpAnnotation(
-      Type type, gpr_timespec time,
-      absl::optional<chttp2::TransportFlowControl::Stats> transport_stats,
-      absl::optional<chttp2::StreamFlowControl::Stats> stream_stats);
+  // A snapshot of write stats to export.
+  struct WriteStats {
+    size_t target_write_size;
+  };
+
+  HttpAnnotation(Type type, gpr_timespec time);
+
+  HttpAnnotation& Add(const chttp2::TransportFlowControl::Stats& stats) {
+    transport_stats_ = stats;
+    return *this;
+  }
+
+  HttpAnnotation& Add(const chttp2::StreamFlowControl::Stats& stats) {
+    stream_stats_ = stats;
+    return *this;
+  }
+
+  HttpAnnotation& Add(const WriteStats& stats) {
+    write_stats_ = stats;
+    return *this;
+  }
 
   std::string ToString() const override;
 
@@ -127,12 +144,14 @@ class HttpAnnotation : public CallTracerAnnotationInterface::Annotation {
   absl::optional<chttp2::StreamFlowControl::Stats> stream_stats() const {
     return stream_stats_;
   }
+  absl::optional<WriteStats> write_stats() const { return write_stats_; }
 
  private:
   const Type type_;
   const gpr_timespec time_;
   absl::optional<chttp2::TransportFlowControl::Stats> transport_stats_;
   absl::optional<chttp2::StreamFlowControl::Stats> stream_stats_;
+  absl::optional<WriteStats> write_stats_;
 };
 
 }  // namespace grpc_core

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

@@ -38,38 +38,41 @@ namespace grpc_core {
 // sent over the wire. A data chunk being written over the wire is multiplexed
 // with bytes from multiple RPCs. If one such RPC is traced, we store the
 // following information about the traced RPC:
-// - byte_offset_in_stream: Number of bytes belonging to that traced RPC which
-// have been sent so far from the start of the RPC stream.
-// - relative_start_pos_in_chunk: Starting offset of the traced RPC within
-// the current chunk that is being sent.
-// - num_traced_bytes_in_chunk: Number of bytes belonging to the traced RPC
-// within the current chunk.
 class ContextListEntry {
  public:
-  ContextListEntry(void* context, int64_t relative_start_pos,
+  ContextListEntry(void* context, int64_t outbuf_offset,
                    int64_t num_traced_bytes, size_t byte_offset,
+                   size_t stream_index,
                    std::shared_ptr<TcpTracerInterface> tcp_tracer)
       : trace_context_(context),
-        relative_start_pos_in_chunk_(relative_start_pos),
+        outbuf_offset_(outbuf_offset),
         num_traced_bytes_in_chunk_(num_traced_bytes),
         byte_offset_in_stream_(byte_offset),
+        stream_index_(stream_index),
         tcp_tracer_(std::move(tcp_tracer)) {}
 
   ContextListEntry() = delete;
 
   void* TraceContext() { return trace_context_; }
-  int64_t RelativeStartPosInChunk() { return relative_start_pos_in_chunk_; }
+  int64_t OutbufOffset() { return outbuf_offset_; }
   int64_t NumTracedBytesInChunk() { return num_traced_bytes_in_chunk_; }
   size_t ByteOffsetInStream() { return byte_offset_in_stream_; }
+  size_t StreamIndex() { return stream_index_; }
   std::shared_ptr<TcpTracerInterface> ReleaseTcpTracer() {
     return std::move(tcp_tracer_);
   }
 
  private:
   void* trace_context_;
-  int64_t relative_start_pos_in_chunk_;
+  // Offset of the head of the current chunk in the output buffer.
+  int64_t outbuf_offset_;
+  // Number of bytes traced in the current chunk.
   int64_t num_traced_bytes_in_chunk_;
+  // Offset of the head of the current chunk in the RPC stream.
   size_t byte_offset_in_stream_;
+  // Index of the current chunk in the RPC stream.
+  // Set to zero for the first chunk of the RPC stream.
+  size_t stream_index_;
   std::shared_ptr<TcpTracerInterface> tcp_tracer_;
 };
 

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

@@ -52,6 +52,7 @@
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_refcount.h"
 #include "src/core/lib/surface/validate_metadata.h"
+#include "src/core/lib/transport/metadata_info.h"
 #include "src/core/lib/transport/parsed_metadata.h"
 
 // IWYU pragma: no_include <type_traits>
@@ -91,12 +92,14 @@ constexpr Base64InverseTable kBase64InverseTable;
 class HPackParser::Input {
  public:
   Input(grpc_slice_refcount* current_slice_refcount, const uint8_t* begin,
-        const uint8_t* end, absl::BitGenRef bitsrc, HpackParseResult& error)
+        const uint8_t* end, absl::BitGenRef bitsrc,
+        HpackParseResult& frame_error, HpackParseResult& field_error)
       : current_slice_refcount_(current_slice_refcount),
         begin_(begin),
         end_(end),
         frontier_(begin),
-        error_(error),
+        frame_error_(frame_error),
+        field_error_(field_error),
         bitsrc_(bitsrc) {}
 
   // If input is backed by a slice, retrieve its refcount. If not, return
@@ -215,14 +218,18 @@ class HPackParser::Input {
 
   // Check if we saw an EOF
   bool eof_error() const {
-    return min_progress_size_ != 0 || error_.connection_error();
+    return min_progress_size_ != 0 || frame_error_.connection_error();
+  }
+
+  // Reset the field error to be ok
+  void ClearFieldError() {
+    if (field_error_.ok()) return;
+    field_error_ = HpackParseResult();
   }
 
   // Minimum number of bytes to unstuck the current parse
   size_t min_progress_size() const { return min_progress_size_; }
 
-  bool has_error() const { return !error_.ok(); }
-
   // Set the current error - tweaks the error to include a stream id so that
   // chttp2 does not close the connection.
   // Intended for errors that are specific to a stream and recoverable.
@@ -246,10 +253,7 @@ class HPackParser::Input {
   // read prior to being able to get further in this parse.
   void UnexpectedEOF(size_t min_progress_size) {
     GPR_ASSERT(min_progress_size > 0);
-    if (min_progress_size_ != 0 || error_.connection_error()) {
-      GPR_DEBUG_ASSERT(eof_error());
-      return;
-    }
+    if (eof_error()) return;
     // Set min progress size, taking into account bytes parsed already but not
     // consumed.
     min_progress_size_ = min_progress_size + (begin_ - frontier_);
@@ -302,13 +306,18 @@ class HPackParser::Input {
   // Do not use this directly, instead use SetErrorAndContinueParsing or
   // SetErrorAndStopParsing.
   void SetError(HpackParseResult error) {
-    if (!error_.ok() || min_progress_size_ > 0) {
-      if (error.connection_error() && !error_.connection_error()) {
-        error_ = std::move(error);  // connection errors dominate
+    SetErrorFor(frame_error_, error);
+    SetErrorFor(field_error_, std::move(error));
+  }
+
+  void SetErrorFor(HpackParseResult& error, HpackParseResult new_error) {
+    if (!error.ok() || min_progress_size_ > 0) {
+      if (new_error.connection_error() && !error.connection_error()) {
+        error = std::move(new_error);  // connection errors dominate
       }
       return;
     }
-    error_ = std::move(error);
+    error = std::move(new_error);
   }
 
   // Refcount if we are backed by a slice
@@ -320,7 +329,8 @@ class HPackParser::Input {
   // Frontier denotes the first byte past successfully processed input
   const uint8_t* frontier_;
   // Current error
-  HpackParseResult& error_;
+  HpackParseResult& frame_error_;
+  HpackParseResult& field_error_;
   // If the error was EOF, we flag it here by noting how many more bytes would
   // be needed to make progress
   size_t min_progress_size_ = 0;
@@ -597,6 +607,7 @@ class HPackParser::Parser {
   bool ParseTop() {
     GPR_DEBUG_ASSERT(state_.parse_state == ParseState::kTop);
     auto cur = *input_->Next();
+    input_->ClearFieldError();
     switch (cur >> 4) {
         // Literal header not indexed - First byte format: 0000xxxx
         // Literal header never indexed - First byte format: 0001xxxx
@@ -702,7 +713,7 @@ class HPackParser::Parser {
         break;
     }
     gpr_log(
-        GPR_DEBUG, "HTTP:%d:%s:%s: %s%s", log_info_.stream_id, type,
+        GPR_INFO, "HTTP:%d:%s:%s: %s%s", log_info_.stream_id, type,
         log_info_.is_client ? "CLI" : "SVR", memento.md.DebugString().c_str(),
         memento.parse_status == nullptr
             ? ""
@@ -951,11 +962,10 @@ class HPackParser::Parser {
                                   state_.string_length)
             : String::Parse(input_, state_.is_string_huff_compressed,
                             state_.string_length);
-    HpackParseResult& status = state_.frame_error;
     absl::string_view key_string;
     if (auto* s = absl::get_if<Slice>(&state_.key)) {
       key_string = s->as_string_view();
-      if (status.ok()) {
+      if (state_.field_error.ok()) {
         auto r = ValidateKey(key_string);
         if (r != ValidateMetadataResult::kOk) {
           input_->SetErrorAndContinueParsing(
@@ -965,7 +975,7 @@ class HPackParser::Parser {
     } else {
       const auto* memento = absl::get<const HPackTable::Memento*>(state_.key);
       key_string = memento->md.key();
-      if (status.ok() && memento->parse_status != nullptr) {
+      if (state_.field_error.ok() && memento->parse_status != nullptr) {
         input_->SetErrorAndContinueParsing(*memento->parse_status);
       }
     }
@@ -992,16 +1002,16 @@ class HPackParser::Parser {
         key_string.size() + value.wire_size + hpack_constants::kEntryOverhead;
     auto md = grpc_metadata_batch::Parse(
         key_string, std::move(value_slice), state_.add_to_table, transport_size,
-        [key_string, &status, this](absl::string_view message, const Slice&) {
-          if (!status.ok()) return;
+        [key_string, this](absl::string_view message, const Slice&) {
+          if (!state_.field_error.ok()) return;
           input_->SetErrorAndContinueParsing(
               HpackParseResult::MetadataParseError(key_string));
           gpr_log(GPR_ERROR, "Error parsing '%s' metadata: %s",
                   std::string(key_string).c_str(),
                   std::string(message).c_str());
         });
-    HPackTable::Memento memento{std::move(md),
-                                status.PersistentStreamErrorOrNullptr()};
+    HPackTable::Memento memento{
+        std::move(md), state_.field_error.PersistentStreamErrorOrNullptr()};
     input_->UpdateFrontier();
     state_.parse_state = ParseState::kTop;
     if (state_.add_to_table) {
@@ -1076,55 +1086,6 @@ Slice HPackParser::String::Take() {
   GPR_UNREACHABLE_CODE(return Slice());
 }
 
-class HPackParser::MetadataSizeEncoder {
- public:
-  explicit MetadataSizeEncoder(std::string& summary) : summary_(summary) {}
-
-  void Encode(const Slice& key, const Slice& value) {
-    AddToSummary(key.as_string_view(), value.size());
-  }
-
-  template <typename Key, typename Value>
-  void Encode(Key, const Value& value) {
-    AddToSummary(Key::key(), EncodedSizeOfKey(Key(), value));
-  }
-
- private:
-  void AddToSummary(absl::string_view key,
-                    size_t value_length) GPR_ATTRIBUTE_NOINLINE {
-    absl::StrAppend(&summary_, key, ":",
-                    hpack_constants::SizeForEntry(key.size(), value_length),
-                    ",");
-  }
-  std::string& summary_;
-};
-
-class HPackParser::MetadataSizesAnnotation
-    : public CallTracerAnnotationInterface::Annotation {
- public:
-  MetadataSizesAnnotation(grpc_metadata_batch* metadata_buffer,
-                          uint64_t soft_limit, uint64_t hard_limit)
-      : CallTracerAnnotationInterface::Annotation(
-            CallTracerAnnotationInterface::AnnotationType::kMetadataSizes),
-        metadata_buffer_(metadata_buffer),
-        soft_limit_(soft_limit),
-        hard_limit_(hard_limit) {}
-
-  std::string ToString() const override {
-    std::string metadata_annotation =
-        absl::StrCat("gRPC metadata soft_limit:", soft_limit_,
-                     ",hard_limit:", hard_limit_, ",");
-    MetadataSizeEncoder encoder(metadata_annotation);
-    metadata_buffer_->Encode(&encoder);
-    return metadata_annotation;
-  }
-
- private:
-  grpc_metadata_batch* metadata_buffer_;
-  uint64_t soft_limit_;
-  uint64_t hard_limit_;
-};
-
 // PUBLIC INTERFACE
 
 HPackParser::HPackParser() = default;
@@ -1163,13 +1124,13 @@ grpc_error_handle HPackParser::Parse(
     std::vector<uint8_t> buffer = std::move(unparsed_bytes_);
     return ParseInput(
         Input(nullptr, buffer.data(), buffer.data() + buffer.size(), bitsrc,
-              state_.frame_error),
+              state_.frame_error, state_.field_error),
         is_last, call_tracer);
   }
-  return ParseInput(
-      Input(slice.refcount, GRPC_SLICE_START_PTR(slice),
-            GRPC_SLICE_END_PTR(slice), bitsrc, state_.frame_error),
-      is_last, call_tracer);
+  return ParseInput(Input(slice.refcount, GRPC_SLICE_START_PTR(slice),
+                          GRPC_SLICE_END_PTR(slice), bitsrc, state_.frame_error,
+                          state_.field_error),
+                    is_last, call_tracer);
 }
 
 grpc_error_handle HPackParser::ParseInput(

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

@@ -123,8 +123,6 @@ class HPackParser {
   // Helper classes: see implementation
   class Parser;
   class Input;
-  class MetadataSizeEncoder;
-  class MetadataSizesAnnotation;
 
   // Helper to parse a string and turn it into a slice with appropriate memory
   // management characteristics
@@ -238,6 +236,8 @@ class HPackParser {
     HPackTable hpack_table;
     // Error so far for this frame (set by class Input)
     HpackParseResult frame_error;
+    // Error so far for this field (set by class Input)
+    HpackParseResult field_error;
     // Length of frame so far.
     uint32_t frame_length = 0;
     // Length of the string being parsed

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

@@ -546,7 +546,7 @@ typedef enum {
 
 struct grpc_chttp2_stream {
   grpc_chttp2_stream(grpc_chttp2_transport* t, grpc_stream_refcount* refcount,
-                     const void* server_data, grpc_core::Arena* arena);
+                     const void* server_data);
   ~grpc_chttp2_stream();
 
   void* context = nullptr;
@@ -640,6 +640,9 @@ struct grpc_chttp2_stream {
   /// Byte counter for number of bytes written
   size_t byte_counter = 0;
 
+  /// Number of times written
+  int64_t write_counter = 0;
+
   /// Only set when enabled.
   grpc_core::CallTracerInterface* call_tracer = nullptr;
 
@@ -775,7 +778,6 @@ void grpc_chttp2_add_incoming_goaway(grpc_chttp2_transport* t,
 void grpc_chttp2_parsing_become_skip_parser(grpc_chttp2_transport* t);
 
 void grpc_chttp2_complete_closure_step(grpc_chttp2_transport* t,
-                                       grpc_chttp2_stream* s,
                                        grpc_closure** pclosure,
                                        grpc_error_handle error,
                                        const char* desc,

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

@@ -644,17 +644,12 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
     } else if (GPR_UNLIKELY(t->stream_map.size() + t->extra_streams >=
                             t->settings.acked().max_concurrent_streams())) {
-      if (grpc_core::IsRfcMaxConcurrentStreamsEnabled()) {
-        ++t->num_pending_induced_frames;
-        grpc_slice_buffer_add(
-            &t->qbuf,
-            grpc_chttp2_rst_stream_create(t->incoming_stream_id,
+      ++t->num_pending_induced_frames;
+      grpc_slice_buffer_add(&t->qbuf, grpc_chttp2_rst_stream_create(
+                                          t->incoming_stream_id,
                                           GRPC_HTTP2_REFUSED_STREAM, nullptr));
-        grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
-        return init_header_skip_frame_parser(t, priority_type, is_eoh);
-      } else {
-        return GRPC_ERROR_CREATE("Max stream count exceeded");
-      }
+      grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
+      return init_header_skip_frame_parser(t, priority_type, is_eoh);
     } else if (GPR_UNLIKELY(
                    t->max_concurrent_streams_overload_protection &&
                    t->streams_allocated.load(std::memory_order_relaxed) >