grpc 1.74.1 → 1.75.0.pre1

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

@@ -27,13 +27,16 @@
 #include "src/core/ext/transport/chttp2/transport/header_assembler.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_status.h"
 #include "src/core/ext/transport/chttp2/transport/http2_transport.h"
 #include "src/core/ext/transport/chttp2/transport/keepalive.h"
 #include "src/core/ext/transport/chttp2/transport/message_assembler.h"
 #include "src/core/ext/transport/chttp2/transport/ping_promise.h"
+#include "src/core/ext/transport/chttp2/transport/stream_data_queue.h"
+#include "src/core/ext/transport/chttp2/transport/writable_streams.h"
 #include "src/core/lib/promise/inter_activity_mutex.h"
+#include "src/core/lib/promise/loop.h"
 #include "src/core/lib/promise/mpsc.h"
 #include "src/core/lib/promise/party.h"
 #include "src/core/lib/transport/connectivity_state.h"
@@ -69,10 +72,11 @@ namespace http2 {
 // |---------------------|--------------|-----------------------|------------|
 // | Endpoint Read Loop  | Infinite     | On transport close    | One        |
 // | Endpoint Write Loop | Infinite     | On transport close    | One        |
+// | Stream Multiplexer  | Infinite     | On transport close    | One        |
 // | Close Transport     | CloseTimeout | On transport close    | One        |
 
-// Max Party Slots (Always): 2
-// Max Promise Slots (Worst Case): 3
+// Max Party Slots (Always): 3
+// Max Promise Slots (Worst Case): 4
 
 // Experimental : This is just the initial skeleton of class
 // and it is functions. The code will be written iteratively.
@@ -137,8 +141,9 @@ class Http2ClientTransport final : public ClientTransport {
         }));
   }
 
-  auto TestOnlySendPing(absl::AnyInvocable<void()> on_initiate) {
-    return ping_manager_.RequestPing(std::move(on_initiate));
+  auto TestOnlySendPing(absl::AnyInvocable<void()> on_initiate,
+                        bool important = false) {
+    return ping_manager_.RequestPing(std::move(on_initiate), important);
   }
 
   template <typename Factory>
@@ -189,6 +194,15 @@ class Http2ClientTransport final : public ClientTransport {
   // Returns a promise that will do the cleanup after the WriteLoop ends.
   auto OnWriteLoopEnded();
 
+  // Returns a promise to keep draining data and control frames from all the
+  // active streams. This includes all stream specific frames like data, header,
+  // continuation and reset stream frames.
+  auto StreamMultiplexerLoop();
+
+  // Returns a promise that will do the cleanup after the StreamMultiplexerLoop
+  // ends.
+  auto OnStreamMultiplexerLoopEnded();
+
   // Returns a promise to fetch data from the callhandler and pass it further
   // down towards the endpoint.
   auto CallOutboundLoop(CallHandler call_handler, uint32_t stream_id,
@@ -219,6 +233,7 @@ class Http2ClientTransport final : public ClientTransport {
 
   PromiseEndpoint endpoint_;
   Http2SettingsManager settings_;
+  Duration settings_timeout_;
 
   Http2FrameHeader current_frame_header_;
 
@@ -230,7 +245,59 @@ class Http2ClientTransport final : public ClientTransport {
           stream_id(stream_id1),
           header_assembler(stream_id1),
           did_push_initial_metadata(false),
-          did_push_trailing_metadata(false) {}
+          did_push_trailing_metadata(false),
+          data_queue(MakeRefCounted<StreamDataQueue<ClientMetadataHandle>>(
+              /*is_client*/ true, /*stream_id*/ stream_id1,
+              /*queue_size*/ kStreamQueueSize)) {}
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Data Queue Helpers
+
+    auto EnqueueInitialMetadata(ClientMetadataHandle&& metadata) {
+      GRPC_HTTP2_CLIENT_DLOG
+          << "Http2ClientTransport::Stream::EnqueueInitialMetadata stream_id="
+          << stream_id;
+      return data_queue->EnqueueInitialMetadata(std::move(metadata));
+    }
+
+    auto EnqueueTrailingMetadata(ClientMetadataHandle&& metadata) {
+      GRPC_HTTP2_CLIENT_DLOG
+          << "Http2ClientTransport::Stream::EnqueueTrailingMetadata stream_id="
+          << stream_id;
+      return data_queue->EnqueueTrailingMetadata(std::move(metadata));
+    }
+
+    auto EnqueueMessage(MessageHandle&& message) {
+      GRPC_HTTP2_CLIENT_DLOG
+          << "Http2ClientTransport::Stream::EnqueueMessage stream_id="
+          << stream_id
+          << " with payload size = " << message->payload()->Length();
+      return data_queue->EnqueueMessage(std::move(message));
+    }
+
+    auto EnqueueHalfClosed() {
+      GRPC_HTTP2_CLIENT_DLOG
+          << "Http2ClientTransport::Stream::EnqueueHalfClosed stream_id="
+          << stream_id;
+      return data_queue->EnqueueHalfClosed();
+    }
+
+    auto EnqueueResetStream(const uint32_t error_code) {
+      GRPC_HTTP2_CLIENT_DLOG
+          << "Http2ClientTransport::Stream::EnqueueResetStream stream_id="
+          << stream_id << " with error_code = " << error_code;
+      return data_queue->EnqueueResetStream(error_code);
+    }
+
+    auto DequeueFrames(const uint32_t transport_tokens,
+                       const uint32_t max_frame_length,
+                       HPackCompressor& encoder) {
+      return data_queue->DequeueFrames(transport_tokens, max_frame_length,
+                                       encoder);
+    }
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Stream State Management
 
     // Modify the stream state
     // The possible stream transitions are as follows:
@@ -257,6 +324,7 @@ class Http2ClientTransport final : public ClientTransport {
         case HttpStreamState::kHalfClosedLocal:
           break;
         case HttpStreamState::kClosed:
+          DCHECK(false) << "MarkHalfClosedLocal called for a closed stream";
           break;
       }
     }
@@ -275,10 +343,13 @@ class Http2ClientTransport final : public ClientTransport {
         case HttpStreamState::kHalfClosedRemote:
           break;
         case HttpStreamState::kClosed:
+          DCHECK(false) << "MarkHalfClosedRemote called for a closed stream";
           break;
       }
     }
 
+    HttpStreamState GetStreamState() const { return stream_state; }
+
     inline bool IsClosed() const {
       return stream_state == HttpStreamState::kClosed;
     }
@@ -287,7 +358,6 @@ class Http2ClientTransport final : public ClientTransport {
     // TODO(akshitpatel) : [PH2][P3] : Investigate if this needs to be atomic.
     HttpStreamState stream_state;
     const uint32_t stream_id;
-    TransportSendQeueue send_queue;
     GrpcMessageAssembler assembler;
     HeaderAssembler header_assembler;
     // TODO(akshitpatel) : [PH2][P2] : StreamQ should maintain a flag that
@@ -300,6 +370,7 @@ class Http2ClientTransport final : public ClientTransport {
     // transition to HalfClosedLocal till the end_stream frame is sent.
     bool did_push_initial_metadata;
     bool did_push_trailing_metadata;
+    RefCountedPtr<StreamDataQueue<ClientMetadataHandle>> data_queue;
   };
 
   uint32_t NextStreamId(
@@ -430,6 +501,8 @@ class Http2ClientTransport final : public ClientTransport {
   uint32_t incoming_header_stream_id_;
   grpc_closure* on_receive_settings_;
 
+  uint32_t max_header_list_size_soft_limit_;
+
   // Ping related members
   // TODO(akshitpatel) : [PH2][P2] : Consider removing the timeout related
   // members.
@@ -447,8 +520,8 @@ class Http2ClientTransport final : public ClientTransport {
   // Flags
   bool keepalive_permit_without_calls_;
 
-  auto SendPing(absl::AnyInvocable<void()> on_initiate) {
-    return ping_manager_.RequestPing(std::move(on_initiate));
+  auto SendPing(absl::AnyInvocable<void()> on_initiate, bool important) {
+    return ping_manager_.RequestPing(std::move(on_initiate), important);
   }
   auto WaitForPingAck() { return ping_manager_.WaitForPingAck(); }
 
@@ -490,6 +563,33 @@ class Http2ClientTransport final : public ClientTransport {
         }));
   }
 
+  auto AckPing(uint64_t opaque_data) {
+    bool valid_ping_ack_received = true;
+
+    if (!ping_manager_.AckPing(opaque_data)) {
+      GRPC_HTTP2_CLIENT_DLOG << "Unknown ping response received for ping id="
+                             << opaque_data;
+      valid_ping_ack_received = false;
+    }
+
+    return If(
+        // It is possible that the PingRatePolicy may decide to not send a ping
+        // request (in cases like the number of inflight pings is too high).
+        // When this happens, it becomes important to ensure that if a ping ack
+        // is received and there is an "important" outstanding ping request, we
+        // should retry to send it out now.
+        valid_ping_ack_received && ping_manager_.ImportantPingRequested(),
+        [self = RefAsSubclass<Http2ClientTransport>()] {
+          return Map(self->TriggerWriteCycle(), [](const absl::Status status) {
+            return (status.ok())
+                       ? Http2Status::Ok()
+                       : Http2Status::AbslConnectionError(
+                             status.code(), std::string(status.message()));
+          });
+        },
+        [] { return Immediate(Http2Status::Ok()); });
+  }
+
   class PingSystemInterfaceImpl : public PingInterface {
    public:
     static std::unique_ptr<PingInterface> Make(
@@ -579,6 +679,25 @@ class Http2ClientTransport final : public ClientTransport {
     // transport and greatly simpilfy the cleanup path.
     Http2ClientTransport* transport_;
   };
+
+  WritableStreams writable_stream_list_;
+
+  auto MaybeAddStreamToWritableStreamList(const uint32_t stream_id,
+                                          const bool became_writable) {
+    if (became_writable) {
+      GRPC_HTTP2_CLIENT_DLOG
+          << "Http2ClientTransport MaybeAddStreamToWritableStreamList "
+             " Stream id: "
+          << stream_id << " became writable";
+      absl::Status status = writable_stream_list_.Enqueue(
+          stream_id, WritableStreams::StreamPriority::kDefault);
+      if (!status.ok()) {
+        return HandleError(Http2Status::Http2ConnectionError(
+            Http2ErrorCode::kProtocolError, "Failed to enqueue stream"));
+      }
+    }
+    return absl::OkStatus();
+  }
 };
 
 // Since the corresponding class in CHTTP2 is about 3.9KB, our goal is to

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

@@ -23,7 +23,6 @@
 #include <grpc/support/port_platform.h>
 
 #include "absl/strings/str_cat.h"
-#include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/util/useful.h"
 
@@ -32,35 +31,36 @@ using grpc_core::http2::Http2ErrorCode;
 namespace grpc_core {
 
 void Http2Settings::Diff(
-    bool is_first_send, const Http2Settings& old,
+    bool is_first_send, const Http2Settings& old_setting,
     absl::FunctionRef<void(uint16_t key, uint32_t value)> cb) const {
-  if (header_table_size_ != old.header_table_size_) {
+  if (header_table_size_ != old_setting.header_table_size_) {
     cb(kHeaderTableSizeWireId, header_table_size_);
   }
-  if (enable_push_ != old.enable_push_) {
+  if (enable_push_ != old_setting.enable_push_) {
     cb(kEnablePushWireId, enable_push_);
   }
-  if (max_concurrent_streams_ != old.max_concurrent_streams_) {
+  if (max_concurrent_streams_ != old_setting.max_concurrent_streams_) {
     cb(kMaxConcurrentStreamsWireId, max_concurrent_streams_);
   }
-  if (is_first_send || initial_window_size_ != old.initial_window_size_) {
+  if (is_first_send ||
+      initial_window_size_ != old_setting.initial_window_size_) {
     cb(kInitialWindowSizeWireId, initial_window_size_);
   }
-  if (max_frame_size_ != old.max_frame_size_) {
+  if (max_frame_size_ != old_setting.max_frame_size_) {
     cb(kMaxFrameSizeWireId, max_frame_size_);
   }
-  if (max_header_list_size_ != old.max_header_list_size_) {
+  if (max_header_list_size_ != old_setting.max_header_list_size_) {
     cb(kMaxHeaderListSizeWireId, max_header_list_size_);
   }
-  if (allow_true_binary_metadata_ != old.allow_true_binary_metadata_) {
+  if (allow_true_binary_metadata_ != old_setting.allow_true_binary_metadata_) {
     cb(kGrpcAllowTrueBinaryMetadataWireId, allow_true_binary_metadata_);
   }
   if (preferred_receive_crypto_message_size_ !=
-      old.preferred_receive_crypto_message_size_) {
+      old_setting.preferred_receive_crypto_message_size_) {
     cb(kGrpcPreferredReceiveCryptoFrameSizeWireId,
        preferred_receive_crypto_message_size_);
   }
-  if (allow_security_frame_ != old.allow_security_frame_) {
+  if (allow_security_frame_ != old_setting.allow_security_frame_) {
     cb(kGrpcAllowSecurityFrameWireId, allow_security_frame_);
   }
 }
@@ -134,31 +134,4 @@ Http2ErrorCode Http2Settings::Apply(uint16_t key, uint32_t value) {
   return Http2ErrorCode::kNoError;
 }
 
-std::optional<Http2SettingsFrame> Http2SettingsManager::MaybeSendUpdate() {
-  switch (update_state_) {
-    case UpdateState::kSending:
-      return std::nullopt;
-    case UpdateState::kIdle:
-      if (local_ == sent_) return std::nullopt;
-      break;
-    case UpdateState::kFirst:
-      break;
-  }
-  Http2SettingsFrame frame;
-  local_.Diff(update_state_ == UpdateState::kFirst, sent_,
-              [&frame](uint16_t key, uint32_t value) {
-                frame.settings.emplace_back(key, value);
-              });
-  sent_ = local_;
-  update_state_ = UpdateState::kSending;
-  return frame;
-}
-
-bool Http2SettingsManager::AckLastSend() {
-  if (update_state_ != UpdateState::kSending) return false;
-  update_state_ = UpdateState::kIdle;
-  acked_ = sent_;
-  return true;
-}
-
 }  // namespace grpc_core

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

@@ -26,7 +26,6 @@
 #include "absl/functional/function_ref.h"
 #include "absl/strings/string_view.h"
 #include "src/core/channelz/property_list.h"
-#include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/util/useful.h"
 
@@ -35,18 +34,21 @@ namespace grpc_core {
 class Http2Settings {
  public:
   enum : uint16_t {
+    // These values are as defined in RFC9113
+    // https://www.rfc-editor.org/rfc/rfc9113.html#name-defined-settings
     kHeaderTableSizeWireId = 1,
     kEnablePushWireId = 2,
     kMaxConcurrentStreamsWireId = 3,
     kInitialWindowSizeWireId = 4,
     kMaxFrameSizeWireId = 5,
     kMaxHeaderListSizeWireId = 6,
+    // gRPC specific settings
     kGrpcAllowTrueBinaryMetadataWireId = 65027,
     kGrpcPreferredReceiveCryptoFrameSizeWireId = 65028,
     kGrpcAllowSecurityFrameWireId = 65029,
   };
 
-  void Diff(bool is_first_send, const Http2Settings& old,
+  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,
                                                    uint32_t value);
@@ -148,47 +150,62 @@ class Http2Settings {
   }
 
  private:
-  uint32_t header_table_size_ = 4096;
+  // 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;
+
+  // TODO(tjagtap) [PH2][P4] : Get the history of why this default was decided
+  // and write it here.
+  // 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 max_concurrent_streams_ = 4294967295u;
+
+  // 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;
+
+  // 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;
+
+  // TODO(tjagtap) [PH2][P4] : Get the history of why this default was decided
+  // and write it here.
+  // 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 preferred_receive_crypto_message_size_ = 0u;
-  bool enable_push_ = true;
-  bool allow_true_binary_metadata_ = false;
-  bool allow_security_frame_ = false;
-};
 
-class Http2SettingsManager {
- public:
-  Http2Settings& mutable_local() { return local_; }
-  const Http2Settings& local() const { return local_; }
-  const Http2Settings& acked() const { return acked_; }
-  Http2Settings& mutable_peer() { return peer_; }
-  const Http2Settings& peer() const { return peer_; }
+  // 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;
 
-  channelz::PropertyGrid ChannelzProperties() const {
-    return channelz::PropertyGrid()
-        .SetColumn("local", local_.ChannelzProperties())
-        .SetColumn("sent", sent_.ChannelzProperties())
-        .SetColumn("peer", peer_.ChannelzProperties())
-        .SetColumn("acked", acked_.ChannelzProperties());
-  }
+  // 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;
 
-  std::optional<Http2SettingsFrame> MaybeSendUpdate();
-  GRPC_MUST_USE_RESULT bool AckLastSend();
+  // gRPC defined setting
+  // Unlike most other SETTINGS, this setting is negotiated between the client
+  // and the server.
+  // 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_true_binary_metadata_ = false;
 
- private:
-  enum class UpdateState : uint8_t {
-    kFirst,
-    kSending,
-    kIdle,
-  };
-  UpdateState update_state_ = UpdateState::kFirst;
-  Http2Settings local_;
-  Http2Settings sent_;
-  Http2Settings peer_;
-  Http2Settings acked_;
+  // gRPC defined setting
+  // Unlike most other SETTINGS, this setting is negotiated between the client
+  // and the server. Both have to set it to true for the system to successfully
+  // 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;
 };
 
 }  // namespace grpc_core

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

@@ -0,0 +1,61 @@
+//
+// Copyright 2017 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+//
+// Automatically generated by tools/codegen/core/gen_settings_ids.py
+//
+
+#include "src/core/ext/transport/chttp2/transport/http2_settings_manager.h"
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/strings/str_cat.h"
+#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.h"
+#include "src/core/util/useful.h"
+
+namespace grpc_core {
+
+std::optional<Http2SettingsFrame> Http2SettingsManager::MaybeSendUpdate() {
+  switch (update_state_) {
+    case UpdateState::kSending:
+      return std::nullopt;
+    case UpdateState::kIdle:
+      if (local_ == sent_) return std::nullopt;
+      break;
+    case UpdateState::kFirst:
+      break;
+  }
+  Http2SettingsFrame frame;
+  local_.Diff(/*is_first_send=*/update_state_ == UpdateState::kFirst,
+              /*old_setting=*/sent_,
+              /*cb=*/[&frame](uint16_t key, uint32_t value) {
+                frame.settings.emplace_back(key, value);
+              });
+  sent_ = local_;
+  update_state_ = UpdateState::kSending;
+  return frame;
+}
+
+bool Http2SettingsManager::AckLastSend() {
+  if (update_state_ != UpdateState::kSending) return false;
+  update_state_ = UpdateState::kIdle;
+  acked_ = sent_;
+  return true;
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,142 @@
+//
+// Copyright 2017 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_SETTINGS_MANAGER_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_SETTINGS_MANAGER_H
+
+#include <grpc/support/port_platform.h>
+#include <stdint.h>
+
+#include <cstdint>
+#include <optional>
+
+#include "absl/functional/function_ref.h"
+#include "absl/strings/string_view.h"
+#include "src/core/channelz/property_list.h"
+#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.h"
+#include "src/core/util/useful.h"
+
+namespace grpc_core {
+
+class Http2SettingsManager {
+ public:
+  // Only local and peer settings can be edited by the transport.
+  Http2Settings& mutable_local() { return local_; }
+  Http2Settings& mutable_peer() { return peer_; }
+
+  const Http2Settings& local() const { return local_; }
+  // Before the first SETTINGS ACK frame is received acked_ will hold the
+  // default values.
+  const Http2Settings& acked() const { return acked_; }
+  const Http2Settings& peer() const { return peer_; }
+
+  channelz::PropertyGrid ChannelzProperties() const {
+    return channelz::PropertyGrid()
+        .SetColumn("local", local_.ChannelzProperties())
+        .SetColumn("sent", sent_.ChannelzProperties())
+        .SetColumn("peer", peer_.ChannelzProperties())
+        .SetColumn("acked", acked_.ChannelzProperties());
+  }
+
+  // Returns nullopt if we don't need to send a SETTINGS frame to the peer.
+  // Returns Http2SettingsFrame if we need to send a SETTINGS frame to the
+  // peer. Transport MUST send a frame returned by this function to the peer.
+  // This function is not idempotent.
+  std::optional<Http2SettingsFrame> MaybeSendUpdate();
+
+  // To be called from a promise based HTTP2 transport only
+  http2::Http2ErrorCode ApplyIncomingSettings(
+      std::vector<Http2SettingsFrame::Setting>& settings) {
+    for (const auto& setting : settings) {
+      http2::Http2ErrorCode error1 =
+          count_updates_.IsUpdatePermitted(setting.id, setting.value, peer_);
+      if (GPR_UNLIKELY(error1 != http2::Http2ErrorCode::kNoError)) {
+        return error1;
+      }
+      http2::Http2ErrorCode error = peer_.Apply(setting.id, setting.value);
+      if (GPR_UNLIKELY(error != http2::Http2ErrorCode::kNoError)) {
+        return error;
+      }
+    }
+    return http2::Http2ErrorCode::kNoError;
+  }
+
+  // Call when we receive an ACK from our peer.
+  // This function is not idempotent.
+  GRPC_MUST_USE_RESULT bool AckLastSend();
+
+ private:
+  struct CountUpdates {
+    http2::Http2ErrorCode IsUpdatePermitted(const uint16_t setting_id,
+                                            const uint32_t value,
+                                            const Http2Settings& peer) {
+      switch (setting_id) {
+        case Http2Settings::kGrpcAllowTrueBinaryMetadataWireId:
+          // These settings must not change more than once. This is a gRPC
+          // defined settings.
+          if (allow_true_binary_metadata_update &&
+              peer.allow_true_binary_metadata() != static_cast<bool>(value)) {
+            return http2::Http2ErrorCode::kConnectError;
+          }
+          allow_true_binary_metadata_update = true;
+          break;
+        case Http2Settings::kGrpcAllowSecurityFrameWireId:
+          // These settings must not change more than once. This is a gRPC
+          // defined settings.
+          if (allow_security_frame_update &&
+              peer.allow_security_frame() != static_cast<bool>(value)) {
+            return http2::Http2ErrorCode::kConnectError;
+          }
+          allow_security_frame_update = true;
+          break;
+        default:
+          break;
+      }
+      return http2::Http2ErrorCode::kNoError;
+    }
+    bool allow_true_binary_metadata_update = false;
+    bool allow_security_frame_update = false;
+  };
+  CountUpdates count_updates_;
+
+  enum class UpdateState : uint8_t {
+    kFirst,
+    kSending,
+    kIdle,
+  };
+  UpdateState update_state_ = UpdateState::kFirst;
+
+  // This holds a copy of the peers settings.
+  Http2Settings peer_;
+
+  // These are different sets of our settings.
+  // local_  : Setting that has been changed inside our transport,
+  //           but not yet sent to the peer.
+  // sent_   : New settings frame is sent to the peer but we have not yet
+  //           received the ACK from the peer.
+  // acked_  : The settings that have already been ACKed by the peer. These
+  //           settings can be enforced and any violation of these settings by a
+  //           peer may cause an error.
+  Http2Settings local_;
+  Http2Settings sent_;
+  Http2Settings acked_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_SETTINGS_MANAGER_H