grpc 1.75.0.pre1 → 1.76.0.pre1

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

@@ -26,19 +26,23 @@
 #include <optional>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
+#include "absl/strings/string_view.h"
 #include "src/core/call/call_spine.h"
 #include "src/core/call/message.h"
 #include "src/core/call/metadata_batch.h"
+#include "src/core/ext/transport/chttp2/transport/flow_control.h"
+#include "src/core/ext/transport/chttp2/transport/flow_control_manager.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/header_assembler.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings_manager.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
+#include "src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h"
 #include "src/core/ext/transport/chttp2/transport/internal_channel_arg_names.h"
 #include "src/core/ext/transport/chttp2/transport/message_assembler.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/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
@@ -51,10 +55,12 @@
 #include "src/core/lib/promise/promise.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"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/promise_endpoint.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
 
@@ -62,6 +68,7 @@ namespace grpc_core {
 namespace http2 {
 
 using grpc_event_engine::experimental::EventEngine;
+using EnqueueResult = StreamDataQueue<ClientMetadataHandle>::EnqueueResult;
 
 // Experimental : This is just the initial skeleton of class
 // and it is functions. The code will be written iteratively.
@@ -84,8 +91,9 @@ void Http2ClientTransport::PerformOp(grpc_transport_op* op) {
     StopConnectivityWatch(op->stop_connectivity_watch);
     did_stuff = true;
   }
-  CHECK(!op->set_accept_stream) << "Set_accept_stream not supported on clients";
-  DCHECK(did_stuff) << "Unimplemented transport perform op ";
+  GRPC_CHECK(!op->set_accept_stream)
+      << "Set_accept_stream not supported on clients";
+  GRPC_DCHECK(did_stuff) << "Unimplemented transport perform op ";
 
   ExecCtx::Run(DEBUG_LOCATION, op->on_consumed, absl::OkStatus());
   GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport PerformOp End";
@@ -219,8 +227,7 @@ Http2Status Http2ClientTransport::ProcessHttp2HeaderFrame(
       << ", payload=" << frame.payload.JoinIntoString() << " }";
   ping_manager_.ReceivedDataFrame();
 
-  RefCountedPtr<Http2ClientTransport::Stream> stream =
-      LookupStream(frame.stream_id);
+  RefCountedPtr<Stream> stream = LookupStream(frame.stream_id);
   if (stream == nullptr) {
     // TODO(tjagtap) : [PH2][P3] : Implement this.
     // RFC9113 : The identifier of a newly established stream MUST be
@@ -254,19 +261,20 @@ Http2Status Http2ClientTransport::ProcessHttp2HeaderFrame(
   HeaderAssembler& assembler = stream->header_assembler;
   Http2Status append_result = assembler.AppendHeaderFrame(std::move(frame));
   if (append_result.IsOk()) {
-    return ProcessMetadata(stream->stream_id, assembler, stream->call,
-                           stream->did_push_initial_metadata,
-                           stream->did_push_trailing_metadata);
+    return ProcessMetadata(stream);
   }
   return append_result;
 }
 
 Http2Status Http2ClientTransport::ProcessMetadata(
-    uint32_t stream_id, HeaderAssembler& assembler, CallHandler& call,
-    bool& did_push_initial_metadata, bool& did_push_trailing_metadata) {
+    RefCountedPtr<Stream> stream) {
+  const uint32_t stream_id = stream->GetStreamId();
+  HeaderAssembler& assembler = stream->header_assembler;
+  CallHandler call = stream->call;
+
   GRPC_HTTP2_CLIENT_DLOG << "Http2Transport ProcessMetadata";
   if (assembler.IsReady()) {
-    ValueOrHttp2Status<Arena::PoolPtr<grpc_metadata_batch>> read_result =
+    ValueOrHttp2Status<ServerMetadataHandle> read_result =
         assembler.ReadMetadata(parser_, !incoming_header_end_stream_,
                                /*is_client=*/true,
                                /*max_header_list_size_soft_limit=*/
@@ -274,27 +282,21 @@ Http2Status Http2ClientTransport::ProcessMetadata(
                                /*max_header_list_size_hard_limit=*/
                                settings_.acked().max_header_list_size());
     if (read_result.IsOk()) {
-      Arena::PoolPtr<grpc_metadata_batch> metadata =
-          TakeValue(std::move(read_result));
+      ServerMetadataHandle metadata = TakeValue(std::move(read_result));
       if (incoming_header_end_stream_) {
         // TODO(tjagtap) : [PH2][P1] : Is this the right way to differentiate
         // between initial and trailing metadata?
         GRPC_HTTP2_CLIENT_DLOG
             << "Http2Transport ProcessMetadata SpawnPushServerTrailingMetadata";
-        did_push_trailing_metadata = true;
-        call.SpawnPushServerTrailingMetadata(std::move(metadata));
-        CloseStream(stream_id, absl::OkStatus(),
-                    CloseStreamArgs{
-                        /*close_reads=*/true,
-                        /*close_writes=*/true,
-                        /*send_rst_stream=*/false,
-                        /*should_not_push_trailers=*/true,
-                    });
-
+        stream->MarkHalfClosedRemote();
+        BeginCloseStream(
+            stream_id,
+            Http2ErrorCodeToRstFrameErrorCode(Http2ErrorCode::kNoError),
+            std::move(metadata));
       } else {
         GRPC_HTTP2_CLIENT_DLOG
             << "Http2Transport ProcessMetadata SpawnPushServerInitialMetadata";
-        did_push_initial_metadata = true;
+        stream->did_push_initial_metadata = true;
         call.SpawnPushServerInitialMetadata(std::move(metadata));
       }
       return Http2Status::Ok();
@@ -313,16 +315,12 @@ Http2Status Http2ClientTransport::ProcessHttp2RstStreamFrame(
       << "Http2Transport ProcessHttp2RstStreamFrame { stream_id="
       << frame.stream_id << ", error_code=" << frame.error_code << " }";
   Http2ErrorCode error_code =
-      Http2ErrorCodeFromRstFrameErrorCode(frame.error_code);
-  CloseStream(frame.stream_id,
-              absl::Status((ErrorCodeToAbslStatusCode(error_code)),
-                           "Reset stream frame received."),
-              CloseStreamArgs{
-                  /*close_reads=*/true,
-                  /*close_writes=*/true,
-                  /*send_rst_stream=*/false,
-                  /*push_trailing_metadata=*/true,
-              });
+      RstFrameErrorCodeToHttp2ErrorCode(frame.error_code);
+  absl::Status status = absl::Status(ErrorCodeToAbslStatusCode(error_code),
+                                     "Reset stream frame received.");
+  BeginCloseStream(frame.stream_id, /*reset_stream_error_code=*/std::nullopt,
+                   CancelledServerMetadataFromStatus(status));
+
   // In case of stream error, we do not want the Read Loop to be broken. Hence
   // returning an ok status.
   return Http2Status::Ok();
@@ -343,6 +341,9 @@ Http2Status Http2ClientTransport::ProcessHttp2SettingsFrame(
     on_receive_settings_ = nullptr;
   }
 
+  // TODO(tjagtap) : [PH2][P2] Decide later if we want this only for AckLastSend
+  // or does any other operation also need this lock.
+  MutexLock lock(&transport_mutex_);
   if (!frame.ack) {
     // Check if the received settings have legal values
     Http2Status status = ValidateSettingsValues(frame.settings);
@@ -353,9 +354,15 @@ Http2Status Http2ClientTransport::ProcessHttp2SettingsFrame(
     // Apply the new settings
     // Quickly send the ACK to the peer once the settings are applied
   } else {
-    // TODO(tjagtap) : [PH2][P1]
-    // Stop the setting timeout promise
-    // Update the ACKed setting data structure
+    // Process the SETTINGS ACK Frame
+    if (settings_.AckLastSend()) {
+      transport_settings_.OnSettingsAckReceived();
+    } else {
+      // TODO(tjagtap) [PH2][P4] : The RFC does not say anything about what
+      // should happen if we receive an unsolicited SETTINGS ACK. Decide if we
+      // want to respond with any error or just proceed.
+      LOG(ERROR) << "Settings ack received without sending settings";
+    }
   }
 
   return Http2Status::Ok();
@@ -378,7 +385,7 @@ auto Http2ClientTransport::ProcessHttp2PingFrame(Http2PingFrame frame) {
         // writes.
         // RFC9113: PING responses SHOULD be given higher priority than any
         // other frame.
-        self->pending_ping_acks_.push_back(opaque);
+        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
@@ -416,6 +423,18 @@ Http2Status Http2ClientTransport::ProcessHttp2WindowUpdateFrame(
       << "Http2Transport ProcessHttp2WindowUpdateFrame Promise { "
          " stream_id="
       << frame.stream_id << ", increment=" << frame.increment << "}";
+  if (frame.stream_id != 0) {
+    RefCountedPtr<Stream> stream = LookupStream(frame.stream_id);
+    if (stream != nullptr) {
+      chttp2::StreamFlowControl::OutgoingUpdateContext fc_update(
+          &stream->flow_control);
+      fc_update.RecvUpdate(frame.increment);
+    }
+  } else {
+    chttp2::TransportFlowControl::OutgoingUpdateContext fc_update(
+        &flow_control_);
+    fc_update.RecvUpdate(frame.increment);
+  }
   return Http2Status::Ok();
 }
 
@@ -448,9 +467,7 @@ Http2Status Http2ClientTransport::ProcessHttp2ContinuationFrame(
   HeaderAssembler& assember = stream->header_assembler;
   Http2Status result = assember.AppendContinuationFrame(std::move(frame));
   if (result.IsOk()) {
-    return ProcessMetadata(stream->stream_id, assember, stream->call,
-                           stream->did_push_initial_metadata,
-                           stream->did_push_trailing_metadata);
+    return ProcessMetadata(stream);
   }
   return result;
 }
@@ -544,8 +561,10 @@ auto Http2ClientTransport::ReadAndProcessOneFrame() {
             /*incoming_header_stream_id*/ self->incoming_header_stream_id_,
             /*current_frame_header*/ header);
 
-        if (!status.IsOk()) {
-          return self->HandleError(std::move(status));
+        if (GPR_UNLIKELY(!status.IsOk())) {
+          GRPC_DCHECK(status.GetType() ==
+                      Http2Status::Http2ErrorType::kConnectionError);
+          return self->HandleError(std::nullopt, std::move(status));
         }
         GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport ReadAndProcessOneFrame "
                                   "Validated Frame Header:"
@@ -570,6 +589,7 @@ auto Http2ClientTransport::ReadAndProcessOneFrame() {
             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));
@@ -578,14 +598,15 @@ auto Http2ClientTransport::ReadAndProcessOneFrame() {
           GRPC_UNUSED Http2Frame frame) {
         GRPC_HTTP2_CLIENT_DLOG
             << "Http2ClientTransport ReadAndProcessOneFrame ProcessOneFrame";
-        return AssertResultType<absl::Status>(
-            Map(self->ProcessOneFrame(std::move(frame)),
-                [self](Http2Status status) {
-                  if (!status.IsOk()) {
-                    return self->HandleError(std::move(status));
-                  }
-                  return absl::OkStatus();
-                }));
+        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));
+              }
+              return absl::OkStatus();
+            }));
       }));
 }
 
@@ -608,189 +629,281 @@ auto Http2ClientTransport::OnReadLoopEnded() {
       [self = RefAsSubclass<Http2ClientTransport>()](absl::Status status) {
         GRPC_HTTP2_CLIENT_DLOG
             << "Http2ClientTransport OnReadLoopEnded Promise Status=" << status;
-        GRPC_UNUSED absl::Status error =
-            self->HandleError(Http2Status::AbslConnectionError(
-                status.code(), std::string(status.message())));
+        GRPC_UNUSED absl::Status error = self->HandleError(
+            std::nullopt, Http2Status::AbslConnectionError(
+                              status.code(), std::string(status.message())));
       };
 }
 
+// Equivalent to grpc_chttp2_act_on_flowctl_action in chttp2_transport.cc
+// TODO(tjagtap) : [PH2][P4] : grpc_chttp2_act_on_flowctl_action has a "reason"
+// parameter which looks like it would be really helpful for debugging. Add that
+void Http2ClientTransport::ActOnFlowControlAction(
+    const chttp2::FlowControlAction& action, const uint32_t stream_id) {
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::ActOnFlowControlAction";
+  if (action.send_stream_update() != kNoActionNeeded) {
+    GRPC_DCHECK_GT(stream_id, 0u);
+    RefCountedPtr<Stream> stream = LookupStream(stream_id);
+    if (GPR_LIKELY(stream != nullptr)) {
+      const HttpStreamState state = stream->GetStreamState();
+      if (state != HttpStreamState::kHalfClosedRemote &&
+          state != HttpStreamState::kClosed) {
+        // Stream is not remotely closed, so sending a WINDOW_UPDATE is
+        // potentially useful.
+        // TODO(tjagtap) : [PH2][P1] Plumb with flow control
+      }
+    } else {
+      GRPC_HTTP2_CLIENT_DLOG
+          << "Http2ClientTransport ActOnFlowControlAction stream is null";
+    }
+  }
+
+  if (action.send_transport_update() != kNoActionNeeded) {
+    // TODO(tjagtap) : [PH2][P1] Plumb with flow control
+  }
+
+  // TODO(tjagtap) : [PH2][P1] Plumb
+  // enable_preferred_rx_crypto_frame_advertisement with settings
+  ActOnFlowControlActionSettings(
+      action, settings_.mutable_local(),
+      /*enable_preferred_rx_crypto_frame_advertisement=*/true);
+
+  if (action.AnyUpdateImmediately()) {
+    TriggerWriteCycle();
+  }
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Write Related Promises and Promise Factories
 
-auto Http2ClientTransport::WriteFromQueue() {
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport WriteFromQueue Factory";
-  return TrySeq(
-      outgoing_frames_.NextBatch(128),
-      [self = RefAsSubclass<Http2ClientTransport>()](
-          std::vector<Http2Frame> frames) {
-        SliceBuffer output_buf;
-        if (self->is_first_write_) {
-          GRPC_HTTP2_CLIENT_DLOG
-              << "Http2ClientTransport Write GRPC_CHTTP2_CLIENT_CONNECT_STRING";
-          output_buf.Append(Slice(grpc_slice_from_copied_string(
-              GRPC_CHTTP2_CLIENT_CONNECT_STRING)));
-          self->is_first_write_ = false;
-        }
-        Serialize(absl::Span<Http2Frame>(frames), output_buf);
-        uint64_t buffer_length = output_buf.Length();
-        GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport WriteFromQueue Promise";
-        return If(
-            buffer_length > 0,
-            [self, output_buffer = std::move(output_buf)]() mutable {
-              self->bytes_sent_in_last_write_ = true;
-              return self->endpoint_.Write(std::move(output_buffer),
-                                           PromiseEndpoint::WriteArgs{});
-            },
-            [] { return absl::OkStatus(); });
+auto Http2ClientTransport::WriteControlFrames() {
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport WriteControlFrames Factory";
+  SliceBuffer output_buf;
+  if (is_first_write_) {
+    GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport Write "
+                              "GRPC_CHTTP2_CLIENT_CONNECT_STRING";
+    output_buf.Append(Slice(
+        grpc_slice_from_copied_string(GRPC_CHTTP2_CLIENT_CONNECT_STRING)));
+    is_first_write_ = false;
+  }
+  MaybeGetSettingsFrame(output_buf);
+  ping_manager_.MaybeGetSerializedPingFrames(output_buf,
+                                             NextAllowedPingInterval());
+  const uint64_t buffer_length = output_buf.Length();
+  return If(
+      buffer_length > 0,
+      [self = RefAsSubclass<Http2ClientTransport>(),
+       output_buf = std::move(output_buf), buffer_length]() mutable {
+        GRPC_HTTP2_CLIENT_DLOG
+            << "Http2ClientTransport WriteControlFrames Writing buffer of size "
+            << buffer_length << " to endpoint";
+        return self->endpoint_.Write(std::move(output_buf),
+                                     PromiseEndpoint::WriteArgs{});
+      },
+      [self = RefAsSubclass<Http2ClientTransport>(), buffer_length] {
+        self->ztrace_collector_->Append(
+            PromiseEndpointWriteTrace{buffer_length});
+        return absl::OkStatus();
       });
 }
 
-auto Http2ClientTransport::WriteLoop() {
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport WriteLoop Factory";
-  return AssertResultType<absl::Status>(
-      Loop([self = RefAsSubclass<Http2ClientTransport>()]() {
-        // TODO(akshitpatel) : [PH2][P1] : Once a common SliceBuffer is used, we
-        // can move bytes_sent_in_last_write_ to be a local variable.
-        self->bytes_sent_in_last_write_ = false;
-        return TrySeq(
-            // TODO(akshitpatel) : [PH2][P1] : WriteFromQueue may write settings
-            // acks as well. This will break the call to ResetPingClock as it
-            // only needs to be called on writing Data/Header/WindowUpdate
-            // frames. Possible fixes: Either WriteFromQueue iterates over all
-            // the frames and figures out the types of frames needed (this may
-            // anyways be needed to check that we do not send frames for closed
-            // streams) or we have flags to indicate the types of frame that are
-            // enqueued.
-            self->WriteFromQueue(), [self] { return self->MaybeSendPing(); },
-            [self] { return self->MaybeSendPingAcks(); },
-            [self]() -> LoopCtl<absl::Status> {
-              // If any Header/Data/WindowUpdate frame was sent in the last
-              // write, reset the ping clock.
-              if (self->bytes_sent_in_last_write_) {
-                self->ping_manager_.ResetPingClock(/*is_client=*/true);
-              }
-              GRPC_HTTP2_CLIENT_DLOG
-                  << "Http2ClientTransport WriteLoop Continue";
-              return Continue();
-            });
-      }));
+void Http2ClientTransport::NotifyControlFramesWriteDone() {
+  // Notify Control modules that we have sent the frames.
+  // All notifications are expected to be synchronous.
+  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport NotifyControlFramesWriteDone";
+  ping_manager_.NotifyPingSent(ping_timeout_);
 }
 
-auto Http2ClientTransport::OnWriteLoopEnded() {
-  GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport OnWriteLoopEnded Factory";
-  return
-      [self = RefAsSubclass<Http2ClientTransport>()](absl::Status status) {
-        GRPC_HTTP2_CLIENT_DLOG
-            << "Http2ClientTransport OnWriteLoopEnded Promise Status="
-            << status;
-        GRPC_UNUSED absl::Status error =
-            self->HandleError(Http2Status::AbslConnectionError(
-                status.code(), std::string(status.message())));
-      };
+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;
+  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),
+                                     PromiseEndpoint::WriteArgs{});
+      },
+      []() { return absl::OkStatus(); }));
 }
 
-auto Http2ClientTransport::StreamMultiplexerLoop() {
-  GRPC_HTTP2_CLIENT_DLOG
-      << "Http2ClientTransport StreamMultiplexerLoop Factory";
-  // This loop iterates over all the writable streams and drains them. If
-  // there are no writable streams, StreamMultiplexerLoop blocks until there
-  // is a writable stream.
-  return Loop([self = RefAsSubclass<Http2ClientTransport>()]() mutable {
-    // Overview:
-    // 1. Get the next writable stream.
-    // 2. Dequeue frames from the stream queue based on available transport
-    //    tokens.
-    // 3. If the stream is still writable, enqueue the stream back to the
-    //    writable stream list.
-    // 4. Enqueue the dequeued frames to the MPSC queue.
-    return TrySeq(
-        self->writable_stream_list_.Next(/*transport_tokens_available*/ true),
-        [self](const uint32_t stream_id) mutable
-            -> absl::StatusOr<std::vector<Http2Frame>> {
-          RefCountedPtr<Stream> stream = self->LookupStream(stream_id);
-          if (GPR_UNLIKELY(stream == nullptr)) {
-            // Stream was closed before we could dequeue.
-            // TODO(akshitpatel) : [PH2][P2] : Race condition. Determine should
-            // we have a DCHECK here based on how ResetStream/Aborts are
-            // handled.
-            return std::vector<Http2Frame>();
-          }
+absl::StatusOr<std::vector<Http2Frame>>
+Http2ClientTransport::DequeueStreamFrames(RefCountedPtr<Stream> stream) {
+  // 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.
+  // TODO(akshitpatel) : [PH2][P3] : Plug transport_tokens when
+  // transport flow control is implemented.
+  StreamDataQueue<ClientMetadataHandle>::DequeueResult result =
+      stream->DequeueFrames(
+          /*transport_tokens*/ std::min(
+              std::numeric_limits<uint32_t>::max(),
+              static_cast<uint32_t>(Clamp<size_t>(write_bytes_remaining_, 0,
+                                                  RFC9113::kMaxSize31Bit - 1))),
+          settings_.peer().max_frame_size(), encoder_);
+  if (result.is_writable) {
+    // Stream is still writable. Enqueue it back to the writable
+    // stream list.
+    // TODO(akshitpatel) : [PH2][P3] : Plug transport_tokens when
+    // transport flow control is implemented.
+    absl::Status status =
+        writable_stream_list_.Enqueue(stream, result.priority);
+    if (GPR_UNLIKELY(!status.ok())) {
+      GRPC_HTTP2_CLIENT_DLOG
+          << "Http2ClientTransport MultiplexerLoop Failed to "
+             "enqueue stream "
+          << stream->GetStreamId() << " with status: " << status;
+      // Close transport if we fail to enqueue stream.
+      return HandleError(std::nullopt, Http2Status::AbslConnectionError(
+                                           absl::StatusCode::kUnavailable,
+                                           std::string(status.message())));
+    }
+  }
+  if (result.InitialMetadataDequeued()) {
+    stream->SentInitialMetadata();
+  }
+  if (result.HalfCloseDequeued()) {
+    CloseStream(stream, CloseStreamArgs{/*close_reads=*/false,
+                                        /*close_writes=*/true});
+    stream->MarkHalfClosedLocal();
+  }
+  if (result.ResetStreamDequeued()) {
+    CloseStream(stream, CloseStreamArgs{/*close_reads=*/true,
+                                        /*close_writes=*/true});
+    stream->MarkHalfClosedLocal();
+  }
 
-          // TODO(akshitpatel) : [PH2][P3] : Plug transport_tokens when
-          // transport flow control is implemented.
-          absl::StatusOr<StreamDataQueue<ClientMetadataHandle>::DequeueResult>
-              result = stream->DequeueFrames(
-                  /*transport_tokens*/ std::numeric_limits<uint32_t>::max(),
-                  self->settings_.peer().max_frame_size(), self->encoder_);
-          if (result.ok() && result->is_writable) {
-            // Stream is still writable. Enqueue it back to the writable stream
-            // list.
+  // 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 MultiplexerLoop "
+                            "write_bytes_remaining_ after dequeue = "
+                         << write_bytes_remaining_ << " total_bytes_consumed = "
+                         << result.total_bytes_consumed
+                         << " 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);
+}
+
+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();
+    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->WriteControlFrames(), [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) {
             // TODO(akshitpatel) : [PH2][P3] : Plug transport_tokens when
             // transport flow control is implemented.
-            absl::Status status = self->writable_stream_list_.Enqueue(
-                stream_id, WritableStreams::StreamPriority::kDefault);
+            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;
+            }
+            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 (GPR_LIKELY(!stream->IsClosedForWrites())) {
+              auto 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();
+              }
 
-            if (GPR_UNLIKELY(!status.ok())) {
-              LOG(ERROR) << "Failed to enqueue stream " << stream_id
-                         << " with status: " << status;
-              // Close transport if we fail to enqueue stream.
-              return absl::InternalError("Failed to enqueue stream");
+              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()));
             }
-          } else if (GPR_UNLIKELY(!result.ok())) {
-            // Close the corresponding stream if we fail to dequeue frames from
-            // the stream queue.
-            LOG(ERROR) << "Failed to dequeue frames for stream " << stream_id
-                       << " with status: " << result.status();
-            absl::Status status =
-                self->HandleError(Http2Status::AbslStreamError(
-                    absl::StatusCode::kInternal, "Failed to dequeue frames"));
-            return std::vector<Http2Frame>();
           }
+
           GRPC_HTTP2_CLIENT_DLOG
-              << "Http2ClientTransport StreamMultiplexerLoop. Dequeued "
-              << result->frames.size()
-              << " frames for "
-                 "stream: "
-              << stream_id;
-          return std::move(result->frames);
+              << "Http2ClientTransport MultiplexerLoop "
+                 "write_bytes_remaining_ after draining all writable streams = "
+              << self->write_bytes_remaining_;
+
+          return std::move(frames);
         },
         [self](std::vector<Http2Frame> frames) {
-          // Enqueue the frames to the MPSC queue.
-          return Loop([self, frames = std::move(frames), idx = 0u]() mutable {
-            return If(
-                idx < frames.size(),
-                [self, &frames, &idx]() {
-                  return Map(
-                      // Enqueue to the MPSC queue could return pending. This
-                      // induces backpressure for the sender. Only after writing
-                      // to the MPSC queue we will loop back to read more
-                      // streams.
-                      self->EnqueueOutgoingFrame(std::move(frames[idx++])),
-                      [](absl::Status status) -> LoopCtl<absl::Status> {
-                        if (GPR_UNLIKELY(!status.ok())) {
-                          return status;
-                        }
-                        return Continue{};
-                      });
-                },
-                []() -> LoopCtl<absl::Status> { return absl::OkStatus(); });
-          });
+          return self->SerializeAndWrite(std::move(frames));
         },
-        []() -> LoopCtl<absl::Status> { return Continue{}; });
-  });
+        [self]() -> LoopCtl<absl::Status> {
+          if (self->should_reset_ping_clock_) {
+            GRPC_HTTP2_CLIENT_DLOG
+                << "Http2ClientTransport MultiplexerLoop ResetPingClock";
+            self->ping_manager_.ResetPingClock(/*is_client=*/true);
+            self->should_reset_ping_clock_ = false;
+          }
+          return Continue();
+        });
+  }));
 }
 
-auto Http2ClientTransport::OnStreamMultiplexerLoopEnded() {
+auto Http2ClientTransport::OnMultiplexerLoopEnded() {
   GRPC_HTTP2_CLIENT_DLOG
-      << "Http2ClientTransport OnStreamMultiplexerLoopEnded Factory";
-  return [self = RefAsSubclass<Http2ClientTransport>()](absl::Status status) {
-    GRPC_HTTP2_CLIENT_DLOG
-        << "Http2ClientTransport OnStreamMultiplexerLoopEnded Promise Status="
-        << status;
-    GRPC_UNUSED absl::Status error =
-        self->HandleError(Http2Status::AbslConnectionError(
-            status.code(), std::string(status.message())));
-  };
+      << "Http2ClientTransport OnMultiplexerLoopEnded Factory";
+  return
+      [self = RefAsSubclass<Http2ClientTransport>()](absl::Status status) {
+        GRPC_HTTP2_CLIENT_DLOG
+            << "Http2ClientTransport OnMultiplexerLoopEnded Promise Status="
+            << status;
+        GRPC_UNUSED absl::Status error = self->HandleError(
+            std::nullopt, Http2Status::AbslConnectionError(
+                              status.code(), std::string(status.message())));
+      };
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -800,10 +913,11 @@ Http2ClientTransport::Http2ClientTransport(
     PromiseEndpoint endpoint, GRPC_UNUSED const ChannelArgs& channel_args,
     std::shared_ptr<EventEngine> event_engine,
     grpc_closure* on_receive_settings)
-    : endpoint_(std::move(endpoint)),
-      outgoing_frames_(kMpscSize),
+    : channelz::DataSource(http2::CreateChannelzSocketNode(
+          endpoint.GetEventEngineEndpoint(), channel_args)),
+      endpoint_(std::move(endpoint)),
       stream_id_mutex_(/*Initial Stream Id*/ 1),
-      bytes_sent_in_last_write_(false),
+      should_reset_ping_clock_(false),
       incoming_header_in_progress_(false),
       incoming_header_end_stream_(false),
       is_first_write_(true),
@@ -811,6 +925,7 @@ Http2ClientTransport::Http2ClientTransport(
       on_receive_settings_(on_receive_settings),
       max_header_list_size_soft_limit_(
           GetSoftLimitFromChannelArgs(channel_args)),
+      max_write_size_(kMaxWriteSize),
       keepalive_time_(std::max(
           Duration::Seconds(10),
           channel_args.GetDurationFromIntMillis(GRPC_ARG_KEEPALIVE_TIME_MS)
@@ -838,24 +953,38 @@ Http2ClientTransport::Http2ClientTransport(
           ((keepalive_timeout_ < ping_timeout_) ? keepalive_timeout_
                                                 : Duration::Infinity()),
           keepalive_time_),
-      keepalive_permit_without_calls_(false) {
+      keepalive_permit_without_calls_(
+          channel_args.GetBool(GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS)
+              .value_or(false)),
+      enable_preferred_rx_crypto_frame_advertisement_(
+          channel_args
+              .GetBool(GRPC_ARG_EXPERIMENTAL_HTTP2_PREFERRED_CRYPTO_FRAME_SIZE)
+              .value_or(false)),
+      memory_owner_(channel_args.GetObject<ResourceQuota>()
+                        ->memory_quota()
+                        ->CreateMemoryOwner()),
+      flow_control_(
+          "PH2_Client",
+          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";
+  SourceConstructed();
 
   InitLocalSettings(settings_.mutable_local(), /*is_client=*/true);
   ReadSettingsFromChannelArgs(channel_args, settings_.mutable_local(),
-                              /*is_client=*/true);
+                              flow_control_, /*is_client=*/true);
 
   // Initialize the general party and write party.
   auto general_party_arena = SimpleArenaAllocator(0)->MakeArena();
   general_party_arena->SetContext<EventEngine>(event_engine.get());
   general_party_ = Party::Make(std::move(general_party_arena));
 
-  general_party_->Spawn("ReadLoop", ReadLoop(), OnReadLoopEnded());
-  // TODO(tjagtap) : [PH2][P2] Fix when needed.
-  general_party_->Spawn("WriteLoop", WriteLoop(), OnWriteLoopEnded());
-  general_party_->Spawn("StreamMultiplexerLoop", StreamMultiplexerLoop(),
-                        OnStreamMultiplexerLoopEnded());
-
+  general_party_->Spawn("ReadLoop", UntilTransportClosed(ReadLoop()),
+                        OnReadLoopEnded());
+  general_party_->Spawn("MultiplexerLoop",
+                        UntilTransportClosed(MultiplexerLoop()),
+                        OnMultiplexerLoopEnded());
   // The keepalive loop is only spawned if the keepalive time is not infinity.
   keepalive_manager_.Spawn(general_party_.get());
 
@@ -867,7 +996,7 @@ Http2ClientTransport::Http2ClientTransport(
   Http2ErrorCode code = settings_.mutable_local().Apply(
       Http2Settings::kInitialWindowSizeWireId,
       (Http2Settings::max_initial_window_size() - 1));
-  DCHECK(code == Http2ErrorCode::kNoError);
+  GRPC_DCHECK(code == Http2ErrorCode::kNoError);
   // </DeleteAfterFlowControl>
 
   const int max_hpack_table_size =
@@ -876,79 +1005,127 @@ Http2ClientTransport::Http2ClientTransport(
     encoder_.SetMaxUsableSize(max_hpack_table_size);
   }
 
-  settings_timeout_ =
-      channel_args.GetDurationFromIntMillis(GRPC_ARG_SETTINGS_TIMEOUT)
-          .value_or(std::max(keepalive_timeout_ * 2, Duration::Minutes(1)));
+  transport_settings_.SetSettingsTimeout(channel_args, keepalive_timeout_);
 
-  std::optional<Http2SettingsFrame> settings_frame =
-      settings_.MaybeSendUpdate();
-  if (settings_frame.has_value()) {
-    GRPC_HTTP2_CLIENT_DLOG
-        << "Http2ClientTransport Constructor Spawn SendFirstSettingsFrame";
-    general_party_->Spawn(
-        "SendFirstSettingsFrame",
-        [self = RefAsSubclass<Http2ClientTransport>(),
-         frame = std::move(*settings_frame)]() mutable {
-          return self->EnqueueOutgoingFrame(std::move(frame));
-        },
-        [](GRPC_UNUSED absl::Status status) {});
-  }
   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.
   }
+
+  // Spawn a promise to flush the gRPC initial connection string and settings
+  // frames.
+  general_party_->Spawn("SpawnFlushInitialFrames", TriggerWriteCycle(),
+                        [](GRPC_UNUSED absl::Status status) {});
+
   GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport Constructor End";
 }
 
-// This function MUST be idempotent.
-void Http2ClientTransport::CloseStream(uint32_t stream_id, absl::Status status,
+// This function MUST be idempotent. This function MUST be called from the
+// transport party.
+void Http2ClientTransport::CloseStream(RefCountedPtr<Stream> stream,
                                        CloseStreamArgs args,
                                        DebugLocation whence) {
+  // 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_id << " status=" << status
+                         << stream->GetStreamId()
                          << " location=" << whence.file() << ":"
                          << whence.line();
 
-  // TODO(akshitpatel) : [PH2][P3] : Measure the impact of holding mutex
-  // throughout this function.
-  MutexLock lock(&transport_mutex_);
-  auto pair = stream_list_.find(stream_id);
-  if (pair == stream_list_.end()) {
-    GRPC_HTTP2_CLIENT_DLOG
-        << "Http2ClientTransport::CloseStream for stream id: " << stream_id
-        << " stream not found";
-    return;
+  if (args.close_writes) {
+    stream->SetWriteClosed();
   }
-  auto& stream = pair->second;
 
   if (args.close_reads) {
-    stream->MarkHalfClosedRemote();
-  }
-  if (args.close_writes) {
-    stream->MarkHalfClosedLocal();
+    GRPC_HTTP2_CLIENT_DLOG
+        << "Http2ClientTransport::CloseStream for stream id: "
+        << stream->GetStreamId() << " closing stream for reads.";
+    stream_list_.erase(stream->GetStreamId());
   }
+}
 
-  if (stream->IsClosed()) {
-    GRPC_HTTP2_CLIENT_DLOG
-        << "Http2ClientTransport::CloseStream for stream id: " << stream_id
-        << " closing stream.";
-    if (args.send_rst_stream) {
-      // TODO(akshitpatel) : [PH2][P2] : Send RST_STREAM frame.
+// Here is the flow for stream close:
+// 1. BeginCloseStream is invoked if the transport needs to close the stream.
+// 2. If reset stream does not need to be sent, the stream is closed for reads
+//    and writes immediately. Also, the stream is removed from the
+//    stream_list_.
+// 3. If reset stream needs to be sent and the stream is cancelled, the stream
+//    is closed for reads immediately. This will result in stream being removed
+//    from the stream_list_. Additionally, the reset stream frame is enqueued
+//    and the stream is closed for writes once the frame is created.
+// 4. Trailing metadata is pushed to the call stack.
+// Extended:
+// 5. Eventually CallHandler.OnDone() is invoked.
+// 6. If the call was cancelled, we try to enqueue a reset stream frame. In most
+//    of the cases, this would be a no-op. The only case where this would
+//    enqueue the reset stream frame is an application initiated abort.
+// 7. If the call was not cancelled, we try to enqueue a half close frame. If
+//    the stream was already closed from writes, this would be a no-op.
+void Http2ClientTransport::BeginCloseStream(
+    const uint32_t stream_id, std::optional<uint32_t> reset_stream_error_code,
+    ServerMetadataHandle&& metadata, DebugLocation whence) {
+  GRPC_HTTP2_CLIENT_DLOG
+      << "Http2ClientTransport::BeginCloseStream for stream id: " << stream_id
+      << " error_code="
+      << (reset_stream_error_code.has_value()
+              ? absl::StrCat(*reset_stream_error_code)
+              : "nullopt")
+      << " ServerMetadata=" << metadata->DebugString()
+      << " location=" << whence.file() << ":" << whence.line();
+
+  RefCountedPtr<Stream> stream = LookupStream(stream_id);
+  if (stream != nullptr) {
+    if (stream->did_push_trailing_metadata) {
+      return;
     }
 
-    if (args.push_trailing_metadata) {
-      stream->call.SpawnPushServerTrailingMetadata(
-          ServerMetadataFromStatus(status));
+    // If reset stream needs to be sent, CloseStream will be called from the
+    // Multiplexer after the reset stream frame is created.
+    if (!reset_stream_error_code) {
+      // Callers taking this path:
+      // 1. Reading a RST stream frame (will not send any frame out).
+
+      CloseStream(stream,
+                  CloseStreamArgs{/*close_reads*/ true, /*close_writes=*/true},
+                  whence);
+      stream->MarkHalfClosedRemote();
+    } else {
+      // Callers taking this path:
+      // 1. Reading Trailing Metadata (MAY send half close from OnDone).
+      // 2. Processing Error in transport (will send reset stream from here).
+
+      if (metadata->get(GrpcCallWasCancelled())) {
+        CloseStream(
+            stream,
+            CloseStreamArgs{/*close_reads*/ true, /*close_writes=*/false},
+            whence);
+        absl::StatusOr<EnqueueResult> enqueue_result =
+            stream->EnqueueResetStream(reset_stream_error_code.value());
+        GRPC_HTTP2_CLIENT_DLOG << "Enqueued ResetStream with error code="
+                               << reset_stream_error_code.value()
+                               << " status=" << enqueue_result.status();
+        if (enqueue_result.ok()) {
+          GRPC_UNUSED absl::Status status = MaybeAddStreamToWritableStreamList(
+              stream, enqueue_result.value());
+        }
+      }
     }
-    stream_list_.erase(stream_id);
+
+    stream->did_push_trailing_metadata = true;
+    // This maybe called multiple times while closing a stream. This should be
+    // fine as the the call spine ignores the subsequent calls.
+    stream->call.SpawnPushServerTrailingMetadata(std::move(metadata));
   }
 }
 
 void Http2ClientTransport::CloseTransport() {
   GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::CloseTransport";
 
+  transport_closed_latch_.Set();
   // This is the only place where the general_party_ is
   // reset.
   general_party_.reset();
@@ -995,8 +1172,11 @@ void Http2ClientTransport::MaybeSpawnCloseTransport(Http2Status http2_status,
           // fail. Also, as this is running on the transport
           // party, there would not be concurrent access to the stream.
           auto& stream = pair.second;
-          stream->call.SpawnPushServerTrailingMetadata(
-              ServerMetadataFromStatus(http2_status.GetAbslConnectionError()));
+          self->BeginCloseStream(stream->stream_id,
+                                 Http2ErrorCodeToRstFrameErrorCode(
+                                     http2_status.GetConnectionErrorCode()),
+                                 CancelledServerMetadataFromStatus(
+                                     http2_status.GetAbslConnectionError()));
         }
 
         // RFC9113 : A GOAWAY frame might not immediately precede closing of
@@ -1017,15 +1197,30 @@ void Http2ClientTransport::MaybeSpawnCloseTransport(Http2Status http2_status,
 
 Http2ClientTransport::~Http2ClientTransport() {
   GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport Destructor Begin";
-  DCHECK(stream_list_.empty());
+  GRPC_DCHECK(stream_list_.empty());
+  memory_owner_.Reset();
+  SourceDestructing();
   GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport Destructor End";
 }
 
+void Http2ClientTransport::AddData(channelz::DataSink sink) {
+  sink.AddData(
+      "Http2ClientTransport",
+      channelz::PropertyList()
+          .Set("settings", settings_.ChannelzProperties())
+          .Set("keepalive_time", keepalive_time_)
+          .Set("keepalive_timeout", keepalive_timeout_)
+          .Set("ping_timeout", ping_timeout_)
+          .Set("keepalive_permit_without_calls",
+               keepalive_permit_without_calls_)
+          .Set("flow_control", flow_control_.stats().ChannelzProperties()));
+  general_party_->ExportToChannelz("Http2ClientTransport Party", sink);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Stream Related Operations
 
-RefCountedPtr<Http2ClientTransport::Stream> Http2ClientTransport::LookupStream(
-    uint32_t stream_id) {
+RefCountedPtr<Stream> Http2ClientTransport::LookupStream(uint32_t stream_id) {
   MutexLock lock(&transport_mutex_);
   auto it = stream_list_.find(stream_id);
   if (it == stream_list_.end()) {
@@ -1037,8 +1232,45 @@ RefCountedPtr<Http2ClientTransport::Stream> Http2ClientTransport::LookupStream(
   return it->second;
 }
 
-bool Http2ClientTransport::MakeStream(CallHandler call_handler,
-                                      const 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<EnqueueResult> 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();
+        }
+
+        if (enqueue_result.ok()) {
+          GRPC_UNUSED absl::Status status =
+              self->MaybeAddStreamToWritableStreamList(stream,
+                                                       enqueue_result.value());
+        }
+      });
+}
+
+std::optional<RefCountedPtr<Stream>> Http2ClientTransport::MakeStream(
+    CallHandler call_handler, const uint32_t stream_id) {
   // https://datatracker.ietf.org/doc/html/rfc9113#name-stream-identifiers
   // TODO(tjagtap) : [PH2][P2] Validate implementation.
 
@@ -1047,118 +1279,62 @@ bool Http2ClientTransport::MakeStream(CallHandler call_handler,
   // OnDone needs to be synchronous and hence InterActivityMutex might not be
   // an option to protect the stream_list_.
   MutexLock lock(&transport_mutex_);
-  const bool on_done_added =
-      call_handler.OnDone([self = RefAsSubclass<Http2ClientTransport>(),
-                           stream_id](bool cancelled) {
-        GRPC_HTTP2_CLIENT_DLOG << "PH2: Client call " << self.get()
-                               << " id=" << stream_id
-                               << " done: cancelled=" << cancelled;
-        if (cancelled) {
-          // TODO(akshitpatel) : [PH2][P2] : There are two ways to handle
-          // cancellation.
-          // 1. Call CloseStream from the on_done callback as done here. This
-          //    will be invoked when PullServerTrailingMetadata resolves.
-          // 2. Call CloseStream from the OutboundLoop. When the call is
-          //    cancelled, for_each() should return with an error. The
-          //    WasCancelled() function can be used to determinie if the call
-          //    was cancelled.
-          // At this point, both the above mentioned approaches seem to be more
-          // or less the same as both are running on the call party.
-          self->CloseStream(stream_id, absl::CancelledError(),
-                            CloseStreamArgs{
-                                /*close_reads=*/true,
-                                /*close_writes=*/true,
-                                /*send_rst_stream=*/true,
-                                /*push_trailing_metadata=*/false,
-                            });
-        }
-      });
-  if (!on_done_added) return false;
-  stream_list_.emplace(
-      stream_id, MakeRefCounted<Stream>(std::move(call_handler), stream_id));
-  return true;
+  RefCountedPtr<Stream> stream = MakeRefCounted<Stream>(
+      call_handler, stream_id, settings_.peer().allow_true_binary_metadata(),
+      settings_.acked().allow_true_binary_metadata(), flow_control_);
+  const bool on_done_added = SetOnDone(call_handler, stream);
+  if (!on_done_added) return std::nullopt;
+  stream_list_.emplace(stream_id, stream);
+  return stream;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Call Spine related operations
 
 auto Http2ClientTransport::CallOutboundLoop(
-    CallHandler call_handler, const uint32_t stream_id,
+    CallHandler call_handler, RefCountedPtr<Stream> stream,
     InterActivityMutex<uint32_t>::Lock lock /* Locked stream_id_mutex */,
     ClientMetadataHandle metadata) {
   GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport CallOutboundLoop";
+  GRPC_DCHECK(stream != nullptr);
 
   auto send_message = [self = RefAsSubclass<Http2ClientTransport>(),
-                       stream_id](MessageHandle&& message) mutable {
-    RefCountedPtr<Stream> stream = self->LookupStream(stream_id);
-    return If(
-        stream != nullptr,
-        [self, stream, message = std::move(message), stream_id]() mutable {
-          return TrySeq(stream->EnqueueMessage(std::move(message)),
-                        [self, stream_id](bool became_writable) {
-                          GRPC_HTTP2_CLIENT_DLOG
-                              << "Http2ClientTransport CallOutboundLoop "
-                                 "Enqueued Message";
-                          return self->MaybeAddStreamToWritableStreamList(
-                              stream_id, became_writable);
-                        });
-        },
-        []() {
-          // This will trigger Call stack cleanup.
-          return absl::InternalError("Stream not found while sending message");
-        });
+                       stream](MessageHandle&& message) mutable {
+    return TrySeq(stream->EnqueueMessage(std::move(message)),
+                  [self, stream](const EnqueueResult 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_id,
+                                stream,
                                 metadata = std::move(metadata)]() mutable {
-    RefCountedPtr<Stream> stream = self->LookupStream(stream_id);
-    return If(
-        stream != nullptr,
-        [self, stream, metadata = std::move(metadata), stream_id]() mutable {
-          return TrySeq(
-              stream->EnqueueInitialMetadata(std::move(metadata)),
-              [self, stream_id](bool became_writable) {
-                GRPC_HTTP2_CLIENT_DLOG
-                    << "Http2ClientTransport CallOutboundLoop "
-                       "Enqueued Initial Metadata";
-                return self->MaybeAddStreamToWritableStreamList(
-                    stream_id, became_writable);
-              },
-              [stream] {
-                // TODO(akshitpatel) : [PH2][P2] : Think how to handle stream
-                // states.
-                stream->SentInitialMetadata();
-                return absl::OkStatus();
-              });
+    return TrySeq(
+        [stream, metadata = std::move(metadata)]() mutable {
+          return stream->EnqueueInitialMetadata(std::move(metadata));
         },
-        []() {
-          // This will trigger Call stack cleanup.
-          return absl::InternalError(
-              "Stream not found while sending initial metadata");
+        [self, stream](const EnqueueResult result) mutable {
+          GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport CallOutboundLoop "
+                                    "Enqueued Initial Metadata";
+          return self->MaybeAddStreamToWritableStreamList(std::move(stream),
+                                                          result);
         });
   };
 
   auto send_half_closed = [self = RefAsSubclass<Http2ClientTransport>(),
-                           stream_id]() mutable {
-    RefCountedPtr<Stream> stream = self->LookupStream(stream_id);
-    return If(
-        stream != nullptr,
-        [self, stream, stream_id]() mutable {
-          return TrySeq(stream->EnqueueHalfClosed(),
-                        [self, stream_id](bool became_writable) {
-                          GRPC_HTTP2_CLIENT_DLOG
-                              << "Http2ClientTransport CallOutboundLoop "
-                                 "Enqueued Half Closed";
-                          return self->MaybeAddStreamToWritableStreamList(
-                              stream_id, became_writable);
-                        });
-        },
-        []() {
-          // This will trigger Call stack cleanup.
-          return absl::InternalError(
-              "Stream not found while sending half closed");
-        });
+                           stream]() mutable {
+    return TrySeq([stream]() { return stream->EnqueueHalfClosed(); },
+                  [self, stream](const EnqueueResult result) mutable {
+                    GRPC_HTTP2_CLIENT_DLOG
+                        << "Http2ClientTransport CallOutboundLoop "
+                           "Enqueued Half Closed";
+                    return self->MaybeAddStreamToWritableStreamList(
+                        std::move(stream), result);
+                  });
   };
   return GRPC_LATENT_SEE_PROMISE(
       "Ph2CallOutboundLoop",
@@ -1214,12 +1390,13 @@ void Http2ClientTransport::StartCall(CallHandler call_handler) {
             // from a client than is allowed by the clients settings, whether or
             // not we should fail is debatable.
             const uint32_t stream_id = self->NextStreamId(std::get<0>(args));
+            std::optional<RefCountedPtr<Stream>> stream =
+                self->MakeStream(call_handler, stream_id);
             return If(
-                self->MakeStream(call_handler, stream_id),
-                [self, call_handler, stream_id,
-                 args = std::move(args)]() mutable {
+                stream.has_value(),
+                [self, call_handler, stream, args = std::move(args)]() mutable {
                   return Map(
-                      self->CallOutboundLoop(call_handler, stream_id,
+                      self->CallOutboundLoop(call_handler, stream.value(),
                                              std::move(std::get<0>(args)),
                                              std::move(std::get<1>(args))),
                       [](absl::Status status) { return status; });