grpc 1.60.0 → 1.61.0.pre2

data/src/core/ext/filters/server_config_selector/server_config_selector_filter.cc

@@ -47,7 +47,8 @@ namespace grpc_core {
 
 namespace {
 
-class ServerConfigSelectorFilter final : public ChannelFilter {
+class ServerConfigSelectorFilter final
+    : public ImplementChannelFilter<ServerConfigSelectorFilter> {
  public:
   ~ServerConfigSelectorFilter() override;
 
@@ -60,8 +61,16 @@ class ServerConfigSelectorFilter final : public ChannelFilter {
   static absl::StatusOr<ServerConfigSelectorFilter> Create(
       const ChannelArgs& args, ChannelFilter::Args);
 
-  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
-      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+  class Call {
+   public:
+    absl::Status OnClientInitialMetadata(ClientMetadata& md,
+                                         ServerConfigSelectorFilter* filter);
+    static const NoInterceptor OnServerInitialMetadata;
+    static const NoInterceptor OnServerTrailingMetadata;
+    static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnServerToClientMessage;
+    static const NoInterceptor OnFinalize;
+  };
 
   absl::StatusOr<RefCountedPtr<ServerConfigSelector>> config_selector() {
     MutexLock lock(&state_->mu);
@@ -130,25 +139,28 @@ ServerConfigSelectorFilter::~ServerConfigSelectorFilter() {
   }
 }
 
-ArenaPromise<ServerMetadataHandle> ServerConfigSelectorFilter::MakeCallPromise(
-    CallArgs call_args, NextPromiseFactory next_promise_factory) {
-  auto sel = config_selector();
-  if (!sel.ok()) return Immediate(ServerMetadataFromStatus(sel.status()));
-  auto call_config =
-      sel.value()->GetCallConfig(call_args.client_initial_metadata.get());
+absl::Status ServerConfigSelectorFilter::Call::OnClientInitialMetadata(
+    ClientMetadata& md, ServerConfigSelectorFilter* filter) {
+  auto sel = filter->config_selector();
+  if (!sel.ok()) return sel.status();
+  auto call_config = sel.value()->GetCallConfig(&md);
   if (!call_config.ok()) {
-    auto r = Immediate(ServerMetadataFromStatus(
-        absl::UnavailableError(StatusToString(call_config.status()))));
-    return std::move(r);
+    return absl::UnavailableError(StatusToString(call_config.status()));
   }
   auto* service_config_call_data =
       GetContext<Arena>()->New<ServiceConfigCallData>(
           GetContext<Arena>(), GetContext<grpc_call_context_element>());
   service_config_call_data->SetServiceConfig(
       std::move(call_config->service_config), call_config->method_configs);
-  return next_promise_factory(std::move(call_args));
+  return absl::OkStatus();
 }
 
+const NoInterceptor ServerConfigSelectorFilter::Call::OnServerInitialMetadata;
+const NoInterceptor ServerConfigSelectorFilter::Call::OnServerTrailingMetadata;
+const NoInterceptor ServerConfigSelectorFilter::Call::OnClientToServerMessage;
+const NoInterceptor ServerConfigSelectorFilter::Call::OnServerToClientMessage;
+const NoInterceptor ServerConfigSelectorFilter::Call::OnFinalize;
+
 }  // namespace
 
 const grpc_channel_filter kServerConfigSelectorFilter =

data/src/core/ext/filters/stateful_session/stateful_session_filter.cc

@@ -38,7 +38,7 @@
 
 #include <grpc/support/log.h>
 
-#include "src/core/ext/filters/client_channel/resolver/xds/xds_resolver.h"
+#include "src/core/ext/filters/client_channel/resolver/xds/xds_resolver_attributes.h"
 #include "src/core/ext/filters/stateful_session/stateful_session_service_config_parser.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/context.h"
@@ -58,6 +58,9 @@
 namespace grpc_core {
 
 TraceFlag grpc_stateful_session_filter_trace(false, "stateful_session_filter");
+const NoInterceptor StatefulSessionFilter::Call::OnClientToServerMessage;
+const NoInterceptor StatefulSessionFilter::Call::OnServerToClientMessage;
+const NoInterceptor StatefulSessionFilter::Call::OnFinalize;
 
 UniqueTypeName XdsOverrideHostAttribute::TypeName() {
   static UniqueTypeName::Factory kFactory("xds_override_host");
@@ -103,7 +106,7 @@ void MaybeUpdateServerInitialMetadata(
     bool cluster_changed, absl::string_view actual_cluster,
     absl::string_view cookie_address_list,
     XdsOverrideHostAttribute* override_host_attribute,
-    ServerMetadata* server_initial_metadata) {
+    ServerMetadata& server_initial_metadata) {
   // If cookie doesn't need to change, do nothing.
   if (cookie_address_list == override_host_attribute->actual_address_list() &&
       !cluster_changed) {
@@ -121,7 +124,7 @@ void MaybeUpdateServerInitialMetadata(
     parts.emplace_back(
         absl::StrCat("Max-Age=", cookie_config->ttl.as_timespec().tv_sec));
   }
-  server_initial_metadata->Append(
+  server_initial_metadata.Append(
       "set-cookie", Slice::FromCopiedString(absl::StrJoin(parts, "; ")),
       [](absl::string_view error, const Slice&) {
         Crash(absl::StrCat("ERROR ADDING set-cookie METADATA: ", error));
@@ -168,12 +171,11 @@ absl::string_view GetClusterToUse(
   return absl::StripPrefix(arena_allocated_cluster, kClusterPrefix);
 }
 
-std::string GetCookieValue(const ClientMetadataHandle& client_initial_metadata,
+std::string GetCookieValue(const ClientMetadata& client_initial_metadata,
                            absl::string_view cookie_name) {
   // Check to see if the cookie header is present.
   std::string buffer;
-  auto header_value =
-      client_initial_metadata->GetStringValue("cookie", &buffer);
+  auto header_value = client_initial_metadata.GetStringValue("cookie", &buffer);
   if (!header_value.has_value()) return "";
   // Parse cookie header.
   std::vector<absl::string_view> values;
@@ -193,13 +195,14 @@ std::string GetCookieValue(const ClientMetadataHandle& client_initial_metadata,
 }
 
 bool IsConfiguredPath(absl::string_view configured_path,
-                      const ClientMetadataHandle& client_initial_metadata) {
+                      const ClientMetadata& client_initial_metadata) {
   // No path configured meaning all paths match
   if (configured_path.empty()) {
     return true;
   }
   // Check to see if the configured path matches the request path.
-  Slice* path_slice = client_initial_metadata->get_pointer(HttpPathMetadata());
+  const Slice* path_slice =
+      client_initial_metadata.get_pointer(HttpPathMetadata());
   GPR_ASSERT(path_slice != nullptr);
   absl::string_view path = path_slice->as_string_view();
   // Matching criteria from
@@ -218,9 +221,8 @@ bool IsConfiguredPath(absl::string_view configured_path,
 }
 }  // namespace
 
-// Construct a promise for one call.
-ArenaPromise<ServerMetadataHandle> StatefulSessionFilter::MakeCallPromise(
-    CallArgs call_args, NextPromiseFactory next_promise_factory) {
+void StatefulSessionFilter::Call::OnClientInitialMetadata(
+    ClientMetadata& md, StatefulSessionFilter* filter) {
   // Get config.
   auto* service_config_call_data = static_cast<ServiceConfigCallData*>(
       GetContext<
@@ -229,62 +231,57 @@ ArenaPromise<ServerMetadataHandle> StatefulSessionFilter::MakeCallPromise(
   GPR_ASSERT(service_config_call_data != nullptr);
   auto* method_params = static_cast<StatefulSessionMethodParsedConfig*>(
       service_config_call_data->GetMethodParsedConfig(
-          service_config_parser_index_));
+          filter->service_config_parser_index_));
   GPR_ASSERT(method_params != nullptr);
-  auto* cookie_config = method_params->GetConfig(index_);
-  GPR_ASSERT(cookie_config != nullptr);
-  if (!cookie_config->name.has_value() ||
-      !IsConfiguredPath(cookie_config->path,
-                        call_args.client_initial_metadata)) {
-    return next_promise_factory(std::move(call_args));
+  cookie_config_ = method_params->GetConfig(filter->index_);
+  GPR_ASSERT(cookie_config_ != nullptr);
+  if (!cookie_config_->name.has_value() ||
+      !IsConfiguredPath(cookie_config_->path, md)) {
+    return;
   }
   // Base64-decode cookie value.
-  std::string cookie_value =
-      GetCookieValue(call_args.client_initial_metadata, *cookie_config->name);
+  std::string cookie_value = GetCookieValue(md, *cookie_config_->name);
   // Cookie format is "host;cluster"
   std::pair<absl::string_view, absl::string_view> host_cluster =
       absl::StrSplit(cookie_value, absl::MaxSplits(';', 1));
-  absl::string_view cookie_address_list;
   // Allocate the string on the arena, so that it has the right lifetime.
   if (!host_cluster.first.empty()) {
-    cookie_address_list = AllocateStringOnArena(host_cluster.first);
+    cookie_address_list_ = AllocateStringOnArena(host_cluster.first);
   }
   // Set override host attribute.
-  auto* override_host_attribute =
+  override_host_attribute_ =
       GetContext<Arena>()->ManagedNew<XdsOverrideHostAttribute>(
-          cookie_address_list);
-  service_config_call_data->SetCallAttribute(override_host_attribute);
+          cookie_address_list_);
+  service_config_call_data->SetCallAttribute(override_host_attribute_);
   // Check if the cluster override is valid, and apply it if necessary.
   // Note that cluster_name will point to an arena-allocated string
   // that will still be alive when we see the server initial metadata.
   // If the cluster name is empty, that means we cannot use a
   // cluster override (i.e., the route uses a cluster specifier plugin).
-  absl::string_view cluster_name =
+  cluster_name_ =
       GetClusterToUse(host_cluster.second, service_config_call_data);
-  bool cluster_changed = cluster_name != host_cluster.second;
-  // Intercept server initial metadata.
-  call_args.server_initial_metadata->InterceptAndMap(
-      [cookie_config, cluster_changed, cluster_name, cookie_address_list,
-       override_host_attribute](ServerMetadataHandle md) {
-        // Add cookie to server initial metadata if needed.
-        MaybeUpdateServerInitialMetadata(cookie_config, cluster_changed,
-                                         cluster_name, cookie_address_list,
-                                         override_host_attribute, md.get());
-        return md;
-      });
-  return Map(next_promise_factory(std::move(call_args)),
-             [cookie_config, cluster_changed, cluster_name, cookie_address_list,
-              override_host_attribute](ServerMetadataHandle md) {
-               // If we got a Trailers-Only response, then add the
-               // cookie to the trailing metadata instead of the
-               // initial metadata.
-               if (md->get(GrpcTrailersOnly()).value_or(false)) {
-                 MaybeUpdateServerInitialMetadata(
-                     cookie_config, cluster_changed, cluster_name,
-                     cookie_address_list, override_host_attribute, md.get());
-               }
-               return md;
-             });
+  cluster_changed_ = cluster_name_ != host_cluster.second;
+  perform_filtering_ = true;
+}
+
+void StatefulSessionFilter::Call::OnServerInitialMetadata(ServerMetadata& md) {
+  if (!perform_filtering_) return;
+  // Add cookie to server initial metadata if needed.
+  MaybeUpdateServerInitialMetadata(cookie_config_, cluster_changed_,
+                                   cluster_name_, cookie_address_list_,
+                                   override_host_attribute_, md);
+}
+
+void StatefulSessionFilter::Call::OnServerTrailingMetadata(ServerMetadata& md) {
+  if (!perform_filtering_) return;
+  // If we got a Trailers-Only response, then add the
+  // cookie to the trailing metadata instead of the
+  // initial metadata.
+  if (md.get(GrpcTrailersOnly()).value_or(false)) {
+    MaybeUpdateServerInitialMetadata(cookie_config_, cluster_changed_,
+                                     cluster_name_, cookie_address_list_,
+                                     override_host_attribute_, md);
+  }
 }
 
 void StatefulSessionFilterRegister(CoreConfiguration::Builder* builder) {

data/src/core/ext/filters/stateful_session/stateful_session_filter.h

@@ -26,6 +26,7 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
+#include "src/core/ext/filters/stateful_session/stateful_session_service_config_parser.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/promise_based_filter.h"
@@ -68,16 +69,32 @@ class XdsOverrideHostAttribute
 };
 
 // A filter to provide cookie-based stateful session affinity.
-class StatefulSessionFilter : public ChannelFilter {
+class StatefulSessionFilter
+    : public ImplementChannelFilter<StatefulSessionFilter> {
  public:
   static const grpc_channel_filter kFilter;
 
   static absl::StatusOr<StatefulSessionFilter> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
-  // Construct a promise for one call.
-  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
-      CallArgs call_args, NextPromiseFactory next_promise_factory) override;
+  class Call {
+   public:
+    void OnClientInitialMetadata(ClientMetadata& md,
+                                 StatefulSessionFilter* filter);
+    void OnServerInitialMetadata(ServerMetadata& md);
+    void OnServerTrailingMetadata(ServerMetadata& md);
+    static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnServerToClientMessage;
+    static const NoInterceptor OnFinalize;
+
+   private:
+    const StatefulSessionMethodParsedConfig::CookieConfig* cookie_config_;
+    XdsOverrideHostAttribute* override_host_attribute_;
+    absl::string_view cluster_name_;
+    absl::string_view cookie_address_list_;
+    bool cluster_changed_;
+    bool perform_filtering_ = false;
+  };
 
  private:
   explicit StatefulSessionFilter(ChannelFilter::Args filter_args);

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

@@ -25,7 +25,7 @@
 #include "src/core/lib/gpr/useful.h"
 
 // in order of preference
-static const char* const supported_versions[] = {"grpc-exp", "h2"};
+static const char* const supported_versions[] = {"h2"};
 
 int grpc_chttp2_is_alpn_version_supported(const char* version, size_t size) {
   size_t i;

data/src/core/ext/transport/chttp2/client/chttp2_connector.cc

@@ -177,9 +177,9 @@ void Chttp2Connector::OnHandshakeDone(void* arg, grpc_error_handle error) {
       grpc_chttp2_transport_start_reading(self->result_->transport,
                                           args->read_buffer,
                                           &self->on_receive_settings_, nullptr);
-      RefCountedPtr<Chttp2Connector> cc = self->Ref();
       self->timer_handle_ = self->event_engine_->RunAfter(
-          self->args_.deadline - Timestamp::Now(), [self = std::move(cc)] {
+          self->args_.deadline - Timestamp::Now(),
+          [self = self->RefAsSubclass<Chttp2Connector>()] {
             ApplicationCallbackExecCtx callback_exec_ctx;
             ExecCtx exec_ctx;
             self->OnTimeout();

data/src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -617,8 +617,17 @@ void Chttp2ServerListener::ActiveConnection::Start(
   RefCountedPtr<HandshakingState> handshaking_state_ref;
   listener_ = std::move(listener);
   {
-    MutexLock lock(&mu_);
-    if (shutdown_) return;
+    ReleasableMutexLock lock(&mu_);
+    if (shutdown_) {
+      lock.Release();
+      // If the Connection is already shutdown at this point, it implies the
+      // owning Chttp2ServerListener and all associated ActiveConnections have
+      // been orphaned. The generated endpoints need to be shutdown here to
+      // ensure the tcp connections are closed appropriately.
+      grpc_endpoint_shutdown(endpoint, absl::OkStatus());
+      grpc_endpoint_destroy(endpoint);
+      return;
+    }
     // Hold a ref to HandshakingState to allow starting the handshake outside
     // the critical region.
     handshaking_state_ref = handshaking_state_->Ref();

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

@@ -79,6 +79,7 @@
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/debug/stats_data.h"
 #include "src/core/lib/experiments/experiments.h"
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/bitset.h"
 #include "src/core/lib/gprpp/crash.h"
@@ -162,10 +163,6 @@ static void read_action_locked(grpc_core::RefCountedPtr<grpc_chttp2_transport>,
 static void continue_read_action_locked(
     grpc_core::RefCountedPtr<grpc_chttp2_transport> t);
 
-// Set a transport level setting, and push it to our peer
-static void queue_setting_update(grpc_chttp2_transport* t,
-                                 grpc_chttp2_setting_id id, uint32_t value);
-
 static void close_from_api(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
                            grpc_error_handle error, bool tarpit);
 
@@ -342,7 +339,7 @@ void ForEachContextListEntryExecute(void* arg, Timestamps* ts,
 }
 
 HttpAnnotation::HttpAnnotation(
-    Type type, Timestamp time,
+    Type type, gpr_timespec time,
     absl::optional<chttp2::TransportFlowControl::Stats> transport_stats,
     absl::optional<chttp2::StreamFlowControl::Stats> stream_stats)
     : CallTracerAnnotationInterface::Annotation(
@@ -367,7 +364,7 @@ std::string HttpAnnotation::ToString() const {
     default:
       absl::StrAppend(&s, "Unknown");
   }
-  absl::StrAppend(&s, " time: ", time_.ToString());
+  absl::StrAppend(&s, " time: ", gpr_format_timespec(time_));
   if (transport_stats_.has_value()) {
     absl::StrAppend(&s, " transport:[", transport_stats_->ToString(), "]");
   }
@@ -503,10 +500,8 @@ static void read_channel_args(grpc_chttp2_transport* t,
   if (max_requests_per_read.has_value()) {
     t->max_requests_per_read =
         grpc_core::Clamp(*max_requests_per_read, 1, 10000);
-  } else if (grpc_core::IsChttp2BatchRequestsEnabled()) {
-    t->max_requests_per_read = 32;
   } else {
-    t->max_requests_per_read = std::numeric_limits<size_t>::max();
+    t->max_requests_per_read = 32;
   }
 
   if (channel_args.GetBool(GRPC_ARG_ENABLE_CHANNELZ)
@@ -523,8 +518,8 @@ static void read_channel_args(grpc_chttp2_transport* t,
 
   t->ack_pings = channel_args.GetBool("grpc.http2.ack_pings").value_or(true);
 
-  t->allow_tarpit = channel_args.GetBool(GRPC_ARG_HTTP_ALLOW_TARPIT)
-                        .value_or(grpc_core::IsTarpitEnabled());
+  t->allow_tarpit =
+      channel_args.GetBool(GRPC_ARG_HTTP_ALLOW_TARPIT).value_or(true);
   t->min_tarpit_duration_ms =
       channel_args
           .GetDurationFromIntMillis(GRPC_ARG_HTTP_TARPIT_MIN_DURATION_MS)
@@ -551,93 +546,54 @@ static void read_channel_args(grpc_chttp2_transport* t,
     t->max_header_list_size_soft_limit = soft_limit;
   }
 
-  static const struct {
-    absl::string_view channel_arg_name;
-    grpc_chttp2_setting_id setting_id;
-    int default_value;
-    int min;
-    int max;
-    bool availability[2] /* server, client */;
-  } settings_map[] = {{GRPC_ARG_MAX_CONCURRENT_STREAMS,
-                       GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS,
-                       -1,
-                       0,
-                       INT32_MAX,
-                       {true, false}},
-                      {GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER,
-                       GRPC_CHTTP2_SETTINGS_HEADER_TABLE_SIZE,
-                       -1,
-                       0,
-                       INT32_MAX,
-                       {true, true}},
-                      {GRPC_ARG_ABSOLUTE_MAX_METADATA_SIZE,
-                       GRPC_CHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE,
-                       -1,
-                       0,
-                       INT32_MAX,
-                       {true, true}},
-                      {GRPC_ARG_HTTP2_MAX_FRAME_SIZE,
-                       GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE,
-                       -1,
-                       16384,
-                       16777215,
-                       {true, true}},
-                      {GRPC_ARG_HTTP2_ENABLE_TRUE_BINARY,
-                       GRPC_CHTTP2_SETTINGS_GRPC_ALLOW_TRUE_BINARY_METADATA,
-                       1,
-                       0,
-                       1,
-                       {true, true}},
-                      {GRPC_ARG_HTTP2_STREAM_LOOKAHEAD_BYTES,
-                       GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE,
-                       -1,
-                       5,
-                       INT32_MAX,
-                       {true, true}}};
-
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(settings_map); i++) {
-    const auto& setting = settings_map[i];
-    if (setting.availability[is_client]) {
-      const int value = channel_args.GetInt(setting.channel_arg_name)
-                            .value_or(setting.default_value);
-      if (value >= 0) {
-        const int clamped_value =
-            grpc_core::Clamp(value, setting.min, setting.max);
-        queue_setting_update(t, setting.setting_id, clamped_value);
-        if (setting.setting_id == GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS) {
-          t->max_concurrent_streams_policy.SetTarget(clamped_value);
-        }
-      } else if (setting.setting_id ==
-                 GRPC_CHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE) {
-        // Set value to 1.25 * soft limit if this is larger than
-        // `DEFAULT_MAX_HEADER_LIST_SIZE` and
-        // `GRPC_ARG_ABSOLUTE_MAX_METADATA_SIZE` is not set.
-        const int soft_limit = channel_args.GetInt(GRPC_ARG_MAX_METADATA_SIZE)
-                                   .value_or(setting.default_value);
-        const int value = (soft_limit >= 0 && soft_limit < (INT_MAX / 1.25))
-                              ? static_cast<int>(soft_limit * 1.25)
-                              : soft_limit;
-        if (value > DEFAULT_MAX_HEADER_LIST_SIZE) {
-          queue_setting_update(
-              t, setting.setting_id,
-              grpc_core::Clamp(value, setting.min, setting.max));
-        }
-      }
-    } else if (channel_args.Contains(setting.channel_arg_name)) {
-      gpr_log(GPR_DEBUG, "%s is not available on %s",
-              std::string(setting.channel_arg_name).c_str(),
-              is_client ? "clients" : "servers");
+  int value;
+  if (!is_client) {
+    value = channel_args.GetInt(GRPC_ARG_MAX_CONCURRENT_STREAMS).value_or(-1);
+    if (value >= 0) {
+      t->settings.mutable_local().SetMaxConcurrentStreams(value);
+      t->max_concurrent_streams_policy.SetTarget(value);
+    }
+  } else if (channel_args.Contains(GRPC_ARG_MAX_CONCURRENT_STREAMS)) {
+    gpr_log(GPR_DEBUG, "%s is not available on clients",
+            GRPC_ARG_MAX_CONCURRENT_STREAMS);
+  }
+  value =
+      channel_args.GetInt(GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER).value_or(-1);
+  if (value >= 0) {
+    t->settings.mutable_local().SetHeaderTableSize(value);
+  }
+  value = channel_args.GetInt(GRPC_ARG_ABSOLUTE_MAX_METADATA_SIZE).value_or(-1);
+  if (value >= 0) {
+    t->settings.mutable_local().SetMaxHeaderListSize(value);
+  } else {
+    // Set value to 1.25 * soft limit if this is larger than
+    // `DEFAULT_MAX_HEADER_LIST_SIZE` and
+    // `GRPC_ARG_ABSOLUTE_MAX_METADATA_SIZE` is not set.
+    const int soft_limit =
+        channel_args.GetInt(GRPC_ARG_MAX_METADATA_SIZE).value_or(-1);
+    const int value = (soft_limit >= 0 && soft_limit < (INT_MAX / 1.25))
+                          ? static_cast<int>(soft_limit * 1.25)
+                          : soft_limit;
+    if (value > DEFAULT_MAX_HEADER_LIST_SIZE) {
+      t->settings.mutable_local().SetMaxHeaderListSize(value);
     }
   }
+  value = channel_args.GetInt(GRPC_ARG_HTTP2_MAX_FRAME_SIZE).value_or(-1);
+  if (value >= 0) {
+    t->settings.mutable_local().SetMaxFrameSize(value);
+  }
+  value =
+      channel_args.GetInt(GRPC_ARG_HTTP2_STREAM_LOOKAHEAD_BYTES).value_or(-1);
+  if (value >= 0) {
+    t->settings.mutable_local().SetInitialWindowSize(value);
+  }
+  value = channel_args.GetInt(GRPC_ARG_HTTP2_ENABLE_TRUE_BINARY).value_or(-1);
+  if (value >= 0) {
+    t->settings.mutable_local().SetAllowTrueBinaryMetadata(value != 0);
+  }
 
   if (t->enable_preferred_rx_crypto_frame_advertisement) {
-    const grpc_chttp2_setting_parameters* sp =
-        &grpc_chttp2_settings_parameters
-            [GRPC_CHTTP2_SETTINGS_GRPC_PREFERRED_RECEIVE_CRYPTO_FRAME_SIZE];
-    queue_setting_update(
-        t, GRPC_CHTTP2_SETTINGS_GRPC_PREFERRED_RECEIVE_CRYPTO_FRAME_SIZE,
-        grpc_core::Clamp(INT_MAX, static_cast<int>(sp->min_value),
-                         static_cast<int>(sp->max_value)));
+    t->settings.mutable_local().SetPreferredReceiveCryptoMessageSize(INT_MAX);
   }
 
   t->ping_on_rst_stream_percent = grpc_core::Clamp(
@@ -647,7 +603,7 @@ static void read_channel_args(grpc_chttp2_transport* t,
 
   t->max_concurrent_streams_overload_protection =
       channel_args.GetBool(GRPC_ARG_MAX_CONCURRENT_STREAMS_OVERLOAD_PROTECTION)
-          .value_or(grpc_core::IsOverloadProtectionEnabled());
+          .value_or(true);
 }
 
 static void init_keepalive_pings_if_enabled_locked(
@@ -711,33 +667,22 @@ grpc_chttp2_transport::grpc_chttp2_transport(
         grpc_slice_from_copied_string(GRPC_CHTTP2_CLIENT_CONNECT_STRING));
   }
   grpc_slice_buffer_init(&qbuf);
-  // copy in initial settings to all setting sets
-  size_t i;
-  int j;
-  for (i = 0; i < GRPC_CHTTP2_NUM_SETTINGS; i++) {
-    for (j = 0; j < GRPC_NUM_SETTING_SETS; j++) {
-      settings[j][i] = grpc_chttp2_settings_parameters[i].default_value;
-    }
-  }
   grpc_chttp2_goaway_parser_init(&goaway_parser);
 
   // configure http2 the way we like it
   if (is_client) {
-    queue_setting_update(this, GRPC_CHTTP2_SETTINGS_ENABLE_PUSH, 0);
-    queue_setting_update(this, GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS, 0);
+    settings.mutable_local().SetEnablePush(false);
+    settings.mutable_local().SetMaxConcurrentStreams(0);
   }
-  queue_setting_update(this, GRPC_CHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE,
-                       DEFAULT_MAX_HEADER_LIST_SIZE);
-  queue_setting_update(this,
-                       GRPC_CHTTP2_SETTINGS_GRPC_ALLOW_TRUE_BINARY_METADATA, 1);
+  settings.mutable_local().SetMaxHeaderListSize(DEFAULT_MAX_HEADER_LIST_SIZE);
+  settings.mutable_local().SetAllowTrueBinaryMetadata(true);
 
   read_channel_args(this, channel_args, is_client);
 
   // Initially allow *UP TO* MAX_CONCURRENT_STREAMS incoming before we start
   // blanket cancelling them.
   num_incoming_streams_before_settings_ack =
-      settings[GRPC_LOCAL_SETTINGS]
-              [GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS];
+      settings.local().max_concurrent_streams();
 
   grpc_core::ExecCtx exec_ctx;
   combiner->Run(
@@ -1127,9 +1072,7 @@ static void write_action(grpc_chttp2_transport* t) {
   // Choose max_frame_size as the prefered rx crypto frame size indicated by the
   // peer.
   int max_frame_size =
-      t->settings
-          [GRPC_PEER_SETTINGS]
-          [GRPC_CHTTP2_SETTINGS_GRPC_PREFERRED_RECEIVE_CRYPTO_FRAME_SIZE];
+      t->settings.peer().preferred_receive_crypto_message_size();
   // Note: max frame size is 0 if the remote peer does not support adjusting the
   // sending frame size.
   if (max_frame_size == 0) {
@@ -1206,23 +1149,6 @@ static void write_action_end_locked(
   grpc_chttp2_end_write(t.get(), error);
 }
 
-// Dirties an HTTP2 setting to be sent out next time a writing path occurs.
-// If the change needs to occur immediately, manually initiate a write.
-static void queue_setting_update(grpc_chttp2_transport* t,
-                                 grpc_chttp2_setting_id id, uint32_t value) {
-  const grpc_chttp2_setting_parameters* sp =
-      &grpc_chttp2_settings_parameters[id];
-  uint32_t use_value = grpc_core::Clamp(value, sp->min_value, sp->max_value);
-  if (use_value != value) {
-    gpr_log(GPR_INFO, "Requested parameter %s clamped from %d to %d", sp->name,
-            value, use_value);
-  }
-  if (use_value != t->settings[GRPC_LOCAL_SETTINGS][id]) {
-    t->settings[GRPC_LOCAL_SETTINGS][id] = use_value;
-    t->dirtied_local_settings = true;
-  }
-}
-
 // Cancel out streams that haven't yet started if we have received a GOAWAY
 static void cancel_unstarted_streams(grpc_chttp2_transport* t,
                                      grpc_error_handle error, bool tarpit) {
@@ -1321,9 +1247,7 @@ static void maybe_start_some_streams(grpc_chttp2_transport* t) {
   // start streams where we have free grpc_chttp2_stream ids and free
   // * concurrency
   while (t->next_stream_id <= MAX_CLIENT_STREAM_ID &&
-         t->stream_map.size() <
-             t->settings[GRPC_PEER_SETTINGS]
-                        [GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS] &&
+         t->stream_map.size() < t->settings.peer().max_concurrent_streams() &&
          grpc_chttp2_list_pop_waiting_for_concurrency(t, &s)) {
     // safe since we can't (legally) be parsing this stream yet
     GRPC_CHTTP2_IF_TRACING(gpr_log(
@@ -1510,7 +1434,7 @@ static void perform_stream_op_locked(void* stream_op,
   if (op->send_initial_metadata) {
     if (s->call_tracer) {
       s->call_tracer->RecordAnnotation(grpc_core::HttpAnnotation(
-          grpc_core::HttpAnnotation::Type::kStart, grpc_core::Timestamp::Now(),
+          grpc_core::HttpAnnotation::Type::kStart, gpr_now(GPR_CLOCK_REALTIME),
           s->t->flow_control.stats(), s->flow_control.stats()));
     }
     if (t->is_client && t->channelz_socket != nullptr) {
@@ -2708,21 +2632,19 @@ void grpc_chttp2_act_on_flowctl_action(
               GRPC_CHTTP2_INITIATE_WRITE_TRANSPORT_FLOW_CONTROL, []() {});
   WithUrgency(t, action.send_initial_window_update(),
               GRPC_CHTTP2_INITIATE_WRITE_SEND_SETTINGS, [t, &action]() {
-                queue_setting_update(t,
-                                     GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE,
-                                     action.initial_window_size());
-              });
-  WithUrgency(t, action.send_max_frame_size_update(),
-              GRPC_CHTTP2_INITIATE_WRITE_SEND_SETTINGS, [t, &action]() {
-                queue_setting_update(t, GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE,
-                                     action.max_frame_size());
+                t->settings.mutable_local().SetInitialWindowSize(
+                    action.initial_window_size());
               });
+  WithUrgency(
+      t, action.send_max_frame_size_update(),
+      GRPC_CHTTP2_INITIATE_WRITE_SEND_SETTINGS, [t, &action]() {
+        t->settings.mutable_local().SetMaxFrameSize(action.max_frame_size());
+      });
   if (t->enable_preferred_rx_crypto_frame_advertisement) {
     WithUrgency(
         t, action.preferred_rx_crypto_frame_size_update(),
         GRPC_CHTTP2_INITIATE_WRITE_SEND_SETTINGS, [t, &action]() {
-          queue_setting_update(
-              t, GRPC_CHTTP2_SETTINGS_GRPC_PREFERRED_RECEIVE_CRYPTO_FRAME_SIZE,
+          t->settings.mutable_local().SetPreferredReceiveCryptoMessageSize(
               action.preferred_rx_crypto_frame_size());
         });
   }