grpc 1.70.1 → 1.72.0

data/src/core/handshaker/proxy_mapper_registry.cc

@@ -22,11 +22,10 @@
 
 #include <algorithm>
 #include <memory>
+#include <optional>
 #include <utility>
 #include <vector>
 
-#include "absl/types/optional.h"
-
 namespace grpc_core {
 
 void ProxyMapperRegistry::Builder::Register(
@@ -44,7 +43,7 @@ ProxyMapperRegistry ProxyMapperRegistry::Builder::Build() {
   return registry;
 }
 
-absl::optional<std::string> ProxyMapperRegistry::MapName(
+std::optional<std::string> ProxyMapperRegistry::MapName(
     absl::string_view server_uri, ChannelArgs* args) const {
   ChannelArgs args_backup = *args;
   for (const auto& mapper : mappers_) {
@@ -53,10 +52,10 @@ absl::optional<std::string> ProxyMapperRegistry::MapName(
     if (r.has_value()) return r;
   }
   *args = args_backup;
-  return absl::nullopt;
+  return std::nullopt;
 }
 
-absl::optional<grpc_resolved_address> ProxyMapperRegistry::MapAddress(
+std::optional<grpc_resolved_address> ProxyMapperRegistry::MapAddress(
     const grpc_resolved_address& address, ChannelArgs* args) const {
   ChannelArgs args_backup = *args;
   for (const auto& mapper : mappers_) {
@@ -65,7 +64,7 @@ absl::optional<grpc_resolved_address> ProxyMapperRegistry::MapAddress(
     if (r.has_value()) return r;
   }
   *args = args_backup;
-  return absl::nullopt;
+  return std::nullopt;
 }
 
 }  // namespace grpc_core

data/src/core/handshaker/proxy_mapper_registry.h

@@ -23,11 +23,11 @@
 
 #include <algorithm>
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
 
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/handshaker/proxy_mapper.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/resolved_address.h"
@@ -57,10 +57,10 @@ class ProxyMapperRegistry {
   ProxyMapperRegistry(ProxyMapperRegistry&&) = default;
   ProxyMapperRegistry& operator=(ProxyMapperRegistry&&) = default;
 
-  absl::optional<std::string> MapName(absl::string_view server_uri,
-                                      ChannelArgs* args) const;
+  std::optional<std::string> MapName(absl::string_view server_uri,
+                                     ChannelArgs* args) const;
 
-  absl::optional<grpc_resolved_address> MapAddress(
+  std::optional<grpc_resolved_address> MapAddress(
       const grpc_resolved_address& address, ChannelArgs* args) const;
 
  private:

data/src/core/handshaker/security/secure_endpoint.cc

@@ -31,6 +31,7 @@
 #include <algorithm>
 #include <atomic>
 #include <memory>
+#include <optional>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
@@ -38,7 +39,6 @@
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
@@ -191,7 +191,7 @@ static void maybe_post_reclaimer(secure_endpoint* ep) {
     ep->has_posted_reclaimer.exchange(true, std::memory_order_relaxed);
     ep->memory_owner.PostReclaimer(
         grpc_core::ReclamationPass::kBenign,
-        [ep](absl::optional<grpc_core::ReclamationSweep> sweep) {
+        [ep](std::optional<grpc_core::ReclamationSweep> sweep) {
           if (sweep.has_value()) {
             GRPC_TRACE_LOG(resource_quota, INFO)
                 << "secure endpoint: benign reclamation to free memory";

data/src/core/handshaker/security/security_handshaker.cc

@@ -31,6 +31,7 @@
 
 #include <algorithm>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 
@@ -40,7 +41,6 @@
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/handshaker/handshaker.h"
@@ -54,11 +54,11 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/tcp_server.h"
-#include "src/core/lib/security/context/security_context.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
+#include "src/core/transport/auth_context.h"
 #include "src/core/tsi/transport_security_grpc.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -199,7 +199,7 @@ MakeChannelzSecurityFromAuthContext(grpc_auth_context* auth_context) {
   // https://github.com/grpc/grpc/blob/fcd43e90304862a823316b224ee733d17a8cfd90/src/proto/grpc/channelz/channelz.proto#L326
   // from grpc_auth_context.
   security->type = channelz::SocketNode::Security::ModelType::kTls;
-  security->tls = absl::make_optional<channelz::SocketNode::Security::Tls>();
+  security->tls = std::make_optional<channelz::SocketNode::Security::Tls>();
   grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name(
       auth_context, GRPC_X509_PEM_CERT_PROPERTY_NAME);
   const grpc_auth_property* prop = grpc_auth_property_iterator_next(&it);
@@ -245,7 +245,7 @@ void SecurityHandshaker::OnPeerCheckedFn(grpc_error_handle error) {
   tsi_frame_protector* protector = nullptr;
   switch (frame_protector_type) {
     case TSI_FRAME_PROTECTOR_ZERO_COPY:
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case TSI_FRAME_PROTECTOR_NORMAL_OR_ZERO_COPY:
       // Create zero-copy frame protector.
       result = tsi_handshaker_result_create_zero_copy_grpc_protector(
@@ -440,7 +440,6 @@ void SecurityHandshaker::OnHandshakeDataReceivedFromPeerFnScheduler(
     grpc_error_handle error) {
   args_->event_engine->Run([self = RefAsSubclass<SecurityHandshaker>(),
                             error = std::move(error)]() mutable {
-    ApplicationCallbackExecCtx callback_exec_ctx;
     ExecCtx exec_ctx;
     self->OnHandshakeDataReceivedFromPeerFn(std::move(error));
     // Avoid destruction outside of an ExecCtx (since this is non-cancelable).
@@ -472,7 +471,6 @@ void SecurityHandshaker::OnHandshakeDataSentToPeerFnScheduler(
     grpc_error_handle error) {
   args_->event_engine->Run([self = RefAsSubclass<SecurityHandshaker>(),
                             error = std::move(error)]() mutable {
-    ApplicationCallbackExecCtx callback_exec_ctx;
     ExecCtx exec_ctx;
     self->OnHandshakeDataSentToPeerFn(std::move(error));
     // Avoid destruction outside of an ExecCtx (since this is non-cancelable).

data/src/core/handshaker/security/security_handshaker.h

@@ -24,9 +24,9 @@
 
 #include "absl/status/statusor.h"
 #include "src/core/config/core_configuration.h"
+#include "src/core/credentials/transport/security_connector.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/security/security_connector/security_connector.h"
 #include "src/core/tsi/transport_security_interface.h"
 #include "src/core/util/ref_counted_ptr.h"
 

data/src/core/handshaker/tcp_connect/tcp_connect_handshaker.cc

@@ -24,6 +24,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <memory>
+#include <optional>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
@@ -31,7 +32,6 @@
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/handshaker/handshaker_factory.h"
@@ -125,11 +125,13 @@ void TCPConnectHandshaker::DoHandshake(
   }
   CHECK_EQ(args->endpoint.get(), nullptr);
   args_ = args;
-  absl::StatusOr<URI> uri = URI::Parse(
-      args->args.GetString(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS).value());
+  absl::string_view resolved_address_text =
+      args->args.GetString(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS).value();
+  absl::StatusOr<URI> uri = URI::Parse(resolved_address_text);
   if (!uri.ok() || !grpc_parse_uri(*uri, &addr_)) {
     MutexLock lock(&mu_);
-    FinishLocked(GRPC_ERROR_CREATE("Resolved address in invalid format"));
+    FinishLocked(GRPC_ERROR_CREATE(absl::StrCat(
+        "Resolved address in invalid format: ", resolved_address_text)));
     return;
   }
   bind_endpoint_to_pollset_ =

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

@@ -218,34 +218,34 @@ ChannelArgs ChannelArgs::RemoveAllKeysWithPrefix(
   return ChannelArgs(std::move(args));
 }
 
-absl::optional<int> ChannelArgs::GetInt(absl::string_view name) const {
+std::optional<int> ChannelArgs::GetInt(absl::string_view name) const {
   auto* v = Get(name);
-  if (v == nullptr) return absl::nullopt;
+  if (v == nullptr) return std::nullopt;
   return v->GetIfInt();
 }
 
-absl::optional<Duration> ChannelArgs::GetDurationFromIntMillis(
+std::optional<Duration> ChannelArgs::GetDurationFromIntMillis(
     absl::string_view name) const {
   auto ms = GetInt(name);
-  if (!ms.has_value()) return absl::nullopt;
+  if (!ms.has_value()) return std::nullopt;
   if (*ms == INT_MAX) return Duration::Infinity();
   if (*ms == INT_MIN) return Duration::NegativeInfinity();
   return Duration::Milliseconds(*ms);
 }
 
-absl::optional<absl::string_view> ChannelArgs::GetString(
+std::optional<absl::string_view> ChannelArgs::GetString(
     absl::string_view name) const {
   auto* v = Get(name);
-  if (v == nullptr) return absl::nullopt;
+  if (v == nullptr) return std::nullopt;
   const auto s = v->GetIfString();
-  if (s == nullptr) return absl::nullopt;
+  if (s == nullptr) return std::nullopt;
   return s->as_string_view();
 }
 
-absl::optional<std::string> ChannelArgs::GetOwnedString(
+std::optional<std::string> ChannelArgs::GetOwnedString(
     absl::string_view name) const {
-  absl::optional<absl::string_view> v = GetString(name);
-  if (!v.has_value()) return absl::nullopt;
+  std::optional<absl::string_view> v = GetString(name);
+  if (!v.has_value()) return std::nullopt;
   return std::string(*v);
 }
 
@@ -257,13 +257,13 @@ void* ChannelArgs::GetVoidPointer(absl::string_view name) const {
   return pp->c_pointer();
 }
 
-absl::optional<bool> ChannelArgs::GetBool(absl::string_view name) const {
+std::optional<bool> ChannelArgs::GetBool(absl::string_view name) const {
   auto* v = Get(name);
-  if (v == nullptr) return absl::nullopt;
+  if (v == nullptr) return std::nullopt;
   auto i = v->GetIfInt();
   if (!i.has_value()) {
     LOG(ERROR) << name << " ignored: it must be an integer";
-    return absl::nullopt;
+    return std::nullopt;
   }
   switch (*i) {
     case 0:

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

@@ -28,13 +28,13 @@
 #include <algorithm>  // IWYU pragma: keep
 #include <iosfwd>
 #include <memory>
+#include <optional>
 #include <string>
 #include <type_traits>
 #include <utility>
 
 #include "absl/meta/type_traits.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/util/avl.h"
 #include "src/core/util/debug_location.h"
@@ -91,6 +91,31 @@ struct IsRawPointerTagged<T,
                           absl::void_t<typename T::RawPointerChannelArgTag>> {
   static constexpr bool kValue = true;
 };
+
+// Define a check for shared_ptr supported types, which must extend
+// enable_shared_from_this.
+template <typename T>
+struct SupportedSharedPtrType
+    : std::integral_constant<
+          bool, std::is_base_of<std::enable_shared_from_this<T>, T>::value> {};
+template <>
+struct SupportedSharedPtrType<grpc_event_engine::experimental::EventEngine>
+    : std::true_type {};
+
+// Specialization for shared_ptr
+// Incurs an allocation because shared_ptr.release is not a thing.
+template <typename T>
+struct is_shared_ptr : std::false_type {};
+template <typename T>
+struct is_shared_ptr<std::shared_ptr<T>> : std::true_type {};
+
+template <typename T, typename = void>
+struct has_channel_args_compare : std::false_type {};
+template <typename T>
+struct has_channel_args_compare<
+    T, absl::void_t<decltype(T::ChannelArgsCompare(std::declval<const T*>(),
+                                                   std::declval<const T*>()))>>
+    : std::true_type {};
 }  // namespace channel_args_detail
 
 // Specialization for ref-counted pointers.
@@ -133,25 +158,9 @@ struct ChannelArgTypeTraits<
   };
 };
 
-// Define a check for shared_ptr supported types, which must extend
-// enable_shared_from_this.
 template <typename T>
-struct SupportedSharedPtrType
-    : std::integral_constant<
-          bool, std::is_base_of<std::enable_shared_from_this<T>, T>::value> {};
-template <>
-struct SupportedSharedPtrType<grpc_event_engine::experimental::EventEngine>
-    : std::true_type {};
-
-// Specialization for shared_ptr
-// Incurs an allocation because shared_ptr.release is not a thing.
-template <typename T>
-struct is_shared_ptr : std::false_type {};
-template <typename T>
-struct is_shared_ptr<std::shared_ptr<T>> : std::true_type {};
-template <typename T>
-struct ChannelArgTypeTraits<T,
-                            absl::enable_if_t<is_shared_ptr<T>::value, void>> {
+struct ChannelArgTypeTraits<
+    T, absl::enable_if_t<channel_args_detail::is_shared_ptr<T>::value, void>> {
   static void* TakeUnownedPointer(T* p) { return p; }
   static const grpc_arg_pointer_vtable* VTable() {
     static const grpc_arg_pointer_vtable tbl = {
@@ -161,8 +170,15 @@ struct ChannelArgTypeTraits<T,
         [](void* p) { delete static_cast<T*>(p); },
         // compare
         [](void* p1, void* p2) {
-          return QsortCompare(static_cast<const T*>(p1)->get(),
-                              static_cast<const T*>(p2)->get());
+          if constexpr (channel_args_detail::has_channel_args_compare<
+                            typename T::element_type>::value) {
+            return T::element_type::ChannelArgsCompare(
+                static_cast<const T*>(p1)->get(),
+                static_cast<const T*>(p2)->get());
+          } else {
+            return QsortCompare(static_cast<const T*>(p1)->get(),
+                                static_cast<const T*>(p2)->get());
+          }
         },
     };
     return &tbl;
@@ -209,9 +225,10 @@ struct GetObjectImpl;
 // std::shared_ptr implementation
 template <typename T>
 struct GetObjectImpl<
-    T, absl::enable_if_t<!ChannelArgPointerShouldBeConst<T>::kValue &&
-                             SupportedSharedPtrType<T>::value,
-                         void>> {
+    T,
+    absl::enable_if_t<!ChannelArgPointerShouldBeConst<T>::kValue &&
+                          channel_args_detail::SupportedSharedPtrType<T>::value,
+                      void>> {
   using Result = T*;
   using ReffedResult = std::shared_ptr<T>;
   using StoredType = std::shared_ptr<T>*;
@@ -232,9 +249,10 @@ struct GetObjectImpl<
 // RefCountedPtr
 template <typename T>
 struct GetObjectImpl<
-    T, absl::enable_if_t<!ChannelArgPointerShouldBeConst<T>::kValue &&
-                             !SupportedSharedPtrType<T>::value,
-                         void>> {
+    T, absl::enable_if_t<
+           !ChannelArgPointerShouldBeConst<T>::kValue &&
+               !channel_args_detail::SupportedSharedPtrType<T>::value,
+           void>> {
   using Result = T*;
   using ReffedResult = RefCountedPtr<T>;
   using StoredType = Result;
@@ -252,9 +270,10 @@ struct GetObjectImpl<
 
 template <typename T>
 struct GetObjectImpl<
-    T, absl::enable_if_t<ChannelArgPointerShouldBeConst<T>::kValue &&
-                             !SupportedSharedPtrType<T>::value,
-                         void>> {
+    T, absl::enable_if_t<
+           ChannelArgPointerShouldBeConst<T>::kValue &&
+               !channel_args_detail::SupportedSharedPtrType<T>::value,
+           void>> {
   using Result = const T*;
   using ReffedResult = RefCountedPtr<const T>;
   using StoredType = Result;
@@ -353,8 +372,8 @@ class ChannelArgs {
         : rep_(RefCountedString::Make(s).release(), &string_vtable_) {}
     explicit Value(Pointer p) : rep_(std::move(p)) {}
 
-    absl::optional<int> GetIfInt() const {
-      if (rep_.c_vtable() != &int_vtable_) return absl::nullopt;
+    std::optional<int> GetIfInt() const {
+      if (rep_.c_vtable() != &int_vtable_) return std::nullopt;
       return reinterpret_cast<intptr_t>(rep_.c_pointer());
     }
     RefCountedPtr<RefCountedString> GetIfString() const {
@@ -469,7 +488,7 @@ class ChannelArgs {
           decltype(ChannelArgTypeTraits<std::shared_ptr<T>>::VTable())>::value,
       ChannelArgs>
   Set(absl::string_view name, std::shared_ptr<T> value) const {
-    static_assert(SupportedSharedPtrType<T>::value,
+    static_assert(channel_args_detail::SupportedSharedPtrType<T>::value,
                   "Type T must extend std::enable_shared_from_this to be added "
                   "into ChannelArgs as a shared_ptr<T>");
     auto* store_value = new std::shared_ptr<T>(value);
@@ -496,9 +515,9 @@ class ChannelArgs {
     return Get(ChannelArgNameTraits<T>::ChannelArgName()) != nullptr;
   }
 
-  absl::optional<int> GetInt(absl::string_view name) const;
-  absl::optional<absl::string_view> GetString(absl::string_view name) const;
-  absl::optional<std::string> GetOwnedString(absl::string_view name) const;
+  std::optional<int> GetInt(absl::string_view name) const;
+  std::optional<absl::string_view> GetString(absl::string_view name) const;
+  std::optional<std::string> GetOwnedString(absl::string_view name) const;
   // WARNING: this is broken if `name` represents something that was stored as a
   // RefCounted<const T> - we will discard the const-ness.
   void* GetVoidPointer(absl::string_view name) const;
@@ -508,9 +527,9 @@ class ChannelArgs {
     return static_cast<typename GetObjectImpl<T>::StoredType>(
         GetVoidPointer(name));
   }
-  absl::optional<Duration> GetDurationFromIntMillis(
+  std::optional<Duration> GetDurationFromIntMillis(
       absl::string_view name) const;
-  absl::optional<bool> GetBool(absl::string_view name) const;
+  std::optional<bool> GetBool(absl::string_view name) const;
 
   // Object based get/set.
   // Deal with the common case that we set a pointer to an object under

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

@@ -81,7 +81,6 @@ struct grpc_channel_element_args {
 struct grpc_call_element_args {
   grpc_call_stack* call_stack;
   const void* server_transport_data;
-  const grpc_slice& path;
   gpr_cycle_counter start_time;  // Note: not populated in subchannel stack.
   grpc_core::Timestamp deadline;
   grpc_core::Arena* arena;
@@ -198,7 +197,7 @@ struct grpc_channel_stack {
   }
 
   grpc_core::ManualConstructor<
-      grpc_core::GlobalStatsPluginRegistry::StatsPluginGroup>
+      std::shared_ptr<grpc_core::GlobalStatsPluginRegistry::StatsPluginGroup>>
       stats_plugin_group;
 
   // Minimal infrastructure to act like a RefCounted thing without converting

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

@@ -33,6 +33,7 @@
 #include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/debug/trace.h"
@@ -43,7 +44,6 @@
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/no_destruct.h"
 #include "src/core/util/sync.h"

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

@@ -26,6 +26,7 @@
 
 #include <functional>
 #include <memory>
+#include <optional>
 #include <string>
 #include <type_traits>
 #include <utility>
@@ -33,9 +34,9 @@
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
-#include "absl/types/optional.h"
+#include "src/core/call/call_finalization.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/config/core_configuration.h"
-#include "src/core/lib/channel/call_finalization.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -67,7 +68,6 @@
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/alloc.h"
 #include "src/core/util/debug_location.h"

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) {