grpc 1.60.2 → 1.61.0.pre2

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

@@ -22,43 +22,133 @@
 
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 
+#include "absl/strings/str_cat.h"
+
+#include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/transport/http2_errors.h"
 
-const uint16_t grpc_setting_id_to_wire_id[] = {1, 2, 3, 4, 5, 6, 65027, 65028};
+namespace grpc_core {
+
+void Http2Settings::Diff(
+    bool is_first_send, const Http2Settings& old,
+    absl::FunctionRef<void(uint16_t key, uint32_t value)> cb) const {
+  if (header_table_size_ != old.header_table_size_) {
+    cb(kHeaderTableSizeWireId, header_table_size_);
+  }
+  if (enable_push_ != old.enable_push_) {
+    cb(kEnablePushWireId, enable_push_);
+  }
+  if (max_concurrent_streams_ != old.max_concurrent_streams_) {
+    cb(kMaxConcurrentStreamsWireId, max_concurrent_streams_);
+  }
+  if (is_first_send || initial_window_size_ != old.initial_window_size_) {
+    cb(kInitialWindowSizeWireId, initial_window_size_);
+  }
+  if (max_frame_size_ != old.max_frame_size_) {
+    cb(kMaxFrameSizeWireId, max_frame_size_);
+  }
+  if (max_header_list_size_ != old.max_header_list_size_) {
+    cb(kMaxHeaderListSizeWireId, max_header_list_size_);
+  }
+  if (allow_true_binary_metadata_ != old.allow_true_binary_metadata_) {
+    cb(kGrpcAllowTrueBinaryMetadataWireId, allow_true_binary_metadata_);
+  }
+  if (preferred_receive_crypto_message_size_ !=
+      old.preferred_receive_crypto_message_size_) {
+    cb(kGrpcPreferredReceiveCryptoFrameSizeWireId,
+       preferred_receive_crypto_message_size_);
+  }
+}
+
+std::string Http2Settings::WireIdToName(uint16_t wire_id) {
+  switch (wire_id) {
+    case kHeaderTableSizeWireId:
+      return std::string(header_table_size_name());
+    case kEnablePushWireId:
+      return std::string(enable_push_name());
+    case kMaxConcurrentStreamsWireId:
+      return std::string(max_concurrent_streams_name());
+    case kInitialWindowSizeWireId:
+      return std::string(initial_window_size_name());
+    case kMaxFrameSizeWireId:
+      return std::string(max_frame_size_name());
+    case kMaxHeaderListSizeWireId:
+      return std::string(max_header_list_size_name());
+    case kGrpcAllowTrueBinaryMetadataWireId:
+      return std::string(allow_true_binary_metadata_name());
+    case kGrpcPreferredReceiveCryptoFrameSizeWireId:
+      return std::string(preferred_receive_crypto_message_size_name());
+    default:
+      return absl::StrCat("UNKNOWN (", wire_id, ")");
+  }
+}
+
+grpc_http2_error_code Http2Settings::Apply(uint16_t key, uint32_t value) {
+  switch (key) {
+    case kHeaderTableSizeWireId:
+      header_table_size_ = value;
+      break;
+    case kEnablePushWireId:
+      if (value > 1) return GRPC_HTTP2_PROTOCOL_ERROR;
+      enable_push_ = value != 0;
+      break;
+    case kMaxConcurrentStreamsWireId:
+      max_concurrent_streams_ = value;
+      break;
+    case kInitialWindowSizeWireId:
+      if (value > max_initial_window_size()) {
+        return GRPC_HTTP2_FLOW_CONTROL_ERROR;
+      }
+      initial_window_size_ = value;
+      break;
+    case kMaxFrameSizeWireId:
+      if (value < min_max_frame_size() || value > max_max_frame_size()) {
+        return GRPC_HTTP2_PROTOCOL_ERROR;
+      }
+      max_frame_size_ = value;
+      break;
+    case kMaxHeaderListSizeWireId:
+      max_header_list_size_ = std::min(value, 16777216u);
+      break;
+    case kGrpcAllowTrueBinaryMetadataWireId:
+      if (value > 1) return GRPC_HTTP2_PROTOCOL_ERROR;
+      allow_true_binary_metadata_ = value != 0;
+      break;
+    case kGrpcPreferredReceiveCryptoFrameSizeWireId:
+      preferred_receive_crypto_message_size_ =
+          Clamp(value, min_preferred_receive_crypto_message_size(),
+                max_preferred_receive_crypto_message_size());
+      break;
+  }
+  return GRPC_HTTP2_NO_ERROR;
+}
 
-bool grpc_wire_id_to_setting_id(uint32_t wire_id, grpc_chttp2_setting_id* out) {
-  uint32_t i = wire_id - 1;
-  uint32_t x = i % 256;
-  uint32_t y = i / 256;
-  uint32_t h = x;
-  switch (y) {
-    case 254:
-      h += 4;
+absl::optional<Http2SettingsFrame> Http2SettingsManager::MaybeSendUpdate() {
+  switch (update_state_) {
+    case UpdateState::kSending:
+      return absl::nullopt;
+    case UpdateState::kIdle:
+      if (local_ == sent_) return absl::nullopt;
+      break;
+    case UpdateState::kFirst:
       break;
   }
-  *out = static_cast<grpc_chttp2_setting_id>(h);
-  return h < GPR_ARRAY_SIZE(grpc_setting_id_to_wire_id) &&
-         grpc_setting_id_to_wire_id[h] == wire_id;
+  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;
 }
 
-const grpc_chttp2_setting_parameters
-    grpc_chttp2_settings_parameters[GRPC_CHTTP2_NUM_SETTINGS] = {
-        {"HEADER_TABLE_SIZE", 4096u, 0u, 4294967295u,
-         GRPC_CHTTP2_CLAMP_INVALID_VALUE, GRPC_HTTP2_PROTOCOL_ERROR},
-        {"ENABLE_PUSH", 1u, 0u, 1u, GRPC_CHTTP2_DISCONNECT_ON_INVALID_VALUE,
-         GRPC_HTTP2_PROTOCOL_ERROR},
-        {"MAX_CONCURRENT_STREAMS", 4294967295u, 0u, 4294967295u,
-         GRPC_CHTTP2_DISCONNECT_ON_INVALID_VALUE, GRPC_HTTP2_PROTOCOL_ERROR},
-        {"INITIAL_WINDOW_SIZE", 65535u, 0u, 2147483647u,
-         GRPC_CHTTP2_DISCONNECT_ON_INVALID_VALUE,
-         GRPC_HTTP2_FLOW_CONTROL_ERROR},
-        {"MAX_FRAME_SIZE", 16384u, 16384u, 16777215u,
-         GRPC_CHTTP2_DISCONNECT_ON_INVALID_VALUE, GRPC_HTTP2_PROTOCOL_ERROR},
-        {"MAX_HEADER_LIST_SIZE", 16777216u, 0u, 16777216u,
-         GRPC_CHTTP2_CLAMP_INVALID_VALUE, GRPC_HTTP2_PROTOCOL_ERROR},
-        {"GRPC_ALLOW_TRUE_BINARY_METADATA", 0u, 0u, 1u,
-         GRPC_CHTTP2_CLAMP_INVALID_VALUE, GRPC_HTTP2_PROTOCOL_ERROR},
-        {"GRPC_PREFERRED_RECEIVE_CRYPTO_FRAME_SIZE", 0u, 16384u, 2147483647u,
-         GRPC_CHTTP2_CLAMP_INVALID_VALUE, GRPC_HTTP2_PROTOCOL_ERROR},
-};
+}  // namespace grpc_core

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

@@ -14,10 +14,6 @@
 // limitations under the License.
 //
 
-//
-// Automatically generated by tools/codegen/core/gen_settings_ids.py
-//
-
 #ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_SETTINGS_H
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_SETTINGS_H
 
@@ -25,38 +21,147 @@
 
 #include <stdint.h>
 
-typedef enum {
-  GRPC_CHTTP2_SETTINGS_HEADER_TABLE_SIZE = 0,                // wire id 1
-  GRPC_CHTTP2_SETTINGS_ENABLE_PUSH = 1,                      // wire id 2
-  GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS = 2,           // wire id 3
-  GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE = 3,              // wire id 4
-  GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE = 4,                   // wire id 5
-  GRPC_CHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE = 5,             // wire id 6
-  GRPC_CHTTP2_SETTINGS_GRPC_ALLOW_TRUE_BINARY_METADATA = 6,  // wire id 65027
-  GRPC_CHTTP2_SETTINGS_GRPC_PREFERRED_RECEIVE_CRYPTO_FRAME_SIZE =
-      7,  // wire id 65028
-} grpc_chttp2_setting_id;
-
-#define GRPC_CHTTP2_NUM_SETTINGS 8
-extern const uint16_t grpc_setting_id_to_wire_id[];
-
-bool grpc_wire_id_to_setting_id(uint32_t wire_id, grpc_chttp2_setting_id* out);
-
-typedef enum {
-  GRPC_CHTTP2_CLAMP_INVALID_VALUE,
-  GRPC_CHTTP2_DISCONNECT_ON_INVALID_VALUE
-} grpc_chttp2_invalid_value_behavior;
-
-typedef struct {
-  const char* name;
-  uint32_t default_value;
-  uint32_t min_value;
-  uint32_t max_value;
-  grpc_chttp2_invalid_value_behavior invalid_value_behavior;
-  uint32_t error_value;
-} grpc_chttp2_setting_parameters;
-
-extern const grpc_chttp2_setting_parameters
-    grpc_chttp2_settings_parameters[GRPC_CHTTP2_NUM_SETTINGS];
+#include <cstdint>
+
+#include "absl/functional/function_ref.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/transport/http2_errors.h"
+
+namespace grpc_core {
+
+class Http2Settings {
+ public:
+  enum : uint16_t {
+    kHeaderTableSizeWireId = 1,
+    kEnablePushWireId = 2,
+    kMaxConcurrentStreamsWireId = 3,
+    kInitialWindowSizeWireId = 4,
+    kMaxFrameSizeWireId = 5,
+    kMaxHeaderListSizeWireId = 6,
+    kGrpcAllowTrueBinaryMetadataWireId = 65027,
+    kGrpcPreferredReceiveCryptoFrameSizeWireId = 65028,
+  };
+
+  void Diff(bool is_first_send, const Http2Settings& old,
+            absl::FunctionRef<void(uint16_t key, uint32_t value)> cb) const;
+  GRPC_MUST_USE_RESULT grpc_http2_error_code Apply(uint16_t key,
+                                                   uint32_t value);
+  uint32_t header_table_size() const { return header_table_size_; }
+  uint32_t max_concurrent_streams() const { return max_concurrent_streams_; }
+  uint32_t initial_window_size() const { return initial_window_size_; }
+  uint32_t max_frame_size() const { return max_frame_size_; }
+  uint32_t max_header_list_size() const { return max_header_list_size_; }
+  uint32_t preferred_receive_crypto_message_size() const {
+    return preferred_receive_crypto_message_size_;
+  }
+  bool enable_push() const { return enable_push_; }
+  bool allow_true_binary_metadata() const {
+    return allow_true_binary_metadata_;
+  }
+
+  void SetHeaderTableSize(uint32_t x) { header_table_size_ = x; }
+  void SetMaxConcurrentStreams(uint32_t x) { max_concurrent_streams_ = x; }
+  void SetInitialWindowSize(uint32_t x) {
+    initial_window_size_ = std::min(x, max_initial_window_size());
+  }
+  void SetEnablePush(bool x) { enable_push_ = x; }
+  void SetMaxHeaderListSize(uint32_t x) {
+    max_header_list_size_ = std::min(x, 16777216u);
+  }
+  void SetAllowTrueBinaryMetadata(bool x) { allow_true_binary_metadata_ = x; }
+  void SetMaxFrameSize(uint32_t x) {
+    max_frame_size_ = Clamp(x, min_max_frame_size(), max_max_frame_size());
+  }
+  void SetPreferredReceiveCryptoMessageSize(uint32_t x) {
+    preferred_receive_crypto_message_size_ =
+        Clamp(x, min_preferred_receive_crypto_message_size(),
+              max_preferred_receive_crypto_message_size());
+  }
+
+  static absl::string_view header_table_size_name() {
+    return "HEADER_TABLE_SIZE";
+  }
+  static absl::string_view max_concurrent_streams_name() {
+    return "MAX_CONCURRENT_STREAMS";
+  }
+  static absl::string_view initial_window_size_name() {
+    return "INITIAL_WINDOW_SIZE";
+  }
+  static absl::string_view max_frame_size_name() { return "MAX_FRAME_SIZE"; }
+  static absl::string_view max_header_list_size_name() {
+    return "MAX_HEADER_LIST_SIZE";
+  }
+  static absl::string_view enable_push_name() { return "ENABLE_PUSH"; }
+  static absl::string_view allow_true_binary_metadata_name() {
+    return "GRPC_ALLOW_TRUE_BINARY_METADATA";
+  }
+  static absl::string_view preferred_receive_crypto_message_size_name() {
+    return "GRPC_PREFERRED_RECEIVE_MESSAGE_SIZE";
+  }
+
+  static uint32_t max_initial_window_size() { return 2147483647u; }
+  static uint32_t max_max_frame_size() { return 16777215u; }
+  static uint32_t min_max_frame_size() { return 16384u; }
+  static uint32_t min_preferred_receive_crypto_message_size() { return 16384u; }
+  static uint32_t max_preferred_receive_crypto_message_size() {
+    return 2147483647u;
+  }
+
+  static std::string WireIdToName(uint16_t wire_id);
+
+  bool operator==(const Http2Settings& rhs) const {
+    return header_table_size_ == rhs.header_table_size_ &&
+           max_concurrent_streams_ == rhs.max_concurrent_streams_ &&
+           initial_window_size_ == rhs.initial_window_size_ &&
+           max_frame_size_ == rhs.max_frame_size_ &&
+           max_header_list_size_ == rhs.max_header_list_size_ &&
+           preferred_receive_crypto_message_size_ ==
+               rhs.preferred_receive_crypto_message_size_ &&
+           enable_push_ == rhs.enable_push_ &&
+           allow_true_binary_metadata_ == rhs.allow_true_binary_metadata_;
+  }
+
+  bool operator!=(const Http2Settings& rhs) const { return !operator==(rhs); }
+
+ private:
+  uint32_t header_table_size_ = 4096;
+  uint32_t max_concurrent_streams_ = 4294967295u;
+  uint32_t initial_window_size_ = 65535u;
+  uint32_t max_frame_size_ = 16384u;
+  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;
+};
+
+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_; }
+
+  absl::optional<Http2SettingsFrame> MaybeSendUpdate();
+  GRPC_MUST_USE_RESULT bool AckLastSend();
+
+ private:
+  enum class UpdateState : uint8_t {
+    kFirst,
+    kSending,
+    kIdle,
+  };
+  UpdateState update_state_ = UpdateState::kFirst;
+  Http2Settings local_;
+  Http2Settings sent_;
+  Http2Settings peer_;
+  Http2Settings acked_;
+};
+
+}  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_SETTINGS_H

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

@@ -203,18 +203,6 @@ struct grpc_chttp2_stream_link {
   grpc_chttp2_stream* next;
   grpc_chttp2_stream* prev;
 };
-// We keep several sets of connection wide parameters
-typedef enum {
-  // The settings our peer has asked for (and we have acked)
-  GRPC_PEER_SETTINGS = 0,
-  // The settings we'd like to have
-  GRPC_LOCAL_SETTINGS,
-  // The settings we've published to our peer
-  GRPC_SENT_SETTINGS,
-  // The settings the peer has acked
-  GRPC_ACKED_SETTINGS,
-  GRPC_NUM_SETTING_SETS
-} grpc_chttp2_setting_set;
 
 typedef enum {
   GRPC_CHTTP2_NO_GOAWAY_SEND,
@@ -359,12 +347,8 @@ struct grpc_chttp2_transport final
 
   grpc_chttp2_sent_goaway_state sent_goaway_state = GRPC_CHTTP2_NO_GOAWAY_SEND;
 
-  /// bitmask of setting indexes to send out
-  /// Hack: it's common for implementations to assume 65536 bytes initial send
-  /// window -- this should by rights be 0
-  uint32_t force_send_settings = 1 << GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE;
   /// settings values
-  uint32_t settings[GRPC_NUM_SETTING_SETS][GRPC_CHTTP2_NUM_SETTINGS];
+  grpc_core::Http2SettingsManager settings;
 
   grpc_event_engine::experimental::EventEngine::TaskHandle
       settings_ack_watchdog =
@@ -538,11 +522,6 @@ struct grpc_chttp2_transport final
   /// is this a client?
   bool is_client;
 
-  /// are the local settings dirty and need to be sent?
-  bool dirtied_local_settings = true;
-  /// have local settings been sent?
-  bool sent_local_settings = false;
-
   /// If start_bdp_ping_locked has been called
   bool bdp_ping_started = false;
   // True if pings should be acked

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

@@ -357,13 +357,10 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         }
         goto dts_fh_0;  // loop
       } else if (t->incoming_frame_size >
-                 t->settings[GRPC_ACKED_SETTINGS]
-                            [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE]) {
-        return GRPC_ERROR_CREATE(
-            absl::StrFormat("Frame size %d is larger than max frame size %d",
-                            t->incoming_frame_size,
-                            t->settings[GRPC_ACKED_SETTINGS]
-                                       [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE]));
+                 t->settings.acked().max_frame_size()) {
+        return GRPC_ERROR_CREATE(absl::StrFormat(
+            "Frame size %d is larger than max frame size %d",
+            t->incoming_frame_size, t->settings.acked().max_frame_size()));
       }
       if (++cur == end) {
         return absl::OkStatus();
@@ -395,8 +392,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         }
         cur += t->incoming_frame_size;
         t->incoming_stream = nullptr;
-        if (t->incoming_frame_type == GRPC_CHTTP2_FRAME_RST_STREAM &&
-            grpc_core::IsChttp2OffloadOnRstStreamEnabled()) {
+        if (t->incoming_frame_type == GRPC_CHTTP2_FRAME_RST_STREAM) {
           requests_started = std::numeric_limits<size_t>::max();
         }
         goto dts_fh_0;  // loop
@@ -506,8 +502,7 @@ static grpc_error_handle init_header_skip_frame_parser(
       /*metadata_size_soft_limit=*/
       t->max_header_list_size_soft_limit,
       /*metadata_size_hard_limit=*/
-      t->settings[GRPC_ACKED_SETTINGS]
-                 [GRPC_CHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE],
+      t->settings.acked().max_header_list_size(),
       hpack_boundary_type(t, is_eoh), priority_type,
       hpack_parser_log_info(t, HPackParser::LogInfo::kDontKnow));
   return absl::OkStatus();
@@ -647,10 +642,8 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
           "ignoring grpc_chttp2_stream with non-client generated index %d",
           t->incoming_stream_id));
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
-    } else if (GPR_UNLIKELY(
-                   t->stream_map.size() + t->extra_streams >=
-                   t->settings[GRPC_ACKED_SETTINGS]
-                              [GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS])) {
+    } else if (GPR_UNLIKELY(t->stream_map.size() + t->extra_streams >=
+                            t->settings.acked().max_concurrent_streams())) {
       if (grpc_core::IsRfcMaxConcurrentStreamsEnabled()) {
         ++t->num_pending_induced_frames;
         grpc_slice_buffer_add(
@@ -675,13 +668,11 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
       grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
     } else if (GPR_UNLIKELY(
-                   grpc_core::IsRedMaxConcurrentStreamsEnabled() &&
                    t->stream_map.size() >=
                        t->max_concurrent_streams_policy.AdvertiseValue() &&
                    grpc_core::RandomEarlyDetection(
                        t->max_concurrent_streams_policy.AdvertiseValue(),
-                       t->settings[GRPC_ACKED_SETTINGS]
-                                  [GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS])
+                       t->settings.acked().max_concurrent_streams())
                        .Reject(t->stream_map.size(), t->bitgen))) {
       // We are under the limit of max concurrent streams for the current
       // setting, but are over the next value that will be advertised.
@@ -702,8 +693,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
           t, std::string(t->peer_string.as_string_view()).c_str(),
           t->incoming_stream_id, t->last_new_stream_id));
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
-    } else if (grpc_core::IsBlockExcessiveRequestsBeforeSettingsAckEnabled() &&
-               t->num_incoming_streams_before_settings_ack == 0) {
+    } else if (t->num_incoming_streams_before_settings_ack == 0) {
       GRPC_CHTTP2_IF_TRACING(gpr_log(
           GPR_ERROR,
           "transport:%p SERVER peer:%s rejecting grpc_chttp2_stream id=%d, "
@@ -791,15 +781,13 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
     return GRPC_ERROR_CREATE(
         "Trailing metadata frame received without an end-o-stream");
   }
-  t->hpack_parser.BeginFrame(
-      incoming_metadata_buffer,
-      /*metadata_size_soft_limit=*/
-      t->max_header_list_size_soft_limit,
-      /*metadata_size_hard_limit=*/
-      t->settings[GRPC_ACKED_SETTINGS]
-                 [GRPC_CHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE],
-      hpack_boundary_type(t, is_eoh), priority_type,
-      hpack_parser_log_info(t, frame_type));
+  t->hpack_parser.BeginFrame(incoming_metadata_buffer,
+                             /*metadata_size_soft_limit=*/
+                             t->max_header_list_size_soft_limit,
+                             /*metadata_size_hard_limit=*/
+                             t->settings.acked().max_header_list_size(),
+                             hpack_boundary_type(t, is_eoh), priority_type,
+                             hpack_parser_log_info(t, frame_type));
   return absl::OkStatus();
 }
 
@@ -870,21 +858,20 @@ static grpc_error_handle init_settings_frame_parser(grpc_chttp2_transport* t) {
 
   grpc_error_handle err = grpc_chttp2_settings_parser_begin_frame(
       &t->simple.settings, t->incoming_frame_size, t->incoming_frame_flags,
-      t->settings[GRPC_PEER_SETTINGS]);
+      t->settings.mutable_peer());
   if (!err.ok()) {
     return err;
   }
   if (t->incoming_frame_flags & GRPC_CHTTP2_FLAG_ACK) {
     t->max_concurrent_streams_policy.AckLastSend();
-    memcpy(t->settings[GRPC_ACKED_SETTINGS], t->settings[GRPC_SENT_SETTINGS],
-           GRPC_CHTTP2_NUM_SETTINGS * sizeof(uint32_t));
+    if (!t->settings.AckLastSend()) {
+      return GRPC_ERROR_CREATE("Received unexpected settings ack");
+    }
     t->hpack_parser.hpack_table()->SetMaxBytes(
-        t->settings[GRPC_ACKED_SETTINGS]
-                   [GRPC_CHTTP2_SETTINGS_HEADER_TABLE_SIZE]);
+        t->settings.acked().header_table_size());
     grpc_chttp2_act_on_flowctl_action(
         t->flow_control.SetAckedInitialWindow(
-            t->settings[GRPC_ACKED_SETTINGS]
-                       [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE]),
+            t->settings.acked().initial_window_size()),
         t, nullptr);
     if (t->settings_ack_watchdog !=
         grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid) {
@@ -892,7 +879,6 @@ static grpc_error_handle init_settings_frame_parser(grpc_chttp2_transport* t) {
           t->settings_ack_watchdog,
           grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid));
     }
-    t->sent_local_settings = false;
     // This is more streams than can be started in http2, so setting this
     // effictively removes the limit for the rest of the connection.
     t->num_incoming_streams_before_settings_ack =