grpc 1.60.0 → 1.62.0

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

@@ -0,0 +1,214 @@
+// Copyright 2015 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_FRAME_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FRAME_H
+
+#include <grpc/support/port_platform.h>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
+#include "absl/types/variant.h"
+
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_buffer.h"
+
+namespace grpc_core {
+
+///////////////////////////////////////////////////////////////////////////////
+// Frame types
+//
+// Define structs for each kind of frame that chttp2 reasons about.
+//
+// Each struct gets the members defined by the HTTP/2 spec for that frame type
+// *that the semantic layers of chttp2 neead to reason about*.
+//
+// That means, for instance, that we drop padding and prioritization data from
+// these structs, as they are handled by the HTTP/2 framing layer and are
+// meaningless to the semantic layers above.
+//
+// If a frame type is associated with a stream, it has a stream_id member.
+// If that frame type is only used at the channel layer it does not.
+//
+// Instead of carrying bitfields of flags like the wire format, we instead
+// declare a bool per flag to make producing/consuming code easier to write.
+//
+// Equality operators are defined for use in unit tests.
+
+// DATA frame
+struct Http2DataFrame {
+  uint32_t stream_id = 0;
+  bool end_stream = false;
+  SliceBuffer payload;
+
+  bool operator==(const Http2DataFrame& other) const {
+    return stream_id == other.stream_id && end_stream == other.end_stream &&
+           payload.JoinIntoString() == other.payload.JoinIntoString();
+  }
+};
+
+// HEADER frame
+struct Http2HeaderFrame {
+  uint32_t stream_id = 0;
+  bool end_headers = false;
+  bool end_stream = false;
+  SliceBuffer payload;
+
+  bool operator==(const Http2HeaderFrame& other) const {
+    return stream_id == other.stream_id && end_headers == other.end_headers &&
+           end_stream == other.end_stream &&
+           payload.JoinIntoString() == other.payload.JoinIntoString();
+  }
+};
+
+// CONTINUATION frame
+struct Http2ContinuationFrame {
+  uint32_t stream_id = 0;
+  bool end_headers = false;
+  SliceBuffer payload;
+
+  bool operator==(const Http2ContinuationFrame& other) const {
+    return stream_id == other.stream_id && end_headers == other.end_headers &&
+           payload.JoinIntoString() == other.payload.JoinIntoString();
+  }
+};
+
+// RST_STREAM frame
+struct Http2RstStreamFrame {
+  uint32_t stream_id = 0;
+  uint32_t error_code = 0;
+
+  bool operator==(const Http2RstStreamFrame& other) const {
+    return stream_id == other.stream_id && error_code == other.error_code;
+  }
+};
+
+// SETTINGS frame
+struct Http2SettingsFrame {
+  struct Setting {
+    Setting(uint16_t id, uint32_t value) : id(id), value(value) {}
+
+    uint16_t id;
+    uint32_t value;
+
+    bool operator==(const Setting& other) const {
+      return id == other.id && value == other.value;
+    }
+  };
+  bool ack = false;
+  std::vector<Setting> settings;
+
+  bool operator==(const Http2SettingsFrame& other) const {
+    return ack == other.ack && settings == other.settings;
+  }
+};
+
+// PING frame
+struct Http2PingFrame {
+  bool ack = false;
+  uint64_t opaque = 0;
+
+  bool operator==(const Http2PingFrame& other) const {
+    return ack == other.ack && opaque == other.opaque;
+  }
+};
+
+// GOAWAY frame
+struct Http2GoawayFrame {
+  uint32_t last_stream_id = 0;
+  uint32_t error_code = 0;
+  Slice debug_data;
+
+  bool operator==(const Http2GoawayFrame& other) const {
+    return last_stream_id == other.last_stream_id &&
+           error_code == other.error_code &&
+           debug_data.as_string_view() == other.debug_data.as_string_view();
+  }
+};
+
+// WINDOW_UPDATE frame
+struct Http2WindowUpdateFrame {
+  uint32_t stream_id;
+  uint32_t increment;
+
+  bool operator==(const Http2WindowUpdateFrame& other) const {
+    return stream_id == other.stream_id && increment == other.increment;
+  }
+};
+
+// Type of frame was unknown (and should be ignored)
+struct Http2UnknownFrame {
+  bool operator==(const Http2UnknownFrame&) const { return true; }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Frame variant
+//
+// A union of all the frame types above, so that we may pass around an
+// arbitrary frame between layers as appropriate.
+using Http2Frame =
+    absl::variant<Http2DataFrame, Http2HeaderFrame, Http2ContinuationFrame,
+                  Http2RstStreamFrame, Http2SettingsFrame, Http2PingFrame,
+                  Http2GoawayFrame, Http2WindowUpdateFrame, Http2UnknownFrame>;
+
+///////////////////////////////////////////////////////////////////////////////
+// Frame header
+//
+// Define a struct for the frame header.
+// Parsing this type is the first step in parsing a frame.
+// No validation on the header is done during parsing - the fields should be
+// instead interpreted by the frame type parser.
+struct Http2FrameHeader {
+  uint32_t length;
+  uint8_t type;
+  uint8_t flags;
+  uint32_t stream_id;
+  // Serialize header to 9 byte long buffer output
+  // Crashes if length > 16777215 (as this is unencodable)
+  void Serialize(uint8_t* output) const;
+  // Parse header from 9 byte long buffer input
+  static Http2FrameHeader Parse(const uint8_t* input);
+  std::string ToString() const;
+
+  bool operator==(const Http2FrameHeader& other) const {
+    return length == other.length && type == other.type &&
+           flags == other.flags && stream_id == other.stream_id;
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Parsing & serialization
+
+// Given a frame header and a payload, parse the payload into a frame and
+// return it.
+// If this function returns an error, that should be considered a connection
+// error.
+// If a frame should simply be ignored, this function returns a
+// Http2UnknownFrame.
+// It is expected that hdr.length == payload.Length().
+absl::StatusOr<Http2Frame> ParseFramePayload(const Http2FrameHeader& hdr,
+                                             SliceBuffer payload);
+
+// Serialize frame and append to out, leaves frames in an unknown state (may
+// move things out of frames)
+void Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FRAME_H

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

@@ -126,7 +126,7 @@ grpc_error_handle grpc_chttp2_rst_stream_parser_parse(void* parser,
           grpc_core::StatusIntProperty::kHttp2Error,
           static_cast<intptr_t>(reason));
     }
-    if (grpc_core::IsPingOnRstStreamEnabled() && !t->is_client &&
+    if (!t->is_client &&
         absl::Bernoulli(t->bitgen, t->ping_on_rst_stream_percent / 100.0)) {
       ++t->num_pending_induced_frames;
       t->ping_callbacks.RequestPing();

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

@@ -33,6 +33,7 @@
 
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/frame_goaway.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/ext/transport/chttp2/transport/http_trace.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
@@ -55,38 +56,6 @@ static uint8_t* fill_header(uint8_t* out, uint32_t length, uint8_t flags) {
   return out;
 }
 
-grpc_slice grpc_chttp2_settings_create(uint32_t* old_settings,
-                                       const uint32_t* new_settings,
-                                       uint32_t force_mask, size_t count) {
-  size_t i;
-  uint32_t n = 0;
-  grpc_slice output;
-  uint8_t* p;
-
-  for (i = 0; i < count; i++) {
-    n += (new_settings[i] != old_settings[i] || (force_mask & (1u << i)) != 0);
-  }
-
-  output = GRPC_SLICE_MALLOC(9 + 6 * n);
-  p = fill_header(GRPC_SLICE_START_PTR(output), 6 * n, 0);
-
-  for (i = 0; i < count; i++) {
-    if (new_settings[i] != old_settings[i] || (force_mask & (1u << i)) != 0) {
-      *p++ = static_cast<uint8_t>(grpc_setting_id_to_wire_id[i] >> 8);
-      *p++ = static_cast<uint8_t>(grpc_setting_id_to_wire_id[i]);
-      *p++ = static_cast<uint8_t>(new_settings[i] >> 24);
-      *p++ = static_cast<uint8_t>(new_settings[i] >> 16);
-      *p++ = static_cast<uint8_t>(new_settings[i] >> 8);
-      *p++ = static_cast<uint8_t>(new_settings[i]);
-      old_settings[i] = new_settings[i];
-    }
-  }
-
-  GPR_ASSERT(p == GRPC_SLICE_END_PTR(output));
-
-  return output;
-}
-
 grpc_slice grpc_chttp2_settings_ack_create(void) {
   grpc_slice output = GRPC_SLICE_MALLOC(9);
   fill_header(GRPC_SLICE_START_PTR(output), 0, GRPC_CHTTP2_FLAG_ACK);
@@ -95,10 +64,9 @@ grpc_slice grpc_chttp2_settings_ack_create(void) {
 
 grpc_error_handle grpc_chttp2_settings_parser_begin_frame(
     grpc_chttp2_settings_parser* parser, uint32_t length, uint8_t flags,
-    uint32_t* settings) {
-  parser->target_settings = settings;
-  memcpy(parser->incoming_settings, settings,
-         GRPC_CHTTP2_NUM_SETTINGS * sizeof(uint32_t));
+    grpc_core::Http2Settings& settings) {
+  parser->target_settings = &settings;
+  parser->incoming_settings.Init(settings);
   parser->is_ack = 0;
   parser->state = GRPC_CHTTP2_SPS_ID0;
   if (flags == GRPC_CHTTP2_FLAG_ACK) {
@@ -125,7 +93,6 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
       static_cast<grpc_chttp2_settings_parser*>(p);
   const uint8_t* cur = GRPC_SLICE_START_PTR(slice);
   const uint8_t* end = GRPC_SLICE_END_PTR(slice);
-  grpc_chttp2_setting_id id;
 
   if (parser->is_ack) {
     return absl::OkStatus();
@@ -137,8 +104,7 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
         if (cur == end) {
           parser->state = GRPC_CHTTP2_SPS_ID0;
           if (is_last) {
-            memcpy(parser->target_settings, parser->incoming_settings,
-                   GRPC_CHTTP2_NUM_SETTINGS * sizeof(uint32_t));
+            *parser->target_settings = *parser->incoming_settings;
             t->num_pending_induced_frames++;
             grpc_slice_buffer_add(&t->qbuf, grpc_chttp2_settings_ack_create());
             grpc_chttp2_initiate_write(t,
@@ -187,7 +153,7 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
         parser->value |= (static_cast<uint32_t>(*cur)) << 8;
         cur++;
         ABSL_FALLTHROUGH_INTENDED;
-      case GRPC_CHTTP2_SPS_VAL3:
+      case GRPC_CHTTP2_SPS_VAL3: {
         if (cur == end) {
           parser->state = GRPC_CHTTP2_SPS_VAL3;
           return absl::OkStatus();
@@ -197,47 +163,35 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
         parser->value |= *cur;
         cur++;
 
-        if (grpc_wire_id_to_setting_id(parser->id, &id)) {
-          const grpc_chttp2_setting_parameters* sp =
-              &grpc_chttp2_settings_parameters[id];
-          if (parser->value < sp->min_value || parser->value > sp->max_value) {
-            switch (sp->invalid_value_behavior) {
-              case GRPC_CHTTP2_CLAMP_INVALID_VALUE:
-                parser->value = grpc_core::Clamp(parser->value, sp->min_value,
-                                                 sp->max_value);
-                break;
-              case GRPC_CHTTP2_DISCONNECT_ON_INVALID_VALUE:
-                grpc_chttp2_goaway_append(
-                    t->last_new_stream_id, sp->error_value,
-                    grpc_slice_from_static_string("HTTP2 settings error"),
-                    &t->qbuf);
-                return GRPC_ERROR_CREATE(absl::StrFormat(
-                    "invalid value %u passed for %s", parser->value, sp->name));
-            }
-          }
-          if (id == GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE &&
-              parser->incoming_settings[id] != parser->value) {
-            t->initial_window_update += static_cast<int64_t>(parser->value) -
-                                        parser->incoming_settings[id];
-            if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
-                GRPC_TRACE_FLAG_ENABLED(grpc_flowctl_trace)) {
-              gpr_log(GPR_INFO, "%p[%s] adding %d for initial_window change", t,
-                      t->is_client ? "cli" : "svr",
-                      static_cast<int>(t->initial_window_update));
-            }
-          }
-          parser->incoming_settings[id] = parser->value;
-          if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
-            gpr_log(GPR_INFO, "CHTTP2:%s:%s: got setting %s = %d",
-                    t->is_client ? "CLI" : "SVR",
-                    std::string(t->peer_string.as_string_view()).c_str(),
-                    sp->name, parser->value);
+        if (parser->id == grpc_core::Http2Settings::kInitialWindowSizeWireId) {
+          t->initial_window_update +=
+              static_cast<int64_t>(parser->value) -
+              parser->incoming_settings->initial_window_size();
+          if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
+              GRPC_TRACE_FLAG_ENABLED(grpc_flowctl_trace)) {
+            gpr_log(GPR_INFO, "%p[%s] adding %d for initial_window change", t,
+                    t->is_client ? "cli" : "svr",
+                    static_cast<int>(t->initial_window_update));
           }
-        } else if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
-          gpr_log(GPR_DEBUG, "CHTTP2: Ignoring unknown setting %d (value %d)",
-                  parser->id, parser->value);
         }
-        break;
+        auto error =
+            parser->incoming_settings->Apply(parser->id, parser->value);
+        if (error != GRPC_HTTP2_NO_ERROR) {
+          grpc_chttp2_goaway_append(
+              t->last_new_stream_id, error,
+              grpc_slice_from_static_string("HTTP2 settings error"), &t->qbuf);
+          return GRPC_ERROR_CREATE(absl::StrFormat(
+              "invalid value %u passed for %s", parser->value,
+              grpc_core::Http2Settings::WireIdToName(parser->id).c_str()));
+        }
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
+          gpr_log(GPR_INFO, "CHTTP2:%s:%s: got setting %s = %d",
+                  t->is_client ? "CLI" : "SVR",
+                  std::string(t->peer_string.as_string_view()).c_str(),
+                  grpc_core::Http2Settings::WireIdToName(parser->id).c_str(),
+                  parser->value);
+        }
+      } break;
     }
   }
 }

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

@@ -28,6 +28,7 @@
 
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
+#include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/iomgr/error.h"
 
 typedef enum {
@@ -41,22 +42,18 @@ typedef enum {
 
 struct grpc_chttp2_settings_parser {
   grpc_chttp2_settings_parse_state state;
-  uint32_t* target_settings;
+  grpc_core::Http2Settings* target_settings;
+  grpc_core::ManualConstructor<grpc_core::Http2Settings> incoming_settings;
   uint8_t is_ack;
   uint16_t id;
   uint32_t value;
-  uint32_t incoming_settings[GRPC_CHTTP2_NUM_SETTINGS];
 };
-// Create a settings frame by diffing old & new, and updating old to be new
-grpc_slice grpc_chttp2_settings_create(uint32_t* old_settings,
-                                       const uint32_t* new_settings,
-                                       uint32_t force_mask, size_t count);
 // Create an ack settings frame
 grpc_slice grpc_chttp2_settings_ack_create(void);
 
 grpc_error_handle grpc_chttp2_settings_parser_begin_frame(
     grpc_chttp2_settings_parser* parser, uint32_t length, uint8_t flags,
-    uint32_t* settings);
+    grpc_core::Http2Settings& settings);
 grpc_error_handle grpc_chttp2_settings_parser_parse(void* parser,
                                                     grpc_chttp2_transport* t,
                                                     grpc_chttp2_stream* s,

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

@@ -331,6 +331,11 @@ class HPackCompressor {
   HPackCompressor() = default;
   ~HPackCompressor() = default;
 
+  HPackCompressor(const HPackCompressor&) = delete;
+  HPackCompressor& operator=(const HPackCompressor&) = delete;
+  HPackCompressor(HPackCompressor&&) = default;
+  HPackCompressor& operator=(HPackCompressor&&) = default;
+
   // Maximum table size we'll actually use.
   static constexpr uint32_t kMaxTableSize = 1024 * 1024;
 

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

@@ -88,9 +88,11 @@ class HPackParser {
   HPackParser();
   ~HPackParser();
 
-  // Non-copyable/movable
+  // Non-copyable
   HPackParser(const HPackParser&) = delete;
   HPackParser& operator=(const HPackParser&) = delete;
+  HPackParser(HPackParser&&) = default;
+  HPackParser& operator=(HPackParser&&) = default;
 
   // Begin parsing a new frame
   // Sink receives each parsed header,

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

@@ -45,6 +45,8 @@ class HPackTable {
 
   HPackTable(const HPackTable&) = delete;
   HPackTable& operator=(const HPackTable&) = delete;
+  HPackTable(HPackTable&&) = default;
+  HPackTable& operator=(HPackTable&&) = default;
 
   void SetMaxBytes(uint32_t max_bytes);
   bool SetCurrentTableSize(uint32_t bytes);
@@ -151,7 +153,7 @@ class HPackTable {
   // HPack table entries
   MementoRingBuffer entries_;
   // Static mementos
-  const StaticMementos* const static_mementos_ = GetStaticMementos();
+  const StaticMementos* static_mementos_ = GetStaticMementos();
 };
 
 }  // namespace grpc_core

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