grpc 1.70.1 → 1.72.0

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

@@ -32,8 +32,7 @@
 #include "src/core/lib/event_engine/utils.h"
 #include "src/core/util/crash.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 struct CFEventEngine::Closure final : public EventEngine::Closure {
   absl::AnyInvocable<void()> cb;
@@ -213,8 +212,7 @@ EventEngine::TaskHandle CFEventEngine::RunAfterInternal(
   return handle;
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
 #endif  // GPR_APPLE

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

@@ -29,8 +29,7 @@
 #include "src/core/lib/surface/init_internally.h"
 #include "src/core/util/sync.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 class CFEventEngine : public EventEngine,
                       public Scheduler,
@@ -80,8 +79,7 @@ class CFEventEngine : public EventEngine,
   TimerManager timer_manager_;
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
 #endif  // GPR_APPLE

data/src/core/lib/event_engine/cf_engine/cfstream_endpoint.cc

@@ -24,8 +24,7 @@
 #include "src/core/lib/event_engine/cf_engine/cfstream_endpoint.h"
 #include "src/core/util/strerror.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 namespace {
 
@@ -170,7 +169,7 @@ void CFStreamEndpointImpl::Connect(
       // wait for write stream open completed to signal connection ready
       break;
     case kCFStreamEventHasBytesAvailable:
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case kCFStreamEventEndEncountered:
       self->read_event_.SetReady();
       break;
@@ -202,7 +201,7 @@ void CFStreamEndpointImpl::WriteCallback(CFWriteStreamRef stream,
       self->open_event_.SetReady();
       break;
     case kCFStreamEventCanAcceptBytes:
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case kCFStreamEventEndEncountered:
       self->write_event_.SetReady();
       break;
@@ -299,7 +298,8 @@ void CFStreamEndpointImpl::DoRead(
   }
 
   buffer->RemoveLastNBytes(buffer->Length() - read_size);
-  on_read(absl::OkStatus());
+  on_read(read_size == 0 ? absl::InternalError("Socket closed")
+                         : absl::OkStatus());
 }
 
 bool CFStreamEndpointImpl::Write(
@@ -367,8 +367,7 @@ void CFStreamEndpointImpl::DoWrite(
   on_writable(absl::OkStatus());
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
 #endif  // GPR_APPLE

data/src/core/lib/event_engine/cf_engine/cfstream_endpoint.h

@@ -32,8 +32,7 @@
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 class CFStreamEndpointImpl
     : public grpc_core::RefCounted<CFStreamEndpointImpl> {
@@ -138,8 +137,7 @@ class CFStreamEndpoint : public EventEngine::Endpoint {
   grpc_core::RefCountedPtr<CFStreamEndpointImpl> impl_;
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
 #endif  // GPR_APPLE

data/src/core/lib/event_engine/cf_engine/cftype_unique_ref.h

@@ -21,8 +21,7 @@
 
 #include <CoreFoundation/CoreFoundation.h>
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 template <typename T>
 class CFTypeUniqueRef {
@@ -73,8 +72,7 @@ class CFTypeUniqueRef {
   T cf_type_ref_;
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
 #endif  // GPR_APPLE

data/src/core/lib/event_engine/cf_engine/dns_service_resolver.cc

@@ -27,8 +27,7 @@
 #include "src/core/lib/event_engine/tcp_socket_utils.h"
 #include "src/core/util/host_port.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 void DNSServiceResolverImpl::LookupHostname(
     EventEngine::DNSResolver::LookupHostnameCallback on_resolve,
@@ -226,9 +225,7 @@ void DNSServiceResolverImpl::Shutdown() {
     auto requests = std::exchange(that->requests_, {});
     lock.Release();
 
-    for (auto& kv : requests) {
-      auto& sdRef = kv.first;
-      auto& request = kv.second;
+    for (auto& [sdRef, request] : requests) {
       GRPC_TRACE_LOG(event_engine_dns, INFO)
           << "DNSServiceResolverImpl::Shutdown sdRef: " << sdRef
           << ", this: " << thatPtr;
@@ -239,8 +236,7 @@ void DNSServiceResolverImpl::Shutdown() {
   });
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
 #endif  // GPR_APPLE

data/src/core/lib/event_engine/cf_engine/dns_service_resolver.h

@@ -29,8 +29,7 @@
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 class DNSServiceResolverImpl
     : public grpc_core::RefCounted<DNSServiceResolverImpl> {
@@ -110,8 +109,7 @@ class DNSServiceResolver : public EventEngine::DNSResolver {
   grpc_core::RefCountedPtr<DNSServiceResolverImpl> impl_;
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // AVAILABLE_MAC_OS_X_VERSION_10_12_AND_LATER
 #endif  // GPR_APPLE

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

@@ -16,20 +16,19 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
-absl::optional<int> ChannelArgsEndpointConfig::GetInt(
+std::optional<int> ChannelArgsEndpointConfig::GetInt(
     absl::string_view key) const {
   return args_.GetInt(key);
 }
 
-absl::optional<absl::string_view> ChannelArgsEndpointConfig::GetString(
+std::optional<absl::string_view> ChannelArgsEndpointConfig::GetString(
     absl::string_view key) const {
   return args_.GetString(key);
 }
@@ -41,5 +40,4 @@ void* ChannelArgsEndpointConfig::GetVoidPointer(absl::string_view key) const {
   return args_.GetVoidPointer(key);
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental

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

@@ -17,12 +17,12 @@
 #include <grpc/event_engine/endpoint_config.h>
 #include <grpc/support/port_platform.h>
 
+#include <optional>
+
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 class ChannelArgsEndpointConfig : public EndpointConfig {
  public:
@@ -32,8 +32,8 @@ class ChannelArgsEndpointConfig : public EndpointConfig {
   ChannelArgsEndpointConfig(const ChannelArgsEndpointConfig& config) = default;
   ChannelArgsEndpointConfig& operator=(const ChannelArgsEndpointConfig& other) =
       default;
-  absl::optional<int> GetInt(absl::string_view key) const override;
-  absl::optional<absl::string_view> GetString(
+  std::optional<int> GetInt(absl::string_view key) const override;
+  std::optional<absl::string_view> GetString(
       absl::string_view key) const override;
   void* GetVoidPointer(absl::string_view key) const override;
 
@@ -41,7 +41,6 @@ class ChannelArgsEndpointConfig : public EndpointConfig {
   grpc_core::ChannelArgs args_;
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_CHANNEL_ARGS_ENDPOINT_CONFIG_H

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

@@ -22,8 +22,7 @@
 
 #include "absl/functional/any_invocable.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 class AnyInvocableClosure : public EventEngine::Closure {
  public:
@@ -64,7 +63,6 @@ class SelfDeletingClosure : public EventEngine::Closure {
   absl::AnyInvocable<void()> dest_cb_;
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_COMMON_CLOSURES_H

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

@@ -17,79 +17,109 @@
 #include <grpc/support/port_platform.h>
 
 #include <atomic>
+#include <chrono>
 #include <memory>
 #include <utility>
+#include <variant>
 
 #include "absl/functional/any_invocable.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/default_event_engine_factory.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/match.h"
 #include "src/core/util/no_destruct.h"
 #include "src/core/util/sync.h"
+#include "src/core/util/wait_for_single_owner.h"
 
 #ifdef GRPC_MAXIMIZE_THREADYNESS
 #include "src/core/lib/event_engine/thready_event_engine/thready_event_engine.h"  // IWYU pragma: keep
 #endif
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 namespace {
-std::atomic<absl::AnyInvocable<std::unique_ptr<EventEngine>()>*>
+// TODO(hork): delete the factory once all known users have migrated away
+std::atomic<absl::AnyInvocable<std::shared_ptr<EventEngine>()>*>
     g_event_engine_factory{nullptr};
 grpc_core::NoDestruct<grpc_core::Mutex> g_mu;
-grpc_core::NoDestruct<std::weak_ptr<EventEngine>> g_event_engine;
+// Defaults to a null weak_ptr<>.  If it contains a shared_ptr<>, will always be
+// non-null.
+grpc_core::NoDestruct<
+    std::variant<std::weak_ptr<EventEngine>, std::shared_ptr<EventEngine>>>
+    g_default_event_engine ABSL_GUARDED_BY(*g_mu);
+
+// Returns nullptr if no engine is set.
+std::shared_ptr<EventEngine> InternalGetDefaultEventEngineIfAny()
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(*g_mu) {
+  return grpc_core::MatchMutable(
+      g_default_event_engine.get(),
+      [&](std::shared_ptr<EventEngine>* event_engine) { return *event_engine; },
+      [&](std::weak_ptr<EventEngine>* weak_ee) { return weak_ee->lock(); });
+}
+
 }  // namespace
 
 void SetEventEngineFactory(
-    absl::AnyInvocable<std::unique_ptr<EventEngine>()> factory) {
+    absl::AnyInvocable<std::shared_ptr<EventEngine>()> factory) {
   delete g_event_engine_factory.exchange(
-      new absl::AnyInvocable<std::unique_ptr<EventEngine>()>(
+      new absl::AnyInvocable<std::shared_ptr<EventEngine>()>(
           std::move(factory)));
-  // Forget any previous EventEngines
+  // Forget any previous factory-created EventEngines
   grpc_core::MutexLock lock(&*g_mu);
-  g_event_engine->reset();
+  g_default_event_engine->emplace<std::weak_ptr<EventEngine>>();
 }
 
 void EventEngineFactoryReset() {
+  grpc_core::MutexLock lock(&*g_mu);
   delete g_event_engine_factory.exchange(nullptr);
-  g_event_engine->reset();
+  g_default_event_engine->emplace<std::weak_ptr<EventEngine>>();
 }
 
-std::unique_ptr<EventEngine> CreateEventEngineInner() {
+std::shared_ptr<EventEngine> CreateEventEngine() {
+  std::shared_ptr<EventEngine> engine;
   if (auto* factory = g_event_engine_factory.load()) {
-    return (*factory)();
+    engine = (*factory)();
+  } else {
+    engine = DefaultEventEngineFactory();
   }
-  return DefaultEventEngineFactory();
-}
-
-std::unique_ptr<EventEngine> CreateEventEngine() {
 #ifdef GRPC_MAXIMIZE_THREADYNESS
-  return std::make_unique<ThreadyEventEngine>(CreateEventEngineInner());
-#else
-  return CreateEventEngineInner();
+  return std::make_shared<ThreadyEventEngine>(std::move(engine));
 #endif
+  return engine;
 }
 
-std::shared_ptr<EventEngine> GetDefaultEventEngine(
-    grpc_core::SourceLocation location) {
+void SetDefaultEventEngine(std::shared_ptr<EventEngine> engine) {
   grpc_core::MutexLock lock(&*g_mu);
-  if (std::shared_ptr<EventEngine> engine = g_event_engine->lock()) {
-    GRPC_TRACE_LOG(event_engine, INFO)
-        << "Returning existing EventEngine::" << engine.get()
-        << ". use_count:" << engine.use_count() << ". Called from " << location;
-    return engine;
+  if (engine == nullptr) {
+    // If it's being set to null, switch back to a weak_ptr.
+    g_default_event_engine->emplace<std::weak_ptr<EventEngine>>();
+  } else {
+    *g_default_event_engine = std::move(engine);
   }
-  std::shared_ptr<EventEngine> engine{CreateEventEngine()};
-  GRPC_TRACE_LOG(event_engine, INFO)
-      << "Created DefaultEventEngine::" << engine.get() << ". Called from "
-      << location;
-  *g_event_engine = engine;
+}
+
+std::shared_ptr<EventEngine> GetDefaultEventEngine() {
+  grpc_core::MutexLock lock(&*g_mu);
+  auto engine = InternalGetDefaultEventEngineIfAny();
+  if (engine != nullptr) return engine;
+  engine = CreateEventEngine();
+  g_default_event_engine->emplace<std::weak_ptr<EventEngine>>(engine);
   return engine;
 }
 
+void ShutdownDefaultEventEngine() {
+  std::shared_ptr<EventEngine> tmp_engine;
+  {
+    grpc_core::MutexLock lock(&*g_mu);
+    tmp_engine = InternalGetDefaultEventEngineIfAny();
+    g_default_event_engine->emplace<std::weak_ptr<EventEngine>>();
+  }
+  if (tmp_engine != nullptr) {
+    grpc_core::WaitForSingleOwner(std::move(tmp_engine));
+  }
+}
+
 namespace {
 grpc_core::ChannelArgs EnsureEventEngineInChannelArgs(
     grpc_core::ChannelArgs args) {
@@ -104,5 +134,4 @@ void RegisterEventEngineChannelArgPreconditioning(
       grpc_event_engine::experimental::EnsureEventEngineInChannelArgs);
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental

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

@@ -23,44 +23,35 @@
 #include "src/core/config/core_configuration.h"
 #include "src/core/util/debug_location.h"
 
-namespace grpc_event_engine {
-namespace experimental {
-
-/// Access the shared global EventEngine instance.
-///
-/// GetDefaultEventEngine is a lazy thing: either a shared global EventEngine
-/// instance exists and will be returned, or that shared global instance will be
-/// created and returned. The returned shared_ptr<EventEngine>'s life is
-/// determined by the shared_ptr, and therefore EventEngines may be created and
-/// destroyed multiple times through the life of your gRPC process, there is no
-/// guarantee of one persistent global instance like in iomgr.
-///
-/// Why would we do this? To begin with, users may provide their own EventEngine
-/// instances on channel or server creation; if they do that, there is some
-/// chance that a default EventEngine instance will not have to be created, and
-/// applications will not have to pay the (probably small) price of
-/// instantiating an engine they do not own. The other major consideration is
-/// that gRPC shutdown is likely going away. Without a well-defined point at
-/// which a persistent global EventEngine instance can safely be shut down, we
-/// risk undefined behavior and various documented breakages if the engine is
-/// not shut down cleanly before the process exits. Therefore, allowing the
-/// EventEngine lifetimes to be determined by the scopes in which they are
-/// needed is a fine solution.
-///
-/// If you're writing code that needs an EventEngine, prefer 1) getting the
-/// EventEngine from somewhere it is already cached - preconditioned
-/// ChannelArgs, or the channel stack for example - or 2) if not otherwise
-/// available, call \a GetDefaultEventEngine and save that shared_ptr to ensure
-/// the Engine's lifetime is at least as long as you need it to be.
-std::shared_ptr<EventEngine> GetDefaultEventEngine(
-    grpc_core::SourceLocation location = grpc_core::SourceLocation());
+namespace grpc_event_engine::experimental {
 
 /// On ingress, ensure that an EventEngine exists in channel args via
 /// preconditioning.
 void RegisterEventEngineChannelArgPreconditioning(
     grpc_core::CoreConfiguration::Builder* builder);
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+/// Register a default EventEngine that is reset and destroyed when this object
+/// is destroyed.
+///
+/// Usage:
+///
+///   {
+///     DefaultEventEngineScope engine_holder(std::make_shared<MyEngine>());
+///     // returns the instance of MyEngine
+///     auto engine = GetDefaultEventEngine();
+///   }
+///   // returns some default internal instance. The previous instance has been
+///   // destroyed.
+///   auto engine = GetDefaultEventEngine();
+///
+class DefaultEventEngineScope {
+ public:
+  explicit DefaultEventEngineScope(std::shared_ptr<EventEngine> engine) {
+    SetDefaultEventEngine(std::move(engine));
+  }
+  ~DefaultEventEngineScope() { ShutdownDefaultEventEngine(); }
+};
+
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_H

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

@@ -22,38 +22,32 @@
 #if defined(GPR_WINDOWS)
 #include "src/core/lib/event_engine/windows/windows_engine.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
-std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
-  return std::make_unique<WindowsEventEngine>();
+std::shared_ptr<EventEngine> DefaultEventEngineFactory() {
+  return std::make_shared<WindowsEventEngine>();
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 #elif defined(GRPC_CFSTREAM)
 #include "src/core/lib/event_engine/cf_engine/cf_engine.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
-std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
-  return std::make_unique<CFEventEngine>();
+std::shared_ptr<EventEngine> DefaultEventEngineFactory() {
+  return std::make_shared<CFEventEngine>();
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 #else
 #include "src/core/lib/event_engine/posix_engine/posix_engine.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
-std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
-  return std::make_unique<PosixEventEngine>();
+std::shared_ptr<EventEngine> DefaultEventEngineFactory() {
+  return std::make_shared<PosixEventEngine>();
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif

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

@@ -20,13 +20,11 @@
 
 #include <memory>
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 /// Create an EventEngine using the default factory provided at link time.
-std::unique_ptr<EventEngine> DefaultEventEngineFactory();
+std::shared_ptr<EventEngine> DefaultEventEngineFactory();
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_DEFAULT_EVENT_ENGINE_FACTORY_H

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

@@ -16,8 +16,7 @@
 
 #include "absl/strings/str_cat.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 const EventEngine::TaskHandle EventEngine::TaskHandle::kInvalid = {-1, -1};
 const EventEngine::ConnectionHandle EventEngine::ConnectionHandle::kInvalid = {
@@ -72,5 +71,4 @@ std::ostream& operator<<(std::ostream& out,
   return printout(out, handle);
 }
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/extensions/can_track_errors.h

@@ -19,8 +19,7 @@
 
 #include "absl/strings/string_view.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 class EndpointCanTrackErrorsExtension {
  public:
@@ -34,7 +33,6 @@ class EndpointCanTrackErrorsExtension {
   virtual bool CanTrackErrors() = 0;
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_CAN_TRACK_ERRORS_H

data/src/core/lib/event_engine/extensions/chaotic_good_extension.h

@@ -20,8 +20,7 @@
 #include "absl/strings/string_view.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 
-namespace grpc_event_engine {
-namespace experimental {
+namespace grpc_event_engine::experimental {
 
 /// An Endpoint extension class that will be supported by EventEngine endpoints
 /// which need to work with the ChaoticGood transport.
@@ -58,7 +57,6 @@ class ChaoticGoodExtension {
   virtual void EnforceRxMemoryAlignment() = 0;
 };
 
-}  // namespace experimental
-}  // namespace grpc_event_engine
+}  // namespace grpc_event_engine::experimental
 
 #endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_CHAOTIC_GOOD_EXTENSION_H

data/src/core/lib/event_engine/extensions/iomgr_compatible.h

@@ -0,0 +1,39 @@
+// Copyright 2025 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.
+
+#ifndef GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_IOMGR_COMPATIBLE_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_IOMGR_COMPATIBLE_H
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_event_engine::experimental {
+
+class IomgrCompatibleListener {
+ public:
+  virtual ~IomgrCompatibleListener() = default;
+  static absl::string_view EndpointExtensionName() {
+    return "io.grpc.event_engine.extension.iomgr_compatible_listener";
+  }
+  /// Supports shutdown before destruction.
+  virtual void Shutdown() = 0;
+};
+
+}  // namespace grpc_event_engine::experimental
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_IOMGR_COMPATIBLE_H