grpc 1.62.0 → 1.64.0

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

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <inttypes.h>
 #include <string.h>
 
@@ -30,6 +28,7 @@
 
 #include "absl/base/attributes.h"
 #include "absl/container/flat_hash_map.h"
+#include "absl/log/check.h"
 #include "absl/random/bit_gen_ref.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
@@ -41,7 +40,9 @@
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
+#include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/frame_data.h"
 #include "src/core/ext/transport/chttp2/transport/frame_goaway.h"
@@ -59,7 +60,6 @@
 #include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
 #include "src/core/lib/backoff/random_early_detection.h"
 #include "src/core/lib/channel/call_tracer.h"
-#include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
@@ -268,7 +268,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_0:
-      GPR_DEBUG_ASSERT(cur < end);
+      DCHECK_LT(cur, end);
       t->incoming_frame_size = (static_cast<uint32_t>(*cur)) << 16;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_1;
@@ -276,7 +276,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_1:
-      GPR_DEBUG_ASSERT(cur < end);
+      DCHECK_LT(cur, end);
       t->incoming_frame_size |= (static_cast<uint32_t>(*cur)) << 8;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_2;
@@ -284,7 +284,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_2:
-      GPR_DEBUG_ASSERT(cur < end);
+      DCHECK_LT(cur, end);
       t->incoming_frame_size |= *cur;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_3;
@@ -292,7 +292,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_3:
-      GPR_DEBUG_ASSERT(cur < end);
+      DCHECK_LT(cur, end);
       t->incoming_frame_type = *cur;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_4;
@@ -300,7 +300,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_4:
-      GPR_DEBUG_ASSERT(cur < end);
+      DCHECK_LT(cur, end);
       t->incoming_frame_flags = *cur;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_5;
@@ -308,7 +308,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_5:
-      GPR_DEBUG_ASSERT(cur < end);
+      DCHECK_LT(cur, end);
       t->incoming_stream_id = ((static_cast<uint32_t>(*cur)) & 0x7f) << 24;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_6;
@@ -316,7 +316,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_6:
-      GPR_DEBUG_ASSERT(cur < end);
+      DCHECK_LT(cur, end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur)) << 16;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_7;
@@ -324,7 +324,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_7:
-      GPR_DEBUG_ASSERT(cur < end);
+      DCHECK_LT(cur, end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur)) << 8;
       if (++cur == end) {
         t->deframe_state = GRPC_DTS_FH_8;
@@ -332,7 +332,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_8:
-      GPR_DEBUG_ASSERT(cur < end);
+      DCHECK_LT(cur, end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur));
       if (grpc_http_trace.enabled()) {
         gpr_log(GPR_INFO, "INCOMING[%p]: %s len:%d id:0x%08x", t,
@@ -367,7 +367,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FRAME:
-      GPR_DEBUG_ASSERT(cur < end);
+      DCHECK_LT(cur, end);
       if (static_cast<uint32_t>(end - cur) == t->incoming_frame_size) {
         err = parse_frame_slice(
             t,
@@ -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) >
@@ -735,7 +730,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
   } else {
     t->incoming_stream = s;
   }
-  GPR_DEBUG_ASSERT(s != nullptr);
+  DCHECK_NE(s, nullptr);
   s->stats.incoming.framing_bytes += 9;
   if (GPR_UNLIKELY(s->read_closed)) {
     GRPC_CHTTP2_IF_TRACING(gpr_log(

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

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/ext/transport/chttp2/transport/ping_abuse_policy.h"
 
 #include <algorithm>
@@ -22,6 +20,7 @@
 #include "absl/types/optional.h"
 
 #include <grpc/impl/channel_arg_names.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 

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

@@ -15,10 +15,10 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_ABUSE_POLICY_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_ABUSE_POLICY_H
 
-#include <grpc/support/port_platform.h>
-
 #include <string>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/time.h"
 

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

@@ -12,16 +12,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/ext/transport/chttp2/transport/ping_callbacks.h"
 
 #include <utility>
 
+#include "absl/log/check.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/distributions.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 grpc_core::TraceFlag grpc_ping_trace(false, "http2_ping");
 
@@ -96,7 +96,7 @@ absl::optional<uint64_t> Chttp2PingCallbacks::OnPingTimeout(
     Duration ping_timeout,
     grpc_event_engine::experimental::EventEngine* event_engine,
     Callback callback) {
-  GPR_ASSERT(started_new_ping_without_setting_timeout_);
+  CHECK(started_new_ping_without_setting_timeout_);
   started_new_ping_without_setting_timeout_ = false;
   auto it = inflight_.find(most_recent_inflight_);
   if (it == inflight_.end()) return absl::nullopt;

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

@@ -15,8 +15,6 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_CALLBACKS_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_CALLBACKS_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 #include <stdint.h>
 
@@ -30,6 +28,7 @@
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/time.h"

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

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
 
 #include <algorithm>
@@ -23,6 +21,7 @@
 #include "absl/types/optional.h"
 
 #include <grpc/impl/channel_arg_names.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/match.h"

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

@@ -15,8 +15,6 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_RATE_POLICY_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_RATE_POLICY_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 
 #include <iosfwd>
@@ -24,6 +22,8 @@
 
 #include "absl/types/variant.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/time.h"
 

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

@@ -16,9 +16,10 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
+#include "absl/log/check.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
@@ -58,7 +59,7 @@ static bool stream_list_pop(grpc_chttp2_transport* t,
   grpc_chttp2_stream* s = t->lists[id].head;
   if (s) {
     grpc_chttp2_stream* new_head = s->links[id].next;
-    GPR_ASSERT(s->included.is_set(id));
+    CHECK(s->included.is_set(id));
     if (new_head) {
       t->lists[id].head = new_head;
       new_head->links[id].prev = nullptr;
@@ -78,12 +79,12 @@ static bool stream_list_pop(grpc_chttp2_transport* t,
 
 static void stream_list_remove(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
                                grpc_chttp2_stream_list_id id) {
-  GPR_ASSERT(s->included.is_set(id));
+  CHECK(s->included.is_set(id));
   s->included.clear(id);
   if (s->links[id].prev) {
     s->links[id].prev->links[id].next = s->links[id].next;
   } else {
-    GPR_ASSERT(t->lists[id].head == s);
+    CHECK(t->lists[id].head == s);
     t->lists[id].head = s->links[id].next;
   }
   if (s->links[id].next) {
@@ -112,7 +113,7 @@ static void stream_list_add_tail(grpc_chttp2_transport* t,
                                  grpc_chttp2_stream* s,
                                  grpc_chttp2_stream_list_id id) {
   grpc_chttp2_stream* old_tail;
-  GPR_ASSERT(!s->included.is_set(id));
+  CHECK(!s->included.is_set(id));
   old_tail = t->lists[id].tail;
   s->links[id].next = nullptr;
   s->links[id].prev = old_tail;
@@ -142,7 +143,7 @@ static bool stream_list_add(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
 
 bool grpc_chttp2_list_add_writable_stream(grpc_chttp2_transport* t,
                                           grpc_chttp2_stream* s) {
-  GPR_ASSERT(s->id != 0);
+  CHECK_NE(s->id, 0u);
   return stream_list_add(t, s, GRPC_CHTTP2_LIST_WRITABLE);
 }
 

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

@@ -16,12 +16,12 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/ext/transport/chttp2/transport/varint.h"
 
 #include "absl/base/attributes.h"
 
+#include <grpc/support/port_platform.h>
+
 namespace grpc_core {
 
 size_t VarintLength(size_t tail_value) {

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

@@ -19,12 +19,13 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_VARINT_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_VARINT_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 #include <stdlib.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 // Helpers for hpack varint encoding
 
@@ -50,7 +51,7 @@ class VarintWriter {
   explicit VarintWriter(size_t value)
       : value_(value),
         length_(value < kMaxInPrefix ? 1 : VarintLength(value - kMaxInPrefix)) {
-    GPR_ASSERT(value <= UINT32_MAX);
+    CHECK(value <= UINT32_MAX);
   }
 
   size_t value() const { return value_; }

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

@@ -12,20 +12,21 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/ext/transport/chttp2/transport/write_size_policy.h"
 
 #include <algorithm>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 namespace grpc_core {
 
 size_t Chttp2WriteSizePolicy::WriteTargetSize() { return current_target_; }
 
 void Chttp2WriteSizePolicy::BeginWrite(size_t size) {
-  GPR_ASSERT(experiment_start_time_ == Timestamp::InfFuture());
+  CHECK(experiment_start_time_ == Timestamp::InfFuture());
   if (size < current_target_ * 7 / 10) {
     // If we were trending fast but stopped getting enough data to verify, then
     // reset back to the default state.

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

@@ -15,11 +15,11 @@
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_WRITE_SIZE_POLICY_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_WRITE_SIZE_POLICY_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 #include <stdint.h>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/gprpp/time.h"
 
 namespace grpc_core {

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

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <inttypes.h>
 #include <stddef.h>
 
@@ -28,14 +26,17 @@
 #include <utility>
 
 #include "absl/container/flat_hash_map.h"
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
+#include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/ext/transport/chttp2/transport/context_list_entry.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
@@ -54,7 +55,6 @@
 #include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
 #include "src/core/ext/transport/chttp2/transport/write_size_policy.h"
 #include "src/core/lib/channel/call_tracer.h"
-#include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/debug/stats_data.h"
 #include "src/core/lib/debug/trace.h"
@@ -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);
     }
@@ -270,7 +269,7 @@ class WriteContext {
       grpc_core::Http2Frame frame(std::move(*update));
       Serialize(absl::Span<grpc_core::Http2Frame>(&frame, 1), t_->outbuf);
       if (t_->keepalive_timeout != grpc_core::Duration::Infinity()) {
-        GPR_ASSERT(
+        CHECK(
             t_->settings_ack_watchdog ==
             grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid);
         // We base settings timeout on keepalive timeout, but double it to allow
@@ -292,7 +291,7 @@ class WriteContext {
     // simple writes are queued to qbuf, and flushed here
     grpc_slice_buffer_move_into(&t_->qbuf, t_->outbuf.c_slice_buffer());
     t_->num_pending_induced_frames = 0;
-    GPR_ASSERT(t_->qbuf.count == 0);
+    CHECK_EQ(t_->qbuf.count, 0u);
   }
 
   void FlushWindowUpdates() {
@@ -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));
     }
   }
 
@@ -563,14 +562,6 @@ class StreamWriteContext {
       grpc_chttp2_encode_data(s_->id, &s_->flow_controlled_buffer, 0, true,
                               &s_->stats.outgoing, t_->outbuf.c_slice_buffer());
     } else {
-      if (send_status_.has_value()) {
-        s_->send_trailing_metadata->Set(grpc_core::HttpStatusMetadata(),
-                                        *send_status_);
-      }
-      if (send_content_type_.has_value()) {
-        s_->send_trailing_metadata->Set(grpc_core::ContentTypeMetadata(),
-                                        *send_content_type_);
-      }
       t_->hpack_compressor.EncodeHeaders(
           grpc_core::HPackCompressor::EncodeHeaderOptions{
               s_->id, true, t_->settings.peer().allow_true_binary_metadata(),
@@ -582,23 +573,47 @@ 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_; }
 
  private:
+  class TrailersOnlyMetadataEncoder {
+   public:
+    explicit TrailersOnlyMetadataEncoder(grpc_metadata_batch* trailing_md)
+        : trailing_md_(trailing_md) {}
+
+    template <typename Which, typename Value>
+    void Encode(Which which, Value value) {
+      if (Which::kTransferOnTrailersOnly) {
+        trailing_md_->Set(which, value);
+      }
+    }
+
+    template <typename Which>
+    void Encode(Which which, const grpc_core::Slice& value) {
+      if (Which::kTransferOnTrailersOnly) {
+        trailing_md_->Set(which, value.Ref());
+      }
+    }
+
+    // Non-grpc metadata should not be transferred.
+    void Encode(const grpc_core::Slice&, const grpc_core::Slice&) {}
+
+   private:
+    grpc_metadata_batch* trailing_md_;
+  };
+
   void ConvertInitialMetadataToTrailingMetadata() {
     GRPC_CHTTP2_IF_TRACING(
         gpr_log(GPR_INFO, "not sending initial_metadata (Trailers-Only)"));
-    // When sending Trailers-Only, we need to move the :status and
-    // content-type headers to the trailers.
-    send_status_ =
-        s_->send_initial_metadata->get(grpc_core::HttpStatusMetadata());
-    send_content_type_ =
-        s_->send_initial_metadata->get(grpc_core::ContentTypeMetadata());
+    // When sending Trailers-Only, we need to move metadata from headers to
+    // trailers.
+    TrailersOnlyMetadataEncoder encoder(s_->send_trailing_metadata);
+    s_->send_initial_metadata->Encode(&encoder);
   }
 
   void SentLastFrame() {
@@ -619,9 +634,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()));
     }
   }
 
@@ -629,9 +646,6 @@ class StreamWriteContext {
   grpc_chttp2_transport* const t_;
   grpc_chttp2_stream* const s_;
   bool stream_became_writable_ = false;
-  absl::optional<uint32_t> send_status_;
-  absl::optional<grpc_core::ContentTypeMetadata::ValueType> send_content_type_ =
-      {};
 };
 }  // namespace
 
@@ -662,6 +676,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 +684,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 +757,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;