grpc 1.78.0 → 1.80.0.pre1

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

@@ -23,10 +23,8 @@
 #include <grpc/support/port_platform.h>
 #include <limits.h>
 
-#include <algorithm>
 #include <cstddef>
 #include <cstdint>
-#include <iterator>
 #include <memory>
 #include <optional>
 #include <string>
@@ -37,7 +35,6 @@
 #include "src/core/call/message.h"
 #include "src/core/call/metadata.h"
 #include "src/core/call/metadata_batch.h"
-#include "src/core/call/metadata_info.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control_manager.h"
@@ -53,23 +50,23 @@
 #include "src/core/ext/transport/chttp2/transport/keepalive.h"
 #include "src/core/ext/transport/chttp2/transport/message_assembler.h"
 #include "src/core/ext/transport/chttp2/transport/ping_promise.h"
+#include "src/core/ext/transport/chttp2/transport/security_frame.h"
 #include "src/core/ext/transport/chttp2/transport/stream.h"
 #include "src/core/ext/transport/chttp2/transport/stream_data_queue.h"
 #include "src/core/ext/transport/chttp2/transport/transport_common.h"
+#include "src/core/ext/transport/chttp2/transport/write_cycle.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/promise/activity.h"
-#include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/for_each.h"
 #include "src/core/lib/promise/if.h"
 #include "src/core/lib/promise/loop.h"
 #include "src/core/lib/promise/map.h"
-#include "src/core/lib/promise/match_promise.h"
 #include "src/core/lib/promise/party.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/promise/race.h"
 #include "src/core/lib/promise/sleep.h"
+#include "src/core/lib/promise/status_flag.h"
 #include "src/core/lib/promise/try_seq.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
@@ -85,25 +82,24 @@
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
-#include "absl/base/thread_annotations.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/cord.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/span.h"
 
 namespace grpc_core {
 namespace http2 {
 
-// TODO(akshitpatel)(tjagtap) [PH2][P2] : When settings frame increases incoming
+// TODO(akshitpatel)(tjagtap) [PH2][P1] : When settings frame increases incoming
 // window size, our transport must make the streams that were blocked on stream
 // flow control as writeable.
 
 // As a gRPC server never initiates a stream, the last incoming stream id on
 // the client side will always be 0.
 constexpr uint32_t kLastIncomingStreamIdClient = 0;
+const bool kIsClient = true;
 
 using grpc_event_engine::experimental::EventEngine;
 using StreamWritabilityUpdate =
@@ -113,39 +109,13 @@ using StreamWritabilityUpdate =
 // and it is functions. The code will be written iteratively.
 // Do not use or edit any of these functions unless you are
 // familiar with the PH2 project (Moving chttp2 to promises.)
-// TODO(tjagtap) : [PH2][P3] : Delete this comment when http2
-// rollout begins
-
-template <typename Factory>
-void Http2ClientTransport::SpawnInfallible(RefCountedPtr<Party> party,
-                                           absl::string_view name,
-                                           Factory&& factory) {
-  party->Spawn(name, std::forward<Factory>(factory), [](Empty) {});
-}
-
-template <typename Factory>
-void Http2ClientTransport::SpawnInfallibleTransportParty(absl::string_view name,
-                                                         Factory&& factory) {
-  SpawnInfallible(general_party_, name, std::forward<Factory>(factory));
-}
-
-template <typename Factory>
-void Http2ClientTransport::SpawnGuardedTransportParty(absl::string_view name,
-                                                      Factory&& factory) {
-  general_party_->Spawn(
-      name, std::forward<Factory>(factory),
-      [self = RefAsSubclass<Http2ClientTransport>()](absl::Status status) {
-        if (!status.ok()) {
-          GRPC_UNUSED absl::Status error = self->HandleError(
-              /*stream_id=*/std::nullopt, ToHttpOkOrConnError(status));
-        }
-      });
-}
+// TODO(tjagtap) : [PH2][P5] : Update the experimental status of the code when
+// http2 rollout is completed.
 
 void Http2ClientTransport::PerformOp(grpc_transport_op* op) {
   // Notes : Refer : src/core/ext/transport/chaotic_good/client_transport.cc
   // Functions : StartConnectivityWatch, StopConnectivityWatch, PerformOp
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport PerformOp Begin";
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::PerformOp Begin";
   bool did_stuff = false;
   if (op->start_connectivity_watch != nullptr) {
     StartConnectivityWatch(op->start_connectivity_watch_state,
@@ -161,7 +131,7 @@ void Http2ClientTransport::PerformOp(grpc_transport_op* op) {
   GRPC_DCHECK(did_stuff) << "Unimplemented transport perform op ";
 
   ExecCtx::Run(DEBUG_LOCATION, op->on_consumed, absl::OkStatus());
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport PerformOp End";
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::PerformOp End";
   // TODO(tjagtap) : [PH2][P2] :
   // Refer src/core/ext/transport/chttp2/transport/chttp2_transport.cc
   // perform_transport_op_locked
@@ -193,8 +163,9 @@ void Http2ClientTransport::ReportDisconnection(
 void Http2ClientTransport::ReportDisconnectionLocked(
     const absl::Status& status, StateWatcher::DisconnectInfo disconnect_info,
     const char* reason) {
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport ReportDisconnection: status="
-                         << status.ToString() << "; reason=" << reason;
+  GRPC_HTTP2_CLIENT_DLOG
+      << "Http2ClientTransport::ReportDisconnectionLocked status="
+      << status.ToString() << "; reason=" << reason;
   state_tracker_.SetState(GRPC_CHANNEL_TRANSIENT_FAILURE, status, reason);
   NotifyStateWatcherOnDisconnectLocked(status, disconnect_info);
 }
@@ -230,8 +201,27 @@ void Http2ClientTransport::NotifyStateWatcherOnDisconnectLocked(
   });
 }
 
+absl::Status Http2ClientTransport::AckPing(uint64_t opaque_data) {
+  // It is possible that the PingRatePolicy may decide to not send a ping
+  // request (in cases like the number of inflight pings is too high).
+  // When this happens, it becomes important to ensure that if a ping ack
+  // is received and there is an "important" outstanding ping request, we
+  // should retry to send it out now.
+  if (ping_manager_->AckPing(opaque_data)) {
+    if (ping_manager_->ImportantPingRequested()) {
+      return TriggerWriteCycle();
+    }
+  } else {
+    GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::AckPing Unknown ping "
+                              "response received for ping id="
+                           << opaque_data;
+  }
+
+  return absl::OkStatus();
+}
+
 void Http2ClientTransport::Orphan() {
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport Orphan Begin";
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::Orphan Begin";
   // Accessing general_party here is not advisable. It may so happen that
   // the party is already freed/may free up any time. The only guarantee here
   // is that the transport is still valid.
@@ -239,37 +229,33 @@ void Http2ClientTransport::Orphan() {
   MaybeSpawnCloseTransport(
       ToHttpOkOrConnError(absl::UnavailableError("Orphaned")));
   Unref();
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport Orphan End";
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::Orphan End";
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Processing each type of frame
 
-Http2Status Http2ClientTransport::ProcessHttp2DataFrame(Http2DataFrame frame) {
+Http2Status Http2ClientTransport::ProcessIncomingFrame(Http2DataFrame&& frame) {
   // https://www.rfc-editor.org/rfc/rfc9113.html#name-data
   GRPC_HTTP2_CLIENT_DLOG
-      << "Http2ClientTransport ProcessHttp2DataFrame { stream_id="
-      << frame.stream_id << ", end_stream=" << frame.end_stream
-      << ", payload=" << MaybeTruncatePayload(frame.payload)
+      << "Http2ClientTransport::ProcessIncomingFrame(DataFrame) { stream_id="
+      << frame.stream_id << ", end_stream:" << frame.end_stream
       << ", payload length=" << frame.payload.Length() << "}";
 
   // TODO(akshitpatel) : [PH2][P3] : Investigate if we should do this even if
   // the function returns a non-ok status?
   ping_manager_->ReceivedDataFrame();
 
-  // Lookup stream
-  GRPC_HTTP2_CLIENT_DLOG
-      << "Http2ClientTransport ProcessHttp2DataFrame LookupStream";
   RefCountedPtr<Stream> stream = LookupStream(frame.stream_id);
 
   ValueOrHttp2Status<chttp2::FlowControlAction> flow_control_action =
       ProcessIncomingDataFrameFlowControl(current_frame_header_, flow_control_,
-                                          stream);
+                                          stream.get());
   if (!flow_control_action.IsOk()) {
     return ValueOrHttp2Status<chttp2::FlowControlAction>::TakeStatus(
         std::move(flow_control_action));
   }
-  ActOnFlowControlAction(flow_control_action.value(), stream);
+  ActOnFlowControlAction(flow_control_action.value(), stream.get());
 
   if (stream == nullptr) {
     // TODO(tjagtap) : [PH2][P2] : Implement the correct behaviour later.
@@ -277,7 +263,7 @@ Http2Status Http2ClientTransport::ProcessHttp2DataFrame(Http2DataFrame frame) {
     // or "half-closed (local)" state, the recipient MUST respond with a stream
     // error (Section 5.4.2) of type STREAM_CLOSED.
     GRPC_HTTP2_CLIENT_DLOG
-        << "Http2ClientTransport ProcessHttp2DataFrame { stream_id="
+        << "Http2ClientTransport::ProcessIncomingFrame(DataFrame) { stream_id="
         << frame.stream_id << "} Lookup Failed";
     return Http2Status::Ok();
   }
@@ -292,36 +278,41 @@ Http2Status Http2ClientTransport::ProcessHttp2DataFrame(Http2DataFrame frame) {
 
   // Add frame to assembler
   GRPC_HTTP2_CLIENT_DLOG
-      << "Http2ClientTransport ProcessHttp2DataFrame AppendNewDataFrame";
-  GrpcMessageAssembler& assembler = stream->assembler;
+      << "Http2ClientTransport::ProcessIncomingFrame(DataFrame) "
+         "AppendNewDataFrame";
+  GrpcMessageAssembler& assembler = stream->GetGrpcMessageAssembler();
   Http2Status status =
       assembler.AppendNewDataFrame(frame.payload, frame.end_stream);
   if (!status.IsOk()) {
-    GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport ProcessHttp2DataFrame "
-                              "AppendNewDataFrame Failed";
+    GRPC_HTTP2_CLIENT_DLOG
+        << "Http2ClientTransport::ProcessIncomingFrame(DataFrame) "
+           "AppendNewDataFrame Failed";
     return status;
   }
 
   // Pass the messages up the stack if it is ready.
   while (true) {
     GRPC_HTTP2_CLIENT_DLOG
-        << "Http2ClientTransport ProcessHttp2DataFrame ExtractMessage";
+        << "Http2ClientTransport::ProcessIncomingFrame(DataFrame) "
+           "ExtractMessage";
     ValueOrHttp2Status<MessageHandle> result = assembler.ExtractMessage();
     if (!result.IsOk()) {
       GRPC_HTTP2_CLIENT_DLOG
-          << "Http2ClientTransport ProcessHttp2DataFrame ExtractMessage Failed";
+          << "Http2ClientTransport::ProcessIncomingFrame(DataFrame) "
+             "ExtractMessage Failed";
       return ValueOrHttp2Status<MessageHandle>::TakeStatus(std::move(result));
     }
     MessageHandle message = TakeValue(std::move(result));
     if (message != nullptr) {
       GRPC_HTTP2_CLIENT_DLOG
-          << "Http2ClientTransport ProcessHttp2DataFrame SpawnPushMessage "
+          << "Http2ClientTransport::ProcessIncomingFrame(DataFrame) "
+             "SpawnPushMessage "
           << message->DebugString();
-      stream->call.SpawnPushMessage(std::move(message));
+      stream->GetCallHandler().SpawnPushMessage(std::move(message));
       continue;
     }
     GRPC_HTTP2_CLIENT_DLOG
-        << "Http2ClientTransport ProcessHttp2DataFrame While Break";
+        << "Http2ClientTransport::ProcessIncomingFrame(DataFrame) While Break";
     break;
   }
 
@@ -337,14 +328,13 @@ Http2Status Http2ClientTransport::ProcessHttp2DataFrame(Http2DataFrame frame) {
   return Http2Status::Ok();
 }
 
-Http2Status Http2ClientTransport::ProcessHttp2HeaderFrame(
-    Http2HeaderFrame frame) {
+Http2Status Http2ClientTransport::ProcessIncomingFrame(
+    Http2HeaderFrame&& frame) {
   // https://www.rfc-editor.org/rfc/rfc9113.html#name-headers
   GRPC_HTTP2_CLIENT_DLOG
-      << "Http2ClientTransport ProcessHttp2HeaderFrame Promise { stream_id="
+      << "Http2ClientTransport::ProcessIncomingFrame(HeaderFrame) { stream_id="
       << frame.stream_id << ", end_headers=" << frame.end_headers
-      << ", end_stream=" << frame.end_stream
-      << ", payload=" << MaybeTruncatePayload(frame.payload) << " }";
+      << ", end_stream=" << frame.end_stream << " }";
   // State update MUST happen before processing the frame.
   incoming_headers_.OnHeaderReceived(frame);
 
@@ -360,7 +350,8 @@ Http2Status Http2ClientTransport::ProcessHttp2HeaderFrame(
     // receives an unexpected stream identifier MUST respond with a connection
     // error (Section 5.4.1) of type PROTOCOL_ERROR.
     GRPC_HTTP2_CLIENT_DLOG
-        << "Http2ClientTransport ProcessHttp2HeaderFrame Promise { stream_id="
+        << "Http2ClientTransport::ProcessIncomingFrame(HeaderFrame) { "
+           "stream_id="
         << frame.stream_id << "} Lookup Failed";
     return ParseAndDiscardHeaders(std::move(frame.payload), frame.end_headers,
                                   /*stream=*/nullptr, Http2Status::Ok());
@@ -368,85 +359,49 @@ Http2Status Http2ClientTransport::ProcessHttp2HeaderFrame(
 
   if (stream->IsStreamHalfClosedRemote()) {
     return ParseAndDiscardHeaders(
-        std::move(frame.payload), frame.end_headers, stream,
+        std::move(frame.payload), frame.end_headers, stream.get(),
         Http2Status::Http2StreamError(
             Http2ErrorCode::kStreamClosed,
             std::string(RFC9113::kHalfClosedRemoteState)));
   }
 
-  if (incoming_headers_.ClientReceivedDuplicateMetadata(
-          stream->did_receive_initial_metadata,
-          stream->did_receive_trailing_metadata)) {
+  if (incoming_headers_.DidReceiveDuplicateMetadata(
+          stream->IsInitialMetadataReceived(),
+          stream->IsTrailingMetadataReceived())) {
     return ParseAndDiscardHeaders(
-        std::move(frame.payload), frame.end_headers, stream,
+        std::move(frame.payload), frame.end_headers, stream.get(),
         Http2Status::Http2StreamError(
             Http2ErrorCode::kInternalError,
             std::string(GrpcErrors::kTooManyMetadata)));
   }
 
-  Http2Status append_result = stream->header_assembler.AppendHeaderFrame(frame);
+  Http2Status append_result =
+      stream->GetHeaderAssembler().AppendHeaderFrame(frame);
   if (!append_result.IsOk()) {
     // Frame payload is not consumed if AppendHeaderFrame returns a non-OK
     // status. We need to process it to keep our in consistent state.
     return ParseAndDiscardHeaders(std::move(frame.payload), frame.end_headers,
-                                  stream, std::move(append_result));
+                                  stream.get(), std::move(append_result));
   }
 
   Http2Status status = ProcessMetadata(stream);
   if (!status.IsOk()) {
     // Frame payload has been moved to the HeaderAssembler. So calling
     // ParseAndDiscardHeaders with an empty buffer.
-    return ParseAndDiscardHeaders(SliceBuffer(), frame.end_headers, stream,
-                                  std::move(status));
+    return ParseAndDiscardHeaders(SliceBuffer(), frame.end_headers,
+                                  stream.get(), std::move(status));
   }
 
   // Frame payload has either been processed or moved to the HeaderAssembler.
   return Http2Status::Ok();
 }
 
-Http2Status Http2ClientTransport::ProcessMetadata(
-    RefCountedPtr<Stream> stream) {
-  HeaderAssembler& assembler = stream->header_assembler;
-  CallHandler call = stream->call;
-
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport ProcessMetadata";
-  if (assembler.IsReady()) {
-    ValueOrHttp2Status<ServerMetadataHandle> read_result =
-        assembler.ReadMetadata(parser_, !incoming_headers_.HeaderHasEndStream(),
-                               /*is_client=*/true,
-                               /*max_header_list_size_soft_limit=*/
-                               incoming_headers_.soft_limit(),
-                               /*max_header_list_size_hard_limit=*/
-                               settings_->acked().max_header_list_size());
-    if (read_result.IsOk()) {
-      ServerMetadataHandle metadata = TakeValue(std::move(read_result));
-      if (incoming_headers_.HeaderHasEndStream()) {
-        // TODO(tjagtap) : [PH2][P1] : Is this the right way to differentiate
-        // between initial and trailing metadata?
-        stream->MarkHalfClosedRemote();
-        stream->did_receive_trailing_metadata = true;
-        BeginCloseStream(stream, /*reset_stream_error_code=*/std::nullopt,
-                         std::move(metadata));
-      } else {
-        GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport ProcessMetadata "
-                                  "SpawnPushServerInitialMetadata";
-        stream->did_receive_initial_metadata = true;
-        call.SpawnPushServerInitialMetadata(std::move(metadata));
-      }
-      return Http2Status::Ok();
-    }
-    GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport ProcessMetadata Failed";
-    return ValueOrHttp2Status<Arena::PoolPtr<grpc_metadata_batch>>::TakeStatus(
-        std::move(read_result));
-  }
-  return Http2Status::Ok();
-}
-
-Http2Status Http2ClientTransport::ProcessHttp2RstStreamFrame(
-    Http2RstStreamFrame frame) {
+Http2Status Http2ClientTransport::ProcessIncomingFrame(
+    Http2RstStreamFrame&& frame) {
   // https://www.rfc-editor.org/rfc/rfc9113.html#name-rst_stream
   GRPC_HTTP2_CLIENT_DLOG
-      << "Http2ClientTransport ProcessHttp2RstStreamFrame { stream_id="
+      << "Http2ClientTransport::ProcessIncomingFrame(RstStreamFrame) { "
+         "stream_id="
       << frame.stream_id << ", error_code=" << frame.error_code << " }";
 
   Http2ErrorCode error_code = FrameErrorCodeToHttp2ErrorCode(frame.error_code);
@@ -455,7 +410,8 @@ Http2Status Http2ClientTransport::ProcessHttp2RstStreamFrame(
   RefCountedPtr<Stream> stream = LookupStream(frame.stream_id);
   if (stream != nullptr) {
     stream->MarkHalfClosedRemote();
-    BeginCloseStream(stream, /*reset_stream_error_code=*/std::nullopt,
+    BeginCloseStream(std::move(stream),
+                     /*reset_stream_error_code=*/std::nullopt,
                      CancelledServerMetadataFromStatus(status));
   }
 
@@ -464,13 +420,13 @@ Http2Status Http2ClientTransport::ProcessHttp2RstStreamFrame(
   return Http2Status::Ok();
 }
 
-Http2Status Http2ClientTransport::ProcessHttp2SettingsFrame(
-    Http2SettingsFrame frame) {
+Http2Status Http2ClientTransport::ProcessIncomingFrame(
+    Http2SettingsFrame&& frame) {
   // https://www.rfc-editor.org/rfc/rfc9113.html#name-settings
 
   GRPC_HTTP2_CLIENT_DLOG
-      << "Http2ClientTransport ProcessHttp2SettingsFrame { ack=" << frame.ack
-      << ", settings length=" << frame.settings.size() << "}";
+      << "Http2ClientTransport::ProcessIncomingFrame(SettingsFrame) { ack="
+      << frame.ack << ", settings length=" << frame.settings.size() << "}";
 
   if (!frame.ack) {
     Http2Status status = ValidateSettingsValues(frame.settings);
@@ -478,7 +434,11 @@ Http2Status Http2ClientTransport::ProcessHttp2SettingsFrame(
       return status;
     }
     settings_->BufferPeerSettings(std::move(frame.settings));
-    SpawnGuardedTransportParty("SettingsAck", TriggerWriteCycle());
+    absl::Status trigger_write_status = TriggerWriteCycle();
+    if (!trigger_write_status.ok()) {
+      return ToHttpOkOrConnError(trigger_write_status);
+    }
+
     if (GPR_UNLIKELY(!settings_->IsFirstPeerSettingsApplied())) {
       // Apply the first settings before we read any other frames.
       reader_state_.SetPauseReadLoop();
@@ -501,63 +461,53 @@ Http2Status Http2ClientTransport::ProcessHttp2SettingsFrame(
   return Http2Status::Ok();
 }
 
-auto Http2ClientTransport::ProcessHttp2PingFrame(Http2PingFrame frame) {
+Http2Status Http2ClientTransport::ProcessIncomingFrame(Http2PingFrame&& frame) {
   // https://www.rfc-editor.org/rfc/rfc9113.html#name-ping
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport ProcessHttp2PingFrame { ack="
-                         << frame.ack << ", opaque=" << frame.opaque << " }";
-  return AssertResultType<Http2Status>(If(
-      frame.ack,
-      [self = RefAsSubclass<Http2ClientTransport>(), opaque = frame.opaque]() {
-        // Received a ping ack.
-        return self->AckPing(opaque);
-      },
-      [self = RefAsSubclass<Http2ClientTransport>(), opaque = frame.opaque]() {
-        return If(
-            self->test_only_ack_pings_,
-            [self, opaque]() {
-              // TODO(akshitpatel) : [PH2][P2] : Have a counter to track number
-              // of pending induced frames (Ping/Settings Ack). This is to
-              // ensure that if write is taking a long time, we can stop reads
-              // and prioritize writes. RFC9113: PING responses SHOULD be given
-              // higher priority than any other frame.
-              self->ping_manager_->AddPendingPingAck(opaque);
-              // TODO(akshitpatel) : [PH2][P2] : This is done assuming that the
-              // other ProcessFrame promises may return stream or connection
-              // failures. If this does not turn out to be true, consider
-              // returning absl::Status here.
-              return Map(self->TriggerWriteCycle(), [](absl::Status status) {
-                return ToHttpOkOrConnError(status);
-              });
-            },
-            []() {
-              GRPC_HTTP2_CLIENT_DLOG
-                  << "Http2ClientTransport ProcessHttp2PingFrame "
-                     "test_only_ack_pings_ is false. Ignoring the ping "
-                     "request.";
-              return Immediate(Http2Status::Ok());
-            });
-      }));
+  GRPC_HTTP2_CLIENT_DLOG
+      << "Http2ClientTransport::ProcessIncomingFrame(PingFrame) { ack="
+      << frame.ack << ", opaque=" << frame.opaque << " }";
+  if (frame.ack) {
+    return ToHttpOkOrConnError(AckPing(frame.opaque));
+  } else {
+    if (test_only_ack_pings_) {
+      // TODO(akshitpatel) : [PH2][P2] : Have a counter to track number
+      // of pending induced frames (Ping/Settings Ack). This is to
+      // ensure that if write is taking a long time, we can stop reads
+      // and prioritize writes. RFC9113: PING responses SHOULD be given
+      // higher priority than any other frame.
+      ping_manager_->AddPendingPingAck(frame.opaque);
+      // TODO(akshitpatel) : [PH2][P2] : This is done assuming that the
+      // other ProcessFrame promises may return stream or connection
+      // failures. If this does not turn out to be true, consider
+      // returning absl::Status here.
+      return ToHttpOkOrConnError(TriggerWriteCycle());
+    } else {
+      GRPC_HTTP2_CLIENT_DLOG
+          << "Http2ClientTransport::ProcessIncomingFrame(PingFrame) "
+             "test_only_ack_pings_ is false. Ignoring the ping request.";
+    }
+  }
+  return Http2Status::Ok();
 }
 
-Http2Status Http2ClientTransport::ProcessHttp2GoawayFrame(
-    Http2GoawayFrame frame) {
+Http2Status Http2ClientTransport::ProcessIncomingFrame(
+    Http2GoawayFrame&& frame) {
   // https://www.rfc-editor.org/rfc/rfc9113.html#name-goaway
   GRPC_HTTP2_CLIENT_DLOG
-      << "Http2ClientTransport ProcessHttp2GoawayFrame Promise { "
+      << "Http2ClientTransport::ProcessIncomingFrame(GoawayFrame) { "
          "last_stream_id="
-      << frame.last_stream_id << ", error_code=" << frame.error_code
-      << ", debug_data=" << frame.debug_data.as_string_view() << "}";
+      << frame.last_stream_id << ", error_code=" << frame.error_code << "}";
   LOG_IF(ERROR,
          frame.error_code != static_cast<uint32_t>(Http2ErrorCode::kNoError))
-      << "Received GOAWAY frame with error code: " << frame.error_code
-      << " and debug data: " << frame.debug_data.as_string_view();
+      << "Received GOAWAY frame with error code: " << frame.error_code;
 
   uint32_t last_stream_id = 0;
   absl::Status status(ErrorCodeToAbslStatusCode(
                           FrameErrorCodeToHttp2ErrorCode(frame.error_code)),
-                      frame.debug_data.as_string_view());
-  if (frame.error_code == static_cast<uint32_t>(Http2ErrorCode::kNoError) &&
-      frame.last_stream_id == RFC9113::kMaxStreamId31Bit) {
+                      frame.debug_data.empty()
+                          ? absl::string_view("GOAWAY received")
+                          : frame.debug_data.as_string_view());
+  if (GoawayManager::IsGracefulGoaway(frame)) {
     const uint32_t next_stream_id = PeekNextStreamId();
     last_stream_id = (next_stream_id > 1) ? next_stream_id - 2 : 0;
   } else {
@@ -570,7 +520,8 @@ Http2Status Http2ClientTransport::ProcessHttp2GoawayFrame(
     MutexLock lock(&transport_mutex_);
     if (CanCloseTransportLocked()) {
       close_transport = true;
-      GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport ProcessHttp2GoawayFrame "
+      GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::ProcessIncomingFrame("
+                                "GoawayFrame) "
                                 "stream_list_ is empty";
     }
   }
@@ -596,7 +547,7 @@ Http2Status Http2ClientTransport::ProcessHttp2GoawayFrame(
         keepalive_time_.millis() > max_keepalive_time_millis
             ? INT_MAX
             : keepalive_time_.millis() * KEEPALIVE_TIME_BACKOFF_MULTIPLIER;
-    if (!IsTransportStateWatcherEnabled()) {
+    if (!IsSubchannelConnectionScalingEnabled()) {
       status.SetPayload(kKeepaliveThrottlingKey,
                         absl::Cord(std::to_string(throttled_keepalive_time)));
     }
@@ -614,7 +565,9 @@ Http2Status Http2ClientTransport::ProcessHttp2GoawayFrame(
                     Http2ErrorCodeToFrameErrorCode(Http2ErrorCode::kNoError)
                 ? Http2ErrorCodeToFrameErrorCode(Http2ErrorCode::kInternalError)
                 : frame.error_code)),
-        std::string(frame.debug_data.as_string_view())));
+        frame.debug_data.empty()
+            ? std::string("GOAWAY received")
+            : std::string(frame.debug_data.as_string_view())));
   }
 
   // lie: use transient failure from the transport to indicate goaway has been
@@ -623,11 +576,11 @@ Http2Status Http2ClientTransport::ProcessHttp2GoawayFrame(
   return Http2Status::Ok();
 }
 
-Http2Status Http2ClientTransport::ProcessHttp2WindowUpdateFrame(
-    Http2WindowUpdateFrame frame) {
+Http2Status Http2ClientTransport::ProcessIncomingFrame(
+    Http2WindowUpdateFrame&& frame) {
   // https://www.rfc-editor.org/rfc/rfc9113.html#name-window_update
   GRPC_HTTP2_CLIENT_DLOG
-      << "Http2ClientTransport ProcessHttp2WindowUpdateFrame Promise { "
+      << "Http2ClientTransport::ProcessIncomingFrame(WindowUpdateFrame) { "
          " stream_id="
       << frame.stream_id << ", increment=" << frame.increment << "}";
 
@@ -647,22 +600,21 @@ Http2Status Http2ClientTransport::ProcessHttp2WindowUpdateFrame(
     }
   }
 
-  const bool should_trigger_write =
-      ProcessIncomingWindowUpdateFrameFlowControl(frame, flow_control_, stream);
+  const bool should_trigger_write = ProcessIncomingWindowUpdateFrameFlowControl(
+      frame, flow_control_, stream.get());
   if (should_trigger_write) {
-    SpawnGuardedTransportParty("TransportTokensAvailable", TriggerWriteCycle());
+    return ToHttpOkOrConnError(TriggerWriteCycle());
   }
   return Http2Status::Ok();
 }
 
-Http2Status Http2ClientTransport::ProcessHttp2ContinuationFrame(
-    Http2ContinuationFrame frame) {
+Http2Status Http2ClientTransport::ProcessIncomingFrame(
+    Http2ContinuationFrame&& frame) {
   // https://www.rfc-editor.org/rfc/rfc9113.html#name-continuation
   GRPC_HTTP2_CLIENT_DLOG
-      << "Http2ClientTransport ProcessHttp2ContinuationFrame Promise { "
+      << "Http2ClientTransport::ProcessIncomingFrame(ContinuationFrame) { "
          "stream_id="
-      << frame.stream_id << ", end_headers=" << frame.end_headers
-      << ", payload=" << MaybeTruncatePayload(frame.payload) << " }";
+      << frame.stream_id << ", end_headers=" << frame.end_headers << " }";
 
   // State update MUST happen before processing the frame.
   incoming_headers_.OnContinuationReceived(frame);
@@ -682,102 +634,102 @@ Http2Status Http2ClientTransport::ProcessHttp2ContinuationFrame(
 
   if (stream->IsStreamHalfClosedRemote()) {
     return ParseAndDiscardHeaders(
-        std::move(frame.payload), frame.end_headers, stream,
+        std::move(frame.payload), frame.end_headers, stream.get(),
         Http2Status::Http2StreamError(
             Http2ErrorCode::kStreamClosed,
             std::string(RFC9113::kHalfClosedRemoteState)));
   }
 
   Http2Status append_result =
-      stream->header_assembler.AppendContinuationFrame(frame);
+      stream->GetHeaderAssembler().AppendContinuationFrame(frame);
   if (!append_result.IsOk()) {
     // Frame payload is not consumed if AppendContinuationFrame returns a
     // non-OK status. We need to process it to keep our in consistent state.
     return ParseAndDiscardHeaders(std::move(frame.payload), frame.end_headers,
-                                  stream, std::move(append_result));
+                                  stream.get(), std::move(append_result));
   }
 
   Http2Status status = ProcessMetadata(stream);
   if (!status.IsOk()) {
     // Frame payload is consumed by HeaderAssembler. So passing an empty
     // SliceBuffer to ParseAndDiscardHeaders.
-    return ParseAndDiscardHeaders(SliceBuffer(), frame.end_headers, stream,
-                                  std::move(status));
+    return ParseAndDiscardHeaders(SliceBuffer(), frame.end_headers,
+                                  stream.get(), std::move(status));
   }
 
   // Frame payload has either been processed or moved to the HeaderAssembler.
   return Http2Status::Ok();
 }
 
-Http2Status Http2ClientTransport::ProcessHttp2SecurityFrame(
-    Http2SecurityFrame frame) {
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport ProcessHttp2SecurityFrame "
-                            "{ payload.Length="
-                         << frame.payload.Length() << " }";
+Http2Status Http2ClientTransport::ProcessIncomingFrame(
+    Http2SecurityFrame&& frame) {
+  GRPC_HTTP2_CLIENT_DLOG
+      << "Http2ClientTransport::ProcessIncomingFrame(SecurityFrame) ";
   if (settings_->IsSecurityFrameExpected()) {
-    // TODO(tjagtap) : [PH2][P3] : Add handling of Security frame
-    // Just the frame.payload needs to be passed to the endpoint_ object.
-    // Refer usage of TransportFramingEndpointExtension.
+    security_frame_handler_->ProcessPayload(std::move(frame.payload));
   }
-  // Ignore the Security frame if it is not expected.
   return Http2Status::Ok();
 }
 
-auto Http2ClientTransport::ProcessOneFrame(Http2Frame frame) {
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport ProcessOneFrame Factory";
-  return AssertResultType<Http2Status>(MatchPromise(
-      std::move(frame),
-      [self = RefAsSubclass<Http2ClientTransport>()](Http2DataFrame frame) {
-        return self->ProcessHttp2DataFrame(std::move(frame));
-      },
-      [self = RefAsSubclass<Http2ClientTransport>()](Http2HeaderFrame frame) {
-        return self->ProcessHttp2HeaderFrame(std::move(frame));
-      },
-      [self =
-           RefAsSubclass<Http2ClientTransport>()](Http2RstStreamFrame frame) {
-        return self->ProcessHttp2RstStreamFrame(frame);
-      },
-      [self = RefAsSubclass<Http2ClientTransport>()](Http2SettingsFrame frame) {
-        return self->ProcessHttp2SettingsFrame(std::move(frame));
-      },
-      [self = RefAsSubclass<Http2ClientTransport>()](Http2PingFrame frame) {
-        return self->ProcessHttp2PingFrame(frame);
-      },
-      [self = RefAsSubclass<Http2ClientTransport>()](Http2GoawayFrame frame) {
-        return self->ProcessHttp2GoawayFrame(std::move(frame));
-      },
-      [self = RefAsSubclass<Http2ClientTransport>()](
-          Http2WindowUpdateFrame frame) {
-        return self->ProcessHttp2WindowUpdateFrame(frame);
-      },
-      [self = RefAsSubclass<Http2ClientTransport>()](
-          Http2ContinuationFrame frame) {
-        return self->ProcessHttp2ContinuationFrame(std::move(frame));
-      },
-      [self = RefAsSubclass<Http2ClientTransport>()](Http2SecurityFrame frame) {
-        return self->ProcessHttp2SecurityFrame(std::move(frame));
-      },
-      [](GRPC_UNUSED Http2UnknownFrame frame) {
-        // RFC9113: Implementations MUST ignore and discard frames of
-        // unknown types.
-        return Http2Status::Ok();
-      },
-      [](GRPC_UNUSED Http2EmptyFrame frame) {
-        LOG(DFATAL)
-            << "ParseFramePayload should never return a Http2EmptyFrame";
-        return Http2Status::Ok();
-      }));
+Http2Status Http2ClientTransport::ProcessIncomingFrame(
+    GRPC_UNUSED Http2UnknownFrame&& frame) {
+  // RFC9113: Implementations MUST ignore and discard frames of
+  // unknown types.
+  GRPC_HTTP2_CLIENT_DLOG
+      << "Http2ClientTransport::ProcessIncomingFrame(UnknownFrame) ";
+  return Http2Status::Ok();
+}
+
+Http2Status Http2ClientTransport::ProcessIncomingFrame(
+    GRPC_UNUSED Http2EmptyFrame&& frame) {
+  LOG(DFATAL) << "ParseFramePayload should never return a Http2EmptyFrame";
+  return Http2Status::Ok();
+}
+
+Http2Status Http2ClientTransport::ProcessMetadata(
+    RefCountedPtr<Stream> stream) {
+  HeaderAssembler& assembler = stream->GetHeaderAssembler();
+  CallHandler& call = stream->GetCallHandler();
+
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::ProcessMetadata";
+  if (assembler.IsReady()) {
+    ValueOrHttp2Status<ServerMetadataHandle> read_result =
+        assembler.ReadMetadata(parser_, !incoming_headers_.HeaderHasEndStream(),
+                               /*max_header_list_size_soft_limit=*/
+                               incoming_headers_.soft_limit(),
+                               /*max_header_list_size_hard_limit=*/
+                               settings_->acked().max_header_list_size());
+    if (read_result.IsOk()) {
+      ServerMetadataHandle metadata = TakeValue(std::move(read_result));
+      if (incoming_headers_.HeaderHasEndStream()) {
+        stream->MarkHalfClosedRemote();
+        stream->SetTrailingMetadataReceived();
+        BeginCloseStream(std::move(stream),
+                         /*reset_stream_error_code=*/std::nullopt,
+                         std::move(metadata));
+      } else {
+        GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::ProcessMetadata "
+                                  "SpawnPushServerInitialMetadata";
+        metadata->Set(PeerString(), incoming_headers_.peer_string());
+        stream->SetInitialMetadataReceived();
+        call.SpawnPushServerInitialMetadata(std::move(metadata));
+      }
+      return Http2Status::Ok();
+    }
+    GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::ProcessMetadata Failed";
+    return ValueOrHttp2Status<Arena::PoolPtr<grpc_metadata_batch>>::TakeStatus(
+        std::move(read_result));
+  }
+  return Http2Status::Ok();
 }
 
 Http2Status Http2ClientTransport::ParseAndDiscardHeaders(
-    SliceBuffer&& buffer, const bool is_end_headers,
-    const RefCountedPtr<Stream> stream, Http2Status&& original_status,
-    DebugLocation whence) {
+    SliceBuffer&& buffer, const bool is_end_headers, Stream* stream,
+    Http2Status&& original_status, DebugLocation whence) {
   const bool is_initial_metadata = !incoming_headers_.HeaderHasEndStream();
   const uint32_t incoming_stream_id = incoming_headers_.GetStreamId();
   GRPC_HTTP2_CLIENT_DLOG
-      << "Http2ClientTransport ParseAndDiscardHeaders buffer "
-         "size: "
+      << "Http2ClientTransport::ParseAndDiscardHeaders buffer size: "
       << buffer.Length() << " is_initial_metadata: " << is_initial_metadata
       << " is_end_headers: " << is_end_headers
       << " incoming_stream_id: " << incoming_stream_id
@@ -790,7 +742,7 @@ Http2Status Http2ClientTransport::ParseAndDiscardHeaders(
       HeaderAssembler::ParseHeaderArgs{
           /*is_initial_metadata=*/is_initial_metadata,
           /*is_end_headers=*/is_end_headers,
-          /*is_client=*/true,
+          /*is_client=*/kIsClient,
           /*max_header_list_size_soft_limit=*/
           incoming_headers_.soft_limit(),
           /*max_header_list_size_hard_limit=*/
@@ -802,35 +754,9 @@ Http2Status Http2ClientTransport::ParseAndDiscardHeaders(
 
 ///////////////////////////////////////////////////////////////////////////////
 // Read Related Promises and Promise Factories
-auto Http2ClientTransport::EndpointReadSlice(const size_t num_bytes) {
-  return Map(
-      endpoint_.ReadSlice(num_bytes),
-      [self = RefAsSubclass<Http2ClientTransport>(),
-       num_bytes](absl::StatusOr<Slice> status) {
-        if (status.ok()) {
-          self->keepalive_manager_->GotData();
-          self->ztrace_collector_->Append(PromiseEndpointReadTrace{num_bytes});
-        }
-        return status;
-      });
-}
-
-auto Http2ClientTransport::EndpointRead(const size_t num_bytes) {
-  return Map(
-      endpoint_.Read(num_bytes),
-      [self = RefAsSubclass<Http2ClientTransport>(),
-       num_bytes](absl::StatusOr<SliceBuffer> status) {
-        if (status.ok()) {
-          self->keepalive_manager_->GotData();
-          self->ztrace_collector_->Append(PromiseEndpointReadTrace{num_bytes});
-        }
-        return status;
-      });
-}
-
 auto Http2ClientTransport::ReadAndProcessOneFrame() {
   GRPC_HTTP2_CLIENT_DLOG
-      << "Http2ClientTransport ReadAndProcessOneFrame Factory";
+      << "Http2ClientTransport::ReadAndProcessOneFrame Factory";
   return AssertResultType<absl::Status>(TrySeq(
       // Fetch the first kFrameHeaderSize bytes of the Frame, these contain
       // the frame header.
@@ -838,136 +764,128 @@ auto Http2ClientTransport::ReadAndProcessOneFrame() {
       // Parse the frame header.
       [](Slice header_bytes) -> Http2FrameHeader {
         GRPC_HTTP2_CLIENT_DLOG
-            << "Http2ClientTransport ReadAndProcessOneFrame Parse "
+            << "Http2ClientTransport::ReadAndProcessOneFrame Parse "
             << header_bytes.as_string_view();
         return Http2FrameHeader::Parse(header_bytes.begin());
       },
       // Validate the incoming frame as per the current state of the transport
-      [self = RefAsSubclass<Http2ClientTransport>()](Http2FrameHeader header) {
+      [this](Http2FrameHeader header) {
         Http2Status status = ValidateFrameHeader(
-            /*max_frame_size_setting*/ self->settings_->acked()
-                .max_frame_size(),
+            /*max_frame_size_setting*/ settings_->acked().max_frame_size(),
             /*incoming_header_in_progress*/
-            self->incoming_headers_.IsWaitingForContinuationFrame(),
+            incoming_headers_.IsWaitingForContinuationFrame(),
             /*incoming_header_stream_id*/
-            self->incoming_headers_.GetStreamId(),
+            incoming_headers_.GetStreamId(),
             /*current_frame_header*/ header,
-            /*last_stream_id=*/self->GetLastStreamId(),
-            /*is_client=*/true, /*is_first_settings_processed=*/
-            self->settings_->IsFirstPeerSettingsApplied());
+            /*last_stream_id=*/GetLastStreamId(),
+            /*is_client=*/kIsClient, /*is_first_settings_processed=*/
+            settings_->IsFirstPeerSettingsApplied());
 
         if (GPR_UNLIKELY(!status.IsOk())) {
           GRPC_DCHECK(status.GetType() ==
                       Http2Status::Http2ErrorType::kConnectionError);
-          return self->HandleError(std::nullopt, std::move(status));
+          return HandleError(std::nullopt, std::move(status));
         }
-        GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport ReadAndProcessOneFrame "
-                                  "Validated Frame Header:"
-                               << header.ToString();
-        self->current_frame_header_ = header;
+        GRPC_HTTP2_CLIENT_DLOG
+            << "Http2ClientTransport::ReadAndProcessOneFrame "
+               "Validated Frame Header:"
+            << header.ToString();
+        current_frame_header_ = header;
         return absl::OkStatus();
       },
       // Read the payload of the frame.
-      [self = RefAsSubclass<Http2ClientTransport>()]() {
+      [this]() {
         GRPC_HTTP2_CLIENT_DLOG
-            << "Http2ClientTransport ReadAndProcessOneFrame Read Frame ";
-        return AssertResultType<absl::StatusOr<SliceBuffer>>(
-            self->EndpointRead(self->current_frame_header_.length));
-      },
-      // Parse the payload of the frame based on frame type.
-      [self = RefAsSubclass<Http2ClientTransport>()](
-          SliceBuffer payload) -> absl::StatusOr<Http2Frame> {
-        GRPC_HTTP2_CLIENT_DLOG
-            << "Http2ClientTransport ReadAndProcessOneFrame ParseFramePayload "
-            << MaybeTruncatePayload(payload);
-        ValueOrHttp2Status<Http2Frame> frame =
-            ParseFramePayload(self->current_frame_header_, std::move(payload));
-        if (!frame.IsOk()) {
-          return self->HandleError(
-              self->current_frame_header_.stream_id,
-              ValueOrHttp2Status<Http2Frame>::TakeStatus(std::move(frame)));
-        }
-        return TakeValue(std::move(frame));
-      },
-      [self = RefAsSubclass<Http2ClientTransport>()](
-          GRPC_UNUSED Http2Frame frame) {
-        GRPC_HTTP2_CLIENT_DLOG
-            << "Http2ClientTransport ReadAndProcessOneFrame ProcessOneFrame";
+            << "Http2ClientTransport::ReadAndProcessOneFrame Read Frame ";
         return AssertResultType<absl::Status>(Map(
-            self->ProcessOneFrame(std::move(frame)),
-            [self](Http2Status status) {
-              if (!status.IsOk()) {
-                return self->HandleError(self->current_frame_header_.stream_id,
-                                         std::move(status));
+            EndpointRead(current_frame_header_.length),
+            [this](absl::StatusOr<SliceBuffer>&& payload) {
+              if (GPR_UNLIKELY(!payload.ok())) {
+                return payload.status();
+              }
+              GRPC_HTTP2_CLIENT_DLOG
+                  << "Http2ClientTransport::ReadAndProcessOneFrame "
+                     "ParseFramePayload payload length: "
+                  << payload.value().Length();
+              ValueOrHttp2Status<Http2Frame> frame = ParseFramePayload(
+                  current_frame_header_, TakeValue(std::move(payload)));
+              if (GPR_UNLIKELY(!frame.IsOk())) {
+                return HandleError(current_frame_header_.stream_id,
+                                   ValueOrHttp2Status<Http2Frame>::TakeStatus(
+                                       std::move(frame)));
+              }
+              Http2Status status =
+                  ProcessOneIncomingFrame(TakeValue(std::move(frame)));
+              if (GPR_UNLIKELY(!status.IsOk())) {
+                return HandleError(current_frame_header_.stream_id,
+                                   std::move(status));
               }
               return absl::OkStatus();
             }));
       },
-      [self = RefAsSubclass<Http2ClientTransport>()]() -> Poll<absl::Status> {
-        return self->reader_state_.MaybePauseReadLoop();
+      [this]() -> Poll<absl::Status> {
+        return reader_state_.MaybePauseReadLoop();
       }));
 }
 
 auto Http2ClientTransport::ReadLoop() {
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport ReadLoop Factory";
-  return AssertResultType<absl::Status>(
-      Loop([self = RefAsSubclass<Http2ClientTransport>()]() {
-        return TrySeq(self->ReadAndProcessOneFrame(),
-                      []() -> LoopCtl<absl::Status> {
-                        GRPC_HTTP2_CLIENT_DLOG
-                            << "Http2ClientTransport ReadLoop Continue";
-                        return Continue();
-                      });
-      }));
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::ReadLoop Factory";
+  return AssertResultType<absl::Status>(Loop([this]() {
+    return TrySeq(ReadAndProcessOneFrame(), []() -> LoopCtl<absl::Status> {
+      GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::ReadLoop Continue";
+      return Continue();
+    });
+  }));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Flow Control for the Transport
 
 auto Http2ClientTransport::FlowControlPeriodicUpdateLoop() {
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport PeriodicUpdateLoop Factory";
+  GRPC_HTTP2_CLIENT_DLOG
+      << "Http2ClientTransport::FlowControlPeriodicUpdateLoop Factory";
   return AssertResultType<absl::Status>(
-      Loop([self = RefAsSubclass<Http2ClientTransport>()]() {
+      Loop([this]() {
         GRPC_HTTP2_CLIENT_DLOG
-            << "Http2ClientTransport FlowControlPeriodicUpdateLoop Loop";
+            << "Http2ClientTransport::FlowControlPeriodicUpdateLoop Loop";
         return TrySeq(
             // TODO(tjagtap) [PH2][P2][BDP] Remove this static sleep when the
             // BDP code is done.
             Sleep(chttp2::kFlowControlPeriodicUpdateTimer),
-            [self]() -> Poll<absl::Status> {
+            [this]() -> Poll<absl::Status> {
               GRPC_HTTP2_CLIENT_DLOG
-                  << "Http2ClientTransport FlowControl PeriodicUpdate()";
-              chttp2::FlowControlAction action =
-                  self->flow_control_.PeriodicUpdate();
+                  << "Http2ClientTransport::FlowControlPeriodicUpdateLoop "
+                     "PeriodicUpdate()";
+              chttp2::FlowControlAction action = flow_control_.PeriodicUpdate();
               bool is_action_empty = action == chttp2::FlowControlAction();
               // This may trigger a write cycle
-              self->ActOnFlowControlAction(action, nullptr);
+              ActOnFlowControlAction(action, nullptr);
               if (is_action_empty) {
                 // TODO(tjagtap) [PH2][P2][BDP] Remove this when the BDP code is
                 // done. We must continue to do PeriodicUpdate once BDP is in
                 // place.
-                MutexLock lock(&self->transport_mutex_);
-                if (self->GetActiveStreamCountLocked() == 0) {
-                  self->AddPeriodicUpdatePromiseWaker();
+                MutexLock lock(&transport_mutex_);
+                if (GetActiveStreamCountLocked() == 0) {
+                  AddPeriodicUpdatePromiseWaker();
                   return Pending{};
                 }
               }
               return absl::OkStatus();
             },
-            [self]() -> LoopCtl<absl::Status> { return Continue{}; });
+            []() -> LoopCtl<absl::Status> { return Continue{}; });
       }));
 }
 
 // Equivalent to grpc_chttp2_act_on_flowctl_action in chttp2_transport.cc
 void Http2ClientTransport::ActOnFlowControlAction(
-    const chttp2::FlowControlAction& action, RefCountedPtr<Stream> stream) {
+    const chttp2::FlowControlAction& action, Stream* stream) {
   GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::ActOnFlowControlAction"
                          << action.DebugString();
   if (action.send_stream_update() != kNoActionNeeded) {
     if (GPR_LIKELY(stream != nullptr)) {
       GRPC_DCHECK_GT(stream->GetStreamId(), 0u);
       if (stream->CanSendWindowUpdateFrames()) {
-        window_update_list_.insert(stream->GetStreamId());
+        flow_control_.AddStreamToWindowUpdateList(stream->GetStreamId());
         GRPC_HTTP2_CLIENT_DLOG
             << "Http2ClientTransport::ActOnFlowControlAction "
                "added stream "
@@ -990,7 +908,10 @@ void Http2ClientTransport::ActOnFlowControlAction(
     // updates to the peer, causing the peer to block unnecessarily while
     // waiting for flow control tokens.
     reader_state_.SetPauseReadLoop();
-    SpawnGuardedTransportParty("SendControlFrames", TriggerWriteCycle());
+    if (!TriggerWriteCycleOrHandleError()) {
+      return;
+    }
+
     GRPC_HTTP2_CLIENT_DLOG << "Update Immediately : "
                            << action.ImmediateUpdateReasons();
   }
@@ -998,18 +919,34 @@ void Http2ClientTransport::ActOnFlowControlAction(
 
 ///////////////////////////////////////////////////////////////////////////////
 // Write Related Promises and Promise Factories
+auto Http2ClientTransport::EndpointWrite(SliceBuffer&& output_buf) {
+  size_t output_buf_length = output_buf.Length();
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::EndpointWrite output_buf: "
+                         << output_buf_length;
 
-auto Http2ClientTransport::ProcessAndWriteControlFrames() {
-  SliceBuffer output_buf;
-  if (is_first_write_) {
+  transport_write_context_.GetWriteCycle().BeginWrite(output_buf_length);
+  return Map(
+      endpoint_.Write(std::forward<SliceBuffer>(output_buf),
+                      TransportWriteContext::GetWriteArgs(settings_->peer())),
+      [this](absl::Status status) {
+        GRPC_HTTP2_CLIENT_DLOG
+            << "Http2ClientTransport::EndpointWrite complete with status = "
+            << status;
+        transport_write_context_.GetWriteCycle().EndWrite(status.ok());
+        return status;
+      });
+}
+
+absl::Status Http2ClientTransport::PrepareControlFrames() {
+  FrameSender frame_sender =
+      transport_write_context_.GetWriteCycle().GetFrameSender();
+  if (transport_write_context_.IsFirstWrite()) {
     // RFC9113: That is, the connection preface starts with the string
-    // "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
-    // This sequence MUST be followed by a SETTINGS frame, which MAY be empty.
-    GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport WriteControlFrames "
-                              "GRPC_CHTTP2_CLIENT_CONNECT_STRING";
-    output_buf.Append(
-        Slice::FromCopiedString(GRPC_CHTTP2_CLIENT_CONNECT_STRING));
-    settings_->MaybeGetSettingsAndSettingsAckFrames(flow_control_, output_buf);
+    // "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n". This connection preface string will
+    // be sent as part of the first write cycle. This sequence MUST be followed
+    // by a SETTINGS frame, which MAY be empty.
+    settings_->MaybeGetSettingsAndSettingsAckFrames(flow_control_,
+                                                    frame_sender);
     // TODO(tjagtap) [PH2][P2][Server] : This will be opposite for server. We
     // must read before we write for the server. So the ReadLoop will be Spawned
     // just after the constructor, and the write loop should be spawned only
@@ -1018,7 +955,6 @@ auto Http2ClientTransport::ProcessAndWriteControlFrames() {
     // Because the client is expected to write before it reads, we spawn the
     // ReadLoop of the client only after the first write is queued.
     SpawnGuardedTransportParty("ReadLoop", UntilTransportClosed(ReadLoop()));
-    is_first_write_ = false;
   }
 
   // Order of Control Frames is important.
@@ -1029,86 +965,105 @@ auto Http2ClientTransport::ProcessAndWriteControlFrames() {
   // 4. WINDOW_UPDATE
   // 5. Custom gRPC security frame
 
-  goaway_manager_.MaybeGetSerializedGoawayFrame(output_buf);
+  goaway_manager_.MaybeGetSerializedGoawayFrame(frame_sender);
+  bool should_spawn_security_frame_loop = false;
   http2::Http2ErrorCode apply_status =
-      settings_->MaybeReportAndApplyBufferedPeerSettings(event_engine_.get());
+      settings_->MaybeReportAndApplyBufferedPeerSettings(
+          event_engine_.get(), should_spawn_security_frame_loop);
+  if (should_spawn_security_frame_loop) {
+    const SecurityFrameHandler::EndpointExtensionState state =
+        security_frame_handler_->Initialize(event_engine_);
+    if (state.is_set) {
+      SpawnInfallibleTransportParty("SecurityFrameLoop",
+                                    UntilTransportClosed(SecurityFrameLoop()));
+    }
+  }
+
   if (!goaway_manager_.IsImmediateGoAway() &&
       apply_status == http2::Http2ErrorCode::kNoError) {
     EnforceLatestIncomingSettings();
-    settings_->MaybeGetSettingsAndSettingsAckFrames(flow_control_, output_buf);
-    ping_manager_->MaybeGetSerializedPingFrames(output_buf,
-                                                NextAllowedPingInterval());
-    MaybeGetWindowUpdateFrames(output_buf);
-  }
-  const uint64_t buffer_length = output_buf.Length();
-  ztrace_collector_->Append(PromiseEndpointWriteTrace{buffer_length});
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport WriteControlFrames Size : "
-                         << buffer_length;
-  return AssertResultType<absl::Status>(
-      If((buffer_length > 0 && apply_status == http2::Http2ErrorCode::kNoError),
-         [self = RefAsSubclass<Http2ClientTransport>(),
-          output_buf = std::move(output_buf)]() mutable {
-           return self->endpoint_.Write(std::move(output_buf),
-                                        GetWriteArgs(self->settings_->peer()));
-         },
-         [self = RefAsSubclass<Http2ClientTransport>(), apply_status]() {
-           if (apply_status != http2::Http2ErrorCode::kNoError) {
-             return self->HandleError(
-                 std::nullopt,
-                 Http2Status::Http2ConnectionError(
-                     apply_status, "Failed to apply incoming settings"));
-           }
-           return absl::OkStatus();
-         }));
-}
-
-void Http2ClientTransport::NotifyControlFramesWriteDone() {
+    settings_->MaybeGetSettingsAndSettingsAckFrames(flow_control_,
+                                                    frame_sender);
+    MaybeSpawnDelayedPing(ping_manager_->MaybeGetSerializedPingFrames(
+        frame_sender, NextAllowedPingInterval()));
+    MaybeGetWindowUpdateFrames(frame_sender);
+    security_frame_handler_->MaybeAppendSecurityFrame(frame_sender);
+  }
+
+  if (apply_status != http2::Http2ErrorCode::kNoError) {
+    return HandleError(std::nullopt,
+                       Http2Status::Http2ConnectionError(
+                           apply_status, "Failed to apply incoming settings"));
+  }
+
+  return absl::OkStatus();
+}
+
+auto Http2ClientTransport::MaybeWriteUrgentFrames() {
+  return AssertResultType<absl::Status>(If(
+      transport_write_context_.GetWriteCycle().CanSerializeUrgentFrames(),
+      [this]() mutable {
+        WriteCycle& write_cycle = transport_write_context_.GetWriteCycle();
+        const uint64_t buffer_length = write_cycle.GetUrgentFrameCount();
+        ztrace_collector_->Append(PromiseEndpointWriteTrace{buffer_length});
+        GRPC_HTTP2_CLIENT_DLOG
+            << "Http2ClientTransport::MaybeWriteUrgentFrames frame count: "
+            << buffer_length;
+        return EndpointWrite(write_cycle.SerializeUrgentFrames(
+            WriteCycle::SerializeStats{should_reset_ping_clock_}));
+      },
+      []() { return absl::OkStatus(); }));
+}
+
+void Http2ClientTransport::NotifyFramesWriteDone() {
   // Notify Control modules that we have sent the frames.
   // All notifications are expected to be synchronous.
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport NotifyControlFramesWriteDone";
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::NotifyFramesWriteDone";
   reader_state_.ResumeReadLoopIfPaused();
-  ping_manager_->NotifyPingSent();
+  MaybeSpawnPingTimeout(ping_manager_->NotifyPingSent());
   goaway_manager_.NotifyGoawaySent();
   MaybeSpawnWaitForSettingsTimeout();
 }
 
-auto Http2ClientTransport::SerializeAndWrite(std::vector<Http2Frame>&& frames) {
-  SliceBuffer output_buf;
-  should_reset_ping_clock_ =
-      Serialize(absl::Span<Http2Frame>(frames), output_buf)
-          .should_reset_ping_clock;
-  size_t output_buf_length = output_buf.Length();
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport SerializeAndWrite Write "
-                            "output_buf.length() = "
-                         << output_buf_length;
+void Http2ClientTransport::NotifyUrgentFramesWriteDone() {}
+
+auto Http2ClientTransport::SerializeAndWrite() {
   return AssertResultType<absl::Status>(If(
-      output_buf_length > 0,
-      [self = RefAsSubclass<Http2ClientTransport>(),
-       output_buf = std::move(output_buf)]() mutable {
-        return self->endpoint_.Write(std::move(output_buf),
-                                     GetWriteArgs(self->settings_->peer()));
+      transport_write_context_.GetWriteCycle().CanSerializeRegularFrames(),
+      [this]() mutable {
+        WriteCycle& write_cycle = transport_write_context_.GetWriteCycle();
+        const uint64_t frame_count = write_cycle.GetRegularFrameCount();
+        GRPC_HTTP2_CLIENT_DLOG
+            << "Http2ClientTransport::SerializeAndWrite frame count: "
+            << frame_count;
+        ztrace_collector_->Append(PromiseEndpointWriteTrace{frame_count});
+        return EndpointWrite(write_cycle.SerializeRegularFrames(
+            WriteCycle::SerializeStats{should_reset_ping_clock_}));
       },
       []() { return absl::OkStatus(); }));
 }
 
-absl::StatusOr<std::vector<Http2Frame>>
-Http2ClientTransport::DequeueStreamFrames(RefCountedPtr<Stream> stream) {
+absl::Status Http2ClientTransport::DequeueStreamFrames(
+    RefCountedPtr<Stream> stream, WriteCycle& write_cycle) {
   // write_bytes_remaining_ is passed as an upper bound on the max
   // number of tokens that can be dequeued to prevent dequeuing huge
   // data frames when write_bytes_remaining_ is very low. As the
   // available transport tokens can only range from 0 to 2^31 - 1,
   // we are clamping the write_bytes_remaining_ to that range.
-  const uint32_t tokens =
-      GetMaxPermittedDequeue(flow_control_, stream->flow_control,
-                             write_bytes_remaining_, settings_->peer());
-  const uint32_t stream_flow_control_tokens = static_cast<uint32_t>(
-      GetStreamFlowControlTokens(stream->flow_control, settings_->peer()));
-  stream->flow_control.ReportIfStalled(
-      /*is_client=*/true, stream->GetStreamId(), settings_->peer());
+  FrameSender frame_sender = write_cycle.GetFrameSender();
+  const uint32_t tokens = GetMaxPermittedDequeue(
+      flow_control_, stream->GetStreamFlowControl(),
+      write_cycle.GetWriteBytesRemaining(), settings_->peer());
+  const uint32_t stream_flow_control_tokens =
+      static_cast<uint32_t>(GetStreamFlowControlTokens(
+          stream->GetStreamFlowControl(), settings_->peer()));
+  stream->GetStreamFlowControl().ReportIfStalled(
+      /*is_client=*/kIsClient, stream->GetStreamId(), settings_->peer());
   StreamDataQueue<ClientMetadataHandle>::DequeueResult result =
       stream->DequeueFrames(tokens, stream_flow_control_tokens,
-                            settings_->peer().max_frame_size(), encoder_);
-  ProcessOutgoingDataFrameFlowControl(stream->flow_control,
+                            settings_->peer().max_frame_size(), encoder_,
+                            frame_sender);
+  ProcessOutgoingDataFrameFlowControl(stream->GetStreamFlowControl(),
                                       result.flow_control_tokens_consumed);
   if (result.is_writable) {
     // Stream is still writable. Enqueue it back to the writable
@@ -1118,7 +1073,7 @@ Http2ClientTransport::DequeueStreamFrames(RefCountedPtr<Stream> stream) {
 
     if (GPR_UNLIKELY(!status.ok())) {
       GRPC_HTTP2_CLIENT_DLOG
-          << "Http2ClientTransport DequeueStreamFrames Failed to "
+          << "Http2ClientTransport::DequeueStreamFrames Failed to "
              "enqueue stream "
           << stream->GetStreamId() << " with status: " << status;
       // Close transport if we fail to enqueue stream.
@@ -1134,9 +1089,9 @@ Http2ClientTransport::DequeueStreamFrames(RefCountedPtr<Stream> stream) {
   // multiplexer loop as the stream will never be writable again. Additionally,
   // the other two stream refs, CallHandler OnDone and OutboundLoop will be
   // dropped by Callv3 triggering cleaning up the stream object.
-  if (result.InitialMetadataDequeued()) {
+  if (result.IsInitialMetadataDequeued()) {
     GRPC_HTTP2_CLIENT_DLOG
-        << "Http2ClientTransport DequeueStreamFrames InitialMetadataDequeued "
+        << "Http2ClientTransport::DequeueStreamFrames InitialMetadataDequeued "
            "stream_id = "
         << stream->GetStreamId();
     stream->SentInitialMetadata();
@@ -1144,178 +1099,170 @@ Http2ClientTransport::DequeueStreamFrames(RefCountedPtr<Stream> stream) {
     AddToStreamList(stream);
   }
 
-  if (result.HalfCloseDequeued()) {
-    GRPC_HTTP2_CLIENT_DLOG
-        << "Http2ClientTransport DequeueStreamFrames HalfCloseDequeued "
-           "stream_id = "
-        << stream->GetStreamId();
+  if (result.IsHalfCloseDequeued()) {
+    GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::DequeueStreamFrames "
+                              "HalfCloseDequeued stream_id = "
+                           << stream->GetStreamId();
     stream->MarkHalfClosedLocal();
-    CloseStream(
-        stream,
-        CloseStreamArgs{/*close_reads=*/stream->did_receive_trailing_metadata,
-                        /*close_writes=*/true});
+
+    if (stream->IsTrailingMetadataReceived()) {
+      CloseStream(*stream, CloseStreamArgs{/*close_reads=*/true,
+                                           /*close_writes=*/true});
+    }
   }
-  if (result.ResetStreamDequeued()) {
+  if (result.IsResetStreamDequeued()) {
     GRPC_HTTP2_CLIENT_DLOG
-        << "Http2ClientTransport DequeueStreamFrames ResetStreamDequeued "
+        << "Http2ClientTransport::DequeueStreamFrames ResetStreamDequeued "
            "stream_id = "
         << stream->GetStreamId();
     stream->MarkHalfClosedLocal();
-    CloseStream(stream, CloseStreamArgs{/*close_reads=*/true,
-                                        /*close_writes=*/true});
+    CloseStream(*stream, CloseStreamArgs{/*close_reads=*/true,
+                                         /*close_writes=*/true});
   }
 
   // Update the write_bytes_remaining_ based on the bytes consumed
   // in the current dequeue.
-  write_bytes_remaining_ =
-      (write_bytes_remaining_ >= result.total_bytes_consumed)
-          ? (write_bytes_remaining_ - result.total_bytes_consumed)
-          : 0;
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport DequeueStreamFrames "
-                            "write_bytes_remaining_ after dequeue = "
-                         << write_bytes_remaining_ << " total_bytes_consumed = "
-                         << result.total_bytes_consumed
+  // Note: We do tend to overestimate the bytes consumed here. This may result
+  // in sending less data than target_write_size_.
+
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::DequeueStreamFrames "
+                            "After dequeue: "
+                         << write_cycle.DebugString()
                          << " stream_id = " << stream->GetStreamId()
                          << " is_writable = " << result.is_writable
                          << " stream_priority = "
-                         << static_cast<uint8_t>(result.priority)
-                         << " number of frames = " << result.frames.size();
-  return std::move(result.frames);
+                         << static_cast<uint8_t>(result.priority);
+  return absl::OkStatus();
 }
 
 // This MultiplexerLoop promise is responsible for Multiplexing multiple gRPC
 // Requests (HTTP2 Streams) and writing them into one common endpoint.
 auto Http2ClientTransport::MultiplexerLoop() {
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport MultiplexerLoop Factory";
-  return AssertResultType<
-      absl::Status>(Loop([self = RefAsSubclass<Http2ClientTransport>()]() {
-    self->write_bytes_remaining_ = self->GetMaxWriteSize();
-    GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport MultiplexerLoop "
-                           << " max_write_size_=" << self->GetMaxWriteSize();
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::MultiplexerLoop Factory";
+  return AssertResultType<absl::Status>(Loop([this]() {
     return TrySeq(
-        self->writable_stream_list_.WaitForReady(
-            self->AreTransportFlowControlTokensAvailable()),
-        [self]() {
-          // TODO(akshitpatel) : [PH2][P2] : Return an `important` tag from
-          // WriteControlFrames() to indicate if we should do a separate write
-          // for the queued control frames or send the queued frames with the
-          // data frames(if any).
-          return Map(
-              self->ProcessAndWriteControlFrames(),
-              [self](absl::Status status) {
-                if (GPR_UNLIKELY(!status.ok())) {
-                  GRPC_HTTP2_CLIENT_DLOG
-                      << "Http2ClientTransport MultiplexerLoop Failed to "
-                         "write control frames with status: "
-                      << status;
-                  return status;
-                }
-                self->NotifyControlFramesWriteDone();
-                return absl::OkStatus();
-              });
-        },
-        [self]() -> absl::StatusOr<std::vector<Http2Frame>> {
-          std::vector<Http2Frame> frames;
-          // Drain all the writable streams till we have written
-          // max_write_size_ bytes of data or there is no more data to send. In
-          // some cases, we may write more than max_write_size_ bytes(like
-          // writing metadata).
-          while (self->write_bytes_remaining_ > 0) {
-            std::optional<RefCountedPtr<Stream>> optional_stream =
-                self->writable_stream_list_.ImmediateNext(
-                    self->AreTransportFlowControlTokensAvailable());
-            if (!optional_stream.has_value()) {
-              GRPC_HTTP2_CLIENT_DLOG
-                  << "Http2ClientTransport MultiplexerLoop "
-                     "No writable streams available, write_bytes_remaining_ = "
-                  << self->write_bytes_remaining_;
-              break;
+        Map(writable_stream_list_.WaitForReady(
+                AreTransportFlowControlTokensAvailable()),
+            [this](absl::StatusOr<Empty> status) -> absl::Status {
+              if (GPR_UNLIKELY(!status.ok())) {
+                return status.status();
+              }
+              transport_write_context_.StartWriteCycle();
+              GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::MultiplexerLoop "
+                                        "Created WriteCycle: "
+                                     << transport_write_context_.DebugString();
+              return PrepareControlFrames();
+            }),
+        [this] {
+          return Map(MaybeWriteUrgentFrames(), [this](absl::Status status) {
+            if (GPR_UNLIKELY(!status.ok())) {
+              return status;
             }
-            RefCountedPtr<Stream> stream = std::move(optional_stream.value());
+            NotifyUrgentFramesWriteDone();
+            WriteCycle& write_cycle = transport_write_context_.GetWriteCycle();
             GRPC_HTTP2_CLIENT_DLOG
-                << "Http2ClientTransport MultiplexerLoop "
-                   "Next writable stream id = "
-                << stream->GetStreamId()
-                << " is_closed_for_writes = " << stream->IsClosedForWrites();
-
-            if (stream->GetStreamId() == kInvalidStreamId) {
-              GRPC_DCHECK(stream->IsStreamIdle());
-              // TODO(akshitpatel) : [PH2][P5] : We will waste a stream id in
-              // the rare scenario where the stream is aborted before it can be
-              // written to. This is a possible area to optimize in future.
-              absl::Status status = self->InitializeStream(stream);
-              if (!status.ok()) {
+                << "Http2ClientTransport::MultiplexerLoop "
+                << "Starting to iterate over writable stream list "
+                << write_cycle.DebugString();
+            // Drain all the writable streams till we have written
+            // max_write_size_ bytes of data or there is no more data to send.
+            // In some cases, we may write more than max_write_size_ bytes(like
+            // writing metadata).
+            while (write_cycle.GetWriteBytesRemaining() > 0) {
+              std::optional<RefCountedPtr<Stream>> optional_stream =
+                  writable_stream_list_.ImmediateNext(
+                      AreTransportFlowControlTokensAvailable());
+              if (!optional_stream.has_value()) {
                 GRPC_HTTP2_CLIENT_DLOG
-                    << "Http2ClientTransport MultiplexerLoop "
-                       "Failed to assign stream id and add to stream list for "
-                       "stream: "
-                    << stream.get() << " closing this stream.";
-                self->BeginCloseStream(
-                    stream, /*reset_stream_error_code=*/std::nullopt,
-                    CancelledServerMetadataFromStatus(status));
-                continue;
+                    << "Http2ClientTransport::MultiplexerLoop "
+                       "No writable streams available ";
+                break;
               }
-            }
-
-            if (GPR_LIKELY(!stream->IsClosedForWrites())) {
-              absl::StatusOr<std::vector<Http2Frame>> stream_frames =
-                  self->DequeueStreamFrames(stream);
-              if (GPR_UNLIKELY(!stream_frames.ok())) {
-                GRPC_HTTP2_CLIENT_DLOG
-                    << "Http2ClientTransport MultiplexerLoop "
-                       "Failed to dequeue stream frames with status: "
-                    << stream_frames.status();
-                return stream_frames.status();
+              RefCountedPtr<Stream> stream = std::move(optional_stream.value());
+              GRPC_HTTP2_CLIENT_DLOG
+                  << "Http2ClientTransport::MultiplexerLoop "
+                     "Next writable stream id = "
+                  << stream->GetStreamId()
+                  << " is_closed_for_writes = " << stream->IsClosedForWrites();
+
+              if (stream->GetStreamId() == kInvalidStreamId) {
+                GRPC_DCHECK(stream->IsStreamIdle());
+                // TODO(akshitpatel) : [PH2][P5] : We will waste a stream id in
+                // the rare scenario where the stream is aborted before it can
+                // be written to. This is a possible area to optimize in future.
+                absl::Status status = InitializeStream(*stream);
+                if (!status.ok()) {
+                  GRPC_HTTP2_CLIENT_DLOG
+                      << "Http2ClientTransport::MultiplexerLoop "
+                         "Failed to assign stream id and add to stream list for"
+                         " stream: "
+                      << stream.get() << " closing this stream.";
+                  BeginCloseStream(std::move(stream),
+                                   /*reset_stream_error_code=*/std::nullopt,
+                                   CancelledServerMetadataFromStatus(status));
+                  continue;
+                }
               }
 
-              frames.reserve(frames.size() + stream_frames.value().size());
-              frames.insert(
-                  frames.end(),
-                  std::make_move_iterator(stream_frames.value().begin()),
-                  std::make_move_iterator(stream_frames.value().end()));
+              if (GPR_LIKELY(!stream->IsClosedForWrites())) {
+                absl::Status status = DequeueStreamFrames(
+                    std::move(stream),
+                    transport_write_context_.GetWriteCycle());
+                if (GPR_UNLIKELY(!status.ok())) {
+                  GRPC_HTTP2_CLIENT_DLOG
+                      << "Http2ClientTransport::MultiplexerLoop "
+                         "Failed to dequeue stream frames with status: "
+                      << status;
+                  return status;
+                }
+              }
             }
-          }
 
-          GRPC_HTTP2_CLIENT_DLOG
-              << "Http2ClientTransport MultiplexerLoop "
-                 "write_bytes_remaining_ after draining all writable streams = "
-              << self->write_bytes_remaining_;
+            GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::MultiplexerLoop "
+                                      "After draining all writable streams "
+                                   << write_cycle.DebugString();
 
-          return std::move(frames);
+            return absl::OkStatus();
+          });
         },
-        [self](std::vector<Http2Frame> frames) {
-          return self->SerializeAndWrite(std::move(frames));
+        [this]() {
+          return Map(SerializeAndWrite(), [this](absl::Status status) {
+            if (GPR_UNLIKELY(!status.ok())) {
+              return status;
+            }
+            NotifyFramesWriteDone();
+            return absl::OkStatus();
+          });
         },
-        [self]() -> LoopCtl<absl::Status> {
-          if (self->should_reset_ping_clock_) {
+        [this]() -> LoopCtl<absl::Status> {
+          if (should_reset_ping_clock_) {
             GRPC_HTTP2_CLIENT_DLOG
-                << "Http2ClientTransport MultiplexerLoop ResetPingClock";
-            self->ping_manager_->ResetPingClock(/*is_client=*/true);
-            self->should_reset_ping_clock_ = false;
+                << "Http2ClientTransport::MultiplexerLoop ResetPingClock";
+            ping_manager_->ResetPingClock(/*is_client=*/kIsClient);
+            should_reset_ping_clock_ = false;
           }
+          transport_write_context_.EndWriteCycle();
           return Continue();
         });
   }));
 }
 
-absl::Status Http2ClientTransport::InitializeStream(
-    RefCountedPtr<Stream> stream) {
+absl::Status Http2ClientTransport::InitializeStream(Stream& stream) {
   absl::StatusOr<uint32_t> next_stream_id = NextStreamId();
   if (!next_stream_id.ok()) {
-    GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport InitializeStream "
+    GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::InitializeStream "
                               "Failed to get next stream id for stream: "
-                           << stream.get();
+                           << &stream;
     return std::move(next_stream_id).status();
   }
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport InitializeStream "
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::InitializeStream "
                             "Assigned stream id: "
-                         << next_stream_id.value()
-                         << " to stream: " << stream.get()
+                         << next_stream_id.value() << " to stream: " << &stream
                          << ", allow_true_binary_metadata:"
                          << settings_->peer().allow_true_binary_metadata();
-  stream->InitializeStream(next_stream_id.value(),
-                           settings_->peer().allow_true_binary_metadata(),
-                           settings_->acked().allow_true_binary_metadata());
+  stream.InitializeStream(next_stream_id.value(),
+                          settings_->peer().allow_true_binary_metadata(),
+                          settings_->acked().allow_true_binary_metadata());
   return absl::OkStatus();
 }
 
@@ -1326,9 +1273,10 @@ void Http2ClientTransport::AddToStreamList(RefCountedPtr<Stream> stream) {
     GRPC_DCHECK(stream != nullptr) << "stream is null";
     GRPC_DCHECK_GT(stream->GetStreamId(), 0u) << "stream id is invalid";
     GRPC_HTTP2_CLIENT_DLOG
-        << "Http2ClientTransport AddToStreamList for stream id: "
+        << "Http2ClientTransport::AddToStreamList for stream id: "
         << stream->GetStreamId();
-    stream_list_.emplace(stream->GetStreamId(), stream);
+    const uint32_t stream_id = stream->GetStreamId();
+    stream_list_.emplace(stream_id, std::move(stream));
     // TODO(tjagtap) [PH2][P2][BDP] Remove this when the BDP code is done.
     if (GetActiveStreamCountLocked() == 1) {
       should_wake_periodic_updates = true;
@@ -1363,36 +1311,22 @@ void Http2ClientTransport::MaybeSpawnWaitForSettingsTimeout() {
   if (settings_->ShouldSpawnWaitForSettingsTimeout()) {
     GRPC_HTTP2_CLIENT_DLOG
         << "Http2ClientTransport::MaybeSpawnWaitForSettingsTimeout Spawning";
-    general_party_->Spawn("WaitForSettingsTimeout",
-                          settings_->WaitForSettingsTimeout(),
-                          WaitForSettingsTimeoutOnDone());
+    SpawnWithOnDoneTransportParty("WaitForSettingsTimeout",
+                                  settings_->WaitForSettingsTimeout(),
+                                  WaitForSettingsTimeoutOnDone());
   }
 }
 
-void Http2ClientTransport::MaybeGetWindowUpdateFrames(SliceBuffer& output_buf) {
-  std::vector<Http2Frame> frames;
-  frames.reserve(window_update_list_.size() + 1);
-  uint32_t window_size =
-      flow_control_.DesiredAnnounceSize(/*writing_anyway=*/true);
-  if (window_size > 0) {
-    GRPC_HTTP2_CLIENT_DLOG
-        << "Http2ClientTransport::MaybeGetWindowUpdateFrames Transport Window "
-           "Update : "
-        << window_size;
-    frames.emplace_back(Http2WindowUpdateFrame{/*stream_id=*/0, window_size});
-    flow_control_.SentUpdate(window_size);
-  }
-  for (const uint32_t stream_id : window_update_list_) {
+void Http2ClientTransport::MaybeGetWindowUpdateFrames(
+    FrameSender& frame_sender) {
+  frame_sender.ReserveRegularFrames(flow_control_.window_update_list_size() +
+                                    1);
+  MaybeAddTransportWindowUpdateFrame(flow_control_, frame_sender);
+  for (const uint32_t stream_id : flow_control_.DrainWindowUpdateList()) {
     RefCountedPtr<Stream> stream = LookupStream(stream_id);
-    MaybeAddStreamWindowUpdateFrame(stream, frames);
-  }
-  window_update_list_.clear();
-  if (!frames.empty()) {
-    GRPC_HTTP2_CLIENT_DLOG
-        << "Http2ClientTransport::MaybeGetWindowUpdateFrames Total Window "
-           "Update Frames : "
-        << frames.size();
-    Serialize(absl::Span<Http2Frame>(frames), output_buf);
+    if (stream != nullptr) {
+      MaybeAddStreamWindowUpdateFrame(*stream, frame_sender);
+    }
   }
 }
 
@@ -1400,7 +1334,7 @@ void Http2ClientTransport::MaybeGetWindowUpdateFrames(SliceBuffer& output_buf) {
 // Constructor Destructor
 
 Http2ClientTransport::Http2ClientTransport(
-    PromiseEndpoint endpoint, GRPC_UNUSED const ChannelArgs& channel_args,
+    PromiseEndpoint endpoint, const ChannelArgs& channel_args,
     std::shared_ptr<EventEngine> event_engine,
     absl::AnyInvocable<void(absl::StatusOr<uint32_t>)> on_receive_settings)
     : channelz::DataSource(http2::CreateChannelzSocketNode(
@@ -1411,11 +1345,12 @@ Http2ClientTransport::Http2ClientTransport(
           std::move(on_receive_settings))),
       next_stream_id_(/*Initial Stream ID*/ 1),
       should_reset_ping_clock_(false),
-      is_first_write_(true),
-      max_write_size_(kMaxWriteSize),
+      incoming_headers_(IncomingMetadataTracker::GetPeerString(endpoint_)),
+      transport_write_context_(kIsClient),
       ping_manager_(std::nullopt),
       keepalive_manager_(std::nullopt),
       goaway_manager_(GoawayInterfaceImpl::Make(this)),
+      security_frame_handler_(MakeRefCounted<SecurityFrameHandler>()),
       memory_owner_(channel_args.GetObject<ResourceQuota>()
                         ->memory_quota()
                         ->CreateMemoryOwner()),
@@ -1424,13 +1359,13 @@ Http2ClientTransport::Http2ClientTransport(
           channel_args.GetBool(GRPC_ARG_HTTP2_BDP_PROBE).value_or(true),
           &memory_owner_),
       ztrace_collector_(std::make_shared<PromiseHttp2ZTraceCollector>()) {
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport Constructor Begin";
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::Http2ClientTransport Begin";
   // Initialize the general party and write party.
   RefCountedPtr<Arena> party_arena = SimpleArenaAllocator(0)->MakeArena();
   party_arena->SetContext<EventEngine>(event_engine_.get());
   general_party_ = Party::Make(std::move(party_arena));
 
-  InitLocalSettings(settings_->mutable_local(), /*is_client=*/true);
+  InitLocalSettings(settings_->mutable_local(), /*is_client=*/kIsClient);
   TransportChannelArgs args;
   ReadChannelArgs(channel_args, args);
 
@@ -1442,28 +1377,28 @@ Http2ClientTransport::Http2ClientTransport(
       KeepAliveInterfaceImpl::Make(this),
       ((args.keepalive_timeout < args.ping_timeout) ? args.keepalive_timeout
                                                     : Duration::Infinity()),
-      args.keepalive_time, general_party_.get());
-
-  if (settings_->local().allow_security_frame()) {
-    // TODO(tjagtap) : [PH2][P3] : Setup the plumbing to pass the security frame
-    // to the endpoing via TransportFramingEndpointExtension.
-    // Also decide if this plumbing is done here, or when the peer sends
-    // allow_security_frame too.
-  }
+      args.keepalive_time);
 
   GRPC_DCHECK(ping_manager_.has_value());
   GRPC_DCHECK(keepalive_manager_.has_value());
   SourceConstructed();
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport Constructor End";
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::Http2ClientTransport End";
 }
 
 void Http2ClientTransport::SpawnTransportLoops() {
   GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::SpawnTransportLoops Begin";
+  MaybeSpawnKeepaliveLoop();
   SpawnGuardedTransportParty(
       "FlowControlPeriodicUpdateLoop",
       UntilTransportClosed(FlowControlPeriodicUpdateLoop()));
 
-  SpawnGuardedTransportParty("FlushInitialFrames", TriggerWriteCycle());
+  if (!TriggerWriteCycleOrHandleError()) {
+    return;
+  }
+  // For Client, write happens before read. So MultiplexerLoop is spawned first.
+  // ReadLoop is spawned after the first write.
+  // For Server, read happens before write. So ReadLoop is spawned first.
+  // MultiplexerLoop is spawned after the first read.
   SpawnGuardedTransportParty("MultiplexerLoop",
                              UntilTransportClosed(MultiplexerLoop()));
   GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::SpawnTransportLoops End";
@@ -1473,7 +1408,7 @@ void Http2ClientTransport::ReadChannelArgs(const ChannelArgs& channel_args,
                                            TransportChannelArgs& args) {
   http2::ReadChannelArgs(channel_args, args, settings_->mutable_local(),
                          flow_control_,
-                         /*is_client=*/true);
+                         /*is_client=*/kIsClient);
 
   // Assign the channel args to the member variables.
   keepalive_time_ = args.keepalive_time;
@@ -1493,10 +1428,38 @@ void Http2ClientTransport::ReadChannelArgs(const ChannelArgs& channel_args,
   }
 }
 
+absl::Status Http2ClientTransport::HandleError(
+    const std::optional<uint32_t> stream_id, Http2Status status,
+    DebugLocation whence) {
+  Http2Status::Http2ErrorType error_type = status.GetType();
+  GRPC_DCHECK(error_type != Http2Status::Http2ErrorType::kOk);
+
+  if (error_type == Http2Status::Http2ErrorType::kStreamError) {
+    GRPC_HTTP2_CLIENT_ERROR_DLOG
+        << "Http2ClientTransport::HandleError Stream Error:"
+        << status.DebugString();
+    GRPC_DCHECK(stream_id.has_value());
+    // Passing a cancelled server metadata handle to propagate the error
+    // to the upper layers.
+    BeginCloseStream(
+        LookupStream(stream_id.value()),
+        Http2ErrorCodeToFrameErrorCode(status.GetStreamErrorCode()),
+        CancelledServerMetadataFromStatus(status.GetAbslStreamError()), whence);
+    return absl::OkStatus();
+  } else if (error_type == Http2Status::Http2ErrorType::kConnectionError) {
+    GRPC_HTTP2_CLIENT_ERROR_DLOG
+        << "Http2ClientTransport::HandleError Connection Error:"
+        << status.DebugString();
+    absl::Status absl_status = status.GetAbslConnectionError();
+    MaybeSpawnCloseTransport(std::move(status), whence);
+    return absl_status;
+  }
+  GPR_UNREACHABLE_CODE(return absl::InternalError("Invalid error type"));
+}
+
 // This function MUST be idempotent. This function MUST be called from the
 // transport party.
-void Http2ClientTransport::CloseStream(RefCountedPtr<Stream> stream,
-                                       CloseStreamArgs args,
+void Http2ClientTransport::CloseStream(Stream& stream, CloseStreamArgs args,
                                        DebugLocation whence) {
   std::optional<Http2Status> close_transport_error;
 
@@ -1504,22 +1467,21 @@ void Http2ClientTransport::CloseStream(RefCountedPtr<Stream> stream,
     // TODO(akshitpatel) : [PH2][P3] : Measure the impact of holding mutex
     // throughout this function.
     MutexLock lock(&transport_mutex_);
-    GRPC_DCHECK(stream != nullptr) << "stream is null";
     GRPC_HTTP2_CLIENT_DLOG
         << "Http2ClientTransport::CloseStream for stream id: "
-        << stream->GetStreamId() << " close_reads=" << args.close_reads
+        << stream.GetStreamId() << " close_reads=" << args.close_reads
         << " close_writes=" << args.close_writes
         << " incoming_headers_=" << incoming_headers_.DebugString()
         << " location=" << whence.file() << ":" << whence.line();
 
     if (args.close_writes) {
-      stream->SetWriteClosed();
+      stream.SetWriteClosed();
     }
 
     if (args.close_reads) {
       GRPC_HTTP2_CLIENT_DLOG
           << "Http2ClientTransport::CloseStream for stream id: "
-          << stream->GetStreamId() << " closing stream for reads.";
+          << stream.GetStreamId() << " closing stream for reads.";
       // If the stream is closed while reading HEADER/CONTINUATION frames, we
       // should still parse the enqueued buffer to maintain HPACK state between
       // peers.
@@ -1529,25 +1491,24 @@ void Http2ClientTransport::CloseStream(RefCountedPtr<Stream> stream,
             HeaderAssembler::ParseHeaderArgs{
                 /*is_initial_metadata=*/!incoming_headers_.HeaderHasEndStream(),
                 /*is_end_headers=*/false,
-                /*is_client=*/true,
+                /*is_client=*/kIsClient,
                 /*max_header_list_size_soft_limit=*/
                 incoming_headers_.soft_limit(),
                 /*max_header_list_size_hard_limit=*/
                 settings_->acked().max_header_list_size(),
                 /*stream_id=*/incoming_headers_.GetStreamId(),
             },
-            stream, /*original_status=*/Http2Status::Ok());
+            &stream, /*original_status=*/Http2Status::Ok());
         if (result.GetType() == Http2Status::Http2ErrorType::kConnectionError) {
           GRPC_HTTP2_CLIENT_DLOG
               << "Http2ClientTransport::CloseStream for stream id: "
-              << stream->GetStreamId()
-              << " failed to partially process header: "
+              << stream.GetStreamId() << " failed to partially process header: "
               << result.DebugString();
           close_transport_error.emplace(std::move(result));
         }
       }
 
-      stream_list_.erase(stream->GetStreamId());
+      stream_list_.erase(stream.GetStreamId());
       if (!close_transport_error.has_value() && CanCloseTransportLocked()) {
         // TODO(akshitpatel) : [PH2][P3] : Is kInternalError the right error
         // code to use here? IMO it should be kNoError.
@@ -1653,7 +1614,9 @@ void Http2ClientTransport::BeginCloseStream(
   } else {
     // Callers taking this path:
     // 1. Reading Trailing Metadata (MAY send half close from OnDone).
-    if (stream->IsClosedForWrites()) {
+    // If a half close frame has already been sent, we should close the stream
+    // for reads and writes.
+    if (stream->IsHalfClosedLocal() || stream->IsStreamClosed()) {
       close_reads = true;
       close_writes = true;
       GRPC_HTTP2_CLIENT_DLOG
@@ -1664,7 +1627,7 @@ void Http2ClientTransport::BeginCloseStream(
   }
 
   if (close_reads || close_writes) {
-    CloseStream(stream, CloseStreamArgs{close_reads, close_writes}, whence);
+    CloseStream(*stream, CloseStreamArgs{close_reads, close_writes}, whence);
   }
 
   // If the call was cancelled, the stream MUST be closed for reads.
@@ -1691,7 +1654,6 @@ void Http2ClientTransport::CloseTransport() {
   transport_closed_latch_.Set();
   settings_->HandleTransportShutdown(event_engine_.get());
 
-  MutexLock lock(&transport_mutex_);
   // This is the only place where the general_party_ is reset.
   general_party_.reset();
 }
@@ -1727,16 +1689,18 @@ void Http2ClientTransport::MaybeSpawnCloseTransport(Http2Status http2_status,
       "CloseTransport", [self = RefAsSubclass<Http2ClientTransport>(),
                          stream_list = std::move(stream_list),
                          http2_status = std::move(http2_status)]() mutable {
+        self->security_frame_handler_->OnTransportClosed();
         GRPC_HTTP2_CLIENT_DLOG
-            << "Http2ClientTransport::CloseTransport Cleaning up call stacks";
+            << "Http2ClientTransport::MaybeSpawnCloseTransport "
+               "Cleaning up call stacks";
         // Clean up the call stacks for all active streams.
         for (const auto& pair : stream_list) {
           // There is no merit in transitioning the stream to
           // closed state here as the subsequent lookups would
           // fail. Also, as this is running on the transport
           // party, there would not be concurrent access to the stream.
-          auto& stream = pair.second;
-          self->BeginCloseStream(stream,
+          RefCountedPtr<Stream> stream = pair.second;
+          self->BeginCloseStream(std::move(stream),
                                  Http2ErrorCodeToFrameErrorCode(
                                      http2_status.GetConnectionErrorCode()),
                                  CancelledServerMetadataFromStatus(
@@ -1784,11 +1748,11 @@ bool Http2ClientTransport::CanCloseTransportLocked() const {
 }
 
 Http2ClientTransport::~Http2ClientTransport() {
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport Destructor Begin";
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::~Http2ClientTransport Begin";
   GRPC_DCHECK(stream_list_.empty());
   GRPC_DCHECK(general_party_ == nullptr);
   memory_owner_.Reset();
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport Destructor End";
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::~Http2ClientTransport End";
 }
 
 void Http2ClientTransport::SpawnAddChannelzData(RefCountedPtr<Party> party,
@@ -1797,7 +1761,7 @@ void Http2ClientTransport::SpawnAddChannelzData(RefCountedPtr<Party> party,
       std::move(party), "AddData",
       [self = RefAsSubclass<Http2ClientTransport>(),
        sink = std::move(sink)]() mutable {
-        GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::AddData Promise";
+        GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::SpawnAddChannelzData";
         sink.AddData(
             "Http2ClientTransport",
             channelz::PropertyList()
@@ -1809,7 +1773,8 @@ void Http2ClientTransport::SpawnAddChannelzData(RefCountedPtr<Party> party,
                      self->flow_control_.stats().ChannelzProperties()));
         self->general_party_->ExportToChannelz("Http2ClientTransport Party",
                                                sink);
-        GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::AddData End";
+        GRPC_HTTP2_CLIENT_DLOG
+            << "Http2ClientTransport::SpawnAddChannelzData End";
         return Empty{};
       });
 }
@@ -1819,48 +1784,103 @@ void Http2ClientTransport::AddData(channelz::DataSink sink) {
 
   event_engine_->Run([self = RefAsSubclass<Http2ClientTransport>(),
                       sink = std::move(sink)]() mutable {
-    bool is_party_null = false;
+    RefCountedPtr<Party> party = nullptr;
     {
-      // Apart from CloseTransport, this is the only place where a lock is taken
-      // to access general_party_. All other access to general_party_ happens
-      // on the general party itself and hence do not race with CloseTransport.
-      // TODO(akshitpatel) : [PH2][P4] : Check if a new mutex is needed to
-      // protect general_party_. Curently transport_mutex_ can is used in
-      // these places:
-      // 1. In promises running on the transport party
-      // 2. In AddData promise
-      // 3. In Orphan function.
-      // 4. Stream creation (this will be removed soon).
-      // Given that #1 is already serialized (guaranteed by party), #2 is on
-      // demand and #3 happens once for the lifetime of the transport while
-      // closing the transport, the contention should be minimal.
       MutexLock lock(&self->transport_mutex_);
-      // TODO(akshitpatel) : [PH2][P2] : There is still a potential for a race
-      // here where the general_party_ is reset between the lock being
-      // released and the spawn. We cannot just do a spawn inside the mutex as
-      // that may result in deadlock.
-      // Potential fix to hold a ref to the party inside the mutex and do a
-      // spawn outside the mutex. The only side effect is that this introduces
-      // an additional ref to the party other the transport's copy.
-      if (GPR_UNLIKELY(self->general_party_ == nullptr)) {
-        is_party_null = true;
+      if (GPR_LIKELY(!self->is_transport_closed_)) {
+        GRPC_DCHECK(self->general_party_ != nullptr);
+        party = self->general_party_;
+      } else {
         GRPC_HTTP2_CLIENT_DLOG
-            << "Http2ClientTransport::AddData general_party_ is "
-               "null. Transport is closed.";
+            << "Http2ClientTransport::AddData Transport is closed.";
       }
     }
 
     ExecCtx exec_ctx;
-    if (!is_party_null) {
-      self->SpawnAddChannelzData(self->general_party_, std::move(sink));
+    if (party != nullptr) {
+      self->SpawnAddChannelzData(std::move(party), std::move(sink));
     }
     self.reset();  // Cleanup with exec_ctx in scope
   });
 }
 
+RefCountedPtr<channelz::SocketNode> Http2ClientTransport::GetSocketNode()
+    const {
+  const channelz::BaseNode* node = channelz::DataSource::channelz_node();
+  if (node == nullptr) {
+    return nullptr;
+  }
+  return const_cast<channelz::BaseNode*>(node)
+      ->RefAsSubclass<channelz::SocketNode>();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Stream Related Operations
 
+absl::StatusOr<uint32_t> Http2ClientTransport::NextStreamId() {
+  if (next_stream_id_ > GetMaxAllowedStreamId()) {
+    // TODO(tjagtap) : [PH2][P3] : Handle case if transport runs out of stream
+    // ids
+    // RFC9113 : Stream identifiers cannot be reused. Long-lived connections
+    // can result in an endpoint exhausting the available range of stream
+    // identifiers. A client that is unable to establish a new stream
+    // identifier can establish a new connection for new streams. A server
+    // that is unable to establish a new stream identifier can send a GOAWAY
+    // frame so that the client is forced to open a new connection for new
+    // streams.
+    return absl::ResourceExhaustedError("No more stream ids available");
+  }
+  // TODO(akshitpatel) : [PH2][P3] : There is a channel arg to delay
+  // starting new streams instead of failing them. This needs to be
+  // implemented.
+  {
+    // TODO(tjagtap) : [PH2][P1] : For a server we will have to do
+    // this for incoming streams only. If a server receives more
+    // streams from a client than is allowed by the clients settings,
+    // whether or not we should fail is debatable.
+    MutexLock lock(&transport_mutex_);
+    if (GetActiveStreamCountLocked() >=
+        settings_->peer().max_concurrent_streams()) {
+      return absl::ResourceExhaustedError("Reached max concurrent streams");
+    }
+  }
+
+  // RFC9113 : Streams initiated by a client MUST use odd-numbered stream
+  // identifiers.
+  uint32_t new_stream_id = std::exchange(next_stream_id_, next_stream_id_ + 2);
+  if (GPR_UNLIKELY(next_stream_id_ > GetMaxAllowedStreamId())) {
+    ReportDisconnection(
+        absl::ResourceExhaustedError("Transport Stream IDs exhausted"),
+        {},  // TODO(tjagtap) : [PH2][P2] : Report better disconnect info.
+        "no_more_stream_ids");
+  }
+  return new_stream_id;
+}
+
+absl::Status Http2ClientTransport::MaybeAddStreamToWritableStreamList(
+    RefCountedPtr<Stream> stream,
+    const StreamDataQueue<ClientMetadataHandle>::StreamWritabilityUpdate
+        result) {
+  if (result.became_writable) {
+    GRPC_HTTP2_CLIENT_DLOG
+        << "Http2ClientTransport::MaybeAddStreamToWritableStreamList Stream "
+           "id: "
+        << stream->GetStreamId() << " became writable";
+    // TODO(akshitpatel) [Perf]: Might be worth exploring if this funciton
+    // should take a raw stream ptr and take a ref here.
+    absl::Status status =
+        writable_stream_list_.Enqueue(std::move(stream), result.priority);
+    if (!status.ok()) {
+      return HandleError(
+          std::nullopt,
+          Http2Status::Http2ConnectionError(
+              Http2ErrorCode::kRefusedStream,
+              "Failed to enqueue stream to writable stream list"));
+    }
+  }
+  return absl::OkStatus();
+}
+
 RefCountedPtr<Stream> Http2ClientTransport::LookupStream(uint32_t stream_id) {
   MutexLock lock(&transport_mutex_);
   auto it = stream_list_.find(stream_id);
@@ -1875,64 +1895,69 @@ RefCountedPtr<Stream> Http2ClientTransport::LookupStream(uint32_t stream_id) {
 
 bool Http2ClientTransport::SetOnDone(CallHandler call_handler,
                                      RefCountedPtr<Stream> stream) {
-  return call_handler.OnDone(
-      [self = RefAsSubclass<Http2ClientTransport>(), stream,
-       stream_id = stream->GetStreamId()](bool cancelled) {
-        GRPC_HTTP2_CLIENT_DLOG << "PH2: Client call " << self.get()
-                               << " id=" << stream_id
-                               << " done: cancelled=" << cancelled;
-        absl::StatusOr<StreamWritabilityUpdate> enqueue_result;
-        GRPC_HTTP2_CLIENT_DLOG
-            << "PH2: Client call " << self.get() << " id=" << stream_id
-            << " done: stream=" << stream.get() << " cancelled=" << cancelled;
-        if (cancelled) {
-          // In most of the cases, EnqueueResetStream would be a no-op as
-          // BeginCloseStream would have already enqueued the reset stream.
-          // Currently only Aborts from application will actually enqueue
-          // the reset stream here.
-          enqueue_result = stream->EnqueueResetStream(
-              static_cast<uint32_t>(Http2ErrorCode::kCancel));
-          GRPC_HTTP2_CLIENT_DLOG
-              << "Enqueued ResetStream with error code="
-              << static_cast<uint32_t>(Http2ErrorCode::kCancel)
-              << " status=" << enqueue_result.status();
-        } else {
-          enqueue_result = stream->EnqueueHalfClosed();
-          GRPC_HTTP2_CLIENT_DLOG << "Enqueued HalfClosed with result="
-                                 << enqueue_result.status();
-        }
+  return call_handler.OnDone([self = RefAsSubclass<Http2ClientTransport>(),
+                              stream =
+                                  std::move(stream)](bool cancelled) mutable {
+    GRPC_HTTP2_CLIENT_DLOG << "PH2: Client call " << self.get()
+                           << " id=" << stream->GetStreamId()
+                           << " done: cancelled=" << cancelled;
+    absl::StatusOr<StreamWritabilityUpdate> enqueue_result;
+    GRPC_HTTP2_CLIENT_DLOG << "PH2: Client call " << self.get()
+                           << " id=" << stream->GetStreamId()
+                           << " done: stream=" << stream.get()
+                           << " cancelled=" << cancelled;
+
+    // If the stream is already closed for writes, then we don't need to
+    // enqueue the reset stream or the half closed frame.
+    if (stream->IsClosedForWrites()) {
+      GRPC_HTTP2_CLIENT_DLOG << "PH2: Client call " << self.get()
+                             << " id=" << stream->GetStreamId()
+                             << " done: stream already closed for writes";
+      return;
+    }
 
-        if (enqueue_result.ok()) {
-          GRPC_HTTP2_CLIENT_DLOG
-              << "Http2ClientTransport::SetOnDone "
-                 "MaybeAddStreamToWritableStreamList for stream= "
-              << stream->GetStreamId() << " enqueue_result={became_writable="
-              << enqueue_result.value().became_writable << ", priority="
-              << static_cast<uint8_t>(enqueue_result.value().priority) << "}";
-          GRPC_UNUSED absl::Status status =
-              self->MaybeAddStreamToWritableStreamList(stream,
-                                                       enqueue_result.value());
-        }
-      });
+    if (cancelled) {
+      // In most of the cases, EnqueueResetStream would be a no-op as
+      // BeginCloseStream would have already enqueued the reset stream.
+      // Currently only Aborts from application will actually enqueue
+      // the reset stream here.
+      enqueue_result = stream->EnqueueResetStream(
+          static_cast<uint32_t>(Http2ErrorCode::kCancel));
+      GRPC_HTTP2_CLIENT_DLOG << "Enqueued ResetStream with error code="
+                             << static_cast<uint32_t>(Http2ErrorCode::kCancel)
+                             << " status=" << enqueue_result.status();
+    } else {
+      enqueue_result = stream->EnqueueHalfClosed();
+      GRPC_HTTP2_CLIENT_DLOG << "Enqueued HalfClosed with result="
+                             << enqueue_result.status();
+    }
+
+    if (GPR_LIKELY(enqueue_result.ok())) {
+      GRPC_HTTP2_CLIENT_DLOG
+          << "Http2ClientTransport::SetOnDone "
+             "MaybeAddStreamToWritableStreamList for stream= "
+          << stream->GetStreamId() << " enqueue_result={became_writable="
+          << enqueue_result.value().became_writable << ", priority="
+          << static_cast<uint8_t>(enqueue_result.value().priority) << "}";
+      GRPC_UNUSED absl::Status status =
+          self->MaybeAddStreamToWritableStreamList(std::move(stream),
+                                                   enqueue_result.value());
+    }
+  });
 }
 
 std::optional<RefCountedPtr<Stream>> Http2ClientTransport::MakeStream(
     CallHandler call_handler) {
   // https://datatracker.ietf.org/doc/html/rfc9113#name-stream-identifiers
   RefCountedPtr<Stream> stream;
-  {
-    // TODO(akshitpatel) : [PH2][P3] : Remove this mutex once settings is in
-    // place.
-    MutexLock lock(&transport_mutex_);
-    stream = MakeRefCounted<Stream>(call_handler, flow_control_);
-  }
-  const bool on_done_added = SetOnDone(call_handler, stream);
+  stream = MakeRefCounted<Stream>(call_handler, flow_control_);
+  const bool on_done_added = SetOnDone(std::move(call_handler), stream);
   if (!on_done_added) return std::nullopt;
-  return stream;
+  return std::move(stream);
 }
 
 uint32_t Http2ClientTransport::GetMaxAllowedStreamId() const {
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport GetMaxAllowedStreamId "
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::GetMaxAllowedStreamId "
                          << max_allowed_stream_id_;
   return max_allowed_stream_id_;
 }
@@ -1940,7 +1965,7 @@ uint32_t Http2ClientTransport::GetMaxAllowedStreamId() const {
 void Http2ClientTransport::SetMaxAllowedStreamId(
     const uint32_t max_allowed_stream_id) {
   const uint32_t old_max_allowed_stream_id = GetMaxAllowedStreamId();
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport SetMaxAllowedStreamId "
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::SetMaxAllowedStreamId "
                          << " max_allowed_stream_id: " << max_allowed_stream_id
                          << " old_allowed_max_stream_id: "
                          << old_max_allowed_stream_id;
@@ -1962,115 +1987,241 @@ void Http2ClientTransport::SetMaxAllowedStreamId(
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// Call Spine related operations
+// Http2ClientTransport - Call Spine related operations
 
-auto Http2ClientTransport::CallOutboundLoop(CallHandler call_handler,
-                                            RefCountedPtr<Stream> stream,
-                                            ClientMetadataHandle metadata) {
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport CallOutboundLoop";
+auto Http2ClientTransport::CallOutboundLoop(RefCountedPtr<Stream> stream) {
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::CallOutboundLoop";
   GRPC_DCHECK(stream != nullptr);
 
-  auto send_message = [self = RefAsSubclass<Http2ClientTransport>(),
-                       stream](MessageHandle&& message) mutable {
-    return TrySeq(stream->EnqueueMessage(std::move(message)),
-                  [self, stream](const StreamWritabilityUpdate result) mutable {
-                    GRPC_HTTP2_CLIENT_DLOG
-                        << "Http2ClientTransport CallOutboundLoop "
-                           "Enqueued Message";
-                    return self->MaybeAddStreamToWritableStreamList(
-                        std::move(stream), result);
-                  });
-  };
-
-  auto send_initial_metadata = [self = RefAsSubclass<Http2ClientTransport>(),
-                                stream,
-                                metadata = std::move(metadata)]() mutable {
+  auto send_message = [this, stream](MessageHandle&& message) mutable {
     return TrySeq(
-        [stream, metadata = std::move(metadata)]() mutable {
-          return stream->EnqueueInitialMetadata(std::move(metadata));
-        },
-        [self, stream](const StreamWritabilityUpdate result) mutable {
-          GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport CallOutboundLoop "
-                                    "Enqueued Initial Metadata";
-          return self->MaybeAddStreamToWritableStreamList(std::move(stream),
-                                                          result);
+        stream->EnqueueMessage(std::move(message)),
+        [this, stream](const StreamWritabilityUpdate result) mutable {
+          GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::CallOutboundLoop "
+                                    "Enqueued Message";
+          return MaybeAddStreamToWritableStreamList(std::move(stream), result);
         });
   };
 
-  auto send_half_closed = [self = RefAsSubclass<Http2ClientTransport>(),
-                           stream]() mutable {
-    return TrySeq([stream]() { return stream->EnqueueHalfClosed(); },
-                  [self, stream](const StreamWritabilityUpdate result) mutable {
-                    GRPC_HTTP2_CLIENT_DLOG
-                        << "Http2ClientTransport CallOutboundLoop "
-                           "Enqueued Half Closed";
-                    return self->MaybeAddStreamToWritableStreamList(
-                        std::move(stream), result);
-                  });
+  auto send_initial_metadata =
+      [this, stream](ClientMetadataHandle&& metadata) mutable {
+        absl::StatusOr<StreamWritabilityUpdate> enqueue_result =
+            stream->EnqueueInitialMetadata(
+                std::forward<ClientMetadataHandle>(metadata));
+        if (GPR_UNLIKELY(!enqueue_result.ok())) {
+          return enqueue_result.status();
+        }
+        GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport CallOutboundLoop "
+                                  "Enqueued Initial Metadata";
+        return MaybeAddStreamToWritableStreamList(std::move(stream),
+                                                  enqueue_result.value());
+      };
+
+  auto send_half_closed = [this, stream]() mutable {
+    absl::StatusOr<StreamWritabilityUpdate> enqueue_result =
+        stream->EnqueueHalfClosed();
+    if (GPR_UNLIKELY(!enqueue_result.ok())) {
+      return enqueue_result.status();
+    }
+    GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport CallOutboundLoop "
+                              "Enqueued Half Closed";
+    return MaybeAddStreamToWritableStreamList(std::move(stream),
+                                              enqueue_result.value());
   };
+
   return GRPC_LATENT_SEE_PROMISE(
       "Ph2CallOutboundLoop",
       TrySeq(
-          send_initial_metadata(),
-          [call_handler, send_message]() {
-            // The lock will be released once the promise is constructed from
-            // this factory. ForEach will be polled after the lock is
-            // released.
-            return ForEach(MessagesFrom(call_handler), send_message);
-          },
-          [self = RefAsSubclass<Http2ClientTransport>(),
-           send_half_closed = std::move(send_half_closed)]() mutable {
-            return send_half_closed();
+          Map(stream->GetCallHandler().PullClientInitialMetadata(),
+              [send_initial_metadata = std::move(send_initial_metadata)](
+                  ValueOrFailure<ClientMetadataHandle> metadata) mutable {
+                if (GPR_UNLIKELY(!metadata.ok())) {
+                  return absl::InternalError(
+                      "Failed to pull client initial metadata");
+                }
+                return std::move(send_initial_metadata)(
+                    TakeValue(std::move(metadata)));
+              }),
+          ForEach(MessagesFrom(stream->GetCallHandler()),
+                  std::move(send_message)),
+          [send_half_closed = std::move(send_half_closed)]() mutable {
+            return std::move(send_half_closed)();
           },
-          [call_handler]() mutable {
-            return Map(call_handler.WasCancelled(), [](bool cancelled) {
-              GRPC_HTTP2_CLIENT_DLOG
-                  << "Http2ClientTransport PH2CallOutboundLoop End with "
-                     "cancelled="
-                  << cancelled;
-              return (cancelled) ? absl::CancelledError() : absl::OkStatus();
-            });
+          [stream]() mutable {
+            return Map(
+                stream->GetCallHandler().WasCancelled(), [](bool cancelled) {
+                  GRPC_HTTP2_CLIENT_DLOG
+                      << "Http2ClientTransport::CallOutboundLoop End with "
+                         "cancelled="
+                      << cancelled;
+                  return (cancelled) ? absl::CancelledError()
+                                     : absl::OkStatus();
+                });
           }));
 }
 
 void Http2ClientTransport::StartCall(CallHandler call_handler) {
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport StartCall Begin";
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::StartCall Begin";
+
   call_handler.SpawnGuarded(
       "OutboundLoop",
-      TrySeq(call_handler.PullClientInitialMetadata(),
-             [self = RefAsSubclass<Http2ClientTransport>(),
-              call_handler](ClientMetadataHandle metadata) mutable {
-               // For a gRPC Client, we only need to check the
-               // MAX_CONCURRENT_STREAMS setting compliance at the time of
-               // sending (that is write path). A gRPC Client will never
-               // receive a stream initiated by a server, so we dont have to
-               // check MAX_CONCURRENT_STREAMS compliance on the Read-Path.
-               //
-               // TODO(tjagtap) : [PH2][P1] Check for MAX_CONCURRENT_STREAMS
-               // sent by peer before making a stream. Decide behaviour if we
-               // are crossing this threshold.
-               //
-               // TODO(tjagtap) : [PH2][P1] : For a server we will have to do
-               // this for incoming streams only. If a server receives more
-               // streams from a client than is allowed by the clients settings,
-               // whether or not we should fail is debatable.
-               std::optional<RefCountedPtr<Stream>> stream =
-                   self->MakeStream(call_handler);
-               return If(
-                   stream.has_value(),
-                   [self, call_handler, stream,
-                    initial_metadata = std::move(metadata)]() mutable {
-                     return Map(
-                         self->CallOutboundLoop(call_handler, stream.value(),
-                                                std::move(initial_metadata)),
-                         [](absl::Status status) { return status; });
-                   },
-                   []() {
-                     return absl::InternalError("Failed to make stream");
-                   });
-             }));
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport StartCall End";
+      [self = RefAsSubclass<Http2ClientTransport>(), call_handler]() mutable {
+        std::optional<RefCountedPtr<Stream>> stream =
+            self->MakeStream(std::move(call_handler));
+
+        return If(
+            stream.has_value(),
+            [self = std::move(self), stream]() mutable {
+              return Map(self->CallOutboundLoop(std::move(stream.value())),
+                         [self](absl::Status status) { return status; });
+            },
+            []() { return absl::InternalError("Failed to make stream"); });
+      });
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::StartCall End";
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Http2ClientTransport - Test Only Functions
+
+int64_t Http2ClientTransport::TestOnlyTransportFlowControlWindow() {
+  return flow_control_.remote_window();
+}
+
+int64_t Http2ClientTransport::TestOnlyGetStreamFlowControlWindow(
+    const uint32_t stream_id) {
+  RefCountedPtr<Stream> stream = LookupStream(stream_id);
+  if (stream == nullptr) {
+    return -1;
+  }
+  return stream->GetStreamFlowControl().remote_window_delta();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Http2ClientTransport - Ping Helpers
+
+void Http2ClientTransport::MaybeSpawnPingTimeout(
+    std::optional<uint64_t> opaque_data) {
+  if (opaque_data.has_value()) {
+    SpawnGuardedTransportParty(
+        "PingTimeout", [self = RefAsSubclass<Http2ClientTransport>(),
+                        opaque_data = *opaque_data]() {
+          return self->ping_manager_->TimeoutPromise(opaque_data);
+        });
+  }
+}
+void Http2ClientTransport::MaybeSpawnDelayedPing(
+    std::optional<Duration> delayed_ping_wait) {
+  if (delayed_ping_wait.has_value()) {
+    SpawnGuardedTransportParty(
+        "DelayedPing", [self = RefAsSubclass<Http2ClientTransport>(),
+                        wait = *delayed_ping_wait]() {
+          GRPC_HTTP2_PING_LOG << "Scheduling delayed ping after wait=" << wait;
+          return self->ping_manager_->DelayedPingPromise(wait);
+        });
+  }
+}
+
+void Http2ClientTransport::MaybeSpawnKeepaliveLoop() {
+  if (keepalive_manager_->IsKeepAliveLoopNeeded()) {
+    SpawnGuardedTransportParty(
+        "KeepaliveLoop", [self = RefAsSubclass<Http2ClientTransport>()]() {
+          return self->keepalive_manager_->KeepaliveLoop();
+        });
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Class PingSystemInterfaceImpl
+
+std::unique_ptr<PingInterface>
+Http2ClientTransport::PingSystemInterfaceImpl::Make(
+    Http2ClientTransport* transport) {
+  return std::make_unique<PingSystemInterfaceImpl>(
+      PingSystemInterfaceImpl(transport));
 }
 
+absl::Status Http2ClientTransport::PingSystemInterfaceImpl::TriggerWrite() {
+  return transport_->TriggerWriteCycle();
+}
+
+Promise<absl::Status>
+Http2ClientTransport::PingSystemInterfaceImpl::PingTimeout() {
+  GRPC_HTTP2_CLIENT_DLOG << "PingSystemInterfaceImpl::PingTimeout at time: "
+                         << Timestamp::Now();
+
+  // TODO(akshitpatel) : [PH2][P2] : The error code here has been chosen
+  // based on CHTTP2's usage of GRPC_STATUS_UNAVAILABLE (which corresponds
+  // to kRefusedStream). However looking at RFC9113, definition of
+  // kRefusedStream doesn't seem to fit this case. We should revisit this
+  // and update the error code.
+  return Immediate(transport_->HandleError(
+      std::nullopt,
+      Http2Status::Http2ConnectionError(Http2ErrorCode::kRefusedStream,
+                                        GRPC_CHTTP2_PING_TIMEOUT_STR)));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Class KeepAliveInterfaceImpl
+
+std::unique_ptr<KeepAliveInterface>
+Http2ClientTransport::KeepAliveInterfaceImpl::Make(
+    Http2ClientTransport* transport) {
+  return std::make_unique<KeepAliveInterfaceImpl>(
+      KeepAliveInterfaceImpl(transport));
+}
+
+Promise<absl::Status>
+Http2ClientTransport::KeepAliveInterfaceImpl::SendPingAndWaitForAck() {
+  return TrySeq(
+      [transport = transport_] { return transport->TriggerWriteCycle(); },
+      [transport = transport_] { return transport->WaitForPingAck(); });
+}
+
+Promise<absl::Status>
+Http2ClientTransport::KeepAliveInterfaceImpl::OnKeepAliveTimeout() {
+  GRPC_HTTP2_CLIENT_DLOG
+      << "KeepAliveInterfaceImpl::OnKeepAliveTimeout triggered";
+  // TODO(akshitpatel) : [PH2][P2] : The error code here has been chosen
+  // based on CHTTP2's usage of GRPC_STATUS_UNAVAILABLE (which corresponds
+  // to kRefusedStream). However looking at RFC9113, definition of
+  // kRefusedStream doesn't seem to fit this case. We should revisit this
+  // and update the error code.
+  return Immediate(transport_->HandleError(
+      std::nullopt,
+      Http2Status::Http2ConnectionError(Http2ErrorCode::kRefusedStream,
+                                        GRPC_CHTTP2_KEEPALIVE_TIMEOUT_STR)));
+}
+
+bool Http2ClientTransport::KeepAliveInterfaceImpl::NeedToSendKeepAlivePing() {
+  bool need_to_send_ping = false;
+  {
+    MutexLock lock(&transport_->transport_mutex_);
+    need_to_send_ping = (transport_->keepalive_permit_without_calls_ ||
+                         transport_->GetActiveStreamCountLocked() > 0);
+  }
+  return need_to_send_ping;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Class GoawayInterfaceImpl
+
+std::unique_ptr<GoawayInterface>
+Http2ClientTransport::GoawayInterfaceImpl::Make(
+    Http2ClientTransport* transport) {
+  return std::make_unique<GoawayInterfaceImpl>(GoawayInterfaceImpl(transport));
+}
+
+uint32_t Http2ClientTransport::GoawayInterfaceImpl::GetLastAcceptedStreamId() {
+  LOG(DFATAL) << "GetLastAcceptedStreamId is not implemented for client "
+                 "transport.";
+  return 0;
+}
+
+// TODO(akshitpatel) : [PH2][P2] : Eventually there should be a separate ref
+// counted struct/class passed to all the transport promises/members. This
+// will help removing back references from the transport members to
+// transport and greatly simpilfy the cleanup path. Need to do this for
+// PingSystemInterfaceImpl, KeepAliveInterfaceImpl and GoawayInterfaceImpl.
+
 }  // namespace http2
 }  // namespace grpc_core