grpc 1.80.0 → 1.81.0

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

@@ -76,9 +76,9 @@ constexpr absl::string_view kAssemblerHpackError =
 class HeaderAssembler {
  public:
   // Call this for each incoming HTTP2 Header frame.
-  // If AppendHeaderFrame returns an OK status, the payload will be consumed.
+  // If AppendFrame returns an OK status, the payload will be consumed.
   // Else, the payload will be left in the frame.
-  Http2Status AppendHeaderFrame(Http2HeaderFrame& frame) {
+  Http2Status AppendFrame(Http2HeaderFrame& frame) {
     // Validate input frame
     GRPC_DCHECK_GT(frame.stream_id, 0u)
         << "RFC9113 : HEADERS frames MUST be associated with a stream.";
@@ -103,12 +103,12 @@ class HeaderAssembler {
 
     // Manage payload
     frame.payload.MoveFirstNBytesIntoSliceBuffer(current_len, buffer_);
-    ASSEMBLER_LOG << "HeaderAssembler::AppendHeaderFrame " << current_len
+    ASSEMBLER_LOG << "HeaderAssembler::AppendFrame HEADERS " << current_len
                   << " Bytes.";
 
     // Manage if last frame
     if (frame.end_headers) {
-      ASSEMBLER_LOG << "HeaderAssembler::AppendHeaderFrame end_headers";
+      ASSEMBLER_LOG << "HeaderAssembler::AppendFrame HEADERS end_headers";
       is_ready_ = true;
     }
 
@@ -116,21 +116,21 @@ class HeaderAssembler {
   }
 
   // Call this for each incoming HTTP2 Continuation frame.
-  // If AppendContinuationFrame returns an OK status, the payload will be
+  // If AppendFrame returns an OK status, the payload will be
   // consumed. Else, the payload will be left in the frame.
-  Http2Status AppendContinuationFrame(Http2ContinuationFrame& frame) {
+  Http2Status AppendFrame(Http2ContinuationFrame& frame) {
     // Validate Assembler state
     GRPC_DCHECK(header_in_progress_);
 
     // Manage payload
     const size_t current_len = frame.payload.Length();
     frame.payload.MoveFirstNBytesIntoSliceBuffer(current_len, buffer_);
-    ASSEMBLER_LOG << "HeaderAssembler::AppendContinuationFrame " << current_len
+    ASSEMBLER_LOG << "HeaderAssembler::AppendFrame CONTINUATION " << current_len
                   << " Bytes.";
 
     // Manage if last frame
     if (frame.end_headers) {
-      ASSEMBLER_LOG << "HeaderAssembler::AppendContinuationFrame end_headers";
+      ASSEMBLER_LOG << "HeaderAssembler::AppendFrame CONTINUATION end_headers";
       is_ready_ = true;
     }
 

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

@@ -28,6 +28,7 @@
 #include <memory>
 #include <optional>
 #include <string>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -92,10 +93,6 @@
 namespace grpc_core {
 namespace http2 {
 
-// 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;
@@ -242,8 +239,6 @@ Http2Status Http2ClientTransport::ProcessIncomingFrame(Http2DataFrame&& frame) {
       << 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();
 
   RefCountedPtr<Stream> stream = LookupStream(frame.stream_id);
@@ -276,7 +271,6 @@ Http2Status Http2ClientTransport::ProcessIncomingFrame(Http2DataFrame&& frame) {
     return stream_status;
   }
 
-  // Add frame to assembler
   GRPC_HTTP2_CLIENT_DLOG
       << "Http2ClientTransport::ProcessIncomingFrame(DataFrame) "
          "AppendNewDataFrame";
@@ -328,15 +322,10 @@ Http2Status Http2ClientTransport::ProcessIncomingFrame(Http2DataFrame&& frame) {
   return Http2Status::Ok();
 }
 
-Http2Status Http2ClientTransport::ProcessIncomingFrame(
-    Http2HeaderFrame&& frame) {
-  // https://www.rfc-editor.org/rfc/rfc9113.html#name-headers
-  GRPC_HTTP2_CLIENT_DLOG
-      << "Http2ClientTransport::ProcessIncomingFrame(HeaderFrame) { stream_id="
-      << frame.stream_id << ", end_headers=" << frame.end_headers
-      << ", end_stream=" << frame.end_stream << " }";
+template <typename T>
+Http2Status Http2ClientTransport::ProcessIncomingMetadata(T&& frame) {
   // State update MUST happen before processing the frame.
-  incoming_headers_.OnHeaderReceived(frame);
+  incoming_headers_.UpdateState(frame);
 
   ping_manager_->ReceivedDataFrame();
 
@@ -349,53 +338,53 @@ Http2Status Http2ClientTransport::ProcessIncomingFrame(
     // frame and streams that are reserved using PUSH_PROMISE. An endpoint that
     // receives an unexpected stream identifier MUST respond with a connection
     // error (Section 5.4.1) of type PROTOCOL_ERROR.
-    GRPC_HTTP2_CLIENT_DLOG
-        << "Http2ClientTransport::ProcessIncomingFrame(HeaderFrame) { "
-           "stream_id="
-        << frame.stream_id << "} Lookup Failed";
-    return ParseAndDiscardHeaders(std::move(frame.payload), frame.end_headers,
-                                  /*stream=*/nullptr, Http2Status::Ok());
+    GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::ProcessIncomingMetadata { "
+                              "stream_id="
+                           << frame.stream_id << "} Lookup Failed";
+    return incoming_headers_.ParseAndDiscardHeaders(
+        std::move(frame.payload), frame.end_headers, /*stream=*/nullptr,
+        Http2Status::Ok(), settings_->acked().max_header_list_size());
   }
 
-  if (stream->IsStreamHalfClosedRemote()) {
-    return ParseAndDiscardHeaders(
-        std::move(frame.payload), frame.end_headers, stream.get(),
-        Http2Status::Http2StreamError(
-            Http2ErrorCode::kStreamClosed,
-            std::string(RFC9113::kHalfClosedRemoteState)));
+  Http2Status validation_status =
+      ValidateMetadataFrameState(frame, *stream, incoming_headers_,
+                                 settings_->acked().max_header_list_size());
+  if (!validation_status.IsOk()) {
+    return validation_status;
   }
 
-  if (incoming_headers_.DidReceiveDuplicateMetadata(
-          stream->IsInitialMetadataReceived(),
-          stream->IsTrailingMetadataReceived())) {
-    return ParseAndDiscardHeaders(
-        std::move(frame.payload), frame.end_headers, stream.get(),
-        Http2Status::Http2StreamError(
-            Http2ErrorCode::kInternalError,
-            std::string(GrpcErrors::kTooManyMetadata)));
-  }
-
-  Http2Status append_result =
-      stream->GetHeaderAssembler().AppendHeaderFrame(frame);
+  Http2Status append_result = stream->GetHeaderAssembler().AppendFrame(frame);
   if (!append_result.IsOk()) {
-    // Frame payload is not consumed if AppendHeaderFrame returns a non-OK
+    // Frame payload is not consumed if AppendFrame 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.get(), std::move(append_result));
+    return incoming_headers_.ParseAndDiscardHeaders(
+        std::move(frame.payload), frame.end_headers, stream.get(),
+        std::move(append_result), settings_->acked().max_header_list_size());
   }
 
   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.get(), std::move(status));
+    return incoming_headers_.ParseAndDiscardHeaders(
+        SliceBuffer(), frame.end_headers, stream.get(), std::move(status),
+        settings_->acked().max_header_list_size());
   }
 
   // Frame payload has either been processed or moved to the HeaderAssembler.
   return Http2Status::Ok();
 }
 
+Http2Status Http2ClientTransport::ProcessIncomingFrame(
+    Http2HeaderFrame&& frame) {
+  // https://www.rfc-editor.org/rfc/rfc9113.html#name-headers
+  GRPC_HTTP2_CLIENT_DLOG
+      << "Http2ClientTransport::ProcessIncomingFrame(HeaderFrame) { stream_id="
+      << frame.stream_id << ", end_headers=" << frame.end_headers
+      << ", end_stream=" << frame.end_stream << " }";
+  return ProcessIncomingMetadata(std::forward<Http2HeaderFrame>(frame));
+}
+
 Http2Status Http2ClientTransport::ProcessIncomingFrame(
     Http2RstStreamFrame&& frame) {
   // https://www.rfc-editor.org/rfc/rfc9113.html#name-rst_stream
@@ -445,16 +434,16 @@ Http2Status Http2ClientTransport::ProcessIncomingFrame(
     }
   } else {
     if (settings_->OnSettingsAckReceived()) {
-      parser_.hpack_table()->SetMaxBytes(
+      incoming_headers_.SetMaxHeaderTableSize(
           settings_->acked().header_table_size());
       ActOnFlowControlAction(flow_control_.SetAckedInitialWindow(
                                  settings_->acked().initial_window_size()),
                              /*stream=*/nullptr);
     } 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";
+      // CHTTP2 returns a connection error for an unsolicited SETTINGS ACK.
+      // However, we ignore it in PH2 since RFC 9113 doesn't explicitly mandate
+      // an error.
+      LOG(ERROR) << "Settings ack received without sending settings. Ignore.";
     }
   }
 
@@ -588,9 +577,18 @@ Http2Status Http2ClientTransport::ProcessIncomingFrame(
   if (frame.stream_id != 0) {
     stream = LookupStream(frame.stream_id);
   }
+
+  const bool should_trigger_write = ProcessIncomingWindowUpdateFrameFlowControl(
+      frame, flow_control_, stream.get());
+
+  if (should_trigger_write) {
+    return ToHttpOkOrConnError(TriggerWriteCycle());
+  }
+
   if (stream != nullptr) {
     StreamWritabilityUpdate update =
-        stream->ReceivedFlowControlWindowUpdate(frame.increment);
+        stream->UpdateStreamWritability(GetStreamFlowControlTokens(
+            stream->GetStreamFlowControl(), settings_->peer()));
     if (update.became_writable) {
       absl::Status status = writable_stream_list_.EnqueueWrapper(
           stream, update.priority, AreTransportFlowControlTokensAvailable());
@@ -599,12 +597,6 @@ Http2Status Http2ClientTransport::ProcessIncomingFrame(
       }
     }
   }
-
-  const bool should_trigger_write = ProcessIncomingWindowUpdateFrameFlowControl(
-      frame, flow_control_, stream.get());
-  if (should_trigger_write) {
-    return ToHttpOkOrConnError(TriggerWriteCycle());
-  }
   return Http2Status::Ok();
 }
 
@@ -615,50 +607,7 @@ Http2Status Http2ClientTransport::ProcessIncomingFrame(
       << "Http2ClientTransport::ProcessIncomingFrame(ContinuationFrame) { "
          "stream_id="
       << frame.stream_id << ", end_headers=" << frame.end_headers << " }";
-
-  // State update MUST happen before processing the frame.
-  incoming_headers_.OnContinuationReceived(frame);
-
-  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
-    // numerically greater than all streams that the initiating endpoint has
-    // opened or reserved. This governs streams that are opened using a HEADERS
-    // frame and streams that are reserved using PUSH_PROMISE. An endpoint that
-    // receives an unexpected stream identifier MUST respond with a connection
-    // error (Section 5.4.1) of type PROTOCOL_ERROR.
-    return ParseAndDiscardHeaders(std::move(frame.payload), frame.end_headers,
-                                  nullptr, Http2Status::Ok());
-  }
-
-  if (stream->IsStreamHalfClosedRemote()) {
-    return ParseAndDiscardHeaders(
-        std::move(frame.payload), frame.end_headers, stream.get(),
-        Http2Status::Http2StreamError(
-            Http2ErrorCode::kStreamClosed,
-            std::string(RFC9113::kHalfClosedRemoteState)));
-  }
-
-  Http2Status append_result =
-      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.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.get(), std::move(status));
-  }
-
-  // Frame payload has either been processed or moved to the HeaderAssembler.
-  return Http2Status::Ok();
+  return ProcessIncomingMetadata(std::forward<Http2ContinuationFrame>(frame));
 }
 
 Http2Status Http2ClientTransport::ProcessIncomingFrame(
@@ -694,7 +643,8 @@ Http2Status Http2ClientTransport::ProcessMetadata(
   GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::ProcessMetadata";
   if (assembler.IsReady()) {
     ValueOrHttp2Status<ServerMetadataHandle> read_result =
-        assembler.ReadMetadata(parser_, !incoming_headers_.HeaderHasEndStream(),
+        assembler.ReadMetadata(incoming_headers_.parser(),
+                               !incoming_headers_.HeaderHasEndStream(),
                                /*max_header_list_size_soft_limit=*/
                                incoming_headers_.soft_limit(),
                                /*max_header_list_size_hard_limit=*/
@@ -723,35 +673,6 @@ Http2Status Http2ClientTransport::ProcessMetadata(
   return Http2Status::Ok();
 }
 
-Http2Status Http2ClientTransport::ParseAndDiscardHeaders(
-    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: "
-      << buffer.Length() << " is_initial_metadata: " << is_initial_metadata
-      << " is_end_headers: " << is_end_headers
-      << " incoming_stream_id: " << incoming_stream_id
-      << " stream_id: " << (stream == nullptr ? 0 : stream->GetStreamId())
-      << " original_status: " << original_status.DebugString()
-      << " whence: " << whence.file() << ":" << whence.line();
-
-  return http2::ParseAndDiscardHeaders(
-      parser_, std::move(buffer),
-      HeaderAssembler::ParseHeaderArgs{
-          /*is_initial_metadata=*/is_initial_metadata,
-          /*is_end_headers=*/is_end_headers,
-          /*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_stream_id,
-      },
-      stream, std::move(original_status));
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // Read Related Promises and Promise Factories
 auto Http2ClientTransport::ReadAndProcessOneFrame() {
@@ -762,14 +683,12 @@ auto Http2ClientTransport::ReadAndProcessOneFrame() {
       // the frame header.
       EndpointReadSlice(kFrameHeaderSize),
       // Parse the frame header.
-      [](Slice header_bytes) -> Http2FrameHeader {
+      [this](Slice header_bytes) {
         GRPC_HTTP2_CLIENT_DLOG
             << "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
-      [this](Http2FrameHeader header) {
+        Http2FrameHeader header = Http2FrameHeader::Parse(header_bytes.begin());
+        // Validate the incoming frame as per the current state of the transport
         Http2Status status = ValidateFrameHeader(
             /*max_frame_size_setting*/ settings_->acked().max_frame_size(),
             /*incoming_header_in_progress*/
@@ -917,6 +836,32 @@ void Http2ClientTransport::ActOnFlowControlAction(
   }
 }
 
+absl::Status Http2ClientTransport::UpdateAllStreamsWritability() {
+  MutexLock lock(&transport_mutex_);
+  GRPC_HTTP2_CLIENT_DLOG
+      << "Http2ClientTransport::UpdateAllStreamsWritability total streams: "
+      << stream_list_.size();
+  // This loop iterates over all active streams. For each stream this would
+  // internally take a stream specific lock and update the stream writability.
+  // This is not optimal but should be fine as this function is only called when
+  // initial window size is increased which in theory should not be very
+  // frequent.
+  for (const auto& [stream_id, stream] : stream_list_) {
+    StreamWritabilityUpdate update =
+        stream->UpdateStreamWritability(GetStreamFlowControlTokens(
+            stream->GetStreamFlowControl(), settings_->peer()));
+    absl::Status status = MaybeAddStreamToWritableStreamList(stream, update);
+    if (GPR_UNLIKELY(!status.ok())) {
+      GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::"
+                                "UpdateAllStreamsWritability failed for stream "
+                             << stream_id << " with status " << status;
+      return status;
+    }
+  }
+
+  return absl::OkStatus();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Write Related Promises and Promise Factories
 auto Http2ClientTransport::EndpointWrite(SliceBuffer&& output_buf) {
@@ -967,9 +912,30 @@ absl::Status Http2ClientTransport::PrepareControlFrames() {
 
   goaway_manager_.MaybeGetSerializedGoawayFrame(frame_sender);
   bool should_spawn_security_frame_loop = false;
+
+  const uint32_t old_initial_window_size =
+      settings_->peer().initial_window_size();
   http2::Http2ErrorCode apply_status =
       settings_->MaybeReportAndApplyBufferedPeerSettings(
           event_engine_.get(), should_spawn_security_frame_loop);
+
+  if (apply_status == http2::Http2ErrorCode::kNoError) {
+    const uint32_t new_initial_window_size =
+        settings_->peer().initial_window_size();
+    if (new_initial_window_size > old_initial_window_size) {
+      // TODO(akshitpatel) [PH2][P5] : Currently, if calling
+      // UpdateAllStreamsWritability() makes one or more streams writable. Once
+      // a stream is writable, it is enqueued to the writable stream list.
+      // However, these streams are not written out until the next write cycle.
+      // Might be worth considering to write out these streams immediately.
+      settings_->IncrementInitialWindowSizeIncreaseCount();
+      absl::Status status = UpdateAllStreamsWritability();
+      if (GPR_UNLIKELY(!status.ok())) {
+        return status;
+      }
+    }
+  }
+
   if (should_spawn_security_frame_loop) {
     const SecurityFrameHandler::EndpointExtensionState state =
         security_frame_handler_->Initialize(event_engine_);
@@ -1260,9 +1226,9 @@ absl::Status Http2ClientTransport::InitializeStream(Stream& stream) {
                          << 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.InitializeClientStream(
+      next_stream_id.value(), settings_->peer().allow_true_binary_metadata(),
+      settings_->acked().allow_true_binary_metadata());
   return absl::OkStatus();
 }
 
@@ -1345,7 +1311,8 @@ Http2ClientTransport::Http2ClientTransport(
           std::move(on_receive_settings))),
       next_stream_id_(/*Initial Stream ID*/ 1),
       should_reset_ping_clock_(false),
-      incoming_headers_(IncomingMetadataTracker::GetPeerString(endpoint_)),
+      incoming_headers_(IncomingMetadataTracker::GetPeerString(endpoint_),
+                        kIsClient),
       transport_write_context_(kIsClient),
       ping_manager_(std::nullopt),
       keepalive_manager_(std::nullopt),
@@ -1486,19 +1453,10 @@ void Http2ClientTransport::CloseStream(Stream& stream, CloseStreamArgs args,
       // should still parse the enqueued buffer to maintain HPACK state between
       // peers.
       if (incoming_headers_.IsWaitingForContinuationFrame()) {
-        Http2Status result = http2::ParseAndDiscardHeaders(
-            parser_, SliceBuffer(),
-            HeaderAssembler::ParseHeaderArgs{
-                /*is_initial_metadata=*/!incoming_headers_.HeaderHasEndStream(),
-                /*is_end_headers=*/false,
-                /*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());
+        Http2Status result = incoming_headers_.ParseAndDiscardHeaders(
+            SliceBuffer(), /*is_end_headers=*/false, &stream,
+            /*original_status=*/Http2Status::Ok(),
+            settings_->acked().max_header_list_size());
         if (result.GetType() == Http2Status::Http2ErrorType::kConnectionError) {
           GRPC_HTTP2_CLIENT_DLOG
               << "Http2ClientTransport::CloseStream for stream id: "
@@ -1948,9 +1906,8 @@ bool Http2ClientTransport::SetOnDone(CallHandler call_handler,
 
 std::optional<RefCountedPtr<Stream>> Http2ClientTransport::MakeStream(
     CallHandler call_handler) {
-  // https://datatracker.ietf.org/doc/html/rfc9113#name-stream-identifiers
-  RefCountedPtr<Stream> stream;
-  stream = MakeRefCounted<Stream>(call_handler, flow_control_);
+  RefCountedPtr<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 std::move(stream);

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

@@ -183,9 +183,9 @@ class Http2ClientTransport final : public ClientTransport,
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto EndpointReadSlice(
       const size_t num_bytes) {
     return Map(endpoint_.ReadSlice(num_bytes),
-               [this, num_bytes](absl::StatusOr<Slice> status) {
+               [this, num_bytes](absl::StatusOr<Slice>&& status) {
                  OnEndpointRead(status.ok(), num_bytes);
-                 return status;
+                 return std::move(status);
                });
   }
 
@@ -194,9 +194,9 @@ class Http2ClientTransport final : public ClientTransport,
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto EndpointRead(
       const size_t num_bytes) {
     return Map(endpoint_.Read(num_bytes),
-               [this, num_bytes](absl::StatusOr<SliceBuffer> status) {
+               [this, num_bytes](absl::StatusOr<SliceBuffer>&& status) {
                  OnEndpointRead(status.ok(), num_bytes);
-                 return status;
+                 return std::move(status);
                });
   }
 
@@ -243,11 +243,6 @@ class Http2ClientTransport final : public ClientTransport,
 
   Http2Status ProcessMetadata(RefCountedPtr<Stream> stream);
 
-  Http2Status ParseAndDiscardHeaders(SliceBuffer&& buffer, bool is_end_headers,
-                                     Stream* stream,
-                                     Http2Status&& original_status,
-                                     DebugLocation whence = {});
-
   GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Http2Status
   ProcessOneIncomingFrame(Http2Frame&& frame) {
     GRPC_HTTP2_CLIENT_DLOG << "Http2ClientTransport::ProcessOneIncomingFrame";
@@ -258,6 +253,9 @@ class Http2ClientTransport final : public ClientTransport,
         std::forward<Http2Frame>(frame));
   }
 
+  template <typename T>
+  Http2Status ProcessIncomingMetadata(T&& frame);
+
   auto ReadAndProcessOneFrame();
 
   // Returns a promise to keep reading in a Loop till a fail/close is received.
@@ -328,8 +326,6 @@ class Http2ClientTransport final : public ClientTransport,
     return false;
   }
 
-  absl::Status InitializeStream(Stream& stream);
-
   //////////////////////////////////////////////////////////////////////////////
   // Spawn Helpers and Promise Helpers
 
@@ -395,24 +391,12 @@ class Http2ClientTransport final : public ClientTransport,
                           std::forward<OnDone>(on_done));
   }
 
-  // Runs on the call party.
-  std::optional<RefCountedPtr<Stream>> MakeStream(CallHandler call_handler);
-
-  // This function MUST be idempotent.
-  void CloseStream(Stream& stream, CloseStreamArgs args,
-                   DebugLocation whence = {});
-
-  void BeginCloseStream(RefCountedPtr<Stream> stream,
-                        std::optional<uint32_t> reset_stream_error_code,
-                        ServerMetadataHandle&& metadata,
-                        DebugLocation whence = {});
-
   //////////////////////////////////////////////////////////////////////////////
   // Settings
 
+  void EnforceLatestIncomingSettings();
   auto WaitForSettingsTimeoutOnDone();
   void MaybeSpawnWaitForSettingsTimeout();
-  void EnforceLatestIncomingSettings();
 
   //////////////////////////////////////////////////////////////////////////////
   // Flow Control and BDP
@@ -423,6 +407,12 @@ class Http2ClientTransport final : public ClientTransport,
 
   void MaybeGetWindowUpdateFrames(FrameSender& frame_sender);
 
+  // On receiving an increase in the initial_window size, update the writability
+  // for all active streams. This may un-stall streams that are stalled due to
+  // lack of flow control tokens. This is needed as the stream flow control
+  // tokens are calculated based on the initial window size.
+  absl::Status UpdateAllStreamsWritability();
+
   auto FlowControlPeriodicUpdateLoop();
 
   // TODO(tjagtap) [PH2][P2][BDP] Remove this when the BDP code is done.
@@ -490,25 +480,25 @@ class Http2ClientTransport final : public ClientTransport,
   //////////////////////////////////////////////////////////////////////////////
   // Stream Operations
 
-  // This function MUST run on the transport party.
-  void CloseTransport();
-
-  void MaybeSpawnCloseTransport(Http2Status http2_status,
-                                DebugLocation whence = {});
+  absl::Status InitializeStream(Stream& stream);
 
-  uint32_t GetMaxAllowedStreamId() const;
+  // Runs on the call party.
+  std::optional<RefCountedPtr<Stream>> MakeStream(CallHandler call_handler);
 
-  void SetMaxAllowedStreamId(uint32_t max_allowed_stream_id);
+  void BeginCloseStream(RefCountedPtr<Stream> stream,
+                        std::optional<uint32_t> reset_stream_error_code,
+                        ServerMetadataHandle&& metadata,
+                        DebugLocation whence = {});
 
-  bool CanCloseTransportLocked() const
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(transport_mutex_);
+  // This function MUST be idempotent.
+  void CloseStream(Stream& stream, CloseStreamArgs args,
+                   DebugLocation whence = {});
 
   //////////////////////////////////////////////////////////////////////////////
   // Ping Keepalive and Goaway
 
   void MaybeSpawnPingTimeout(std::optional<uint64_t> opaque_data);
   void MaybeSpawnDelayedPing(std::optional<Duration> delayed_ping_wait);
-  void MaybeSpawnKeepaliveLoop();
 
   auto SendPing(absl::AnyInvocable<void()> on_initiate, bool important) {
     return ping_manager_->RequestPing(std::move(on_initiate), important);
@@ -516,7 +506,6 @@ class Http2ClientTransport final : public ClientTransport,
 
   auto WaitForPingAck() { return ping_manager_->WaitForPingAck(); }
 
-  // Ping Helper functions
   Duration NextAllowedPingInterval() {
     MutexLock lock(&transport_mutex_);
     return (!keepalive_permit_without_calls_ &&
@@ -527,9 +516,23 @@ class Http2ClientTransport final : public ClientTransport,
 
   absl::Status AckPing(uint64_t opaque_data);
 
+  void MaybeSpawnKeepaliveLoop();
+
+  uint32_t GetMaxAllowedStreamId() const;
+  void SetMaxAllowedStreamId(uint32_t max_allowed_stream_id);
+
   //////////////////////////////////////////////////////////////////////////////
   // Error Path and Close Path
 
+  void MaybeSpawnCloseTransport(Http2Status http2_status,
+                                DebugLocation whence = {});
+
+  bool CanCloseTransportLocked() const
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(transport_mutex_);
+
+  // This function MUST run on the transport party.
+  void CloseTransport();
+
   // Handles the error status and returns the corresponding absl status. Absl
   // Status is returned so that the error can be gracefully handled
   // by promise primitives.
@@ -653,7 +656,6 @@ class Http2ClientTransport final : public ClientTransport,
 
   uint32_t next_stream_id_;
   HPackCompressor encoder_;
-  HPackParser parser_;
   bool is_transport_closed_ ABSL_GUARDED_BY(transport_mutex_) = false;
   Latch<void> transport_closed_latch_;
 
@@ -679,7 +681,6 @@ class Http2ClientTransport final : public ClientTransport,
   std::optional<PingManager> ping_manager_;
   std::optional<KeepaliveManager> keepalive_manager_;
 
-  // Flags
   bool keepalive_permit_without_calls_;
 
   GoawayManager goaway_manager_;