grpc 1.82.0 → 1.83.0.pre1

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

@@ -29,7 +29,6 @@
 #include <optional>
 #include <type_traits>
 #include <utility>
-#include <vector>
 
 #include "src/core/call/call_destination.h"
 #include "src/core/call/call_spine.h"
@@ -39,9 +38,6 @@
 #include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/goaway.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder.h"
-#include "src/core/ext/transport/chttp2/transport/hpack_parser.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_settings_promises.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/ext/transport/chttp2/transport/http2_transport.h"
@@ -59,7 +55,6 @@
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/latch.h"
 #include "src/core/lib/promise/map.h"
-#include "src/core/lib/promise/mpsc.h"
 #include "src/core/lib/promise/party.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/promise.h"
@@ -70,7 +65,6 @@
 #include "src/core/lib/transport/promise_endpoint.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/debug_location.h"
-#include "src/core/util/grpc_check.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -80,7 +74,6 @@
 #include "absl/container/flat_hash_map.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/log/log.h"
-#include "absl/meta/type_traits.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
@@ -181,6 +174,10 @@ class Http2ServerTransport final : public ServerTransport,
   int64_t TestOnlyTransportFlowControlWindow();
   int64_t TestOnlyGetStreamFlowControlWindow(const uint32_t stream_id);
 
+  uint32_t TestOnlyLastIncomingStreamId() const {
+    return last_incoming_stream_id_;
+  }
+
  private:
   //////////////////////////////////////////////////////////////////////////////
   // Endpoint Helpers
@@ -190,9 +187,9 @@ class Http2ServerTransport final : public ServerTransport,
   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);
                });
   }
 
@@ -201,9 +198,9 @@ class Http2ServerTransport final : public ServerTransport,
   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);
                });
   }
 
@@ -313,6 +310,27 @@ class Http2ServerTransport final : public ServerTransport,
 
   auto HandleMetadataAndMessages(RefCountedPtr<Stream> stream);
 
+  // Handles failure of a promise by closing the associated stream.
+  template <typename Promise>
+  auto HandleStreamErrorOnFailure(Promise&& promise,
+                                  RefCountedPtr<Stream> stream) {
+    return Map(std::forward<Promise>(promise),
+               [this, stream = std::move(stream)](auto&& result) mutable {
+                 absl::Status status = StatusCast<absl::Status>(result);
+                 GRPC_HTTP2_SERVER_DLOG
+                     << "Http2ServerTransport::HandleStreamErrorOnFailure "
+                        "Received status: "
+                     << status;
+                 if (GPR_UNLIKELY(!status.ok())) {
+                   GRPC_UNUSED absl::Status unused_status = HandleError(
+                       std::move(stream),
+                       Http2Status::AbslStreamError(
+                           status.code(), std::string(status.message())));
+                 }
+                 return std::forward<decltype(result)>(result);
+               });
+  }
+
   // Force triggers a transport write cycle
   absl::Status TriggerWriteCycle(DebugLocation whence = {}) {
     GRPC_HTTP2_SERVER_DLOG
@@ -331,7 +349,7 @@ class Http2ServerTransport final : public ServerTransport,
            "status: "
         << status << " at " << whence.file() << ":" << whence.line();
     GRPC_UNUSED absl::Status unused_status = HandleError(
-        /*stream_id=*/std::nullopt, ToHttpOkOrConnError(status), whence);
+        /*stream=*/nullptr, ToHttpOkOrConnError(status), whence);
     return false;
   }
 
@@ -388,7 +406,7 @@ class Http2ServerTransport final : public ServerTransport,
         [self = RefAsSubclass<Http2ServerTransport>()](absl::Status status) {
           if (!status.ok()) {
             GRPC_UNUSED absl::Status error = self->HandleError(
-                /*stream_id=*/std::nullopt, ToHttpOkOrConnError(status));
+                /*stream=*/nullptr, ToHttpOkOrConnError(status));
           }
         });
   }
@@ -443,21 +461,6 @@ class Http2ServerTransport final : public ServerTransport,
       RefCountedPtr<Stream> stream,
       StreamDataQueue<ServerMetadataHandle>::StreamWritabilityUpdate result);
 
-  // Returns the next stream id. If the next stream id is not available, it
-  // returns std::nullopt. MUST be called from the transport party.
-  // absl::StatusOr<uint32_t> NextStreamId();
-
-  // Returns the next stream id without incrementing it. MUST be called from the
-  // transport party.
-  // uint32_t PeekNextStreamId() const { return next_stream_id_; }
-
-  // Returns the last stream id sent by the transport. If no streams were sent,
-  // returns 0. MUST be called from the transport party.
-  // uint32_t GetLastStreamId() const {
-  //   const uint32_t next_stream_id = PeekNextStreamId();
-  //   return (next_stream_id > 1) ? (next_stream_id - 2) : 0;
-  // }
-
   // Returns the number of active streams. A stream is removed from the `active`
   // list once both client and server agree to close the stream. The count of
   // stream_list_(even though stream list represents streams open for reads)
@@ -499,29 +502,39 @@ class Http2ServerTransport final : public ServerTransport,
   Http2Status IncomingStream(ClientMetadataHandle&& metadata,
                              uint32_t stream_id);
 
-  // void BeginCloseStream(RefCountedPtr<Stream> stream,
-  //                       std::optional<uint32_t> reset_stream_error_code,
-  //                       ServerMetadataHandle&& metadata,
-  //                       DebugLocation whence = {});
-
-  // This function MUST be idempotent.
-  void CloseStream(uint32_t stream_id, absl::Status status,
-                   DebugLocation whence = {}) {
-    LOG(INFO) << "Http2ServerTransport::CloseStream for stream id=" << stream_id
-              << " status=" << status << " location=" << whence.file() << ":"
-              << whence.line();
-    // TODO(akshitpatel) : [PH2][P2] : Implement this.
-  }
-
-  // This function MUST be idempotent.
-  // void CloseStream(Stream& stream, CloseStreamArgs args,
-  //                  DebugLocation whence = {});
+  // Call this when a stream needs to be closed and we must notify the client by
+  // sending a RST_STREAM frame (e.g., due to local stream error, cancellation).
+  // This enqueues the RST_STREAM frame and immediately closes the stream for
+  // reads. Writes will be closed by the write loop after the RST_STREAM frame
+  // is written to the wire.
+  // Prefer calling HandleError over this API.
+  // Parameters:
+  //   stream: The stream to close.
+  //   reset_stream_error_code: The error code to use for the RST_STREAM frame.
+  //   trailing_metadata_status: The failure status to propagate to the
+  //                             application.
+  //   whence: The location of the caller.
+  void BeginCloseStream(RefCountedPtr<Stream> stream,
+                        uint32_t reset_stream_error_code,
+                        absl::Status trailing_metadata_status,
+                        DebugLocation whence = {});
+
+  // Handles stream state changes by discarding pending header parsing if reads
+  // became closed, and triggering cleanup if the stream became closed.
+  // This function does not hold the transport mutex and is safe to call from
+  // the read loop.
+  void HandleStreamStateChange(Stream& stream, StreamStateChange change);
+
+  // Erases the stream from the active stream list. The caller MUST ensure the
+  // stream is closed.
+  // This function acquires the transport mutex internally.
+  void CleanupStream(Stream& stream);
 
   //////////////////////////////////////////////////////////////////////////////
   // Ping Keepalive and Goaway
 
-  // void MaybeSpawnPingTimeout(std::optional<uint64_t> opaque_data);
-  // void MaybeSpawnDelayedPing(std::optional<Duration> delayed_ping_wait);
+  void MaybeSpawnPingTimeout(std::optional<uint64_t> opaque_data);
+  void MaybeSpawnDelayedPing(std::optional<Duration> delayed_ping_wait);
 
   auto SendPing(absl::AnyInvocable<void()> on_initiate, bool important) {
     return ping_manager_->RequestPing(std::move(on_initiate), important);
@@ -529,17 +542,14 @@ class Http2ServerTransport final : public ServerTransport,
 
   auto WaitForPingAck() { return ping_manager_->WaitForPingAck(); }
 
-  // Duration NextAllowedPingInterval() {
-  //   MutexLock lock(&transport_mutex_);
-  //   return (!keepalive_permit_without_calls_ &&
-  //           GetActiveStreamCountLocked() == 0)
-  //              ? Duration::Hours(2)
-  //              : Duration::Seconds(1);
-  // }
+  Duration NextAllowedPingInterval() {
+    // TODO(akshitpatel) : [PH2][P1] : Add server logic.
+    return Duration::Zero();
+  }
 
   absl::Status AckPing(uint64_t opaque_data);
 
-  // void MaybeSpawnKeepaliveLoop();
+  void MaybeSpawnKeepaliveLoop();
 
   // uint32_t GetMaxAllowedStreamId() const;
   // void SetMaxAllowedStreamId(uint32_t max_allowed_stream_id);
@@ -547,8 +557,8 @@ class Http2ServerTransport final : public ServerTransport,
   //////////////////////////////////////////////////////////////////////////////
   // Error Path and Close Path
 
-  // void MaybeSpawnCloseTransport(Http2Status http2_status,
-  //                               DebugLocation whence = {});
+  void MaybeSpawnCloseTransport(Http2Status http2_status,
+                                DebugLocation whence = {});
 
   // bool CanCloseTransportLocked() const
   //     ABSL_EXCLUSIVE_LOCKS_REQUIRED(transport_mutex_);
@@ -559,22 +569,13 @@ class Http2ServerTransport final : public ServerTransport,
   // 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.
-  // If the error is a stream error, it closes the stream and returns an ok
+  // If the error is a stream error, it initiates stream close and returns an ok
   // status. Ok status is returned because the calling transport promise loops
   // should not be cancelled in case of stream errors.
   // If the error is a connection error, it closes the transport and returns the
   // corresponding (failed) absl status.
-  absl::Status HandleError(const std::optional<uint32_t> stream_id,
-                           Http2Status status, DebugLocation whence = {}) {
-    // TODO(akshitpatel) : [PH2][P0] : Implement this. And remove the log.
-    GRPC_HTTP2_SERVER_DLOG << "Http2ServerTransport::HandleError for stream id="
-                           << (stream_id.has_value() ? absl::StrCat(*stream_id)
-                                                     : "nullopt")
-                           << " status=" << status.DebugString()
-                           << " location=" << whence.file() << ":"
-                           << whence.line();
-    return absl::OkStatus();
-  }
+  absl::Status HandleError(RefCountedPtr<Stream> stream, Http2Status status,
+                           DebugLocation whence = {});
 
   //////////////////////////////////////////////////////////////////////////////
   // Misc Transport Stuff
@@ -613,6 +614,8 @@ class Http2ServerTransport final : public ServerTransport,
     }));
   }
 
+  auto SpawnGracefulGoawayPromise(Slice&& debug_data);
+
   //////////////////////////////////////////////////////////////////////////////
   // Inner Classes and Structs
 
@@ -677,13 +680,7 @@ class Http2ServerTransport final : public ServerTransport,
 
   RefCountedPtr<UnstartedCallDestination> call_destination_;
 
-  // TODO(akshitpatel) : [PH2][P0] : Remove this when write path is ready.
-  MpscReceiver<Http2Frame> outgoing_frames_;
-
-  // TODO(tjagtap) : [PH2][P0] : These are copied as is from the client
-  // transport. Take a look if modifications are needed.
-
-  RefCountedPtr<Party> general_party_;  // Refer Gemini.md for party slot usage
+  RefCountedPtr<Party> general_party_;  // Refer AGENTS.md for party slot usage
   std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine_;
 
   PromiseEndpoint endpoint_;
@@ -694,7 +691,6 @@ class Http2ServerTransport final : public ServerTransport,
   absl::flat_hash_map<uint32_t, RefCountedPtr<Stream>> stream_list_
       ABSL_GUARDED_BY(transport_mutex_);
 
-  GRPC_UNUSED uint32_t next_stream_id_;
   HPackCompressor encoder_;
   bool is_transport_closed_ ABSL_GUARDED_BY(transport_mutex_) = false;
   Latch<void> transport_closed_latch_;
@@ -715,6 +711,8 @@ class Http2ServerTransport final : public ServerTransport,
   // Tracks the max allowed stream id. Currently this is only set on receiving a
   // graceful GOAWAY frame.
   GRPC_UNUSED uint32_t max_allowed_stream_id_ = RFC9113::kMaxStreamId31Bit;
+  // Tracks last stream id received by the transport.
+  uint32_t last_incoming_stream_id_ = 0;
 
   // Duration between two consecutive keepalive pings.
   Duration keepalive_time_;

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

@@ -116,7 +116,7 @@ Http2ErrorCode Http2Settings::Apply(uint16_t key, uint32_t value) {
       max_frame_size_ = value;
       break;
     case kMaxHeaderListSizeWireId:
-      max_header_list_size_ = std::min(value, 16777216u);
+      max_header_list_size_ = std::min(value, kDefaultMaxHeaderListSize);
       break;
     case kGrpcAllowTrueBinaryMetadataWireId:
       if (value > 1) return Http2ErrorCode::kProtocolError;

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

@@ -20,6 +20,7 @@
 #include <grpc/support/port_platform.h>
 #include <stdint.h>
 
+#include <algorithm>
 #include <cstdint>
 #include <optional>
 
@@ -50,6 +51,23 @@ class Http2Settings {
 
   constexpr static uint8_t kNumSettings = 9u;
 
+  // RFC9113 defines the default value for some of these settings.
+  // https://datatracker.ietf.org/doc/html/rfc9113#name-defined-settings
+  // RFC defined defaults for RFC defined settings :
+  constexpr static uint32_t kDefaultHeaderTableSize = 4096u;
+  constexpr static uint32_t kDefaultMaxConcurrentStreams = 4294967295u;
+  constexpr static uint32_t kDefaultInitialWindowSize = 65535u;
+  constexpr static uint32_t kDefaultMaxFrameSize = 16384u;
+  constexpr static bool kDefaultEnablePush = true;
+
+  // gRPC defined defaults for RFC defined settings :
+  constexpr static uint32_t kDefaultMaxHeaderListSize = 16777216u;
+
+  // gRPC defined defaults.
+  constexpr static uint32_t kDefaultPreferredReceiveCryptoMessageSize = 0u;
+  constexpr static bool kDefaultAllowTrueBinaryMetadata = false;
+  constexpr static bool kDefaultAllowSecurityFrame = false;
+
   void Diff(bool is_first_send, const Http2Settings& old_setting,
             absl::FunctionRef<void(uint16_t key, uint32_t value)> cb) const;
   GRPC_MUST_USE_RESULT http2::Http2ErrorCode Apply(uint16_t key,
@@ -81,7 +99,7 @@ class Http2Settings {
   }
   void SetEnablePush(bool x) { enable_push_ = x; }
   void SetMaxHeaderListSize(uint32_t x) {
-    max_header_list_size_ = std::min(x, 16777216u);
+    max_header_list_size_ = std::min(x, kDefaultMaxHeaderListSize);
   }
   void SetAllowTrueBinaryMetadata(bool x) { allow_true_binary_metadata_ = x; }
   void SetMaxFrameSize(uint32_t x) {
@@ -178,41 +196,42 @@ class Http2Settings {
   // RFC9113 states the default value for SETTINGS_HEADER_TABLE_SIZE
   // Currently this is set only once in the lifetime of a transport.
   // We plan to change that in the future.
-  uint32_t header_table_size_ = 4096u;
+  uint32_t header_table_size_ = kDefaultHeaderTableSize;
 
   // CLIENT : Set only once in the lifetime of a client transport. This is set
   // to 0 for client.
   // SERVER : This setting can change for the server. This is usually changed to
   // handle memory pressure.
-  uint32_t initial_max_concurrent_streams_ = 4294967295u;
-  uint32_t max_concurrent_streams_ = 4294967295u;
+  uint32_t initial_max_concurrent_streams_ = kDefaultMaxConcurrentStreams;
+  uint32_t max_concurrent_streams_ = kDefaultMaxConcurrentStreams;
 
   // RFC9113 states the default for SETTINGS_INITIAL_WINDOW_SIZE
   // Both client and servers can change this setting. This is usually changed to
   // handle memory pressure.
-  uint32_t initial_window_size_ = 65535u;
+  uint32_t initial_window_size_ = kDefaultInitialWindowSize;
 
   // RFC9113 states the default for SETTINGS_MAX_FRAME_SIZE
   // Both client and servers can change this setting. This is usually changed to
   // handle memory pressure.
-  uint32_t max_frame_size_ = 16384u;
+  uint32_t max_frame_size_ = kDefaultMaxFrameSize;
 
   // This is an advisory but we currently enforce it.
   // Set only once in the lifetime of a transport currently.
   // When a peer that updates this more than once, that may indicate either an
   // underlying issue or a malicious peer.
-  uint32_t max_header_list_size_ = 16777216u;
+  uint32_t max_header_list_size_ = kDefaultMaxHeaderListSize;
 
   // gRPC defined setting
   // Both client and servers can change this setting. This is usually changed to
   // handle memory pressure.
-  uint32_t preferred_receive_crypto_message_size_ = 0u;
+  uint32_t preferred_receive_crypto_message_size_ =
+      kDefaultPreferredReceiveCryptoMessageSize;
 
   // RFC9113 defined default is true. However, for gRPC we always then set it to
   // false via the SetEnablePush function
   // Currently this is set only once in the lifetime of a transport.
   // We have no plans to support this in the future.
-  bool enable_push_ = true;
+  bool enable_push_ = kDefaultEnablePush;
 
   // gRPC defined setting
   // Currently this is set only once in the lifetime of a transport.
@@ -221,7 +240,7 @@ class Http2Settings {
   // flag. Both peers can send each other the default non-binary METADATA
   // irrespective of this flag. This flag says if we are willing to accept
   // Binary-Metadata from the peer or not.
-  bool allow_true_binary_metadata_ = false;
+  bool allow_true_binary_metadata_ = kDefaultAllowTrueBinaryMetadata;
 
   // gRPC defined setting
   // Unlike most other SETTINGS, this setting is negotiated between the client
@@ -229,7 +248,7 @@ class Http2Settings {
   // apply the custom SECURITY frame.
   // Currently this is set only once in the lifetime of a transport.
   // Disconnect if it is received more than once from the peer.
-  bool allow_security_frame_ = false;
+  bool allow_security_frame_ = kDefaultAllowSecurityFrame;
 };
 
 }  // namespace grpc_core

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

@@ -66,6 +66,11 @@ namespace grpc_core {
 #define GRPC_SETTINGS_TIMEOUT_DLOG \
   DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
 
+struct ApplySettingsResult {
+  bool did_change_peer_max_concurrent_streams = false;
+  bool should_spawn_security_frame_loop = false;
+};
+
 // This class can only be used only from a promise based HTTP2 transports
 // general_party_ .
 // This class is designed with the assumption that only 1 SETTINGS frame will be
@@ -74,8 +79,10 @@ namespace grpc_core {
 class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
  public:
   explicit SettingsPromiseManager(
+      const bool is_client,
       absl::AnyInvocable<void(absl::StatusOr<uint32_t>)> on_receive_settings)
-      : on_receive_first_settings_(std::move(on_receive_settings)),
+      : is_client_(is_client),
+        on_receive_first_settings_(std::move(on_receive_settings)),
         state_(SettingsState::kWaitingForFirstPeerSettings) {
     pending_peer_settings_.reserve(Http2Settings::kNumSettings + 1);
   }
@@ -230,7 +237,8 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
   // the peer that that needs some special handling too.
   http2::Http2ErrorCode MaybeReportAndApplyBufferedPeerSettings(
       grpc_event_engine::experimental::EventEngine* event_engine,
-      bool& should_spawn_security_frame_loop) {
+      ApplySettingsResult& apply_settings_result) {
+    const uint32_t old_setting = settings_.peer().max_concurrent_streams();
     std::vector<Http2SettingsFrame::Setting> settings_to_apply;
     settings_to_apply.reserve(pending_peer_settings_.size());
     for (const auto& [id, value] : pending_peer_settings_) {
@@ -239,10 +247,21 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
     pending_peer_settings_.clear();
     http2::Http2ErrorCode status =
         settings_.ApplyIncomingSettings(settings_to_apply);
+    if (status == http2::Http2ErrorCode::kNoError && is_client_) {
+      // Since PH2-Servers do not initiate streams, we ignore this setting for
+      // Servers.
+      const uint32_t applied_max_concurrent_streams =
+          settings_.peer().max_concurrent_streams();
+      apply_settings_result.did_change_peer_max_concurrent_streams =
+          (applied_max_concurrent_streams != old_setting);
+      // TODO(tjagtap) : [PH2][P0] : Plumb this with the StateWatcher code.
+    }
+
     if (state_ == SettingsState::kFirstPeerSettingsReceived) {
       MaybeReportInitialSettings(event_engine);
       state_ = SettingsState::kReady;
-      should_spawn_security_frame_loop = IsSecurityFrameExpected();
+      apply_settings_result.should_spawn_security_frame_loop =
+          IsSecurityFrameExpected();
     }
     GRPC_DCHECK(pending_peer_settings_.empty());
     return status;
@@ -316,15 +335,11 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
   };
 
  private:
-  Http2SettingsManager settings_;
-
   //////////////////////////////////////////////////////////////////////////////
   // Plumbing Settings with Chttp2Connector class
 
   void MaybeReportInitialSettings(
       grpc_event_engine::experimental::EventEngine* event_engine) {
-    // TODO(tjagtap) [PH2][P2] Relook at this while writing server. I think this
-    // will be different for client and server.
     if (on_receive_first_settings_ != nullptr) {
       GRPC_DCHECK(state_ == SettingsState::kFirstPeerSettingsReceived);
       GRPC_DCHECK(event_engine != nullptr);
@@ -345,8 +360,6 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
 
   void MaybeReportInitialSettingsAbort(
       grpc_event_engine::experimental::EventEngine* event_engine) {
-    // TODO(tjagtap) [PH2][P2] Relook at this while writing server. I think this
-    // will be different for client and server.
     if (on_receive_first_settings_ != nullptr) {
       GRPC_DCHECK(event_engine != nullptr);
       GRPC_DCHECK(state_ != SettingsState::kReady);
@@ -447,6 +460,7 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
 
   //////////////////////////////////////////////////////////////////////////////
   // Data Members for SETTINGS being received from the peer.
+  const bool is_client_;
 
   absl::AnyInvocable<void(absl::StatusOr<uint32_t>)> on_receive_first_settings_;
   absl::flat_hash_map<uint16_t, uint32_t> pending_peer_settings_;
@@ -465,6 +479,7 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
   // make them writable. This is tracked via channelz in case it causes any
   // performance issues in the future.
   size_t num_peer_initial_window_size_increases_ = 0;
+  Http2SettingsManager settings_;
 };
 
 }  // namespace grpc_core

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

@@ -73,6 +73,8 @@ namespace http2 {
 // [PH2][EXT] This is a TODO related to a project unrelated to PH2 but happening
 //            in parallel.
 // [PH2][CHTTP2] This TODO is a part of CHTTP2 deletion.
+// [PH2][Px][FCV3] This TODO is related to Flow Control plumbing with the
+// Application and the Call V3 stack.
 
 constexpr Duration kDefaultPingTimeout = Duration::Minutes(1);
 constexpr Duration kDefaultKeepaliveTimeout = Duration::Seconds(20);
@@ -269,6 +271,14 @@ uint32_t MaxNewStreamsPerRead(const ChannelArgs& channel_args) {
       10000);
 }
 
+uint32_t GetMaxSecurityFrameSize(const ChannelArgs& channel_args) {
+  return static_cast<uint32_t>(
+      Clamp(channel_args.GetInt(GRPC_ARG_MAX_SECURITY_FRAME_SIZE)
+                .value_or(GrpcErrors::kMaxSecurityFrameSize),
+            GrpcErrors::kMinMaxSecurityFrameSize,
+            static_cast<int>(GrpcErrors::kMaxSecurityFrameSize)));
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // ChannelZ helpers
 
@@ -399,6 +409,22 @@ bool ProcessIncomingWindowUpdateFrameFlowControl(
 
 void MaybeAddTransportWindowUpdateFrame(
     chttp2::TransportFlowControl& flow_control, FrameSender& frame_sender) {
+  // Known Limitation:
+  // 1. writing_anyway is set to true always. This might cause the write cycle
+  // to just write 1 window update frame in one entire iteration of the
+  // Multiplexer Loop, making it wasteful. In most of the scenarios this is fine
+  // as TriggerWriteCycle is only invoked from code points that want to write
+  // frames on the wire.
+  // 2. This is because we write control frames before we write HEADER and DATA
+  // frames. So we don't know if we are going to write or not when we call
+  // this function.
+  // 3. Setting writing_anyway to false always might be a problem, because we
+  // would rather send a WINDOW_UPDATE frame with a small increment, than not
+  // send it at all.
+  // 4. In the future if we want to fix this, we need to call
+  // MaybeAddTransportWindowUpdateFrame once while writing control frames, and
+  // once after all the DATA and HEADER frames are written for the current write
+  // cycle.
   uint32_t window_size =
       flow_control.DesiredAnnounceSize(/*writing_anyway=*/true);
   if (window_size > 0) {

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

@@ -151,6 +151,8 @@ void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
 
 uint32_t MaxNewStreamsPerRead(const ChannelArgs& channel_args);
 
+uint32_t GetMaxSecurityFrameSize(const ChannelArgs& channel_args);
+
 ///////////////////////////////////////////////////////////////////////////////
 // ChannelZ helpers
 

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

@@ -95,6 +95,9 @@
 //   bits being used for flags defined above)
 #define CLOSURE_BARRIER_FIRST_REF_BIT (1 << 16)
 
+constexpr uint32_t kMaxSecurityFrameSize = 16u * 1024u;
+constexpr int kMinMaxSecurityFrameSize = 0;
+
 // streams are kept in various linked lists depending on what things need to
 // happen to them... this enum labels each list
 typedef enum {
@@ -462,6 +465,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   /// parser for goaway frames
   grpc_chttp2_goaway_parser goaway_parser;
   // parser for secure frames
+  uint32_t max_security_frame_size;
   grpc_chttp2_security_frame_parser security_frame_parser;
 
   grpc_core::chttp2::TransportFlowControl flow_control;

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

@@ -984,8 +984,9 @@ static grpc_error_handle init_settings_frame_parser(grpc_chttp2_transport* t) {
 }
 
 static grpc_error_handle init_security_frame_parser(grpc_chttp2_transport* t) {
-  grpc_error_handle err =
-      grpc_chttp2_security_frame_parser_begin_frame(&t->security_frame_parser);
+  grpc_error_handle err = grpc_chttp2_security_frame_parser_begin_frame(
+      &t->security_frame_parser, t->incoming_frame_size,
+      t->max_security_frame_size);
   if (!err.ok()) return err;
   t->parser = grpc_chttp2_transport::Parser{
       "security_frame", grpc_chttp2_security_frame_parser_parse,

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

@@ -115,7 +115,7 @@ std::optional<Duration> PingManager::MaybeGetSerializedPingFrames(
                       << " next_allowed_ping_interval: "
                       << next_allowed_ping_interval;
   GRPC_DCHECK(!opaque_data_.has_value());
-  frame_sender.ReserveRegularFrames(pending_ping_acks_.size() + 1);
+  frame_sender.ReserveRegularFrames(pending_ping_acks_.size());
 
   // Get the serialized ping acks if needed.
   for (uint64_t opaque_data : pending_ping_acks_) {

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

@@ -58,17 +58,11 @@ void Chttp2PingRatePolicy::SetDefaults(const ChannelArgs& args) {
 Chttp2PingRatePolicy::RequestSendPingResult
 Chttp2PingRatePolicy::RequestSendPing(Duration next_allowed_ping_interval,
                                       size_t inflight_pings) const {
-  if (max_inflight_pings_ > 0) {
-    if (!IsMaxInflightPingsStrictLimitEnabled()) {
-      if (inflight_pings > static_cast<size_t>(max_inflight_pings_)) {
-        return TooManyRecentPings{};
-      }
-    } else {
-      if (inflight_pings >= static_cast<size_t>(max_inflight_pings_)) {
-        return TooManyRecentPings{};
-      }
-    }
+  if (max_inflight_pings_ > 0 &&
+      inflight_pings >= static_cast<size_t>(max_inflight_pings_)) {
+    return TooManyRecentPings{};
   }
+
   const Timestamp next_allowed_ping =
       last_ping_sent_time_ + next_allowed_ping_interval;
   const Timestamp now = Timestamp::Now();