grpc 1.70.1 → 1.71.0

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

@@ -25,8 +25,10 @@
 
 #include <algorithm>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
+#include <variant>
 
 #include "absl/base/attributes.h"
 #include "absl/log/check.h"
@@ -35,9 +37,7 @@
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "absl/types/span.h"
-#include "absl/types/variant.h"
 #include "src/core/ext/transport/chttp2/transport/decode_huff.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parse_result.h"
@@ -115,7 +115,7 @@ class HPackParser::Input {
 
   // Retrieve the current character, or nullopt if end of stream
   // Do not advance
-  absl::optional<uint8_t> peek() const {
+  std::optional<uint8_t> peek() const {
     if (end_of_stream()) {
       return {};
     }
@@ -124,17 +124,17 @@ class HPackParser::Input {
 
   // Retrieve and advance past the current character, or return nullopt if end
   // of stream
-  absl::optional<uint8_t> Next() {
+  std::optional<uint8_t> Next() {
     if (end_of_stream()) {
       UnexpectedEOF(/*min_progress_size=*/1);
-      return absl::optional<uint8_t>();
+      return std::optional<uint8_t>();
     }
     return *begin_++;
   }
 
   // Helper to parse a varint delta on top of value, return nullopt on failure
   // (setting error)
-  absl::optional<uint32_t> ParseVarint(uint32_t value) {
+  std::optional<uint32_t> ParseVarint(uint32_t value) {
     // TODO(ctiller): break out a variant of this when we know there are at
     // least 5 bytes in input_
     auto cur = Next();
@@ -190,7 +190,7 @@ class HPackParser::Input {
   }
 
   // Parse a string prefix
-  absl::optional<StringPrefix> ParseStringPrefix() {
+  std::optional<StringPrefix> ParseStringPrefix() {
     auto cur = Next();
     if (!cur.has_value()) {
       DCHECK(eof_error());
@@ -285,17 +285,17 @@ class HPackParser::Input {
 
  private:
   // Helper to set the error to out of range for ParseVarint
-  absl::optional<uint32_t> ParseVarintOutOfRange(uint32_t value,
-                                                 uint8_t last_byte) {
+  std::optional<uint32_t> ParseVarintOutOfRange(uint32_t value,
+                                                uint8_t last_byte) {
     SetErrorAndStopParsing(
         HpackParseResult::VarintOutOfRangeError(value, last_byte));
-    return absl::optional<uint32_t>();
+    return std::optional<uint32_t>();
   }
 
   // Helper to set the error in the case of a malicious encoding
-  absl::optional<uint32_t> ParseVarintMaliciousEncoding() {
+  std::optional<uint32_t> ParseVarintMaliciousEncoding() {
     SetErrorAndStopParsing(HpackParseResult::MaliciousVarintEncodingError());
-    return absl::optional<uint32_t>();
+    return std::optional<uint32_t>();
   }
 
   // If no error is set, set it to the given error (i.e. first error wins)
@@ -339,12 +339,12 @@ class HPackParser::Input {
 };
 
 absl::string_view HPackParser::String::string_view() const {
-  if (auto* p = absl::get_if<Slice>(&value_)) {
+  if (auto* p = std::get_if<Slice>(&value_)) {
     return p->as_string_view();
-  } else if (auto* p = absl::get_if<absl::Span<const uint8_t>>(&value_)) {
+  } else if (auto* p = std::get_if<absl::Span<const uint8_t>>(&value_)) {
     return absl::string_view(reinterpret_cast<const char*>(p->data()),
                              p->size());
-  } else if (auto* p = absl::get_if<std::vector<uint8_t>>(&value_)) {
+  } else if (auto* p = std::get_if<std::vector<uint8_t>>(&value_)) {
     return absl::string_view(reinterpret_cast<const char*>(p->data()),
                              p->size());
   }
@@ -396,7 +396,7 @@ HPackParser::String::StringResult HPackParser::String::ParseUncompressed(
   }
 }
 
-absl::optional<std::vector<uint8_t>> HPackParser::String::Unbase64Loop(
+std::optional<std::vector<uint8_t>> HPackParser::String::Unbase64Loop(
     const uint8_t* cur, const uint8_t* end) {
   while (cur != end && end[-1] == '=') {
     --end;
@@ -478,14 +478,14 @@ absl::optional<std::vector<uint8_t>> HPackParser::String::Unbase64Loop(
 }
 
 HPackParser::String::StringResult HPackParser::String::Unbase64(String s) {
-  absl::optional<std::vector<uint8_t>> result;
-  if (auto* p = absl::get_if<Slice>(&s.value_)) {
+  std::optional<std::vector<uint8_t>> result;
+  if (auto* p = std::get_if<Slice>(&s.value_)) {
     result = Unbase64Loop(p->begin(), p->end());
   }
-  if (auto* p = absl::get_if<absl::Span<const uint8_t>>(&s.value_)) {
+  if (auto* p = std::get_if<absl::Span<const uint8_t>>(&s.value_)) {
     result = Unbase64Loop(p->begin(), p->end());
   }
-  if (auto* p = absl::get_if<std::vector<uint8_t>>(&s.value_)) {
+  if (auto* p = std::get_if<std::vector<uint8_t>>(&s.value_)) {
     result = Unbase64Loop(p->data(), p->data() + p->size());
   }
   if (!result.has_value()) {
@@ -648,7 +648,7 @@ class HPackParser::Parser {
           // literal key
           return StartParseLiteralKey(true);
         }
-        ABSL_FALLTHROUGH_INTENDED;
+        [[fallthrough]];
       case 5:
       case 6:
         // inline encoded key index
@@ -674,7 +674,7 @@ class HPackParser::Parser {
               HpackParseResult::IllegalHpackOpCode());
           return false;
         }
-        ABSL_FALLTHROUGH_INTENDED;
+        [[fallthrough]];
       case 9:
       case 10:
       case 11:
@@ -756,7 +756,7 @@ class HPackParser::Parser {
     return true;
   }
 
-  bool FinishHeaderOmitFromTable(absl::optional<HPackTable::Memento> md) {
+  bool FinishHeaderOmitFromTable(std::optional<HPackTable::Memento> md) {
     // Allow higher code to just pass in failures ... simplifies things a bit.
     if (!md.has_value()) return false;
     FinishHeaderOmitFromTable(*md);
@@ -960,7 +960,7 @@ class HPackParser::Parser {
             : String::Parse(input_, state_.is_string_huff_compressed,
                             state_.string_length);
     absl::string_view key_string;
-    if (auto* s = absl::get_if<Slice>(&state_.key)) {
+    if (auto* s = std::get_if<Slice>(&state_.key)) {
       key_string = s->as_string_view();
       if (state_.field_error.ok()) {
         auto r = ValidateKey(key_string);
@@ -970,7 +970,7 @@ class HPackParser::Parser {
         }
       }
     } else {
-      const auto* memento = absl::get<const HPackTable::Memento*>(state_.key);
+      const auto* memento = std::get<const HPackTable::Memento*>(state_.key);
       key_string = memento->md.key();
       if (state_.field_error.ok() && memento->parse_status.get() != nullptr) {
         input_->SetErrorAndContinueParsing(*memento->parse_status);
@@ -1028,7 +1028,7 @@ class HPackParser::Parser {
   }
 
   // Emit an indexed field
-  bool FinishIndexed(absl::optional<uint32_t> index) {
+  bool FinishIndexed(std::optional<uint32_t> index) {
     state_.dynamic_table_updates_allowed = 0;
     if (!index.has_value()) return false;
     const auto* elem = state_.hpack_table.Lookup(*index);
@@ -1041,7 +1041,7 @@ class HPackParser::Parser {
   }
 
   // finish parsing a max table size change
-  bool FinishMaxTableSize(absl::optional<uint32_t> size) {
+  bool FinishMaxTableSize(std::optional<uint32_t> size) {
     if (!size.has_value()) return false;
     if (state_.dynamic_table_updates_allowed == 0) {
       input_->SetErrorAndStopParsing(
@@ -1072,11 +1072,11 @@ class HPackParser::Parser {
 };
 
 Slice HPackParser::String::Take() {
-  if (auto* p = absl::get_if<Slice>(&value_)) {
+  if (auto* p = std::get_if<Slice>(&value_)) {
     return p->Copy();
-  } else if (auto* p = absl::get_if<absl::Span<const uint8_t>>(&value_)) {
+  } else if (auto* p = std::get_if<absl::Span<const uint8_t>>(&value_)) {
     return Slice::FromCopiedBuffer(*p);
-  } else if (auto* p = absl::get_if<std::vector<uint8_t>>(&value_)) {
+  } else if (auto* p = std::get_if<std::vector<uint8_t>>(&value_)) {
     return Slice::FromCopiedBuffer(*p);
   }
   GPR_UNREACHABLE_CODE(return Slice());
@@ -1138,7 +1138,8 @@ grpc_error_handle HPackParser::ParseInput(
       HandleMetadataSoftSizeLimitExceeded(&input);
     }
     global_stats().IncrementHttp2MetadataSize(state_.frame_length);
-    if (call_tracer != nullptr && metadata_buffer_ != nullptr) {
+    if (call_tracer != nullptr && call_tracer->IsSampled() &&
+        metadata_buffer_ != nullptr) {
       MetadataSizesAnnotation metadata_sizes_annotation(
           metadata_buffer_, state_.metadata_early_detection.soft_limit(),
           state_.metadata_early_detection.hard_limit());

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

@@ -24,16 +24,16 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <optional>
 #include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/random/bit_gen_ref.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "absl/types/span.h"
-#include "absl/types/variant.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parse_result.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser_table.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
@@ -173,11 +173,10 @@ class HPackParser {
     static StringResult Unbase64(String s);
 
     // Main loop for Unbase64
-    static absl::optional<std::vector<uint8_t>> Unbase64Loop(
-        const uint8_t* cur, const uint8_t* end);
+    static std::optional<std::vector<uint8_t>> Unbase64Loop(const uint8_t* cur,
+                                                            const uint8_t* end);
 
-    absl::variant<Slice, absl::Span<const uint8_t>, std::vector<uint8_t>>
-        value_;
+    std::variant<Slice, absl::Span<const uint8_t>, std::vector<uint8_t>> value_;
   };
 
   // Prefix for a string
@@ -251,7 +250,7 @@ class HPackParser {
     uint8_t dynamic_table_updates_allowed;
     // Current parse state
     ParseState parse_state = ParseState::kTop;
-    absl::variant<const HPackTable::Memento*, Slice> key;
+    std::variant<const HPackTable::Memento*, Slice> key;
   };
 
   grpc_error_handle ParseInput(Input input, bool is_last,

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

@@ -132,12 +132,12 @@ grpc_http2_error_code Http2Settings::Apply(uint16_t key, uint32_t value) {
   return GRPC_HTTP2_NO_ERROR;
 }
 
-absl::optional<Http2SettingsFrame> Http2SettingsManager::MaybeSendUpdate() {
+std::optional<Http2SettingsFrame> Http2SettingsManager::MaybeSendUpdate() {
   switch (update_state_) {
     case UpdateState::kSending:
-      return absl::nullopt;
+      return std::nullopt;
     case UpdateState::kIdle:
-      if (local_ == sent_) return absl::nullopt;
+      if (local_ == sent_) return std::nullopt;
       break;
     case UpdateState::kFirst:
       break;

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

@@ -21,10 +21,10 @@
 #include <stdint.h>
 
 #include <cstdint>
+#include <optional>
 
 #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/transport/http2_errors.h"
 #include "src/core/util/useful.h"
@@ -152,7 +152,7 @@ class Http2SettingsManager {
   Http2Settings& mutable_peer() { return peer_; }
   const Http2Settings& peer() const { return peer_; }
 
-  absl::optional<Http2SettingsFrame> MaybeSendUpdate();
+  std::optional<Http2SettingsFrame> MaybeSendUpdate();
   GRPC_MUST_USE_RESULT bool AckLastSend();
 
  private:

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

@@ -30,14 +30,14 @@
 
 #include <atomic>
 #include <memory>
+#include <optional>
 #include <utility>
+#include <variant>
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/random/random.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
 #include "src/core/ext/transport/chttp2/transport/context_list_entry.h"
@@ -475,6 +475,9 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   ;
   /// time duration in between pings
   grpc_core::Duration keepalive_time;
+  /// Tracks any adjustments to the absolute timestamp of the next keepalive
+  /// timer callback execution.
+  grpc_core::Timestamp next_adjusted_keepalive_timestamp;
   /// grace period to wait for data after sending a ping before keepalives
   /// timeout
   grpc_core::Duration keepalive_timeout;
@@ -606,7 +609,7 @@ struct grpc_chttp2_stream {
   grpc_metadata_batch* recv_initial_metadata;
   grpc_closure* recv_initial_metadata_ready = nullptr;
   bool* trailing_metadata_available = nullptr;
-  absl::optional<grpc_core::SliceBuffer>* recv_message = nullptr;
+  std::optional<grpc_core::SliceBuffer>* recv_message = nullptr;
   uint32_t* recv_message_flags = nullptr;
   bool* call_failed_before_recv_message = nullptr;
   grpc_closure* recv_message_ready = nullptr;
@@ -669,10 +672,10 @@ struct grpc_chttp2_stream {
 
   grpc_core::Chttp2CallTracerWrapper call_tracer_wrapper;
 
-  /// Only set when enabled.
-  // TODO(roth): Remove this when the call_tracer_in_transport
-  // experiment finishes rolling out.
-  grpc_core::CallTracerAnnotationInterface* call_tracer = nullptr;
+  // TODO(roth): Remove this when call v3 is supported.
+  grpc_core::CallTracerInterface* call_tracer = nullptr;
+  // TODO(yashykt): Remove this once call_tracer_transport_fix is rolled out
+  grpc_core::CallTracerAnnotationInterface* parent_call_tracer = nullptr;
 
   /// Only set when enabled.
   std::shared_ptr<grpc_core::TcpTracerInterface> tcp_tracer;
@@ -697,6 +700,14 @@ struct grpc_chttp2_stream {
   // The last time a stream window update was received.
   grpc_core::Timestamp last_window_update_time =
       grpc_core::Timestamp::InfPast();
+
+  // TODO(yashykt): Remove this when call v3 is supported.
+  grpc_core::CallTracerInterface* CallTracer() const {
+    if (t->is_client) {
+      return call_tracer;
+    }
+    return arena->GetContext<grpc_core::CallTracerInterface>();
+  }
 };
 
 #define GRPC_ARG_PING_TIMEOUT_MS "grpc.http2.ping_timeout_ms"
@@ -744,7 +755,7 @@ void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error_handle error);
 ///  - a count of parsed bytes in the event of a partial read: the caller should
 ///    offload responsibilities to another thread to continue parsing.
 ///  - or a status in the case of a completed read
-absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
+std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
     grpc_chttp2_transport* t, const grpc_slice& slice,
     size_t& requests_started);
 

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

@@ -29,6 +29,7 @@
 #include <memory>
 #include <string>
 #include <utility>
+#include <variant>
 
 #include "absl/base/attributes.h"
 #include "absl/container/flat_hash_map.h"
@@ -39,7 +40,6 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/variant.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
@@ -206,7 +206,7 @@ std::string FrameTypeString(uint8_t frame_type, uint8_t flags) {
 }
 }  // namespace
 
-absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
+std::variant<size_t, absl::Status> grpc_chttp2_perform_read(
     grpc_chttp2_transport* t, const grpc_slice& slice,
     size_t& requests_started) {
   GRPC_LATENT_SEE_INNER_SCOPE("grpc_chttp2_perform_read");
@@ -268,7 +268,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         t->deframe_state = GRPC_DTS_FH_0;
         return static_cast<size_t>(cur - beg);
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FH_0:
       DCHECK_LT(cur, end);
       t->incoming_frame_size = (static_cast<uint32_t>(*cur)) << 16;
@@ -276,7 +276,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         t->deframe_state = GRPC_DTS_FH_1;
         return absl::OkStatus();
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FH_1:
       DCHECK_LT(cur, end);
       t->incoming_frame_size |= (static_cast<uint32_t>(*cur)) << 8;
@@ -284,7 +284,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         t->deframe_state = GRPC_DTS_FH_2;
         return absl::OkStatus();
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FH_2:
       DCHECK_LT(cur, end);
       t->incoming_frame_size |= *cur;
@@ -292,7 +292,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         t->deframe_state = GRPC_DTS_FH_3;
         return absl::OkStatus();
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FH_3:
       DCHECK_LT(cur, end);
       t->incoming_frame_type = *cur;
@@ -300,7 +300,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         t->deframe_state = GRPC_DTS_FH_4;
         return absl::OkStatus();
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FH_4:
       DCHECK_LT(cur, end);
       t->incoming_frame_flags = *cur;
@@ -308,7 +308,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         t->deframe_state = GRPC_DTS_FH_5;
         return absl::OkStatus();
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FH_5:
       DCHECK_LT(cur, end);
       t->incoming_stream_id = ((static_cast<uint32_t>(*cur)) & 0x7f) << 24;
@@ -316,7 +316,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         t->deframe_state = GRPC_DTS_FH_6;
         return absl::OkStatus();
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FH_6:
       DCHECK_LT(cur, end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur)) << 16;
@@ -324,7 +324,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         t->deframe_state = GRPC_DTS_FH_7;
         return absl::OkStatus();
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FH_7:
       DCHECK_LT(cur, end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur)) << 8;
@@ -332,7 +332,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
         t->deframe_state = GRPC_DTS_FH_8;
         return absl::OkStatus();
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FH_8:
       DCHECK_LT(cur, end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur));
@@ -366,7 +366,7 @@ absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
       if (++cur == end) {
         return absl::OkStatus();
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case GRPC_DTS_FRAME:
       DCHECK_LT(cur, end);
       if (static_cast<uint32_t>(end - cur) == t->incoming_frame_size) {
@@ -960,8 +960,8 @@ grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
     s->call_tracer_wrapper.RecordIncomingBytes(
         {0, 0, GRPC_SLICE_LENGTH(slice)});
     call_tracer =
-        grpc_core::IsCallTracerInTransportEnabled()
-            ? s->arena->GetContext<grpc_core::CallTracerInterface>()
+        grpc_core::IsCallTracerTransportFixEnabled()
+            ? s->CallTracer()
             : s->arena->GetContext<grpc_core::CallTracerAnnotationInterface>();
   }
   grpc_error_handle error = parser->Parse(

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

@@ -18,9 +18,9 @@
 #include <grpc/support/port_platform.h>
 
 #include <algorithm>
+#include <optional>
 
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
 
 namespace grpc_core {
 

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

@@ -89,14 +89,14 @@ void Chttp2PingCallbacks::CancelAll(
   ping_requested_ = false;
 }
 
-absl::optional<uint64_t> Chttp2PingCallbacks::OnPingTimeout(
+std::optional<uint64_t> Chttp2PingCallbacks::OnPingTimeout(
     Duration ping_timeout,
     grpc_event_engine::experimental::EventEngine* event_engine,
     Callback callback) {
   CHECK(started_new_ping_without_setting_timeout_);
   started_new_ping_without_setting_timeout_ = false;
   auto it = inflight_.find(most_recent_inflight_);
-  if (it == inflight_.end()) return absl::nullopt;
+  if (it == inflight_.end()) return std::nullopt;
   it->second.on_timeout =
       event_engine->RunAfter(ping_timeout, std::move(callback));
   return most_recent_inflight_;

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

@@ -21,13 +21,13 @@
 #include <stdint.h>
 
 #include <algorithm>
+#include <optional>
 #include <vector>
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/hash/hash.h"
 #include "absl/random/bit_gen_ref.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/util/time.h"
 
@@ -85,7 +85,7 @@ class Chttp2PingCallbacks {
   // Clears started_new_ping_without_setting_timeout.
   // Returns the ping id of the ping the timeout was attached to if a timer was
   // started, or nullopt otherwise.
-  absl::optional<uint64_t> OnPingTimeout(
+  std::optional<uint64_t> OnPingTimeout(
       Duration ping_timeout,
       grpc_event_engine::experimental::EventEngine* event_engine,
       Callback callback);

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

@@ -18,10 +18,10 @@
 #include <grpc/support/port_platform.h>
 
 #include <algorithm>
+#include <optional>
 #include <ostream>
 
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/util/match.h"
 
@@ -36,7 +36,7 @@ namespace grpc_core {
 namespace {
 int g_default_max_pings_without_data_sent = 2;
 constexpr Duration kThrottleIntervalWithoutDataSent = Duration::Minutes(1);
-absl::optional<int> g_default_max_inflight_pings;
+std::optional<int> g_default_max_inflight_pings;
 }  // namespace
 
 Chttp2PingRatePolicy::Chttp2PingRatePolicy(const ChannelArgs& args,

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

@@ -20,8 +20,8 @@
 
 #include <iosfwd>
 #include <string>
+#include <variant>
 
-#include "absl/types/variant.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/util/time.h"
 
@@ -49,7 +49,7 @@ class Chttp2PingRatePolicy {
     }
   };
   using RequestSendPingResult =
-      absl::variant<SendGranted, TooManyRecentPings, TooSoon>;
+      std::variant<SendGranted, TooManyRecentPings, TooSoon>;
 
   // Request that one ping be sent.
   // Returns:

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

@@ -128,26 +128,6 @@ static void stream_list_add_tail(grpc_chttp2_transport* t,
       << "]: add to " << stream_list_id_string(id);
 }
 
-static void stream_list_add_head(grpc_chttp2_transport* t,
-                                 grpc_chttp2_stream* s,
-                                 grpc_chttp2_stream_list_id id) {
-  grpc_chttp2_stream* old_head;
-  CHECK(!s->included.is_set(id));
-  old_head = t->lists[id].head;
-  s->links[id].next = old_head;
-  s->links[id].prev = nullptr;
-  if (old_head) {
-    old_head->links[id].prev = s;
-  } else {
-    t->lists[id].tail = s;
-  }
-  t->lists[id].head = s;
-  s->included.set(id);
-  GRPC_TRACE_LOG(http2_stream_state, INFO)
-      << t << "[" << s->id << "][" << (t->is_client ? "cli" : "svr")
-      << "]: add to " << stream_list_id_string(id);
-}
-
 static bool stream_list_add(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
                             grpc_chttp2_stream_list_id id) {
   if (s->included.is_set(id)) {
@@ -157,24 +137,11 @@ static bool stream_list_add(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
   return true;
 }
 
-static bool stream_list_prepend(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
-                                grpc_chttp2_stream_list_id id) {
-  if (s->included.is_set(id)) {
-    return false;
-  }
-  stream_list_add_head(t, s, id);
-  return true;
-}
-
 // wrappers for specializations
 
 bool grpc_chttp2_list_add_writable_stream(grpc_chttp2_transport* t,
                                           grpc_chttp2_stream* s) {
   CHECK_NE(s->id, 0u);
-  if (grpc_core::IsPrioritizeFinishedRequestsEnabled() &&
-      s->send_trailing_metadata != nullptr) {
-    return stream_list_prepend(t, s, GRPC_CHTTP2_LIST_WRITABLE);
-  }
   return stream_list_add(t, s, GRPC_CHTTP2_LIST_WRITABLE);
 }
 
@@ -219,12 +186,7 @@ void grpc_chttp2_list_remove_waiting_for_concurrency(grpc_chttp2_transport* t,
 
 void grpc_chttp2_list_add_stalled_by_transport(grpc_chttp2_transport* t,
                                                grpc_chttp2_stream* s) {
-  if (grpc_core::IsPrioritizeFinishedRequestsEnabled() &&
-      s->send_trailing_metadata != nullptr) {
-    stream_list_prepend(t, s, GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT);
-  } else {
-    stream_list_add(t, s, GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT);
-  }
+  stream_list_add(t, s, GRPC_CHTTP2_LIST_STALLED_BY_TRANSPORT);
 }
 
 bool grpc_chttp2_list_pop_stalled_by_transport(grpc_chttp2_transport* t,

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

@@ -42,16 +42,16 @@ void VarintWriteTail(size_t tail_value, uint8_t* target, size_t tail_length) {
   switch (tail_length) {
     case 5:
       target[4] = static_cast<uint8_t>((tail_value >> 28) | 0x80);
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case 4:
       target[3] = static_cast<uint8_t>((tail_value >> 21) | 0x80);
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case 3:
       target[2] = static_cast<uint8_t>((tail_value >> 14) | 0x80);
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case 2:
       target[1] = static_cast<uint8_t>((tail_value >> 7) | 0x80);
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case 1:
       target[0] = static_cast<uint8_t>((tail_value) | 0x80);
   }