grpc 1.51.0 → 1.52.0

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2017 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.
- *
- */
+//
+//
+// Copyright 2017 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.
+//
+//
 
 #ifndef GRPC_CORE_LIB_DEBUG_STATS_H
 #define GRPC_CORE_LIB_DEBUG_STATS_H

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
+//
+//
+// Copyright 2015 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 <grpc/support/port_platform.h>
 
@@ -64,7 +64,7 @@ bool TraceFlagList::Set(const char* name, bool enabled) {
     // check for unknowns, but ignore "", to allow to GRPC_TRACE=
     if (!found && 0 != strcmp(name, "")) {
       gpr_log(GPR_ERROR, "Unknown trace var: '%s'", name);
-      return false; /* early return */
+      return false;  // early return
     }
   }
   return true;

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
+//
+//
+// Copyright 2015 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.
+//
+//
 
 #ifndef GRPC_CORE_LIB_DEBUG_TRACE_H
 #define GRPC_CORE_LIB_DEBUG_TRACE_H
@@ -88,7 +88,7 @@ class TraceFlag {
   }
 #else
   bool enabled() { return false; }
-#endif /* defined(GRPC_USE_TRACERS) || !defined(NDEBUG) */
+#endif  // defined(GRPC_USE_TRACERS) || !defined(NDEBUG)
 
  private:
   friend void testing::grpc_tracer_enable_flag(TraceFlag* flag);
@@ -130,4 +130,4 @@ class DebugOnlyTraceFlag {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_DEBUG_TRACE_H */
+#endif  // GRPC_CORE_LIB_DEBUG_TRACE_H

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

@@ -35,4 +35,4 @@ class Executor {
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_EXECUTOR_H
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_EXECUTOR_H

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

@@ -58,4 +58,4 @@ void StopManagingForkable(Forkable* forkable);
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_FORKABLE_H
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_FORKABLE_H

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

@@ -22,13 +22,16 @@
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/str_format.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/status.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/event_engine/poller.h"
 #include "src/core/lib/event_engine/time_util.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/port.h"
 
 // This polling engine is only relevant on linux kernels supporting epoll
@@ -46,21 +49,14 @@
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix.h"
 #include "src/core/lib/event_engine/posix_engine/wakeup_fd_posix_default.h"
 #include "src/core/lib/gprpp/fork.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/gprpp/strerror.h"
 #include "src/core/lib/gprpp/sync.h"
 
-using ::grpc_event_engine::posix_engine::LockfreeEvent;
-using ::grpc_event_engine::posix_engine::WakeupFd;
-
 #define MAX_EPOLL_EVENTS_HANDLED_PER_ITERATION 1
 
 namespace grpc_event_engine {
-namespace posix_engine {
-
-using ::grpc_event_engine::experimental::EventEngine;
-using ::grpc_event_engine::experimental::Poller;
-using ::grpc_event_engine::posix_engine::LockfreeEvent;
-using ::grpc_event_engine::posix_engine::WakeupFd;
+namespace experimental {
 
 class Epoll1EventHandle : public EventHandle {
  public:
@@ -268,7 +264,7 @@ void ResetEventManagerOnFork() {
 // It is possible that GLIBC has epoll but the underlying kernel doesn't.
 // Create epoll_fd to make sure epoll support is available
 bool InitEpoll1PollerLinux() {
-  if (!grpc_event_engine::posix_engine::SupportsWakeupFd()) {
+  if (!grpc_event_engine::experimental::SupportsWakeupFd()) {
     return false;
   }
   int fd = EpollCreateAndCloexec();
@@ -329,6 +325,8 @@ void Epoll1EventHandle::OrphanHandle(PosixEngineClosure* on_done,
 // shutdown() syscall on that fd)
 void Epoll1EventHandle::HandleShutdownInternal(absl::Status why,
                                                bool releasing_fd) {
+  grpc_core::StatusSetInt(&why, grpc_core::StatusIntProperty::kRpcStatus,
+                          GRPC_STATUS_UNAVAILABLE);
   if (read_closure_->SetShutdown(why)) {
     if (!releasing_fd) {
       shutdown(fd_, SHUT_RDWR);
@@ -437,9 +435,8 @@ bool Epoll1Poller::ProcessEpollEvents(int max_epoll_events_to_handle,
       was_kicked = true;
     } else {
       Epoll1EventHandle* handle = reinterpret_cast<Epoll1EventHandle*>(
-          reinterpret_cast<intptr_t>(data_ptr) & ~static_cast<intptr_t>(1));
-      bool track_err =
-          reinterpret_cast<intptr_t>(data_ptr) & static_cast<intptr_t>(1);
+          reinterpret_cast<intptr_t>(data_ptr) & ~intptr_t{1});
+      bool track_err = reinterpret_cast<intptr_t>(data_ptr) & intptr_t{1};
       bool cancel = (ev->events & EPOLLHUP) != 0;
       bool error = (ev->events & EPOLLERR) != 0;
       bool read_ev = (ev->events & (EPOLLIN | EPOLLPRI)) != 0;
@@ -468,10 +465,9 @@ int Epoll1Poller::DoEpollWait(EventEngine::Duration timeout) {
                        grpc_event_engine::experimental::Milliseconds(timeout)));
   } while (r < 0 && errno == EINTR);
   if (r < 0) {
-    gpr_log(GPR_ERROR,
-            "(event_engine) Epoll1Poller:%p encountered epoll_wait error: %s",
-            this, grpc_core::StrError(errno).c_str());
-    GPR_ASSERT(false);
+    grpc_core::Crash(absl::StrFormat(
+        "(event_engine) Epoll1Poller:%p encountered epoll_wait error: %s", this,
+        grpc_core::StrError(errno).c_str()));
   }
   g_epoll_set_.num_events = r;
   g_epoll_set_.cursor = 0;
@@ -565,54 +561,54 @@ Epoll1Poller* MakeEpoll1Poller(Scheduler* scheduler) {
   return nullptr;
 }
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
-#else /* defined(GRPC_LINUX_EPOLL) */
+#else  // defined(GRPC_LINUX_EPOLL)
 #if defined(GRPC_POSIX_SOCKET_EV_EPOLL1)
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 using ::grpc_event_engine::experimental::EventEngine;
 using ::grpc_event_engine::experimental::Poller;
 
 Epoll1Poller::Epoll1Poller(Scheduler* /* engine */) {
-  GPR_ASSERT(false && "unimplemented");
+  grpc_core::Crash("unimplemented");
 }
 
-void Epoll1Poller::Shutdown() { GPR_ASSERT(false && "unimplemented"); }
+void Epoll1Poller::Shutdown() { grpc_core::Crash("unimplemented"); }
 
-Epoll1Poller::~Epoll1Poller() { GPR_ASSERT(false && "unimplemented"); }
+Epoll1Poller::~Epoll1Poller() { grpc_core::Crash("unimplemented"); }
 
 EventHandle* Epoll1Poller::CreateHandle(int /*fd*/, absl::string_view /*name*/,
                                         bool /*track_err*/) {
-  GPR_ASSERT(false && "unimplemented");
+  grpc_core::Crash("unimplemented");
 }
 
 bool Epoll1Poller::ProcessEpollEvents(int /*max_epoll_events_to_handle*/,
                                       Events& /*pending_events*/) {
-  GPR_ASSERT(false && "unimplemented");
+  grpc_core::Crash("unimplemented");
 }
 
 int Epoll1Poller::DoEpollWait(EventEngine::Duration /*timeout*/) {
-  GPR_ASSERT(false && "unimplemented");
+  grpc_core::Crash("unimplemented");
 }
 
 Poller::WorkResult Epoll1Poller::Work(
     EventEngine::Duration /*timeout*/,
     absl::FunctionRef<void()> /*schedule_poll_again*/) {
-  GPR_ASSERT(false && "unimplemented");
+  grpc_core::Crash("unimplemented");
 }
 
-void Epoll1Poller::Kick() { GPR_ASSERT(false && "unimplemented"); }
+void Epoll1Poller::Kick() { grpc_core::Crash("unimplemented"); }
 
 // If GRPC_LINUX_EPOLL is not defined, it means epoll is not available. Return
 // nullptr.
 Epoll1Poller* MakeEpoll1Poller(Scheduler* /*scheduler*/) { return nullptr; }
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif /* defined(GRPC_POSIX_SOCKET_EV_EPOLL1) */
-#endif /* !defined(GRPC_LINUX_EPOLL) */
+#endif  // defined(GRPC_POSIX_SOCKET_EV_EPOLL1)
+#endif  // !defined(GRPC_LINUX_EPOLL)

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

@@ -41,7 +41,7 @@
 #define MAX_EPOLL_EVENTS 100
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 class Epoll1EventHandle;
 
@@ -123,7 +123,7 @@ class Epoll1Poller : public PosixEventPoller {
 // engine.
 Epoll1Poller* MakeEpoll1Poller(Scheduler* scheduler);
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
 #endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_EPOLL1_LINUX_H

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

@@ -17,7 +17,6 @@
 #include "src/core/lib/event_engine/posix_engine/ev_poll_posix.h"
 
 #include <stdint.h>
-#include <stdlib.h>
 
 #include <atomic>
 #include <list>
@@ -28,9 +27,10 @@
 #include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/str_format.h"
 
 #include <grpc/event_engine/event_engine.h>
-#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/status.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
@@ -38,6 +38,7 @@
 #include "src/core/lib/event_engine/poller.h"
 #include "src/core/lib/event_engine/posix_engine/event_poller.h"
 #include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/port.h"
 
@@ -57,6 +58,7 @@
 #include "src/core/lib/event_engine/time_util.h"
 #include "src/core/lib/gprpp/fork.h"
 #include "src/core/lib/gprpp/global_config.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/gprpp/strerror.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
@@ -69,12 +71,8 @@ static const int kPollinCheck = POLLIN | POLLHUP | POLLERR;
 static const int kPolloutCheck = POLLOUT | POLLHUP | POLLERR;
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
-using ::grpc_event_engine::experimental::AnyInvocableClosure;
-using ::grpc_event_engine::experimental::EventEngine;
-using ::grpc_event_engine::experimental::Poller;
-using ::grpc_event_engine::posix_engine::WakeupFd;
 using Events = absl::InlinedVector<PollEventHandle*, 5>;
 
 class PollEventHandle : public EventHandle {
@@ -334,7 +332,7 @@ void ResetEventManagerOnFork() {
 // It is possible that GLIBC has epoll but the underlying kernel doesn't.
 // Create epoll_fd to make sure epoll support is available
 bool InitPollPollerPosix() {
-  if (!grpc_event_engine::posix_engine::SupportsWakeupFd()) {
+  if (!grpc_event_engine::experimental::SupportsWakeupFd()) {
     return false;
   }
   if (grpc_core::Fork::Enabled()) {
@@ -377,6 +375,9 @@ void PollEventHandle::OrphanHandle(PosixEngineClosure* on_done, int* release_fd,
       is_shutdown_ = true;
       shutdown_error_ =
           absl::Status(absl::StatusCode::kInternal, "FD Orphaned");
+      grpc_core::StatusSetInt(&shutdown_error_,
+                              grpc_core::StatusIntProperty::kRpcStatus,
+                              GRPC_STATUS_UNAVAILABLE);
       // signal read/write closed to OS so that future operations fail.
       if (!released_) {
         shutdown(fd_, SHUT_RDWR);
@@ -414,11 +415,10 @@ int PollEventHandle::NotifyOnLocked(PosixEngineClosure** st,
     scheduler_->Run(closure);
     return 1;
   } else {
-    /* upcallptr was set to a different closure.  This is an error! */
-    gpr_log(GPR_ERROR,
-            "User called a notify_on function with a previous callback still "
-            "pending");
-    abort();
+    // upcallptr was set to a different closure.  This is an error!
+    grpc_core::Crash(
+        "User called a notify_on function with a previous callback still "
+        "pending");
   }
   return 0;
 }
@@ -452,6 +452,9 @@ void PollEventHandle::ShutdownHandle(absl::Status why) {
     if (!is_shutdown_) {
       is_shutdown_ = true;
       shutdown_error_ = why;
+      grpc_core::StatusSetInt(&shutdown_error_,
+                              grpc_core::StatusIntProperty::kRpcStatus,
+                              GRPC_STATUS_UNAVAILABLE);
       // signal read/write closed to OS so that future operations fail.
       shutdown(fd_, SHUT_RDWR);
       SetReadyLocked(&read_closure_);
@@ -716,18 +719,15 @@ Poller::WorkResult PollPoller::Work(
       // may crash.
       r = poll(pfds, pfd_count, timeout_ms);
     } else {
-      gpr_log(GPR_ERROR,
-              "Attempted a blocking poll when declared non-polling.");
-      GPR_ASSERT(false);
+      grpc_core::Crash("Attempted a blocking poll when declared non-polling.");
     }
 
     if (r <= 0) {
       if (r < 0 && errno != EINTR) {
         // Abort fail here.
-        gpr_log(GPR_ERROR,
-                "(event_engine) PollPoller:%p encountered poll error: %s", this,
-                grpc_core::StrError(errno).c_str());
-        GPR_ASSERT(false);
+        grpc_core::Crash(absl::StrFormat(
+            "(event_engine) PollPoller:%p encountered poll error: %s", this,
+            grpc_core::StrError(errno).c_str()));
       }
 
       for (i = 1; i < pfd_count; i++) {
@@ -844,37 +844,36 @@ PollPoller* MakePollPoller(Scheduler* scheduler, bool use_phony_poll) {
   return nullptr;
 }
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
-#else /* GRPC_POSIX_SOCKET_EV_POLL */
+#else  // GRPC_POSIX_SOCKET_EV_POLL
 
-namespace grpc_event_engine {
-namespace posix_engine {
+#include "src/core/lib/gprpp/crash.h"
 
-using ::grpc_event_engine::experimental::EventEngine;
-using ::grpc_event_engine::experimental::Poller;
+namespace grpc_event_engine {
+namespace experimental {
 
 PollPoller::PollPoller(Scheduler* /* engine */) {
-  GPR_ASSERT(false && "unimplemented");
+  grpc_core::Crash("unimplemented");
 }
 
-void PollPoller::Shutdown() { GPR_ASSERT(false && "unimplemented"); }
+void PollPoller::Shutdown() { grpc_core::Crash("unimplemented"); }
 
-PollPoller::~PollPoller() { GPR_ASSERT(false && "unimplemented"); }
+PollPoller::~PollPoller() { grpc_core::Crash("unimplemented"); }
 
 EventHandle* PollPoller::CreateHandle(int /*fd*/, absl::string_view /*name*/,
                                       bool /*track_err*/) {
-  GPR_ASSERT(false && "unimplemented");
+  grpc_core::Crash("unimplemented");
 }
 
 Poller::WorkResult PollPoller::Work(
     EventEngine::Duration /*timeout*/,
     absl::FunctionRef<void()> /*schedule_poll_again*/) {
-  GPR_ASSERT(false && "unimplemented");
+  grpc_core::Crash("unimplemented");
 }
 
-void PollPoller::Kick() { GPR_ASSERT(false && "unimplemented"); }
+void PollPoller::Kick() { grpc_core::Crash("unimplemented"); }
 
 // If GRPC_LINUX_EPOLL is not defined, it means epoll is not available. Return
 // nullptr.
@@ -884,18 +883,18 @@ PollPoller* MakePollPoller(Scheduler* /*scheduler*/,
 }
 
 void PollPoller::KickExternal(bool /*ext*/) {
-  GPR_ASSERT(false && "unimplemented");
+  grpc_core::Crash("unimplemented");
 }
 
 void PollPoller::PollerHandlesListAddHandle(PollEventHandle* /*handle*/) {
-  GPR_ASSERT(false && "unimplemented");
+  grpc_core::Crash("unimplemented");
 }
 
 void PollPoller::PollerHandlesListRemoveHandle(PollEventHandle* /*handle*/) {
-  GPR_ASSERT(false && "unimplemented");
+  grpc_core::Crash("unimplemented");
 }
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif /* GRPC_POSIX_SOCKET_EV_POLL */
+#endif  // GRPC_POSIX_SOCKET_EV_POLL

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

@@ -33,7 +33,7 @@
 #include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 class PollEventHandle;
 
@@ -91,7 +91,7 @@ class PollPoller : public PosixEventPoller {
 // crash failure.
 PollPoller* MakePollPoller(Scheduler* scheduler, bool use_phony_poll);
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_POLL_POSIX_H
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EV_POLL_POSIX_H

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

@@ -28,7 +28,7 @@
 #include "src/core/lib/event_engine/posix_engine/posix_engine_closure.h"
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 class Scheduler {
  public:
@@ -105,7 +105,7 @@ class PosixEventPoller : public grpc_event_engine::experimental::Poller {
   ~PosixEventPoller() override = default;
 };
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_H
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_H

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

@@ -29,7 +29,7 @@ GPR_GLOBAL_CONFIG_DECLARE_STRING(grpc_poll_strategy);
 #endif
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 namespace {
@@ -70,5 +70,5 @@ PosixEventPoller* MakeDefaultPoller(Scheduler* /*scheduler*/) {
 
 #endif  // GRPC_POSIX_SOCKET_TCP
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -18,7 +18,7 @@
 #include <grpc/support/port_platform.h>
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 class PosixEventPoller;
 class Scheduler;
@@ -27,7 +27,7 @@ class Scheduler;
 // scheduler.
 PosixEventPoller* MakeDefaultPoller(Scheduler* scheduler);
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
 #endif  // GRPC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_EVENT_POLLER_POSIX_DEFAULT_H

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

@@ -35,7 +35,7 @@
 #include "src/core/lib/gprpp/strerror.h"
 
 namespace grpc_event_engine {
-namespace posix_engine {
+namespace experimental {
 
 #ifdef GRPC_LINUX_ERRQUEUE
 int GetSocketTcpInfo(struct tcp_info* info, int fd) {
@@ -71,7 +71,7 @@ bool KernelSupportsErrqueue() {
   return errqueue_supported;
 }
 
-}  // namespace posix_engine
+}  // namespace experimental
 }  // namespace grpc_event_engine
 
 #endif  // GRPC_POSIX_SOCKET_TCP