grpc 1.54.3 → 1.55.0

data/src/core/ext/filters/rbac/rbac_service_config_parser.cc

@@ -219,10 +219,10 @@ RbacConfig::RbacPolicy::Rules::Policy::CidrRange::JsonLoader(const JsonArgs&) {
 void RbacConfig::RbacPolicy::Rules::Policy::CidrRange::JsonPostLoad(
     const Json& json, const JsonArgs& args, ValidationErrors* errors) {
   auto address_prefix = LoadJsonObjectField<std::string>(
-      json.object_value(), args, "addressPrefix", errors);
-  auto prefix_len = LoadJsonObjectField<uint32_t>(json.object_value(), args,
-                                                  "prefixLen", errors,
-                                                  /*required=*/false);
+      json.object(), args, "addressPrefix", errors);
+  auto prefix_len =
+      LoadJsonObjectField<uint32_t>(json.object(), args, "prefixLen", errors,
+                                    /*required=*/false);
   cidr_range =
       Rbac::CidrRange(address_prefix.value_or(""), prefix_len.value_or(0));
 }
@@ -269,13 +269,13 @@ RbacConfig::RbacPolicy::Rules::Policy::HeaderMatch::JsonLoader(
 void RbacConfig::RbacPolicy::Rules::Policy::HeaderMatch::JsonPostLoad(
     const Json& json, const JsonArgs& args, ValidationErrors* errors) {
   const size_t original_error_size = errors->size();
-  std::string name = LoadJsonObjectField<std::string>(json.object_value(), args,
-                                                      "name", errors)
-                         .value_or("");
-  bool invert_match = LoadJsonObjectField<bool>(json.object_value(), args,
-                                                "invertMatch", errors,
-                                                /*required=*/false)
-                          .value_or(false);
+  std::string name =
+      LoadJsonObjectField<std::string>(json.object(), args, "name", errors)
+          .value_or("");
+  bool invert_match =
+      LoadJsonObjectField<bool>(json.object(), args, "invertMatch", errors,
+                                /*required=*/false)
+          .value_or(false);
   auto set_header_matcher = [&](absl::StatusOr<HeaderMatcher> header_matcher) {
     if (header_matcher.ok()) {
       matcher = *header_matcher;
@@ -285,7 +285,7 @@ void RbacConfig::RbacPolicy::Rules::Policy::HeaderMatch::JsonPostLoad(
   };
   auto check_match = [&](absl::string_view field_name,
                          HeaderMatcher::Type type) {
-    auto match = LoadJsonObjectField<std::string>(json.object_value(), args,
+    auto match = LoadJsonObjectField<std::string>(json.object(), args,
                                                   field_name, errors,
                                                   /*required=*/false);
     if (match.has_value()) {
@@ -301,9 +301,9 @@ void RbacConfig::RbacPolicy::Rules::Policy::HeaderMatch::JsonPostLoad(
       check_match("containsMatch", HeaderMatcher::Type::kContains)) {
     return;
   }
-  auto present_match = LoadJsonObjectField<bool>(json.object_value(), args,
-                                                 "presentMatch", errors,
-                                                 /*required=*/false);
+  auto present_match =
+      LoadJsonObjectField<bool>(json.object(), args, "presentMatch", errors,
+                                /*required=*/false);
   if (present_match.has_value()) {
     set_header_matcher(
         HeaderMatcher::Create(name, HeaderMatcher::Type::kPresent, "", 0, 0,
@@ -311,7 +311,7 @@ void RbacConfig::RbacPolicy::Rules::Policy::HeaderMatch::JsonPostLoad(
     return;
   }
   auto regex_match = LoadJsonObjectField<SafeRegexMatch>(
-      json.object_value(), args, "safeRegexMatch", errors,
+      json.object(), args, "safeRegexMatch", errors,
       /*required=*/false);
   if (regex_match.has_value()) {
     set_header_matcher(
@@ -319,9 +319,9 @@ void RbacConfig::RbacPolicy::Rules::Policy::HeaderMatch::JsonPostLoad(
                               regex_match->regex, 0, 0, false, invert_match));
     return;
   }
-  auto range_match = LoadJsonObjectField<RangeMatch>(json.object_value(), args,
-                                                     "rangeMatch", errors,
-                                                     /*required=*/false);
+  auto range_match =
+      LoadJsonObjectField<RangeMatch>(json.object(), args, "rangeMatch", errors,
+                                      /*required=*/false);
   if (range_match.has_value()) {
     set_header_matcher(HeaderMatcher::Create(name, HeaderMatcher::Type::kRange,
                                              "", range_match->start,
@@ -349,7 +349,7 @@ void RbacConfig::RbacPolicy::Rules::Policy::StringMatch::JsonPostLoad(
     const Json& json, const JsonArgs& args, ValidationErrors* errors) {
   const size_t original_error_size = errors->size();
   bool ignore_case =
-      LoadJsonObjectField<bool>(json.object_value(), args, "ignoreCase", errors,
+      LoadJsonObjectField<bool>(json.object(), args, "ignoreCase", errors,
                                 /*required=*/false)
           .value_or(false);
   auto set_string_matcher = [&](absl::StatusOr<StringMatcher> string_matcher) {
@@ -361,7 +361,7 @@ void RbacConfig::RbacPolicy::Rules::Policy::StringMatch::JsonPostLoad(
   };
   auto check_match = [&](absl::string_view field_name,
                          StringMatcher::Type type) {
-    auto match = LoadJsonObjectField<std::string>(json.object_value(), args,
+    auto match = LoadJsonObjectField<std::string>(json.object(), args,
                                                   field_name, errors,
                                                   /*required=*/false);
     if (match.has_value()) {
@@ -376,9 +376,9 @@ void RbacConfig::RbacPolicy::Rules::Policy::StringMatch::JsonPostLoad(
       check_match("contains", StringMatcher::Type::kContains)) {
     return;
   }
-  auto regex_match = LoadJsonObjectField<SafeRegexMatch>(
-      json.object_value(), args, "safeRegex", errors,
-      /*required=*/false);
+  auto regex_match = LoadJsonObjectField<SafeRegexMatch>(json.object(), args,
+                                                         "safeRegex", errors,
+                                                         /*required=*/false);
   if (regex_match.has_value()) {
     set_string_matcher(StringMatcher::Create(StringMatcher::Type::kSafeRegex,
                                              regex_match->regex, ignore_case));
@@ -450,32 +450,32 @@ RbacConfig::RbacPolicy::Rules::Policy::Permission::JsonLoader(const JsonArgs&) {
 void RbacConfig::RbacPolicy::Rules::Policy::Permission::JsonPostLoad(
     const Json& json, const JsonArgs& args, ValidationErrors* errors) {
   const size_t original_error_size = errors->size();
-  auto any = LoadJsonObjectField<bool>(json.object_value(), args, "any", errors,
+  auto any = LoadJsonObjectField<bool>(json.object(), args, "any", errors,
                                        /*required=*/false);
   if (any.has_value()) {
     permission = std::make_unique<Rbac::Permission>(
         Rbac::Permission::MakeAnyPermission());
     return;
   }
-  auto header = LoadJsonObjectField<HeaderMatch>(json.object_value(), args,
-                                                 "header", errors,
-                                                 /*required=*/false);
+  auto header =
+      LoadJsonObjectField<HeaderMatch>(json.object(), args, "header", errors,
+                                       /*required=*/false);
   if (header.has_value()) {
     permission = std::make_unique<Rbac::Permission>(
         Rbac::Permission::MakeHeaderPermission(std::move(header->matcher)));
     return;
   }
-  auto url_path = LoadJsonObjectField<PathMatch>(json.object_value(), args,
-                                                 "urlPath", errors,
-                                                 /*required=*/false);
+  auto url_path =
+      LoadJsonObjectField<PathMatch>(json.object(), args, "urlPath", errors,
+                                     /*required=*/false);
   if (url_path.has_value()) {
     permission = std::make_unique<Rbac::Permission>(
         Rbac::Permission::MakePathPermission(url_path->path.matcher));
     return;
   }
-  auto destination_ip = LoadJsonObjectField<CidrRange>(
-      json.object_value(), args, "destinationIp", errors,
-      /*required=*/false);
+  auto destination_ip = LoadJsonObjectField<CidrRange>(json.object(), args,
+                                                       "destinationIp", errors,
+                                                       /*required=*/false);
   if (destination_ip.has_value()) {
     permission = std::make_unique<Rbac::Permission>(
         Rbac::Permission::MakeDestIpPermission(
@@ -483,23 +483,23 @@ void RbacConfig::RbacPolicy::Rules::Policy::Permission::JsonPostLoad(
     return;
   }
   auto destination_port = LoadJsonObjectField<uint32_t>(
-      json.object_value(), args, "destinationPort", errors,
+      json.object(), args, "destinationPort", errors,
       /*required=*/false);
   if (destination_port.has_value()) {
     permission = std::make_unique<Rbac::Permission>(
         Rbac::Permission::MakeDestPortPermission(*destination_port));
     return;
   }
-  auto metadata = LoadJsonObjectField<Metadata>(json.object_value(), args,
-                                                "metadata", errors,
-                                                /*required=*/false);
+  auto metadata =
+      LoadJsonObjectField<Metadata>(json.object(), args, "metadata", errors,
+                                    /*required=*/false);
   if (metadata.has_value()) {
     permission = std::make_unique<Rbac::Permission>(
         Rbac::Permission::MakeMetadataPermission(metadata->invert));
     return;
   }
   auto requested_server_name = LoadJsonObjectField<StringMatch>(
-      json.object_value(), args, "requestedServerName", errors,
+      json.object(), args, "requestedServerName", errors,
       /*required=*/false);
   if (requested_server_name.has_value()) {
     permission = std::make_unique<Rbac::Permission>(
@@ -507,7 +507,7 @@ void RbacConfig::RbacPolicy::Rules::Policy::Permission::JsonPostLoad(
             std::move(requested_server_name->matcher)));
     return;
   }
-  auto rules = LoadJsonObjectField<PermissionList>(json.object_value(), args,
+  auto rules = LoadJsonObjectField<PermissionList>(json.object(), args,
                                                    "andRules", errors,
                                                    /*required=*/false);
   if (rules.has_value()) {
@@ -516,8 +516,8 @@ void RbacConfig::RbacPolicy::Rules::Policy::Permission::JsonPostLoad(
             MakeRbacPermissionList(std::move(rules->rules))));
     return;
   }
-  rules = LoadJsonObjectField<PermissionList>(json.object_value(), args,
-                                              "orRules", errors,
+  rules = LoadJsonObjectField<PermissionList>(json.object(), args, "orRules",
+                                              errors,
                                               /*required=*/false);
   if (rules.has_value()) {
     permission =
@@ -525,9 +525,9 @@ void RbacConfig::RbacPolicy::Rules::Policy::Permission::JsonPostLoad(
             MakeRbacPermissionList(std::move(rules->rules))));
     return;
   }
-  auto not_rule = LoadJsonObjectField<Permission>(json.object_value(), args,
-                                                  "notRule", errors,
-                                                  /*required=*/false);
+  auto not_rule =
+      LoadJsonObjectField<Permission>(json.object(), args, "notRule", errors,
+                                      /*required=*/false);
   if (not_rule.has_value()) {
     permission = std::make_unique<Rbac::Permission>(
         Rbac::Permission::MakeNotPermission(std::move(*not_rule->permission)));
@@ -590,7 +590,7 @@ RbacConfig::RbacPolicy::Rules::Policy::Principal::JsonLoader(const JsonArgs&) {
 void RbacConfig::RbacPolicy::Rules::Policy::Principal::JsonPostLoad(
     const Json& json, const JsonArgs& args, ValidationErrors* errors) {
   const size_t original_error_size = errors->size();
-  auto any = LoadJsonObjectField<bool>(json.object_value(), args, "any", errors,
+  auto any = LoadJsonObjectField<bool>(json.object(), args, "any", errors,
                                        /*required=*/false);
   if (any.has_value()) {
     principal =
@@ -598,7 +598,7 @@ void RbacConfig::RbacPolicy::Rules::Policy::Principal::JsonPostLoad(
     return;
   }
   auto authenticated = LoadJsonObjectField<Authenticated>(
-      json.object_value(), args, "authenticated", errors,
+      json.object(), args, "authenticated", errors,
       /*required=*/false);
   if (authenticated.has_value()) {
     if (authenticated->principal_name.has_value()) {
@@ -612,16 +612,16 @@ void RbacConfig::RbacPolicy::Rules::Policy::Principal::JsonPostLoad(
     }
     return;
   }
-  auto cidr_range = LoadJsonObjectField<CidrRange>(json.object_value(), args,
-                                                   "sourceIp", errors,
-                                                   /*required=*/false);
+  auto cidr_range =
+      LoadJsonObjectField<CidrRange>(json.object(), args, "sourceIp", errors,
+                                     /*required=*/false);
   if (cidr_range.has_value()) {
     principal = std::make_unique<Rbac::Principal>(
         Rbac::Principal::MakeSourceIpPrincipal(
             std::move(cidr_range->cidr_range)));
     return;
   }
-  cidr_range = LoadJsonObjectField<CidrRange>(json.object_value(), args,
+  cidr_range = LoadJsonObjectField<CidrRange>(json.object(), args,
                                               "directRemoteIp", errors,
                                               /*required=*/false);
   if (cidr_range.has_value()) {
@@ -630,50 +630,49 @@ void RbacConfig::RbacPolicy::Rules::Policy::Principal::JsonPostLoad(
             std::move(cidr_range->cidr_range)));
     return;
   }
-  cidr_range = LoadJsonObjectField<CidrRange>(json.object_value(), args,
-                                              "remoteIp", errors,
-                                              /*required=*/false);
+  cidr_range =
+      LoadJsonObjectField<CidrRange>(json.object(), args, "remoteIp", errors,
+                                     /*required=*/false);
   if (cidr_range.has_value()) {
     principal = std::make_unique<Rbac::Principal>(
         Rbac::Principal::MakeRemoteIpPrincipal(
             std::move(cidr_range->cidr_range)));
     return;
   }
-  auto header = LoadJsonObjectField<HeaderMatch>(json.object_value(), args,
-                                                 "header", errors,
-                                                 /*required=*/false);
+  auto header =
+      LoadJsonObjectField<HeaderMatch>(json.object(), args, "header", errors,
+                                       /*required=*/false);
   if (header.has_value()) {
     principal = std::make_unique<Rbac::Principal>(
         Rbac::Principal::MakeHeaderPrincipal(std::move(header->matcher)));
     return;
   }
-  auto url_path = LoadJsonObjectField<PathMatch>(json.object_value(), args,
-                                                 "urlPath", errors,
-                                                 /*required=*/false);
+  auto url_path =
+      LoadJsonObjectField<PathMatch>(json.object(), args, "urlPath", errors,
+                                     /*required=*/false);
   if (url_path.has_value()) {
     principal = std::make_unique<Rbac::Principal>(
         Rbac::Principal::MakePathPrincipal(std::move(url_path->path.matcher)));
     return;
   }
-  auto metadata = LoadJsonObjectField<Metadata>(json.object_value(), args,
-                                                "metadata", errors,
-                                                /*required=*/false);
+  auto metadata =
+      LoadJsonObjectField<Metadata>(json.object(), args, "metadata", errors,
+                                    /*required=*/false);
   if (metadata.has_value()) {
     principal = std::make_unique<Rbac::Principal>(
         Rbac::Principal::MakeMetadataPrincipal(metadata->invert));
     return;
   }
-  auto ids = LoadJsonObjectField<PrincipalList>(json.object_value(), args,
-                                                "andIds", errors,
-                                                /*required=*/false);
+  auto ids =
+      LoadJsonObjectField<PrincipalList>(json.object(), args, "andIds", errors,
+                                         /*required=*/false);
   if (ids.has_value()) {
     principal =
         std::make_unique<Rbac::Principal>(Rbac::Principal::MakeAndPrincipal(
             MakeRbacPrincipalList(std::move(ids->ids))));
     return;
   }
-  ids = LoadJsonObjectField<PrincipalList>(json.object_value(), args, "orIds",
-                                           errors,
+  ids = LoadJsonObjectField<PrincipalList>(json.object(), args, "orIds", errors,
                                            /*required=*/false);
   if (ids.has_value()) {
     principal =
@@ -682,7 +681,7 @@ void RbacConfig::RbacPolicy::Rules::Policy::Principal::JsonPostLoad(
     return;
   }
   auto not_rule =
-      LoadJsonObjectField<Principal>(json.object_value(), args, "notId", errors,
+      LoadJsonObjectField<Principal>(json.object(), args, "notId", errors,
                                      /*required=*/false);
   if (not_rule.has_value()) {
     principal = std::make_unique<Rbac::Principal>(

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

@@ -29,6 +29,7 @@
 #include <new>
 #include <string>
 #include <utility>
+#include <vector>
 
 #include "absl/base/attributes.h"
 #include "absl/status/status.h"
@@ -47,7 +48,7 @@
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
-#include "src/core/ext/transport/chttp2/transport/context_list.h"
+#include "src/core/ext/transport/chttp2/transport/context_list_entry.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/frame_data.h"
@@ -78,7 +79,6 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/port.h"
-#include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
@@ -215,6 +215,9 @@ grpc_core::CallTracerInterface* CallTracerIfEnabled(grpc_chttp2_stream* s) {
           s->context)[GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE]
           .value);
 }
+
+grpc_core::WriteTimestampsCallback g_write_timestamps_callback = nullptr;
+grpc_core::CopyContextFn g_get_copied_context_fn = nullptr;
 }  // namespace
 
 namespace grpc_core {
@@ -241,6 +244,40 @@ void TestOnlyGlobalHttp2TransportDisableTransientFailureStateNotification(
   test_only_disable_transient_failure_state_notification = disable;
 }
 
+void GrpcHttp2SetWriteTimestampsCallback(WriteTimestampsCallback fn) {
+  g_write_timestamps_callback = fn;
+}
+
+void GrpcHttp2SetCopyContextFn(CopyContextFn fn) {
+  g_get_copied_context_fn = fn;
+}
+
+WriteTimestampsCallback GrpcHttp2GetWriteTimestampsCallback() {
+  return g_write_timestamps_callback;
+}
+
+CopyContextFn GrpcHttp2GetCopyContextFn() { return g_get_copied_context_fn; }
+
+// For each entry in the passed ContextList, it executes the function set using
+// GrpcHttp2SetWriteTimestampsCallback method with each context in the list
+// and \a ts. It also deletes/frees up the passed ContextList after this
+// operation.
+void ForEachContextListEntryExecute(void* arg, Timestamps* ts,
+                                    grpc_error_handle error) {
+  ContextList* context_list = reinterpret_cast<ContextList*>(arg);
+  if (!context_list) {
+    return;
+  }
+  for (auto it = context_list->begin(); it != context_list->end(); it++) {
+    ContextListEntry& entry = (*it);
+    if (ts) {
+      ts->byte_offset = static_cast<uint32_t>(entry.ByteOffsetInStream());
+    }
+    g_write_timestamps_callback(entry.TraceContext(), ts, error);
+  }
+  delete context_list;
+}
+
 }  // namespace grpc_core
 
 //
@@ -265,7 +302,9 @@ grpc_chttp2_transport::~grpc_chttp2_transport() {
   grpc_error_handle error = GRPC_ERROR_CREATE("Transport destroyed");
   // ContextList::Execute follows semantics of a callback function and does not
   // take a ref on error
-  grpc_core::ContextList::Execute(cl, nullptr, error);
+  if (cl != nullptr) {
+    grpc_core::ForEachContextListEntryExecute(cl, nullptr, error);
+  }
   cl = nullptr;
 
   grpc_slice_buffer_destroy(&read_buffer);
@@ -370,6 +409,8 @@ static void read_channel_args(grpc_chttp2_transport* t,
                 .GetObjectRef<grpc_core::channelz::SocketNode::Security>());
   }
 
+  t->ack_pings = channel_args.GetBool("grpc.http2.ack_pings").value_or(true);
+
   const int soft_limit =
       channel_args.GetInt(GRPC_ARG_MAX_METADATA_SIZE).value_or(-1);
   if (soft_limit < 0) {
@@ -444,7 +485,7 @@ static void read_channel_args(grpc_chttp2_transport* t,
         // `GRPC_ARG_ABSOLUTE_MAX_METADATA_SIZE` is not set.
         const int soft_limit = channel_args.GetInt(GRPC_ARG_MAX_METADATA_SIZE)
                                    .value_or(setting.default_value);
-        const int value = (soft_limit < (INT_MAX / 1.25))
+        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) {
@@ -553,6 +594,7 @@ grpc_chttp2_transport::grpc_chttp2_transport(
       event_engine(
           channel_args
               .GetObjectRef<grpc_event_engine::experimental::EventEngine>()) {
+  cl = new grpc_core::ContextList();
   GPR_ASSERT(strlen(GRPC_CHTTP2_CLIENT_CONNECT_STRING) ==
              GRPC_CHTTP2_CLIENT_CONNECT_STRLEN);
   base.vtable = get_vtable();
@@ -984,7 +1026,17 @@ static void write_action_begin_locked(void* gt,
 static void write_action(void* gt, grpc_error_handle /*error*/) {
   grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(gt);
   void* cl = t->cl;
-  t->cl = nullptr;
+  if (!t->cl->empty()) {
+    // Transfer the ownership of the context list to the endpoint and create and
+    // associate a new context list with the transport.
+    // The old context list is stored in the cl local variable which is passed
+    // to the endpoint. Its upto the endpoint to manage its lifetime.
+    t->cl = new grpc_core::ContextList();
+  } else {
+    // t->cl is Empty. There is nothing to trace in this endpoint_write. set cl
+    // to nullptr.
+    cl = nullptr;
+  }
   // Choose max_frame_size as the prefered rx crypto frame size indicated by the
   // peer.
   int max_frame_size =
@@ -1694,7 +1746,7 @@ namespace {
 // Fire and forget (deletes itself on completion). Does a graceful shutdown by
 // sending a GOAWAY frame with the last stream id set to 2^31-1, sending a ping
 // and waiting for an ack (effective waiting for an RTT) and then sending a
-// final GOAWAY freame with an updated last stream identifier. This helps ensure
+// final GOAWAY frame with an updated last stream identifier. This helps ensure
 // that a connection can be cleanly shut down without losing requests.
 // In the event, that the client does not respond to the ping for some reason,
 // we add a 20 second deadline, after which we send the second goaway.
@@ -1707,6 +1759,8 @@ class GracefulGoaway : public grpc_core::RefCounted<GracefulGoaway> {
   }
 
  private:
+  using TaskHandle = ::grpc_event_engine::experimental::EventEngine::TaskHandle;
+
   explicit GracefulGoaway(grpc_chttp2_transport* t) : t_(t) {
     t->sent_goaway_state = GRPC_CHTTP2_GRACEFUL_GOAWAY;
     GRPC_CHTTP2_REF_TRANSPORT(t_, "graceful goaway");
@@ -1714,10 +1768,17 @@ class GracefulGoaway : public grpc_core::RefCounted<GracefulGoaway> {
     send_ping_locked(
         t, nullptr, GRPC_CLOSURE_INIT(&on_ping_ack_, OnPingAck, this, nullptr));
     grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_GOAWAY_SENT);
-    Ref().release();  // Ref for the timer
-    grpc_timer_init(
-        &timer_, grpc_core::Timestamp::Now() + grpc_core::Duration::Seconds(20),
-        GRPC_CLOSURE_INIT(&on_timer_, OnTimer, this, nullptr));
+    timer_handle_ = t_->event_engine->RunAfter(
+        grpc_core::Duration::Seconds(20),
+        [self = Ref(DEBUG_LOCATION, "GoawayTimer")]() mutable {
+          grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+          grpc_core::ExecCtx exec_ctx;
+          // The ref will be unreffed in the combiner.
+          auto* ptr = self.release();
+          ptr->t_->combiner->Run(
+              GRPC_CLOSURE_INIT(&ptr->on_timer_, OnTimerLocked, ptr, nullptr),
+              absl::OkStatus());
+        });
   }
 
   void MaybeSendFinalGoawayLocked() {
@@ -1757,31 +1818,25 @@ class GracefulGoaway : public grpc_core::RefCounted<GracefulGoaway> {
 
   static void OnPingAckLocked(void* arg, grpc_error_handle /* error */) {
     auto* self = static_cast<GracefulGoaway*>(arg);
-    grpc_timer_cancel(&self->timer_);
+    if (self->timer_handle_ != TaskHandle::kInvalid) {
+      self->t_->event_engine->Cancel(
+          std::exchange(self->timer_handle_, TaskHandle::kInvalid));
+    }
     self->MaybeSendFinalGoawayLocked();
     self->Unref();
   }
 
-  static void OnTimer(void* arg, grpc_error_handle error) {
-    auto* self = static_cast<GracefulGoaway*>(arg);
-    if (!error.ok()) {
-      self->Unref();
-      return;
-    }
-    self->t_->combiner->Run(
-        GRPC_CLOSURE_INIT(&self->on_timer_, OnTimerLocked, self, nullptr),
-        absl::OkStatus());
-  }
-
   static void OnTimerLocked(void* arg, grpc_error_handle /* error */) {
     auto* self = static_cast<GracefulGoaway*>(arg);
+    // Clearing the handle since the timer has fired and the handle is invalid.
+    self->timer_handle_ = TaskHandle::kInvalid;
     self->MaybeSendFinalGoawayLocked();
     self->Unref();
   }
 
   grpc_chttp2_transport* t_;
   grpc_closure on_ping_ack_;
-  grpc_timer timer_;
+  TaskHandle timer_handle_ = TaskHandle::kInvalid;
   grpc_closure on_timer_;
 };
 

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

@@ -27,8 +27,10 @@
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/iomgr/buffer_list.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/transport/transport_fwd.h"
 
 extern grpc_core::TraceFlag grpc_keepalive_trace;
@@ -71,6 +73,25 @@ void TestOnlySetGlobalHttp2TransportDestructCallback(
 // same time that a GOAWAY is received.
 void TestOnlyGlobalHttp2TransportDisableTransientFailureStateNotification(
     bool disable);
+
+typedef void (*WriteTimestampsCallback)(void*, Timestamps*,
+                                        grpc_error_handle error);
+typedef void* (*CopyContextFn)(void*);
+
+void GrpcHttp2SetWriteTimestampsCallback(WriteTimestampsCallback fn);
+void GrpcHttp2SetCopyContextFn(CopyContextFn fn);
+
+WriteTimestampsCallback GrpcHttp2GetWriteTimestampsCallback();
+CopyContextFn GrpcHttp2GetCopyContextFn();
+
+// Interprets the passed arg as a ContextList type and for each entry in the
+// passed ContextList, it executes the function set using
+// GrpcHttp2SetWriteTimestampsCallback method with each context in the list
+// and \a ts. It also deletes/frees up the passed ContextList after this
+// operation.
+void ForEachContextListEntryExecute(void* arg, Timestamps* ts,
+                                    grpc_error_handle error);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_CHTTP2_TRANSPORT_H

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

@@ -0,0 +1,70 @@
+//
+//
+// Copyright 2018 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_CONTEXT_LIST_ENTRY_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_CONTEXT_LIST_ENTRY_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <vector>
+
+namespace grpc_core {
+
+/// An RPC trace context and associated information. Each RPC/stream is
+/// associated with a unique \a context. A new ContextList entry is created when
+/// a chunk of data stored in an outgoing buffer is going to be
+// 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,
+                   int64_t num_traced_bytes, size_t byte_offset)
+      : trace_context_(context),
+        relative_start_pos_in_chunk_(relative_start_pos),
+        num_traced_bytes_in_chunk_(num_traced_bytes),
+        byte_offset_in_stream_(byte_offset) {}
+
+  ContextListEntry() = delete;
+
+  void* TraceContext() { return trace_context_; }
+  int64_t RelativeStartPosInChunk() { return relative_start_pos_in_chunk_; }
+  int64_t NumTracedBytesInChunk() { return num_traced_bytes_in_chunk_; }
+  size_t ByteOffsetInStream() { return byte_offset_in_stream_; }
+
+ private:
+  void* trace_context_;
+  int64_t relative_start_pos_in_chunk_;
+  int64_t num_traced_bytes_in_chunk_;
+  size_t byte_offset_in_stream_;
+};
+
+/// A list of RPC Contexts
+typedef std::vector<ContextListEntry> ContextList;
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_CONTEXT_LIST_ENTRY_H

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

@@ -35,8 +35,6 @@
 #include "src/core/ext/transport/chttp2/transport/stream_map.h"
 #include "src/core/lib/gprpp/time.h"
 
-static bool g_disable_ping_ack = false;
-
 grpc_slice grpc_chttp2_ping_create(uint8_t ack, uint64_t opaque_8bytes) {
   grpc_slice slice = GRPC_SLICE_MALLOC(9 + 8);
   uint8_t* p = GRPC_SLICE_START_PTR(slice);
@@ -116,7 +114,7 @@ grpc_error_handle grpc_chttp2_ping_parser_parse(void* parser,
 
         t->ping_recv_state.last_ping_recv_time = now;
       }
-      if (!g_disable_ping_ack) {
+      if (t->ack_pings) {
         if (t->ping_ack_count == t->ping_ack_capacity) {
           t->ping_ack_capacity =
               std::max(t->ping_ack_capacity * 3 / 2, size_t{3});
@@ -132,7 +130,3 @@ grpc_error_handle grpc_chttp2_ping_parser_parse(void* parser,
 
   return absl::OkStatus();
 }
-
-void grpc_set_disable_ping_ack(bool disable_ping_ack) {
-  g_disable_ping_ack = disable_ping_ack;
-}