grpc 1.70.1 → 1.72.0

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

@@ -29,6 +29,7 @@
 #include <memory>
 #include <string>
 #include <utility>
+#include <variant>
 
 #include "absl/base/attributes.h"
 #include "absl/container/flat_hash_map.h"
@@ -39,7 +40,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
@@ -53,6 +54,7 @@
 #include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser_table.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
@@ -65,8 +67,6 @@
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/bdp_estimator.h"
 #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/transport.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/telemetry/stats.h"
@@ -76,6 +76,7 @@
 #include "src/core/util/status_helper.h"
 
 using grpc_core::HPackParser;
+using grpc_core::http2::Http2ErrorCode;
 
 static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t,
                                            size_t& requests_started);
@@ -206,7 +207,7 @@ std::string FrameTypeString(uint8_t frame_type, uint8_t flags) {
 }
 }  // namespace
 
-absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
+std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
     grpc_chttp2_transport* t, const grpc_slice& slice,
     size_t& requests_started) {
   GRPC_LATENT_SEE_INNER_SCOPE("grpc_chttp2_perform_read");
@@ -268,7 +269,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         t->deframe_state = GRPC_DTS_FH_0;
         return static_cast<size_t>(cur - beg);
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FH_0:
       DCHECK_LT(cur, end);
       t->incoming_frame_size = (static_cast<uint32_t>(*cur)) << 16;
@@ -276,7 +277,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         t->deframe_state = GRPC_DTS_FH_1;
         return absl::OkStatus();
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FH_1:
       DCHECK_LT(cur, end);
       t->incoming_frame_size |= (static_cast<uint32_t>(*cur)) << 8;
@@ -284,7 +285,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         t->deframe_state = GRPC_DTS_FH_2;
         return absl::OkStatus();
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FH_2:
       DCHECK_LT(cur, end);
       t->incoming_frame_size |= *cur;
@@ -292,7 +293,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         t->deframe_state = GRPC_DTS_FH_3;
         return absl::OkStatus();
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FH_3:
       DCHECK_LT(cur, end);
       t->incoming_frame_type = *cur;
@@ -300,7 +301,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         t->deframe_state = GRPC_DTS_FH_4;
         return absl::OkStatus();
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FH_4:
       DCHECK_LT(cur, end);
       t->incoming_frame_flags = *cur;
@@ -308,7 +309,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         t->deframe_state = GRPC_DTS_FH_5;
         return absl::OkStatus();
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FH_5:
       DCHECK_LT(cur, end);
       t->incoming_stream_id = ((static_cast<uint32_t>(*cur)) & 0x7f) << 24;
@@ -316,7 +317,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         t->deframe_state = GRPC_DTS_FH_6;
         return absl::OkStatus();
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FH_6:
       DCHECK_LT(cur, end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur)) << 16;
@@ -324,7 +325,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         t->deframe_state = GRPC_DTS_FH_7;
         return absl::OkStatus();
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FH_7:
       DCHECK_LT(cur, end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur)) << 8;
@@ -332,7 +333,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         t->deframe_state = GRPC_DTS_FH_8;
         return absl::OkStatus();
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FH_8:
       DCHECK_LT(cur, end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur));
@@ -366,7 +367,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       if (++cur == end) {
         return absl::OkStatus();
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FRAME:
       DCHECK_LT(cur, end);
       if (static_cast<uint32_t>(end - cur) == t->incoming_frame_size) {
@@ -536,6 +537,8 @@ void grpc_chttp2_parsing_become_skip_parser(grpc_chttp2_transport* t) {
 static grpc_error_handle init_data_frame_parser(grpc_chttp2_transport* t) {
   // Update BDP accounting since we have received a data frame.
   grpc_core::BdpEstimator* bdp_est = t->flow_control.bdp_estimator();
+  grpc_core::global_stats().IncrementHttp2ReadDataFrameSize(
+      t->incoming_frame_size);
   if (bdp_est) {
     if (t->bdp_ping_blocked) {
       t->bdp_ping_blocked = false;
@@ -583,9 +586,10 @@ error_handler:
     // handle stream errors by closing the stream
     grpc_chttp2_mark_stream_closed(t, s, true, false,
                                    absl_status_to_grpc_error(status));
-    grpc_chttp2_add_rst_stream_to_next_write(t, t->incoming_stream_id,
-                                             GRPC_HTTP2_PROTOCOL_ERROR,
-                                             &s->call_tracer_wrapper);
+    grpc_chttp2_add_rst_stream_to_next_write(
+        t, t->incoming_stream_id,
+        static_cast<uint32_t>(Http2ErrorCode::kProtocolError),
+        &s->call_tracer_wrapper);
     return init_non_header_skip_frame_parser(t);
   } else {
     return absl_status_to_grpc_error(status);
@@ -651,9 +655,11 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
     } else if (GPR_UNLIKELY(t->stream_map.size() + t->extra_streams >=
                             t->settings.acked().max_concurrent_streams())) {
       ++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_slice_buffer_add(
+          &t->qbuf,
+          grpc_chttp2_rst_stream_create(
+              t->incoming_stream_id,
+              static_cast<uint32_t>(Http2ErrorCode::kRefusedStream), nullptr));
       grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
     } else if (grpc_core::IsRqFastRejectEnabled() &&
@@ -663,9 +669,10 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
       grpc_core::global_stats().IncrementRqCallsRejected();
       ++t->num_pending_induced_frames;
       grpc_slice_buffer_add(
-          &t->qbuf,
-          grpc_chttp2_rst_stream_create(t->incoming_stream_id,
-                                        GRPC_HTTP2_ENHANCE_YOUR_CALM, nullptr));
+          &t->qbuf, grpc_chttp2_rst_stream_create(
+                        t->incoming_stream_id,
+                        static_cast<uint32_t>(Http2ErrorCode::kEnhanceYourCalm),
+                        nullptr));
       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(
@@ -675,9 +682,11 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
       // We have more streams allocated than we'd like, so apply some pushback
       // by refusing this stream.
       ++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_slice_buffer_add(
+          &t->qbuf,
+          grpc_chttp2_rst_stream_create(
+              t->incoming_stream_id,
+              static_cast<uint32_t>(Http2ErrorCode::kRefusedStream), nullptr));
       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->stream_map.size() >=
@@ -690,9 +699,11 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
       // setting, but are over the next value that will be advertised.
       // Apply some backpressure by randomly not accepting new streams.
       ++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_slice_buffer_add(
+          &t->qbuf,
+          grpc_chttp2_rst_stream_create(
+              t->incoming_stream_id,
+              static_cast<uint32_t>(Http2ErrorCode::kRefusedStream), nullptr));
       grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
     } else if (t->sent_goaway_state == GRPC_CHTTP2_FINAL_GOAWAY_SENT ||
@@ -716,9 +727,10 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
           << " before settings have been acknowledged";
       ++t->num_pending_induced_frames;
       grpc_slice_buffer_add(
-          &t->qbuf,
-          grpc_chttp2_rst_stream_create(t->incoming_stream_id,
-                                        GRPC_HTTP2_ENHANCE_YOUR_CALM, nullptr));
+          &t->qbuf, grpc_chttp2_rst_stream_create(
+                        t->incoming_stream_id,
+                        static_cast<uint32_t>(Http2ErrorCode::kEnhanceYourCalm),
+                        nullptr));
       grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
       t->last_new_stream_id = t->incoming_stream_id;
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
@@ -941,8 +953,9 @@ static void force_client_rst_stream(void* sp, grpc_error_handle /*error*/) {
   grpc_chttp2_stream* s = static_cast<grpc_chttp2_stream*>(sp);
   grpc_chttp2_transport* t = s->t.get();
   if (!s->write_closed) {
-    grpc_chttp2_add_rst_stream_to_next_write(t, s->id, GRPC_HTTP2_NO_ERROR,
-                                             &s->call_tracer_wrapper);
+    grpc_chttp2_add_rst_stream_to_next_write(
+        t, s->id, static_cast<uint32_t>(Http2ErrorCode::kNoError),
+        &s->call_tracer_wrapper);
     grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_FORCE_RST_STREAM);
     grpc_chttp2_mark_stream_closed(t, s, true, true, absl::OkStatus());
   }
@@ -960,8 +973,8 @@ grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
     s->call_tracer_wrapper.RecordIncomingBytes(
         {0, 0, GRPC_SLICE_LENGTH(slice)});
     call_tracer =
-        grpc_core::IsCallTracerInTransportEnabled()
-            ? s->arena->GetContext<grpc_core::CallTracerInterface>()
+        grpc_core::IsCallTracerTransportFixEnabled()
+            ? s->call_tracer
             : s->arena->GetContext<grpc_core::CallTracerAnnotationInterface>();
   }
   grpc_error_handle error = parser->Parse(

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

@@ -18,9 +18,9 @@
 #include <grpc/support/port_platform.h>
 
 #include <algorithm>
+#include <optional>
 
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
 
 namespace grpc_core {
 

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

@@ -89,14 +89,14 @@ void Chttp2PingCallbacks::CancelAll(
   ping_requested_ = false;
 }
 
-absl::optional<uint64_t> Chttp2PingCallbacks::OnPingTimeout(
+std::optional<uint64_t> Chttp2PingCallbacks::OnPingTimeout(
     Duration ping_timeout,
     grpc_event_engine::experimental::EventEngine* event_engine,
     Callback callback) {
   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;
+  if (it == inflight_.end()) return std::nullopt;
   it->second.on_timeout =
       event_engine->RunAfter(ping_timeout, std::move(callback));
   return most_recent_inflight_;

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

@@ -21,13 +21,13 @@
 #include <stdint.h>
 
 #include <algorithm>
+#include <optional>
 #include <vector>
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/hash/hash.h"
 #include "absl/random/bit_gen_ref.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/util/time.h"
 
@@ -85,7 +85,7 @@ class Chttp2PingCallbacks {
   // Clears started_new_ping_without_setting_timeout.
   // Returns the ping id of the ping the timeout was attached to if a timer was
   // started, or nullopt otherwise.
-  absl::optional<uint64_t> OnPingTimeout(
+  std::optional<uint64_t> OnPingTimeout(
       Duration ping_timeout,
       grpc_event_engine::experimental::EventEngine* event_engine,
       Callback callback);

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

@@ -18,10 +18,10 @@
 #include <grpc/support/port_platform.h>
 
 #include <algorithm>
+#include <optional>
 #include <ostream>
 
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/util/match.h"
 
@@ -36,7 +36,7 @@ namespace grpc_core {
 namespace {
 int g_default_max_pings_without_data_sent = 2;
 constexpr Duration kThrottleIntervalWithoutDataSent = Duration::Minutes(1);
-absl::optional<int> g_default_max_inflight_pings;
+std::optional<int> g_default_max_inflight_pings;
 }  // namespace
 
 Chttp2PingRatePolicy::Chttp2PingRatePolicy(const ChannelArgs& args,

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

@@ -20,8 +20,8 @@
 
 #include <iosfwd>
 #include <string>
+#include <variant>
 
-#include "absl/types/variant.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/util/time.h"
 
@@ -49,7 +49,7 @@ class Chttp2PingRatePolicy {
     }
   };
   using RequestSendPingResult =
-      absl::variant<SendGranted, TooManyRecentPings, TooSoon>;
+      std::variant<SendGranted, TooManyRecentPings, TooSoon>;
 
   // Request that one ping be sent.
   // Returns:

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

@@ -128,26 +128,6 @@ static void stream_list_add_tail(grpc_chttp2_transport* t,
       << "]: add to " << stream_list_id_string(id);
 }
 
-static void stream_list_add_head(grpc_chttp2_transport* t,
-                                 grpc_chttp2_stream* s,
-                                 grpc_chttp2_stream_list_id id) {
-  grpc_chttp2_stream* old_head;
-  CHECK(!s->included.is_set(id));
-  old_head = t->lists[id].head;
-  s->links[id].next = old_head;
-  s->links[id].prev = nullptr;
-  if (old_head) {
-    old_head->links[id].prev = s;
-  } else {
-    t->lists[id].tail = s;
-  }
-  t->lists[id].head = s;
-  s->included.set(id);
-  GRPC_TRACE_LOG(http2_stream_state, INFO)
-      << t << "[" << s->id << "][" << (t->is_client ? "cli" : "svr")
-      << "]: add to " << stream_list_id_string(id);
-}
-
 static bool stream_list_add(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
                             grpc_chttp2_stream_list_id id) {
   if (s->included.is_set(id)) {
@@ -157,24 +137,11 @@ static bool stream_list_add(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
   return true;
 }
 
-static bool stream_list_prepend(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
-                                grpc_chttp2_stream_list_id id) {
-  if (s->included.is_set(id)) {
-    return false;
-  }
-  stream_list_add_head(t, s, id);
-  return true;
-}
-
 // wrappers for specializations
 
 bool grpc_chttp2_list_add_writable_stream(grpc_chttp2_transport* t,
                                           grpc_chttp2_stream* s) {
   CHECK_NE(s->id, 0u);
-  if (grpc_core::IsPrioritizeFinishedRequestsEnabled() &&
-      s->send_trailing_metadata != nullptr) {
-    return stream_list_prepend(t, s, GRPC_CHTTP2_LIST_WRITABLE);
-  }
   return stream_list_add(t, s, GRPC_CHTTP2_LIST_WRITABLE);
 }
 
@@ -219,12 +186,7 @@ void grpc_chttp2_list_remove_waiting_for_concurrency(grpc_chttp2_transport* t,
 
 void grpc_chttp2_list_add_stalled_by_transport(grpc_chttp2_transport* t,
                                                grpc_chttp2_stream* s) {
-  if (grpc_core::IsPrioritizeFinishedRequestsEnabled() &&
-      s->send_trailing_metadata != nullptr) {
-    stream_list_prepend(t, s, GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT);
-  } else {
-    stream_list_add(t, s, GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT);
-  }
+  stream_list_add(t, s, GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT);
 }
 
 bool grpc_chttp2_list_pop_stalled_by_transport(grpc_chttp2_transport* t,

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

@@ -42,16 +42,16 @@ void VarintWriteTail(size_t tail_value, uint8_t* target, size_t tail_length) {
   switch (tail_length) {
     case 5:
       target[4] = static_cast<uint8_t>((tail_value >> 28) | 0x80);
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case 4:
       target[3] = static_cast<uint8_t>((tail_value >> 21) | 0x80);
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case 3:
       target[2] = static_cast<uint8_t>((tail_value >> 14) | 0x80);
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case 2:
       target[1] = static_cast<uint8_t>((tail_value >> 7) | 0x80);
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case 1:
       target[0] = static_cast<uint8_t>((tail_value) | 0x80);
   }

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

@@ -26,6 +26,7 @@
 #include <algorithm>
 #include <limits>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 
@@ -33,7 +34,7 @@
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
-#include "absl/types/optional.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
@@ -46,6 +47,7 @@
 #include "src/core/ext/transport/chttp2/transport/frame_window_update.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/ext/transport/chttp2/transport/ping_callbacks.h"
@@ -60,8 +62,6 @@
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/bdp_estimator.h"
-#include "src/core/lib/transport/http2_errors.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/telemetry/stats.h"
@@ -74,6 +74,8 @@
 
 // IWYU pragma: no_include "src/core/util/orphanable.h"
 
+using grpc_core::http2::Http2ErrorCode;
+
 static void add_to_write_list(grpc_chttp2_write_cb** list,
                               grpc_chttp2_write_cb* cb) {
   cb->next = *list;
@@ -174,7 +176,6 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
                 kInvalid) {
           t->delayed_ping_timer_handle = t->event_engine->RunAfter(
               too_soon.wait, [t = t->Ref()]() mutable {
-                grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
                 grpc_core::ExecCtx exec_ctx;
                 grpc_chttp2_retry_initiate_ping(std::move(t));
               });
@@ -253,6 +254,7 @@ class WriteContext {
  public:
   explicit WriteContext(grpc_chttp2_transport* t) : t_(t) {
     grpc_core::global_stats().IncrementHttp2WritesBegun();
+    grpc_core::global_stats().IncrementHttp2WriteTargetSize(target_write_size_);
   }
 
   void FlushSettings() {
@@ -268,7 +270,6 @@ class WriteContext {
         // for implementations taking some more time about acking a setting.
         t_->settings_ack_watchdog = t_->event_engine->RunAfter(
             t_->settings_timeout, [t = t_->Ref()]() mutable {
-              grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
               grpc_core::ExecCtx exec_ctx;
               grpc_chttp2_settings_timeout(std::move(t));
             });
@@ -474,11 +475,11 @@ class StreamWriteContext {
     grpc_chttp2_complete_closure_step(t_, &s_->send_initial_metadata_finished,
                                       absl::OkStatus(),
                                       "send_initial_metadata_finished");
-    if (!grpc_core::IsCallTracerInTransportEnabled()) {
-      if (s_->call_tracer) {
+    if (!grpc_core::IsCallTracerTransportFixEnabled()) {
+      if (s_->parent_call_tracer != nullptr) {
         grpc_core::HttpAnnotation::WriteStats write_stats;
         write_stats.target_write_size = write_context_->target_write_size();
-        s_->call_tracer->RecordAnnotation(
+        s_->parent_call_tracer->RecordAnnotation(
             grpc_core::HttpAnnotation(
                 grpc_core::HttpAnnotation::Type::kHeadWritten,
                 gpr_now(GPR_CLOCK_REALTIME))
@@ -486,13 +487,11 @@ class StreamWriteContext {
                 .Add(s_->flow_control.stats())
                 .Add(write_stats));
       }
-    } else if (grpc_core::IsTraceRecordCallopsEnabled()) {
-      auto* call_tracer =
-          s_->arena->GetContext<grpc_core::CallTracerInterface>();
-      if (call_tracer != nullptr && call_tracer->IsSampled()) {
+    } else {
+      if (s_->call_tracer != nullptr && s_->call_tracer->IsSampled()) {
         grpc_core::HttpAnnotation::WriteStats write_stats;
         write_stats.target_write_size = write_context_->target_write_size();
-        call_tracer->RecordAnnotation(
+        s_->call_tracer->RecordAnnotation(
             grpc_core::HttpAnnotation(
                 grpc_core::HttpAnnotation::Type::kHeadWritten,
                 gpr_now(GPR_CLOCK_REALTIME))
@@ -635,24 +634,23 @@ class StreamWriteContext {
     if (!t_->is_client && !s_->read_closed) {
       grpc_slice_buffer_add(
           t_->outbuf.c_slice_buffer(),
-          grpc_chttp2_rst_stream_create(s_->id, GRPC_HTTP2_NO_ERROR,
-                                        &s_->call_tracer_wrapper));
+          grpc_chttp2_rst_stream_create(
+              s_->id, static_cast<uint32_t>(Http2ErrorCode::kNoError),
+              &s_->call_tracer_wrapper));
     }
     grpc_chttp2_mark_stream_closed(t_, s_, !t_->is_client, true,
                                    absl::OkStatus());
-    if (!grpc_core::IsCallTracerInTransportEnabled()) {
-      if (s_->call_tracer) {
-        s_->call_tracer->RecordAnnotation(
+    if (!grpc_core::IsCallTracerTransportFixEnabled()) {
+      if (s_->parent_call_tracer != nullptr) {
+        s_->parent_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()));
       }
-    } else if (grpc_core::IsTraceRecordCallopsEnabled()) {
-      auto* call_tracer =
-          s_->arena->GetContext<grpc_core::CallTracerInterface>();
-      if (call_tracer != nullptr && call_tracer->IsSampled()) {
-        call_tracer->RecordAnnotation(
+    } else {
+      if (s_->call_tracer != nullptr && s_->call_tracer->IsSampled()) {
+        s_->call_tracer->RecordAnnotation(
             grpc_core::HttpAnnotation(grpc_core::HttpAnnotation::Type::kEnd,
                                       gpr_now(GPR_CLOCK_REALTIME))
                 .Add(s_->t->flow_control.stats())
@@ -703,10 +701,9 @@ grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
             grpc_core::GrpcHttp2GetCopyContextFn();
         if (copy_context_fn != nullptr &&
             grpc_core::GrpcHttp2GetWriteTimestampsCallback() != nullptr) {
-          t->context_list->emplace_back(copy_context_fn(s->arena),
-                                        outbuf_relative_start_pos,
-                                        num_stream_bytes, s->byte_counter,
-                                        s->write_counter - 1, s->tcp_tracer);
+          t->context_list->emplace_back(
+              copy_context_fn(s->arena), outbuf_relative_start_pos,
+              num_stream_bytes, s->byte_counter, s->write_counter - 1, nullptr);
         }
       }
       outbuf_relative_start_pos += num_stream_bytes;
@@ -748,12 +745,11 @@ void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error_handle error) {
     // Set ping timeout after finishing write so we don't measure our own send
     // time.
     const auto timeout = t->ping_timeout;
-    auto id = t->ping_callbacks.OnPingTimeout(
-        timeout, t->event_engine.get(), [t = t->Ref()] {
-          grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
-          grpc_core::ExecCtx exec_ctx;
-          grpc_chttp2_ping_timeout(t);
-        });
+    auto id = t->ping_callbacks.OnPingTimeout(timeout, t->event_engine.get(),
+                                              [t = t->Ref()] {
+                                                grpc_core::ExecCtx exec_ctx;
+                                                grpc_chttp2_ping_timeout(t);
+                                              });
     if (GRPC_TRACE_FLAG_ENABLED(http2_ping) && id.has_value()) {
       LOG(INFO) << (t->is_client ? "CLIENT" : "SERVER") << "[" << t
                 << "]: Set ping timeout timer of " << timeout.ToString()
@@ -773,7 +769,6 @@ void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error_handle error) {
       }
       t->keepalive_ping_timeout_handle =
           t->event_engine->RunAfter(t->keepalive_timeout, [t = t->Ref()] {
-            grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
             grpc_core::ExecCtx exec_ctx;
             grpc_chttp2_keepalive_timeout(t);
           });

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

@@ -23,6 +23,7 @@
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
+#include "src/core/call/metadata.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/ext/transport/inproc/legacy_inproc_transport.h"
 #include "src/core/lib/event_engine/event_engine_context.h"
@@ -31,7 +32,6 @@
 #include "src/core/lib/promise/try_seq.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/surface/channel_create.h"
-#include "src/core/lib/transport/metadata.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/server/server.h"
 #include "src/core/util/crash.h"
@@ -281,8 +281,7 @@ MakeInProcessTransportPair(const ChannelArgs& server_channel_args) {
   auto server_transport =
       MakeOrphanable<InprocServerTransport>(server_channel_args);
   auto client_transport = server_transport->MakeClientTransport();
-  return std::make_pair(std::move(client_transport),
-                        std::move(server_transport));
+  return std::pair(std::move(client_transport), std::move(server_transport));
 }
 
 }  // namespace grpc_core
@@ -290,7 +289,6 @@ MakeInProcessTransportPair(const ChannelArgs& server_channel_args) {
 grpc_channel* grpc_inproc_channel_create(grpc_server* server,
                                          const grpc_channel_args* args,
                                          void* reserved) {
-  grpc_core::ApplicationCallbackExecCtx app_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   const auto channel_args = grpc_core::CoreConfiguration::Get()
                                 .channel_args_preconditioning()