grpc 1.60.0 → 1.61.0.pre2

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 =

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

@@ -34,6 +34,7 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/log.h>
+#include <grpc/support/time.h>
 
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/ext/transport/chttp2/transport/context_list_entry.h"
@@ -217,15 +218,12 @@ static void report_stall(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
         ":peer_initwin=%d:t_win=%" PRId64 ":s_win=%d:s_delta=%" PRId64 "]",
         std::string(t->peer_string.as_string_view()).c_str(), t, s->id, staller,
         s->flow_controlled_buffer.length, s->flow_controlled_bytes_flowed,
-        t->settings[GRPC_ACKED_SETTINGS]
-                   [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE],
+        t->settings.acked().initial_window_size(),
         t->flow_control.remote_window(),
         static_cast<uint32_t>(std::max(
-            int64_t{0},
-            s->flow_control.remote_window_delta() +
-                static_cast<int64_t>(
-                    t->settings[GRPC_PEER_SETTINGS]
-                               [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE]))),
+            int64_t{0}, s->flow_control.remote_window_delta() +
+                            static_cast<int64_t>(
+                                t->settings.peer().initial_window_size()))),
         s->flow_control.remote_window_delta());
   }
 }
@@ -265,23 +263,13 @@ class WriteContext {
   }
 
   void FlushSettings() {
-    const bool dirty =
-        t_->dirtied_local_settings ||
-        t_->settings[GRPC_SENT_SETTINGS]
-                    [GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS] !=
-            t_->max_concurrent_streams_policy.AdvertiseValue();
-    if (dirty && !t_->sent_local_settings) {
-      t_->settings[GRPC_LOCAL_SETTINGS]
-                  [GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS] =
-          t_->max_concurrent_streams_policy.AdvertiseValue();
-      grpc_slice_buffer_add(
-          t_->outbuf.c_slice_buffer(),
-          grpc_chttp2_settings_create(t_->settings[GRPC_SENT_SETTINGS],
-                                      t_->settings[GRPC_LOCAL_SETTINGS],
-                                      t_->force_send_settings,
-                                      GRPC_CHTTP2_NUM_SETTINGS));
-      if (grpc_core::IsSettingsTimeoutEnabled() &&
-          t_->keepalive_timeout != grpc_core::Duration::Infinity()) {
+    t_->settings.mutable_local().SetMaxConcurrentStreams(
+        t_->max_concurrent_streams_policy.AdvertiseValue());
+    auto update = t_->settings.MaybeSendUpdate();
+    if (update.has_value()) {
+      grpc_core::Http2Frame frame(std::move(*update));
+      Serialize(absl::Span<grpc_core::Http2Frame>(&frame, 1), t_->outbuf);
+      if (t_->keepalive_timeout != grpc_core::Duration::Infinity()) {
         GPR_ASSERT(
             t_->settings_ack_watchdog ==
             grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid);
@@ -294,9 +282,6 @@ class WriteContext {
               grpc_chttp2_settings_timeout(std::move(t));
             });
       }
-      t_->force_send_settings = false;
-      t_->dirtied_local_settings = false;
-      t_->sent_local_settings = true;
       t_->flow_control.FlushedSettings();
       t_->max_concurrent_streams_policy.FlushedSettings();
       grpc_core::global_stats().IncrementHttp2SettingsWrites();
@@ -336,8 +321,7 @@ class WriteContext {
 
   void EnactHpackSettings() {
     t_->hpack_compressor.SetMaxTableSize(
-        t_->settings[GRPC_PEER_SETTINGS]
-                    [GRPC_CHTTP2_SETTINGS_HEADER_TABLE_SIZE]);
+        t_->settings.peer().header_table_size());
   }
 
   void UpdateStreamsNoLongerStalled() {
@@ -410,17 +394,14 @@ class DataSendContext {
     return static_cast<uint32_t>(std::max(
         int64_t{0},
         s_->flow_control.remote_window_delta() +
-            static_cast<int64_t>(
-                t_->settings[GRPC_PEER_SETTINGS]
-                            [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE])));
+            static_cast<int64_t>(t_->settings.peer().initial_window_size())));
   }
 
   uint32_t max_outgoing() const {
     return grpc_core::Clamp<uint32_t>(
         std::min<int64_t>(
-            {t_->settings[GRPC_PEER_SETTINGS]
-                         [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE],
-             stream_remote_window(), t_->flow_control.remote_window(),
+            {t_->settings.peer().max_frame_size(), stream_remote_window(),
+             t_->flow_control.remote_window(),
              grpc_core::IsWriteSizeCapEnabled()
                  ? static_cast<int64_t>(write_context_->target_write_size())
                  : std::numeric_limits<uint32_t>::max()}),
@@ -494,14 +475,10 @@ class StreamWriteContext {
           grpc_core::HPackCompressor::EncodeHeaderOptions{
               s_->id,  // stream_id
               false,   // is_eof
-              t_->settings
-                      [GRPC_PEER_SETTINGS]
-                      [GRPC_CHTTP2_SETTINGS_GRPC_ALLOW_TRUE_BINARY_METADATA] !=
-                  0,  // use_true_binary_metadata
-              t_->settings
-                  [GRPC_PEER_SETTINGS]
-                  [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE],  // max_frame_size
-              &s_->stats.outgoing                         // stats
+              t_->settings.peer()
+                  .allow_true_binary_metadata(),     // use_true_binary_metadata
+              t_->settings.peer().max_frame_size(),  // max_frame_size
+              &s_->stats.outgoing                    // stats
           },
           *s_->send_initial_metadata, t_->outbuf.c_slice_buffer());
       grpc_chttp2_reset_ping_clock(t_);
@@ -517,7 +494,7 @@ class StreamWriteContext {
     if (s_->call_tracer) {
       s_->call_tracer->RecordAnnotation(grpc_core::HttpAnnotation(
           grpc_core::HttpAnnotation::Type::kHeadWritten,
-          grpc_core::Timestamp::Now(), s_->t->flow_control.stats(),
+          gpr_now(GPR_CLOCK_REALTIME), s_->t->flow_control.stats(),
           s_->flow_control.stats()));
     }
   }
@@ -596,14 +573,8 @@ class StreamWriteContext {
       }
       t_->hpack_compressor.EncodeHeaders(
           grpc_core::HPackCompressor::EncodeHeaderOptions{
-              s_->id, true,
-              t_->settings
-                      [GRPC_PEER_SETTINGS]
-                      [GRPC_CHTTP2_SETTINGS_GRPC_ALLOW_TRUE_BINARY_METADATA] !=
-                  0,
-              t_->settings[GRPC_PEER_SETTINGS]
-                          [GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE],
-              &s_->stats.outgoing},
+              s_->id, true, t_->settings.peer().allow_true_binary_metadata(),
+              t_->settings.peer().max_frame_size(), &s_->stats.outgoing},
           *s_->send_trailing_metadata, t_->outbuf.c_slice_buffer());
     }
     write_context_->IncTrailingMetadataWrites();
@@ -649,7 +620,7 @@ class StreamWriteContext {
                                    absl::OkStatus());
     if (s_->call_tracer) {
       s_->call_tracer->RecordAnnotation(grpc_core::HttpAnnotation(
-          grpc_core::HttpAnnotation::Type::kEnd, grpc_core::Timestamp::Now(),
+          grpc_core::HttpAnnotation::Type::kEnd, gpr_now(GPR_CLOCK_REALTIME),
           s_->t->flow_control.stats(), s_->flow_control.stats()));
     }
   }
@@ -734,9 +705,7 @@ void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error_handle error) {
       t->keepalive_timeout != grpc_core::Duration::Infinity()) {
     // Set ping timeout after finishing write so we don't measure our own send
     // time.
-    const auto timeout = grpc_core::IsSeparatePingFromKeepaliveEnabled()
-                             ? t->ping_timeout
-                             : t->keepalive_timeout;
+    const auto timeout = t->ping_timeout;
     auto id = t->ping_callbacks.OnPingTimeout(
         timeout, t->event_engine.get(), [t = t->Ref()] {
           grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
@@ -750,8 +719,7 @@ void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error_handle error) {
               id.value());
     }
 
-    if (grpc_core::IsSeparatePingFromKeepaliveEnabled() &&
-        t->keepalive_incoming_data_wanted &&
+    if (t->keepalive_incoming_data_wanted &&
         t->keepalive_timeout < t->ping_timeout &&
         t->keepalive_ping_timeout_handle !=
             grpc_event_engine::experimental::EventEngine::TaskHandle::