grpc 1.70.1 → 1.72.0

data/src/core/lib/event_engine/posix_engine/native_posix_dns_resolver.h

@@ -26,8 +26,7 @@
 
 #include <grpc/event_engine/event_engine.h>
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 // An asynchronous DNS resolver which uses the native platform's getaddrinfo
 // API. Only supports A/AAAA records.
@@ -49,8 +48,7 @@ class NativePosixDNSResolver : public EventEngine::DNSResolver {
   std::shared_ptr<EventEngine> event_engine_;
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_POSIX_SOCKET_RESOLVE_ADDRESS
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_NATIVE_POSIX_DNS_RESOLVER_H

data/src/core/lib/event_engine/posix_engine/posix_endpoint.cc

@@ -27,6 +27,7 @@
 #include <cstdint>
 #include <cstdlib>
 #include <memory>
+#include <optional>
 #include <string>
 #include <type_traits>
 
@@ -36,7 +37,6 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/internal_errqueue.h"
@@ -92,8 +92,7 @@
 
 #define MAX_READ_IOVEC 64
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 namespace {
 
@@ -278,8 +277,6 @@ void PosixEndpointImpl::FinishEstimate() {
 }
 
 absl::Status PosixEndpointImpl::TcpAnnotateError(absl::Status src_error) const {
-  grpc_core::StatusSetInt(&src_error, grpc_core::StatusIntProperty::kFd,
-                          handle_->WrappedFd());
   grpc_core::StatusSetInt(&src_error, grpc_core::StatusIntProperty::kRpcStatus,
                           GRPC_STATUS_UNAVAILABLE);
   return src_error;
@@ -472,7 +469,7 @@ void PosixEndpointImpl::MaybePostReclaimer() {
     memory_owner_.PostReclaimer(
         grpc_core::ReclamationPass::kBenign,
         [self = Ref(DEBUG_LOCATION, "Posix Reclaimer")](
-            absl::optional<grpc_core::ReclamationSweep> sweep) {
+            std::optional<grpc_core::ReclamationSweep> sweep) {
           if (sweep.has_value()) {
             self->PerformReclamation();
           }
@@ -1361,13 +1358,11 @@ std::unique_ptr<PosixEndpoint> CreatePosixEndpoint(
                                          std::move(allocator), options);
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #else  // GRPC_POSIX_SOCKET_TCP
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 std::unique_ptr<PosixEndpoint> CreatePosixEndpoint(
     EventHandle* /*handle*/, PosixEngineClosure* /*on_shutdown*/,
@@ -1376,7 +1371,6 @@ std::unique_ptr<PosixEndpoint> CreatePosixEndpoint(
   grpc_core::Crash("Cannot create PosixEndpoint on this platform");
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_POSIX_SOCKET_TCP

data/src/core/lib/event_engine/posix_engine/posix_endpoint.h

@@ -63,8 +63,7 @@ typedef size_t msg_iovlen_type;
 
 #endif  //  GRPC_POSIX_SOCKET_TCP
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 
@@ -721,7 +720,6 @@ std::unique_ptr<PosixEndpoint> CreatePosixEndpoint(
     grpc_event_engine::experimental::MemoryAllocator&& allocator,
     const PosixTcpOptions& options);
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENDPOINT_H

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

@@ -67,9 +67,7 @@
 
 // IWYU pragma: no_include <ratio>
 
-// TODO(eryu): remove this GRPC_CFSTREAM condition when the CFEngine is ready.
-// The posix poller currently crashes iOS.
-#if defined(GRPC_POSIX_SOCKET_TCP) && !defined(GRPC_CFSTREAM) && \
+#if defined(GRPC_POSIX_SOCKET_TCP) && \
     !defined(GRPC_DO_NOT_INSTANTIATE_POSIX_POLLER)
 #define GRPC_PLATFORM_SUPPORTS_POSIX_POLLING true
 #else
@@ -78,8 +76,7 @@
 
 using namespace std::chrono_literals;
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 namespace {
 
@@ -742,5 +739,4 @@ PosixEventEngine::CreatePosixListener(
 #endif  // GRPC_PLATFORM_SUPPORTS_POSIX_POLLING
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental

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

@@ -48,8 +48,7 @@
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 #endif  // GRPC_POSIX_SOCKET_TCP
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 // A helper class to handle asynchronous connect operations.
@@ -260,7 +259,6 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
 #endif  // GRPC_POSIX_SOCKET_TCP
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_H

data/src/core/lib/event_engine/posix_engine/posix_engine_closure.h

@@ -22,8 +22,7 @@
 #include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 // The callbacks for Endpoint read and write take an absl::Status as
 // argument - this is important for the tcp code to function correctly. We need
@@ -73,7 +72,6 @@ class PosixEngineClosure final
   absl::Status status_;
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_CLOSURE_H

data/src/core/lib/event_engine/posix_engine/posix_engine_listener.cc

@@ -27,6 +27,7 @@
 #include <unistd.h>      // IWYU pragma: keep
 
 #include <atomic>
+#include <optional>
 #include <string>
 #include <tuple>
 #include <type_traits>
@@ -37,7 +38,6 @@
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/posix_endpoint.h"
@@ -49,8 +49,7 @@
 #include "src/core/util/strerror.h"
 #include "src/core/util/time.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 PosixEngineListenerImpl::PosixEngineListenerImpl(
     PosixEventEngineWithFdSupport::PosixAcceptCallback on_accept,
@@ -330,7 +329,6 @@ PosixEngineListenerImpl::~PosixEngineListenerImpl() {
   }
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_POSIX_SOCKET_TCP

data/src/core/lib/event_engine/posix_engine/posix_engine_listener.h

@@ -43,8 +43,7 @@
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #endif
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 class PosixEngineListenerImpl
@@ -278,6 +277,5 @@ class PosixEngineListener : public PosixListenerWithFdSupport {
 
 #endif
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_LISTENER_H

data/src/core/lib/event_engine/posix_engine/posix_engine_listener_utils.cc

@@ -20,6 +20,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <cstdint>
 #include <cstring>
 #include <string>
 
@@ -46,8 +47,7 @@
 #include <unistd.h>      // IWYU pragma: keep
 #endif
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 #ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
 
@@ -227,6 +227,27 @@ absl::StatusOr<ListenerSocket> CreateAndPrepareListenerSocket(
   return socket;
 }
 
+bool IsSockAddrLinkLocal(const EventEngine::ResolvedAddress* resolved_addr) {
+  const sockaddr* addr = resolved_addr->address();
+  if (addr->sa_family == AF_INET) {
+    const sockaddr_in* addr4 = reinterpret_cast<const sockaddr_in*>(addr);
+    // Link-local IPv4 addresses are in the range 169.254.0.0/16
+    if ((addr4->sin_addr.s_addr & htonl(0xFFFF0000)) == htonl(0xA9FE0000)) {
+      return true;
+    }
+  } else if (addr->sa_family == AF_INET6) {
+    const sockaddr_in6* addr6 = reinterpret_cast<const sockaddr_in6*>(addr);
+    const uint8_t* addr_bytes = addr6->sin6_addr.s6_addr;
+
+    // Check the first 10 bits to make sure they are 1111 1110 10
+    if ((addr_bytes[0] == 0xfe) && ((addr_bytes[1] & 0xc0) == 0x80)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
     ListenerSocketsContainer& listener_sockets, const PosixTcpOptions& options,
     int requested_port) {
@@ -272,6 +293,10 @@ absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
     addr = EventEngine::ResolvedAddress(ifa_it->ifa_addr, len);
     ResolvedAddressSetPort(addr, requested_port);
     std::string addr_str = *ResolvedAddressToString(addr);
+    if (IsSockAddrLinkLocal(&addr)) {
+      /* Exclude link-local addresses. */
+      continue;
+    }
     VLOG(2) << absl::StrFormat(
         "Adding local addr from interface %s flags 0x%x to server: %s",
         ifa_name, ifa_it->ifa_flags, addr_str.c_str());
@@ -390,5 +415,4 @@ absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
 
 #endif  // GRPC_POSIX_SOCKET_UTILS_COMMON
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/posix_engine/posix_engine_listener_utils.h

@@ -20,8 +20,7 @@
 #include "absl/status/statusor.h"
 #include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 // This interface exists to allow different EventEngines to implement different
 // custom interception operations while a socket is Appended. The
@@ -83,7 +82,10 @@ absl::StatusOr<int> ListenerContainerAddAllLocalAddresses(
     ListenerSocketsContainer& listener_sockets, const PosixTcpOptions& options,
     int requested_port);
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+// Returns true if addr is link-local (i.e. within the range 169.254.0.0/16 or
+// fe80::/10).
+bool IsSockAddrLinkLocal(const EventEngine::ResolvedAddress* resolved_addr);
+
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_ENGINE_LISTENER_UTILS_H

data/src/core/lib/event_engine/posix_engine/set_socket_dualstack.cc

@@ -0,0 +1,64 @@
+// Copyright 2022 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <errno.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/memory_allocator.h>
+#include <grpc/impl/channel_arg_names.h>
+#include <grpc/support/port_platform.h>
+#include <limits.h>
+
+#include "src/core/lib/event_engine/posix_engine/tcp_socket_utils.h"
+#include "src/core/lib/iomgr/port.h"
+#include "src/core/util/crash.h"  // IWYU pragma: keep
+
+#ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
+#include <arpa/inet.h>  // IWYU pragma: keep
+#ifdef GRPC_LINUX_TCP_H
+#include <linux/tcp.h>
+#else
+#include <netinet/in.h>  // IWYU pragma: keep
+#include <netinet/tcp.h>
+#endif
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#endif  //  GRPC_POSIX_SOCKET_UTILS_COMMON
+
+#ifdef GRPC_HAVE_UNIX_SOCKET
+#ifdef GPR_WINDOWS
+// clang-format off
+#include <ws2def.h>
+#include <afunix.h>
+// clang-format on
+#else
+#include <sys/stat.h>  // IWYU pragma: keep
+#include <sys/un.h>
+#endif  // GPR_WINDOWS
+#endif
+
+namespace grpc_event_engine::experimental {
+
+#ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
+#ifndef GRPC_SET_SOCKET_DUALSTACK_CUSTOM
+
+bool SetSocketDualStack(int fd) {
+  const int off = 0;
+  return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof(off));
+}
+
+#endif  // GRPC_SET_SOCKET_DUALSTACK_CUSTOM
+#endif  // GRPC_POSIX_SOCKET_UTILS_COMMON
+
+}  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/posix_engine/tcp_socket_utils.cc

@@ -21,10 +21,11 @@
 #include <grpc/support/port_platform.h>
 #include <limits.h>
 
+#include <optional>
+
 #include "absl/cleanup/cleanup.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/util/crash.h"  // IWYU pragma: keep
 #include "src/core/util/time.h"
@@ -65,13 +66,12 @@
 #endif  // GPR_WINDOWS
 #endif
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 namespace {
 
 int AdjustValue(int default_value, int min_value, int max_value,
-                absl::optional<int> actual_value) {
+                std::optional<int> actual_value) {
   if (!actual_value.has_value() || *actual_value < min_value ||
       *actual_value > max_value) {
     return default_value;
@@ -150,17 +150,6 @@ absl::Status PrepareTcpClientSocket(PosixSocketWrapper sock,
 
 }  // namespace
 
-#ifdef GRPC_POSIX_SOCKET_UTILS_COMMON
-#ifndef GRPC_SET_SOCKET_DUALSTACK_CUSTOM
-
-bool SetSocketDualStack(int fd) {
-  const int off = 0;
-  return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof(off));
-}
-
-#endif  // GRPC_SET_SOCKET_DUALSTACK_CUSTOM
-#endif  // GRPC_POSIX_SOCKET_UTILS_COMMON
-
 PosixTcpOptions TcpOptionsFromEndpointConfig(const EndpointConfig& config) {
   void* value;
   PosixTcpOptions options;
@@ -922,5 +911,4 @@ PosixSocketWrapper::CreateAndPrepareTcpClientSocket(
 
 #endif  // GRPC_POSIX_SOCKET_UTILS_COMMON
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/posix_engine/tcp_socket_utils.h

@@ -46,8 +46,7 @@
 #endif
 #endif  // ifdef GRPC_LINUX_ERRQUEUE
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 struct PosixTcpOptions {
   static constexpr int kDefaultReadChunkSize = 8192;
@@ -323,7 +322,6 @@ struct PosixSocketWrapper::PosixSocketCreateResult {
 
 bool SetSocketDualStack(int fd);
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TCP_SOCKET_UTILS_H

data/src/core/lib/event_engine/posix_engine/timer.cc

@@ -30,8 +30,7 @@
 #include "src/core/util/time.h"
 #include "src/core/util/useful.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 static const size_t kInvalidHeapIndex = std::numeric_limits<size_t>::max();
 static const double kAddDeadlineScale = 0.33;
@@ -280,7 +279,7 @@ std::vector<experimental::EventEngine::Closure*> TimerList::FindExpiredTimers(
   return done;
 }
 
-absl::optional<std::vector<experimental::EventEngine::Closure*>>
+std::optional<std::vector<experimental::EventEngine::Closure*>>
 TimerList::TimerCheck(grpc_core::Timestamp* next) {
   // prelude
   grpc_core::Timestamp now = host_->Now();
@@ -298,7 +297,7 @@ TimerList::TimerCheck(grpc_core::Timestamp* next) {
     return std::vector<experimental::EventEngine::Closure*>();
   }
 
-  if (!checker_mu_.TryLock()) return absl::nullopt;
+  if (!checker_mu_.TryLock()) return std::nullopt;
   std::vector<experimental::EventEngine::Closure*> run =
       FindExpiredTimers(now, next);
   checker_mu_.Unlock();
@@ -306,5 +305,4 @@ TimerList::TimerCheck(grpc_core::Timestamp* next) {
   return std::move(run);
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/posix_engine/timer.h

@@ -26,17 +26,16 @@
 #include <atomic>
 #include <cstdint>
 #include <memory>
+#include <optional>
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/event_engine/posix_engine/timer_heap.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
 #include "src/core/util/time_averaged_stats.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 struct Timer {
   int64_t deadline;
@@ -97,7 +96,7 @@ class TimerList {
   // *next is never guaranteed to be updated on any given execution; however,
   // with high probability at least one thread in the system will see an update
   // at any time slice.
-  absl::optional<std::vector<experimental::EventEngine::Closure*>> TimerCheck(
+  std::optional<std::vector<experimental::EventEngine::Closure*>> TimerCheck(
       grpc_core::Timestamp* next);
 
  private:
@@ -158,7 +157,6 @@ class TimerList {
   const std::unique_ptr<Shard*[]> shard_queue_ ABSL_GUARDED_BY(mu_);
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_H

data/src/core/lib/event_engine/posix_engine/timer_heap.cc

@@ -25,8 +25,7 @@
 
 #include "src/core/lib/event_engine/posix_engine/timer.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 // Adjusts a heap so as to move a hole at position i closer to the root,
 // until a suitable position is found for element t. Then, copies t into that
@@ -102,5 +101,4 @@ Timer* TimerHeap::Top() { return timers_[0]; }
 
 void TimerHeap::Pop() { Remove(Top()); }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/posix_engine/timer_heap.h

@@ -24,8 +24,7 @@
 #include <cstddef>
 #include <vector>
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 struct Timer;
 
@@ -50,7 +49,6 @@ class TimerHeap {
   std::vector<Timer*> timers_;
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_HEAP_H

data/src/core/lib/event_engine/posix_engine/timer_manager.cc

@@ -22,18 +22,17 @@
 #include <grpc/support/time.h>
 
 #include <memory>
+#include <optional>
 #include <utility>
 
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/time/time.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/debug/trace.h"
 
 static thread_local bool g_timer_thread;
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 void TimerManager::RunSomeTimers(
     std::vector<experimental::EventEngine::Closure*> timers) {
@@ -64,8 +63,8 @@ bool TimerManager::WaitUntil(grpc_core::Timestamp next) {
 
 void TimerManager::MainLoop() {
   grpc_core::Timestamp next = grpc_core::Timestamp::InfFuture();
-  absl::optional<std::vector<experimental::EventEngine::Closure*>>
-      check_result = timer_list_->TimerCheck(&next);
+  std::optional<std::vector<experimental::EventEngine::Closure*>> check_result =
+      timer_list_->TimerCheck(&next);
   CHECK(check_result.has_value())
       << "ERROR: More than one MainLoop is running.";
   bool timers_found = !check_result->empty();
@@ -150,5 +149,4 @@ void TimerManager::PrepareFork() { Shutdown(); }
 void TimerManager::PostforkParent() { RestartPostFork(); }
 void TimerManager::PostforkChild() { RestartPostFork(); }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/posix_engine/timer_manager.h

@@ -24,10 +24,10 @@
 #include <stdint.h>
 
 #include <memory>
+#include <optional>
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/event_engine/forkable.h"
 #include "src/core/lib/event_engine/posix_engine/timer.h"
 #include "src/core/lib/event_engine/thread_pool/thread_pool.h"
@@ -35,8 +35,7 @@
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 // Timer Manager tries to keep only one thread waiting for the next timeout at
 // all times, and thus effectively preventing the thundering herd problem.
@@ -99,10 +98,9 @@ class TimerManager final : public grpc_event_engine::experimental::Forkable {
   // actual timer implementation
   std::unique_ptr<TimerList> timer_list_;
   std::shared_ptr<grpc_event_engine::experimental::ThreadPool> thread_pool_;
-  absl::optional<grpc_core::Notification> main_loop_exit_signal_;
+  std::optional<grpc_core::Notification> main_loop_exit_signal_;
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_TIMER_MANAGER_H

data/src/core/lib/event_engine/posix_engine/traced_buffer_list.cc

@@ -33,8 +33,7 @@
 #include <linux/netlink.h>
 #include <sys/socket.h>  // IWYU pragma: keep
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 namespace {
 // Fills gpr_timespec gts based on values from timespec ts.
@@ -310,22 +309,19 @@ void TcpSetWriteTimestampsCallback(
   g_timestamps_callback = std::move(fn);
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #else  // GRPC_LINUX_ERRQUEUE
 
 #include "src/core/util/crash.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 void TcpSetWriteTimestampsCallback(
     absl::AnyInvocable<void(void*, Timestamps*, absl::Status)> /*fn*/) {
   grpc_core::Crash("Timestamps callback is not enabled for this platform");
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_LINUX_ERRQUEUE