grpc 1.62.0.pre1 → 1.63.0

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>
@@ -1076,55 +1077,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;

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

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) >

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

@@ -82,10 +82,9 @@ static void add_to_write_list(grpc_chttp2_write_cb** list,
   *list = cb;
 }
 
-static void finish_write_cb(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
-                            grpc_chttp2_write_cb* cb, grpc_error_handle error) {
-  grpc_chttp2_complete_closure_step(t, s, &cb->closure, error,
-                                    "finish_write_cb");
+static void finish_write_cb(grpc_chttp2_transport* t, grpc_chttp2_write_cb* cb,
+                            grpc_error_handle error) {
+  grpc_chttp2_complete_closure_step(t, &cb->closure, error, "finish_write_cb");
   cb->next = t->write_cb_pool;
   t->write_cb_pool = cb;
 }
@@ -186,9 +185,9 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
       });
 }
 
-static bool update_list(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
-                        int64_t send_bytes, grpc_chttp2_write_cb** list,
-                        int64_t* ctr, grpc_error_handle error) {
+static bool update_list(grpc_chttp2_transport* t, int64_t send_bytes,
+                        grpc_chttp2_write_cb** list, int64_t* ctr,
+                        grpc_error_handle error) {
   bool sched_any = false;
   grpc_chttp2_write_cb* cb = *list;
   *list = nullptr;
@@ -197,7 +196,7 @@ static bool update_list(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
     grpc_chttp2_write_cb* next = cb->next;
     if (cb->call_at_byte <= *ctr) {
       sched_any = true;
-      finish_write_cb(t, s, cb, error);
+      finish_write_cb(t, cb, error);
     } else {
       add_to_write_list(list, cb);
     }
@@ -368,9 +367,7 @@ class WriteContext {
 
  private:
   grpc_chttp2_transport* const t_;
-  size_t target_write_size_ = grpc_core::IsWriteSizePolicyEnabled()
-                                  ? t_->write_size_policy.WriteTargetSize()
-                                  : 1024 * 1024;
+  size_t target_write_size_ = t_->write_size_policy.WriteTargetSize();
 
   // stats histogram counters: we increment these throughout this function,
   // and at the end publish to the central stats histograms
@@ -402,9 +399,7 @@ class DataSendContext {
         std::min<int64_t>(
             {t_->settings.peer().max_frame_size(), stream_remote_window(),
              t_->flow_control.remote_window(),
-             grpc_core::IsWriteSizeCapEnabled()
-                 ? static_cast<int64_t>(write_context_->target_write_size())
-                 : std::numeric_limits<uint32_t>::max()}),
+             static_cast<int64_t>(write_context_->target_write_size())}),
         0, std::numeric_limits<uint32_t>::max());
   }
 
@@ -428,8 +423,7 @@ class DataSendContext {
 
   void CallCallbacks() {
     if (update_list(
-            t_, s_,
-            static_cast<int64_t>(s_->sending_bytes - sending_bytes_before_),
+            t_, static_cast<int64_t>(s_->sending_bytes - sending_bytes_before_),
             &s_->on_flow_controlled_cbs, &s_->flow_controlled_bytes_flowed,
             absl::OkStatus())) {
       write_context_->NoteScheduledResults();
@@ -488,14 +482,19 @@ class StreamWriteContext {
     s_->send_initial_metadata = nullptr;
     s_->sent_initial_metadata = true;
     write_context_->NoteScheduledResults();
-    grpc_chttp2_complete_closure_step(
-        t_, s_, &s_->send_initial_metadata_finished, absl::OkStatus(),
-        "send_initial_metadata_finished");
+    grpc_chttp2_complete_closure_step(t_, &s_->send_initial_metadata_finished,
+                                      absl::OkStatus(),
+                                      "send_initial_metadata_finished");
     if (s_->call_tracer) {
-      s_->call_tracer->RecordAnnotation(grpc_core::HttpAnnotation(
-          grpc_core::HttpAnnotation::Type::kHeadWritten,
-          gpr_now(GPR_CLOCK_REALTIME), s_->t->flow_control.stats(),
-          s_->flow_control.stats()));
+      grpc_core::HttpAnnotation::WriteStats write_stats;
+      write_stats.target_write_size = write_context_->target_write_size();
+      s_->call_tracer->RecordAnnotation(
+          grpc_core::HttpAnnotation(
+              grpc_core::HttpAnnotation::Type::kHeadWritten,
+              gpr_now(GPR_CLOCK_REALTIME))
+              .Add(s_->t->flow_control.stats())
+              .Add(s_->flow_control.stats())
+              .Add(write_stats));
     }
   }
 
@@ -582,9 +581,9 @@ class StreamWriteContext {
     SentLastFrame();
 
     write_context_->NoteScheduledResults();
-    grpc_chttp2_complete_closure_step(
-        t_, s_, &s_->send_trailing_metadata_finished, absl::OkStatus(),
-        "send_trailing_metadata_finished");
+    grpc_chttp2_complete_closure_step(t_, &s_->send_trailing_metadata_finished,
+                                      absl::OkStatus(),
+                                      "send_trailing_metadata_finished");
   }
 
   bool stream_became_writable() { return stream_became_writable_; }
@@ -619,9 +618,11 @@ class StreamWriteContext {
     grpc_chttp2_mark_stream_closed(t_, s_, !t_->is_client, true,
                                    absl::OkStatus());
     if (s_->call_tracer) {
-      s_->call_tracer->RecordAnnotation(grpc_core::HttpAnnotation(
-          grpc_core::HttpAnnotation::Type::kEnd, 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::kEnd,
+                                    gpr_now(GPR_CLOCK_REALTIME))
+              .Add(s_->t->flow_control.stats())
+              .Add(s_->flow_control.stats()));
     }
   }
 
@@ -662,6 +663,7 @@ grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
       // Add this stream to the list of the contexts to be traced at TCP
       num_stream_bytes = t->outbuf.c_slice_buffer()->length - orig_len;
       s->byte_counter += static_cast<size_t>(num_stream_bytes);
+      ++s->write_counter;
       if (s->traced && grpc_endpoint_can_track_err(t->ep)) {
         grpc_core::CopyContextFn copy_context_fn =
             grpc_core::GrpcHttp2GetCopyContextFn();
@@ -669,7 +671,8 @@ grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
             grpc_core::GrpcHttp2GetWriteTimestampsCallback() != nullptr) {
           t->cl->emplace_back(copy_context_fn(s->context),
                               outbuf_relative_start_pos, num_stream_bytes,
-                              s->byte_counter, s->tcp_tracer);
+                              s->byte_counter, s->write_counter - 1,
+                              s->tcp_tracer);
         }
       }
       outbuf_relative_start_pos += num_stream_bytes;
@@ -741,7 +744,7 @@ void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error_handle error) {
 
   while (grpc_chttp2_list_pop_writing_stream(t, &s)) {
     if (s->sending_bytes != 0) {
-      update_list(t, s, static_cast<int64_t>(s->sending_bytes),
+      update_list(t, static_cast<int64_t>(s->sending_bytes),
                   &s->on_write_finished_cbs, &s->flow_controlled_bytes_written,
                   error);
       s->sending_bytes = 0;

data/src/core/ext/transport/inproc/inproc_transport.cc

@@ -22,10 +22,12 @@
 #include <grpc/support/log.h>
 
 #include "src/core/ext/transport/inproc/legacy_inproc_transport.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/promise/try_seq.h"
+#include "src/core/lib/surface/channel_create.h"
 #include "src/core/lib/surface/server.h"
 #include "src/core/lib/transport/transport.h"
 
@@ -155,7 +157,7 @@ bool UsePromiseBasedTransport() {
   return true;
 }
 
-RefCountedPtr<Channel> MakeLameChannel(absl::string_view why,
+OrphanablePtr<Channel> MakeLameChannel(absl::string_view why,
                                        absl::Status error) {
   gpr_log(GPR_ERROR, "%s: %s", std::string(why).c_str(),
           std::string(error.message()).c_str());
@@ -164,11 +166,11 @@ RefCountedPtr<Channel> MakeLameChannel(absl::string_view why,
   if (grpc_error_get_int(error, StatusIntProperty::kRpcStatus, &integer)) {
     status = static_cast<grpc_status_code>(integer);
   }
-  return RefCountedPtr<Channel>(Channel::FromC(grpc_lame_client_channel_create(
+  return OrphanablePtr<Channel>(Channel::FromC(grpc_lame_client_channel_create(
       nullptr, status, std::string(why).c_str())));
 }
 
-RefCountedPtr<Channel> MakeInprocChannel(Server* server,
+OrphanablePtr<Channel> MakeInprocChannel(Server* server,
                                          ChannelArgs client_channel_args) {
   auto transports = MakeInProcessTransportPair();
   auto client_transport = std::move(transports.first);
@@ -183,7 +185,7 @@ RefCountedPtr<Channel> MakeInprocChannel(Server* server,
     return MakeLameChannel("Failed to create server channel", std::move(error));
   }
   std::ignore = server_transport.release();  // consumed by SetupTransport
-  auto channel = Channel::Create(
+  auto channel = ChannelCreate(
       "inproc",
       client_channel_args.Set(GRPC_ARG_DEFAULT_AUTHORITY, "inproc.authority"),
       GRPC_CLIENT_DIRECT_CHANNEL, client_transport.release());