grpc 1.70.1 → 1.71.0

data/src/core/lib/channel/promise_based_filter.cc

@@ -494,7 +494,7 @@ void BaseCallData::SendMessage::WakeInsideCombiner(Flusher* flusher,
       } else {
         break;
       }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case State::kPushedToPipe: {
       CHECK(push_.has_value());
       auto r_push = (*push_)();
@@ -824,7 +824,7 @@ void BaseCallData::ReceiveMessage::WakeInsideCombiner(Flusher* flusher,
       }
       CHECK(state_ == State::kPushedToPipe ||
             state_ == State::kCompletedWhilePushedToPipe);
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case State::kCompletedWhilePushedToPipe:
     case State::kPushedToPipe: {
       CHECK(push_.has_value());
@@ -852,7 +852,7 @@ void BaseCallData::ReceiveMessage::WakeInsideCombiner(Flusher* flusher,
             state_ = State::kPulledFromPipe;
           }
         } else {
-          *intercepted_slice_buffer_ = absl::nullopt;
+          *intercepted_slice_buffer_ = std::nullopt;
           *intercepted_flags_ = 0;
           state_ = State::kCancelled;
           flusher->AddClosure(
@@ -871,7 +871,7 @@ void BaseCallData::ReceiveMessage::WakeInsideCombiner(Flusher* flusher,
         break;
       }
     }
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case State::kCompletedWhilePulledFromPipe:
     case State::kPulledFromPipe: {
       CHECK(push_.has_value());
@@ -926,8 +926,8 @@ struct ClientCallData::RecvInitialMetadata final {
   grpc_closure on_ready;
   grpc_metadata_batch* metadata = nullptr;
   PipeSender<ServerMetadataHandle>* server_initial_metadata_publisher = nullptr;
-  absl::optional<PipeSender<ServerMetadataHandle>::PushType> metadata_push_;
-  absl::optional<PipeReceiverNextType<ServerMetadataHandle>> metadata_next_;
+  std::optional<PipeSender<ServerMetadataHandle>::PushType> metadata_push_;
+  std::optional<PipeReceiverNextType<ServerMetadataHandle>> metadata_next_;
 
   static const char* StateString(State state) {
     switch (state) {
@@ -1038,7 +1038,7 @@ class ClientCallData::PollContext {
           repoll_ = true;  // ensure Push() gets polled.
           self_->recv_initial_metadata_->metadata_next_.emplace(
               self_->server_initial_metadata_pipe()->receiver.Next());
-          ABSL_FALLTHROUGH_INTENDED;
+          [[fallthrough]];
         case RecvInitialMetadata::kCompleteAndPushedToPipe: {
           CHECK(self_->recv_initial_metadata_->metadata_next_.has_value());
           Poll<NextResult<ServerMetadataHandle>> p =
@@ -1822,8 +1822,8 @@ struct ServerCallData::SendInitialMetadata {
   State state = kInitial;
   CapturedBatch batch;
   PipeSender<ServerMetadataHandle>* server_initial_metadata_publisher = nullptr;
-  absl::optional<PipeSender<ServerMetadataHandle>::PushType> metadata_push_;
-  absl::optional<PipeReceiverNextType<ServerMetadataHandle>> metadata_next_;
+  std::optional<PipeSender<ServerMetadataHandle>::PushType> metadata_push_;
+  std::optional<PipeReceiverNextType<ServerMetadataHandle>> metadata_next_;
 
   static const char* StateString(State state) {
     switch (state) {

data/src/core/lib/channel/promise_based_filter.h

@@ -28,6 +28,7 @@
 #include <atomic>
 #include <memory>
 #include <new>
+#include <optional>
 #include <string>
 #include <type_traits>
 #include <utility>
@@ -39,7 +40,6 @@
 #include "absl/meta/type_traits.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/filter/blackboard.h"
 #include "src/core/filter/filter_args.h"
 #include "src/core/lib/channel/call_finalization.h"
@@ -158,50 +158,6 @@ inline constexpr bool CallHasAsyncErrorInterceptor() {
                                   &Derived::Call::OnServerToClientMessage);
 }
 
-// Determine if an interceptor needs to access the channel via one of its
-// arguments. If so, we need to allocate a pointer to the channel for the
-// generated polyfill promise for the original promise stack.
-
-inline constexpr bool HasChannelAccess() { return false; }
-
-inline constexpr bool HasChannelAccess(const NoInterceptor*) { return false; }
-
-template <typename T, typename R, typename A>
-inline constexpr bool HasChannelAccess(R (T::*)(A)) {
-  return false;
-}
-
-template <typename T, typename R, typename A>
-inline constexpr bool HasChannelAccess(R (T::*)()) {
-  return false;
-}
-
-template <typename T, typename R, typename A, typename C>
-inline constexpr bool HasChannelAccess(R (T::*)(A, C)) {
-  return true;
-}
-
-// For the list case we do two interceptors to avoid amiguities with the single
-// argument forms above.
-template <typename I1, typename I2, typename... Interceptors>
-inline constexpr bool HasChannelAccess(I1 i1, I2 i2,
-                                       Interceptors... interceptors) {
-  return HasChannelAccess(i1) || HasChannelAccess(i2) ||
-         HasChannelAccess(interceptors...);
-}
-
-// Composite for a given channel type to determine if any of its interceptors
-// fall into this category: later code should use this.
-template <typename Derived>
-inline constexpr bool CallHasChannelAccess() {
-  return HasChannelAccess(&Derived::Call::OnClientInitialMetadata,
-                          &Derived::Call::OnClientToServerMessage,
-                          &Derived::Call::OnServerInitialMetadata,
-                          &Derived::Call::OnServerToClientMessage,
-                          &Derived::Call::OnServerTrailingMetadata,
-                          &Derived::Call::OnFinalize);
-}
-
 // Given a boolean X export a type:
 // either T if X is true
 // or an empty type if it is false
@@ -275,8 +231,8 @@ struct FilterCallData {
                         CallHasAsyncErrorInterceptor<Derived>()>::Type
       error_latch;
   GPR_NO_UNIQUE_ADDRESS
-  typename TypeIfNeeded<Derived*, CallHasChannelAccess<Derived>()>::Type
-      channel;
+  typename TypeIfNeeded<
+      Derived*, filters_detail::CallHasChannelAccess<Derived>()>::Type channel;
 };
 
 template <typename Promise>
@@ -442,6 +398,26 @@ struct RunCallImpl<
   }
 };
 
+template <typename Derived, typename Promise>
+struct RunCallImpl<
+    Promise (Derived::Call::*)(ClientMetadataHandle md, Derived* channel),
+    Derived,
+    std::enable_if_t<std::is_same_v<absl::StatusOr<ClientMetadataHandle>,
+                                    PromiseResult<Promise>>>> {
+  static auto Run(CallArgs call_args, NextPromiseFactory next_promise_factory,
+                  FilterCallData<Derived>* call_data) {
+    ClientMetadataHandle md = std::move(call_args.client_initial_metadata);
+    return TrySeq(call_data->call.OnClientInitialMetadata(std::move(md),
+                                                          call_data->channel),
+                  [call_args = std::move(call_args),
+                   next_promise_factory = std::move(next_promise_factory)](
+                      ClientMetadataHandle md) mutable {
+                    call_args.client_initial_metadata = std::move(md);
+                    return next_promise_factory(std::move(call_args));
+                  });
+  }
+};
+
 template <typename Interceptor, typename Derived>
 auto RunCall(Interceptor interceptor, CallArgs call_args,
              NextPromiseFactory next_promise_factory,
@@ -456,7 +432,7 @@ inline auto InterceptClientToServerMessageHandler(
     void (Derived::Call::*fn)(const Message&),
     FilterCallData<Derived>* call_data, const CallArgs&) {
   DCHECK(fn == &Derived::Call::OnClientToServerMessage);
-  return [call_data](MessageHandle msg) -> absl::optional<MessageHandle> {
+  return [call_data](MessageHandle msg) -> std::optional<MessageHandle> {
     call_data->call.OnClientToServerMessage(*msg);
     return std::move(msg);
   };
@@ -467,12 +443,12 @@ inline auto InterceptClientToServerMessageHandler(
     ServerMetadataHandle (Derived::Call::*fn)(const Message&),
     FilterCallData<Derived>* call_data, const CallArgs&) {
   DCHECK(fn == &Derived::Call::OnClientToServerMessage);
-  return [call_data](MessageHandle msg) -> absl::optional<MessageHandle> {
+  return [call_data](MessageHandle msg) -> std::optional<MessageHandle> {
     auto return_md = call_data->call.OnClientToServerMessage(*msg);
     if (return_md == nullptr) return std::move(msg);
-    if (call_data->error_latch.is_set()) return absl::nullopt;
+    if (call_data->error_latch.is_set()) return std::nullopt;
     call_data->error_latch.Set(std::move(return_md));
-    return absl::nullopt;
+    return std::nullopt;
   };
 }
 
@@ -481,13 +457,24 @@ inline auto InterceptClientToServerMessageHandler(
     ServerMetadataHandle (Derived::Call::*fn)(const Message&, Derived*),
     FilterCallData<Derived>* call_data, const CallArgs&) {
   DCHECK(fn == &Derived::Call::OnClientToServerMessage);
-  return [call_data](MessageHandle msg) -> absl::optional<MessageHandle> {
+  return [call_data](MessageHandle msg) -> std::optional<MessageHandle> {
     auto return_md =
         call_data->call.OnClientToServerMessage(*msg, call_data->channel);
     if (return_md == nullptr) return std::move(msg);
-    if (call_data->error_latch.is_set()) return absl::nullopt;
+    if (call_data->error_latch.is_set()) return std::nullopt;
     call_data->error_latch.Set(std::move(return_md));
-    return absl::nullopt;
+    return std::nullopt;
+  };
+}
+
+template <typename Derived>
+inline auto InterceptClientToServerMessageHandler(
+    void (Derived::Call::*fn)(const Message&, Derived*),
+    FilterCallData<Derived>* call_data, const CallArgs&) {
+  DCHECK(fn == &Derived::Call::OnClientToServerMessage);
+  return [call_data](MessageHandle msg) -> std::optional<MessageHandle> {
+    call_data->call.OnClientToServerMessage(*msg, call_data->channel);
+    return std::move(msg);
   };
 }
 
@@ -496,7 +483,7 @@ inline auto InterceptClientToServerMessageHandler(
     MessageHandle (Derived::Call::*fn)(MessageHandle, Derived*),
     FilterCallData<Derived>* call_data, const CallArgs&) {
   DCHECK(fn == &Derived::Call::OnClientToServerMessage);
-  return [call_data](MessageHandle msg) -> absl::optional<MessageHandle> {
+  return [call_data](MessageHandle msg) -> std::optional<MessageHandle> {
     return call_data->call.OnClientToServerMessage(std::move(msg),
                                                    call_data->channel);
   };
@@ -507,13 +494,13 @@ inline auto InterceptClientToServerMessageHandler(
     absl::StatusOr<MessageHandle> (Derived::Call::*fn)(MessageHandle, Derived*),
     FilterCallData<Derived>* call_data, const CallArgs&) {
   DCHECK(fn == &Derived::Call::OnClientToServerMessage);
-  return [call_data](MessageHandle msg) -> absl::optional<MessageHandle> {
+  return [call_data](MessageHandle msg) -> std::optional<MessageHandle> {
     auto r = call_data->call.OnClientToServerMessage(std::move(msg),
                                                      call_data->channel);
     if (r.ok()) return std::move(*r);
-    if (call_data->error_latch.is_set()) return absl::nullopt;
+    if (call_data->error_latch.is_set()) return std::nullopt;
     call_data->error_latch.Set(ServerMetadataFromStatus(r.status()));
-    return absl::nullopt;
+    return std::nullopt;
   };
 }
 
@@ -565,11 +552,11 @@ inline void InterceptServerInitialMetadata(
   DCHECK(fn == &Derived::Call::OnServerInitialMetadata);
   call_args.server_initial_metadata->InterceptAndMap(
       [call_data](
-          ServerMetadataHandle md) -> absl::optional<ServerMetadataHandle> {
+          ServerMetadataHandle md) -> std::optional<ServerMetadataHandle> {
         auto status = call_data->call.OnServerInitialMetadata(*md);
         if (!status.ok() && !call_data->error_latch.is_set()) {
           call_data->error_latch.Set(ServerMetadataFromStatus(status));
-          return absl::nullopt;
+          return std::nullopt;
         }
         return std::move(md);
       });
@@ -594,12 +581,12 @@ inline void InterceptServerInitialMetadata(
   DCHECK(fn == &Derived::Call::OnServerInitialMetadata);
   call_args.server_initial_metadata->InterceptAndMap(
       [call_data](
-          ServerMetadataHandle md) -> absl::optional<ServerMetadataHandle> {
+          ServerMetadataHandle md) -> std::optional<ServerMetadataHandle> {
         auto status =
             call_data->call.OnServerInitialMetadata(*md, call_data->channel);
         if (!status.ok() && !call_data->error_latch.is_set()) {
           call_data->error_latch.Set(ServerMetadataFromStatus(status));
-          return absl::nullopt;
+          return std::nullopt;
         }
         return std::move(md);
       });
@@ -614,7 +601,7 @@ inline void InterceptServerToClientMessage(
     FilterCallData<Derived>* call_data, const CallArgs& call_args) {
   DCHECK(fn == &Derived::Call::OnServerToClientMessage);
   call_args.server_to_client_messages->InterceptAndMap(
-      [call_data](MessageHandle msg) -> absl::optional<MessageHandle> {
+      [call_data](MessageHandle msg) -> std::optional<MessageHandle> {
         call_data->call.OnServerToClientMessage(*msg);
         return std::move(msg);
       });
@@ -626,12 +613,24 @@ inline void InterceptServerToClientMessage(
     FilterCallData<Derived>* call_data, const CallArgs& call_args) {
   DCHECK(fn == &Derived::Call::OnServerToClientMessage);
   call_args.server_to_client_messages->InterceptAndMap(
-      [call_data](MessageHandle msg) -> absl::optional<MessageHandle> {
+      [call_data](MessageHandle msg) -> std::optional<MessageHandle> {
         auto return_md = call_data->call.OnServerToClientMessage(*msg);
         if (return_md == nullptr) return std::move(msg);
-        if (call_data->error_latch.is_set()) return absl::nullopt;
+        if (call_data->error_latch.is_set()) return std::nullopt;
         call_data->error_latch.Set(std::move(return_md));
-        return absl::nullopt;
+        return std::nullopt;
+      });
+}
+
+template <typename Derived>
+inline void InterceptServerToClientMessage(
+    void (Derived::Call::*fn)(const Message&, Derived*),
+    FilterCallData<Derived>* call_data, const CallArgs& call_args) {
+  DCHECK(fn == &Derived::Call::OnServerToClientMessage);
+  call_args.server_to_client_messages->InterceptAndMap(
+      [call_data](MessageHandle msg) -> std::optional<MessageHandle> {
+        call_data->call.OnServerToClientMessage(*msg, call_data->channel);
+        return std::move(msg);
       });
 }
 
@@ -641,13 +640,13 @@ inline void InterceptServerToClientMessage(
     FilterCallData<Derived>* call_data, const CallArgs& call_args) {
   DCHECK(fn == &Derived::Call::OnServerToClientMessage);
   call_args.server_to_client_messages->InterceptAndMap(
-      [call_data](MessageHandle msg) -> absl::optional<MessageHandle> {
+      [call_data](MessageHandle msg) -> std::optional<MessageHandle> {
         auto return_md =
             call_data->call.OnServerToClientMessage(*msg, call_data->channel);
         if (return_md == nullptr) return std::move(msg);
-        if (call_data->error_latch.is_set()) return absl::nullopt;
+        if (call_data->error_latch.is_set()) return std::nullopt;
         call_data->error_latch.Set(std::move(return_md));
-        return absl::nullopt;
+        return std::nullopt;
       });
 }
 
@@ -657,7 +656,7 @@ inline void InterceptServerToClientMessage(
     FilterCallData<Derived>* call_data, const CallArgs& call_args) {
   DCHECK(fn == &Derived::Call::OnServerToClientMessage);
   call_args.server_to_client_messages->InterceptAndMap(
-      [call_data](MessageHandle msg) -> absl::optional<MessageHandle> {
+      [call_data](MessageHandle msg) -> std::optional<MessageHandle> {
         return call_data->call.OnServerToClientMessage(std::move(msg),
                                                        call_data->channel);
       });
@@ -669,13 +668,13 @@ inline void InterceptServerToClientMessage(
     FilterCallData<Derived>* call_data, const CallArgs& call_args) {
   DCHECK(fn == &Derived::Call::OnServerToClientMessage);
   call_args.server_to_client_messages->InterceptAndMap(
-      [call_data](MessageHandle msg) -> absl::optional<MessageHandle> {
+      [call_data](MessageHandle msg) -> std::optional<MessageHandle> {
         auto r = call_data->call.OnServerToClientMessage(std::move(msg),
                                                          call_data->channel);
         if (r.ok()) return std::move(*r);
-        if (call_data->error_latch.is_set()) return absl::nullopt;
+        if (call_data->error_latch.is_set()) return std::nullopt;
         call_data->error_latch.Set(ServerMetadataFromStatus(r.status()));
-        return absl::nullopt;
+        return std::nullopt;
       });
 }
 
@@ -739,7 +738,7 @@ MakeFilterCall(Derived* derived) {
 // the call lifecycle.
 // The type of these members matters, and is selectable by the class
 // author. For $INTERCEPTOR_NAME in the above list:
-// - static const NoInterceptor $INTERCEPTOR_NAME:
+// - static inline const NoInterceptor $INTERCEPTOR_NAME:
 //   defines that this filter does not intercept this event.
 //   there is zero runtime cost added to handling that event by this filter.
 // - void $INTERCEPTOR_NAME($VALUE_TYPE&):
@@ -771,7 +770,7 @@ MakeFilterCall(Derived* derived) {
 // relevant return type listed above.
 // Finally, OnFinalize can be added to intecept call finalization.
 // It must have one of the signatures:
-// - static const NoInterceptor OnFinalize:
+// - static inline const NoInterceptor OnFinalize:
 //   the filter does not intercept call finalization.
 // - void OnFinalize(const grpc_call_final_info*):
 //   the filter intercepts call finalization.
@@ -1098,8 +1097,8 @@ class BaseCallData : public Activity, private Wakeable {
     BaseCallData* const base_;
     State state_ = State::kInitial;
     Interceptor* const interceptor_;
-    absl::optional<PipeSender<MessageHandle>::PushType> push_;
-    absl::optional<PipeReceiverNextType<MessageHandle>> next_;
+    std::optional<PipeSender<MessageHandle>::PushType> push_;
+    std::optional<PipeReceiverNextType<MessageHandle>> next_;
     CapturedBatch batch_;
     grpc_closure* intercepted_on_complete_;
     grpc_closure on_complete_ =
@@ -1197,10 +1196,10 @@ class BaseCallData : public Activity, private Wakeable {
     Interceptor* const interceptor_;
     State state_ = State::kInitial;
     uint32_t scratch_flags_;
-    absl::optional<SliceBuffer>* intercepted_slice_buffer_;
+    std::optional<SliceBuffer>* intercepted_slice_buffer_;
     uint32_t* intercepted_flags_;
-    absl::optional<PipeSender<MessageHandle>::PushType> push_;
-    absl::optional<PipeReceiverNextType<MessageHandle>> next_;
+    std::optional<PipeSender<MessageHandle>::PushType> push_;
+    std::optional<PipeReceiverNextType<MessageHandle>> next_;
     absl::Status completed_status_;
     grpc_closure* intercepted_on_complete_;
     grpc_closure on_complete_ =

data/src/core/lib/compression/compression.cc

@@ -23,7 +23,8 @@
 #include <stdint.h>
 #include <string.h>
 
-#include "absl/types/optional.h"
+#include <optional>
+
 #include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -39,7 +40,7 @@ int grpc_compression_algorithm_is_stream(grpc_compression_algorithm) {
 
 int grpc_compression_algorithm_parse(grpc_slice name,
                                      grpc_compression_algorithm* algorithm) {
-  absl::optional<grpc_compression_algorithm> alg =
+  std::optional<grpc_compression_algorithm> alg =
       grpc_core::ParseCompressionAlgorithm(
           grpc_core::StringViewFromSlice(name));
   if (alg.has_value()) {

data/src/core/lib/compression/compression_internal.cc

@@ -93,7 +93,7 @@ class CommaSeparatedLists {
 const CommaSeparatedLists kCommaSeparatedLists;
 }  // namespace
 
-absl::optional<grpc_compression_algorithm> ParseCompressionAlgorithm(
+std::optional<grpc_compression_algorithm> ParseCompressionAlgorithm(
     absl::string_view algorithm) {
   if (algorithm == "identity") {
     return GRPC_COMPRESS_NONE;
@@ -102,7 +102,7 @@ absl::optional<grpc_compression_algorithm> ParseCompressionAlgorithm(
   } else if (algorithm == "gzip") {
     return GRPC_COMPRESS_GZIP;
   } else {
-    return absl::nullopt;
+    return std::nullopt;
   }
 }
 
@@ -222,10 +222,10 @@ uint32_t CompressionAlgorithmSet::ToLegacyBitmask() const {
   return set_.ToInt<uint32_t>();
 }
 
-absl::optional<grpc_compression_algorithm>
+std::optional<grpc_compression_algorithm>
 DefaultCompressionAlgorithmFromChannelArgs(const ChannelArgs& args) {
   auto* value = args.Get(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM);
-  if (value == nullptr) return absl::nullopt;
+  if (value == nullptr) return std::nullopt;
   auto ival = value->GetIfInt();
   if (ival.has_value()) {
     return static_cast<grpc_compression_algorithm>(*ival);
@@ -234,7 +234,7 @@ DefaultCompressionAlgorithmFromChannelArgs(const ChannelArgs& args) {
   if (sval != nullptr) {
     return ParseCompressionAlgorithm(sval->as_string_view());
   }
-  return absl::nullopt;
+  return std::nullopt;
 }
 
 grpc_compression_options CompressionOptionsFromChannelArgs(
@@ -245,10 +245,10 @@ grpc_compression_options CompressionOptionsFromChannelArgs(
   auto default_level = args.GetInt(GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL);
   if (default_level.has_value()) {
     compression_options.default_level.is_set = true;
-    compression_options.default_level.level = Clamp(
-        static_cast<grpc_compression_level>(*default_level),
-        GRPC_COMPRESS_LEVEL_NONE,
-        static_cast<grpc_compression_level>(GRPC_COMPRESS_LEVEL_COUNT - 1));
+    compression_options.default_level.level =
+        static_cast<grpc_compression_level>(
+            Clamp(*default_level, static_cast<int>(GRPC_COMPRESS_LEVEL_NONE),
+                  static_cast<int>(GRPC_COMPRESS_LEVEL_COUNT - 1)));
   }
   auto default_algorithm =
       args.GetInt(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM);

data/src/core/lib/compression/compression_internal.h

@@ -24,9 +24,9 @@
 #include <stdint.h>
 
 #include <initializer_list>
+#include <optional>
 
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/util/bitset.h"
@@ -35,14 +35,14 @@ namespace grpc_core {
 
 // Given a string naming a compression algorithm, return the corresponding enum
 // or nullopt on error.
-absl::optional<grpc_compression_algorithm> ParseCompressionAlgorithm(
+std::optional<grpc_compression_algorithm> ParseCompressionAlgorithm(
     absl::string_view algorithm);
 // Convert a compression algorithm to a string. Returns nullptr if a name is not
 // known.
 const char* CompressionAlgorithmAsString(grpc_compression_algorithm algorithm);
 // Retrieve the default compression algorithm from channel args, return nullopt
 // if not found.
-absl::optional<grpc_compression_algorithm>
+std::optional<grpc_compression_algorithm>
 DefaultCompressionAlgorithmFromChannelArgs(const ChannelArgs& args);
 
 // A set of grpc_compression_algorithm values.

data/src/core/lib/debug/trace_flags.cc

@@ -26,6 +26,8 @@ DebugOnlyTraceFlag auth_context_refcount_trace(false, "auth_context_refcount");
 DebugOnlyTraceFlag call_combiner_trace(false, "call_combiner");
 DebugOnlyTraceFlag call_refcount_trace(false, "call_refcount");
 DebugOnlyTraceFlag call_state_trace(false, "call_state");
+DebugOnlyTraceFlag chttp2_server_refcount_trace(false,
+                                                "chttp2_server_refcount");
 DebugOnlyTraceFlag closure_trace(false, "closure");
 DebugOnlyTraceFlag combiner_trace(false, "combiner");
 DebugOnlyTraceFlag cq_refcount_trace(false, "cq_refcount");
@@ -125,7 +127,6 @@ TraceFlag xds_cluster_manager_lb_trace(false, "xds_cluster_manager_lb");
 TraceFlag xds_override_host_lb_trace(false, "xds_override_host_lb");
 TraceFlag xds_resolver_trace(false, "xds_resolver");
 TraceFlag xds_server_config_fetcher_trace(false, "xds_server_config_fetcher");
-TraceFlag xds_unittest_trace(true, "xds_unittest");
 TraceFlag xds_wrr_locality_lb_trace(false, "xds_wrr_locality_lb");
 
 const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags() {
@@ -210,13 +211,13 @@ const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags() {
           {"xds_override_host_lb", &xds_override_host_lb_trace},
           {"xds_resolver", &xds_resolver_trace},
           {"xds_server_config_fetcher", &xds_server_config_fetcher_trace},
-          {"xds_unittest", &xds_unittest_trace},
           {"xds_wrr_locality_lb", &xds_wrr_locality_lb_trace},
 #ifndef NDEBUG
           {"auth_context_refcount", &auth_context_refcount_trace},
           {"call_combiner", &call_combiner_trace},
           {"call_refcount", &call_refcount_trace},
           {"call_state", &call_state_trace},
+          {"chttp2_server_refcount", &chttp2_server_refcount_trace},
           {"closure", &closure_trace},
           {"combiner", &combiner_trace},
           {"cq_refcount", &cq_refcount_trace},

data/src/core/lib/debug/trace_flags.h

@@ -27,6 +27,7 @@ extern DebugOnlyTraceFlag auth_context_refcount_trace;
 extern DebugOnlyTraceFlag call_combiner_trace;
 extern DebugOnlyTraceFlag call_refcount_trace;
 extern DebugOnlyTraceFlag call_state_trace;
+extern DebugOnlyTraceFlag chttp2_server_refcount_trace;
 extern DebugOnlyTraceFlag closure_trace;
 extern DebugOnlyTraceFlag combiner_trace;
 extern DebugOnlyTraceFlag cq_refcount_trace;
@@ -124,7 +125,6 @@ extern TraceFlag xds_cluster_manager_lb_trace;
 extern TraceFlag xds_override_host_lb_trace;
 extern TraceFlag xds_resolver_trace;
 extern TraceFlag xds_server_config_fetcher_trace;
-extern TraceFlag xds_unittest_trace;
 extern TraceFlag xds_wrr_locality_lb_trace;
 
 }  // namespace grpc_core

data/src/core/lib/event_engine/ares_resolver.cc

@@ -48,6 +48,7 @@
 #include <algorithm>
 #include <chrono>
 #include <memory>
+#include <optional>
 #include <type_traits>
 #include <utility>
 
@@ -59,7 +60,6 @@
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
-#include "absl/types/optional.h"
 #include "src/core/config/config_vars.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -76,8 +76,7 @@
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 #endif
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 namespace {
 
@@ -667,9 +666,9 @@ void AresResolver::OnHostbynameDoneLocked(void* arg, int status,
     auto nh =
         ares_resolver->callback_map_.extract(hostname_qa->callback_map_id);
     CHECK(!nh.empty());
-    CHECK(absl::holds_alternative<
+    CHECK(std::holds_alternative<
           EventEngine::DNSResolver::LookupHostnameCallback>(nh.mapped()));
-    auto callback = absl::get<EventEngine::DNSResolver::LookupHostnameCallback>(
+    auto callback = std::get<EventEngine::DNSResolver::LookupHostnameCallback>(
         std::move(nh.mapped()));
     if (!hostname_qa->result.empty() || hostname_qa->error_status.ok()) {
       ares_resolver->event_engine_->Run(
@@ -694,9 +693,9 @@ void AresResolver::OnSRVQueryDoneLocked(void* arg, int status, int /*timeouts*/,
   auto* ares_resolver = qa->ares_resolver;
   auto nh = ares_resolver->callback_map_.extract(qa->callback_map_id);
   CHECK(!nh.empty());
-  CHECK(absl::holds_alternative<EventEngine::DNSResolver::LookupSRVCallback>(
+  CHECK(std::holds_alternative<EventEngine::DNSResolver::LookupSRVCallback>(
       nh.mapped()));
-  auto callback = absl::get<EventEngine::DNSResolver::LookupSRVCallback>(
+  auto callback = std::get<EventEngine::DNSResolver::LookupSRVCallback>(
       std::move(nh.mapped()));
   auto fail = [&](absl::string_view prefix) {
     std::string error_message = absl::StrFormat(
@@ -755,9 +754,9 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
   auto* ares_resolver = qa->ares_resolver;
   auto nh = ares_resolver->callback_map_.extract(qa->callback_map_id);
   CHECK(!nh.empty());
-  CHECK(absl::holds_alternative<EventEngine::DNSResolver::LookupTXTCallback>(
+  CHECK(std::holds_alternative<EventEngine::DNSResolver::LookupTXTCallback>(
       nh.mapped()));
-  auto callback = absl::get<EventEngine::DNSResolver::LookupTXTCallback>(
+  auto callback = std::get<EventEngine::DNSResolver::LookupTXTCallback>(
       std::move(nh.mapped()));
   auto fail = [&](absl::string_view prefix) {
     std::string error_message = absl::StrFormat(
@@ -810,8 +809,7 @@ void AresResolver::OnTXTDoneLocked(void* arg, int status, int /*timeouts*/,
       });
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 void noop_inject_channel_config(ares_channel* /*channel*/) {}
 

data/src/core/lib/event_engine/ares_resolver.h

@@ -33,15 +33,12 @@
 #include "absl/container/flat_hash_map.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "src/core/lib/event_engine/grpc_polled_fd.h"
 #include "src/core/lib/event_engine/ref_counted_dns_resolver_interface.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/sync.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 class AresResolver : public RefCountedDNSResolverInterface {
  public:
@@ -89,9 +86,9 @@ class AresResolver : public RefCountedDNSResolverInterface {
   using FdNodeList = std::list<std::unique_ptr<FdNode>>;
 
   using CallbackType =
-      absl::variant<EventEngine::DNSResolver::LookupHostnameCallback,
-                    EventEngine::DNSResolver::LookupSRVCallback,
-                    EventEngine::DNSResolver::LookupTXTCallback>;
+      std::variant<EventEngine::DNSResolver::LookupHostnameCallback,
+                   EventEngine::DNSResolver::LookupSRVCallback,
+                   EventEngine::DNSResolver::LookupTXTCallback>;
 
   void CheckSocketsLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   void MaybeStartTimerLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
@@ -119,14 +116,13 @@ class AresResolver : public RefCountedDNSResolverInterface {
   FdNodeList fd_node_list_ ABSL_GUARDED_BY(mutex_);
   int id_ ABSL_GUARDED_BY(mutex_) = 0;
   absl::flat_hash_map<int, CallbackType> callback_map_ ABSL_GUARDED_BY(mutex_);
-  absl::optional<EventEngine::TaskHandle> ares_backup_poll_alarm_handle_
+  std::optional<EventEngine::TaskHandle> ares_backup_poll_alarm_handle_
       ABSL_GUARDED_BY(mutex_);
   std::unique_ptr<GrpcPolledFdFactory> polled_fd_factory_;
   std::shared_ptr<EventEngine> event_engine_;
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 // Exposed in this header for C-core tests only
 extern void (*event_engine_grpc_ares_test_only_inject_config)(