grpc 1.72.0 → 1.73.0

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

@@ -48,6 +48,7 @@ DebugOnlyTraceFlag slice_refcount_trace(false, "slice_refcount");
 DebugOnlyTraceFlag stream_refcount_trace(false, "stream_refcount");
 DebugOnlyTraceFlag subchannel_refcount_trace(false, "subchannel_refcount");
 DebugOnlyTraceFlag work_serializer_trace(false, "work_serializer");
+DebugOnlyTraceFlag ztrace_trace(false, "ztrace");
 TraceFlag api_trace(false, "api");
 TraceFlag apple_polling_trace(false, "apple_polling");
 TraceFlag backend_metric_trace(false, "backend_metric");
@@ -78,7 +79,6 @@ TraceFlag event_engine_dns_trace(false, "event_engine_dns");
 TraceFlag event_engine_endpoint_trace(false, "event_engine_endpoint");
 TraceFlag event_engine_endpoint_data_trace(false, "event_engine_endpoint_data");
 TraceFlag event_engine_poller_trace(false, "event_engine_poller");
-TraceFlag executor_trace(false, "executor");
 TraceFlag fault_injection_filter_trace(false, "fault_injection_filter");
 TraceFlag flowctl_trace(false, "flowctl");
 TraceFlag fork_trace(false, "fork");
@@ -161,7 +161,6 @@ const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags() {
           {"event_engine_endpoint", &event_engine_endpoint_trace},
           {"event_engine_endpoint_data", &event_engine_endpoint_data_trace},
           {"event_engine_poller", &event_engine_poller_trace},
-          {"executor", &executor_trace},
           {"fault_injection_filter", &fault_injection_filter_trace},
           {"flowctl", &flowctl_trace},
           {"fork", &fork_trace},
@@ -235,6 +234,7 @@ const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags() {
           {"stream_refcount", &stream_refcount_trace},
           {"subchannel_refcount", &subchannel_refcount_trace},
           {"work_serializer", &work_serializer_trace},
+          {"ztrace", &ztrace_trace},
 #endif
       }));
   return *all;

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

@@ -47,6 +47,7 @@ extern DebugOnlyTraceFlag slice_refcount_trace;
 extern DebugOnlyTraceFlag stream_refcount_trace;
 extern DebugOnlyTraceFlag subchannel_refcount_trace;
 extern DebugOnlyTraceFlag work_serializer_trace;
+extern DebugOnlyTraceFlag ztrace_trace;
 extern TraceFlag api_trace;
 extern TraceFlag apple_polling_trace;
 extern TraceFlag backend_metric_trace;
@@ -76,7 +77,6 @@ extern TraceFlag event_engine_dns_trace;
 extern TraceFlag event_engine_endpoint_trace;
 extern TraceFlag event_engine_endpoint_data_trace;
 extern TraceFlag event_engine_poller_trace;
-extern TraceFlag executor_trace;
 extern TraceFlag fault_injection_filter_trace;
 extern TraceFlag flowctl_trace;
 extern TraceFlag fork_trace;

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

@@ -32,6 +32,10 @@
 #include "src/core/lib/event_engine/utils.h"
 #include "src/core/util/crash.h"
 
+#ifndef GRPC_CFSTREAM_MAX_THREADPOOL_SIZE
+#define GRPC_CFSTREAM_MAX_THREADPOOL_SIZE 16u
+#endif  // GRPC_CFSTREAM_MAX_THREADPOOL_SIZE
+
 namespace grpc_event_engine::experimental {
 
 struct CFEventEngine::Closure final : public EventEngine::Closure {
@@ -53,8 +57,8 @@ struct CFEventEngine::Closure final : public EventEngine::Closure {
 };
 
 CFEventEngine::CFEventEngine()
-    : thread_pool_(
-          MakeThreadPool(grpc_core::Clamp(gpr_cpu_num_cores(), 2u, 16u))),
+    : thread_pool_(MakeThreadPool(grpc_core::Clamp(
+          gpr_cpu_num_cores(), 2u, GRPC_CFSTREAM_MAX_THREADPOOL_SIZE))),
       timer_manager_(thread_pool_) {}
 
 CFEventEngine::~CFEventEngine() {

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

@@ -255,9 +255,9 @@ void CFStreamEndpointImpl::Shutdown() {
   CFWriteStreamClose(cf_write_stream_);
 }
 
-bool CFStreamEndpointImpl::Read(
-    absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer,
-    const EventEngine::Endpoint::ReadArgs* /* args */) {
+bool CFStreamEndpointImpl::Read(absl::AnyInvocable<void(absl::Status)> on_read,
+                                SliceBuffer* buffer,
+                                EventEngine::Endpoint::ReadArgs /* args */) {
   GRPC_TRACE_LOG(event_engine_endpoint, INFO)
       << "CFStreamEndpointImpl::Read, this: " << this;
 
@@ -304,7 +304,7 @@ void CFStreamEndpointImpl::DoRead(
 
 bool CFStreamEndpointImpl::Write(
     absl::AnyInvocable<void(absl::Status)> on_writable, SliceBuffer* data,
-    const EventEngine::Endpoint::WriteArgs* /* args */) {
+    EventEngine::Endpoint::WriteArgs /* args */) {
   GRPC_TRACE_LOG(event_engine_endpoint, INFO)
       << "CFStreamEndpointImpl::Write, this: " << this;
 

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

@@ -44,9 +44,9 @@ class CFStreamEndpointImpl
   void Shutdown();
 
   bool Read(absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer,
-            const EventEngine::Endpoint::ReadArgs* args);
+            EventEngine::Endpoint::ReadArgs args);
   bool Write(absl::AnyInvocable<void(absl::Status)> on_writable,
-             SliceBuffer* data, const EventEngine::Endpoint::WriteArgs* args);
+             SliceBuffer* data, EventEngine::Endpoint::WriteArgs args);
 
   const EventEngine::ResolvedAddress& GetPeerAddress() const {
     return peer_address_;
@@ -109,12 +109,12 @@ class CFStreamEndpoint : public EventEngine::Endpoint {
   ~CFStreamEndpoint() override { impl_->Shutdown(); }
 
   bool Read(absl::AnyInvocable<void(absl::Status)> on_read, SliceBuffer* buffer,
-            const ReadArgs* args) override {
-    return impl_->Read(std::move(on_read), buffer, args);
+            ReadArgs args) override {
+    return impl_->Read(std::move(on_read), buffer, std::move(args));
   }
   bool Write(absl::AnyInvocable<void(absl::Status)> on_writable,
-             SliceBuffer* data, const WriteArgs* args) override {
-    return impl_->Write(std::move(on_writable), data, args);
+             SliceBuffer* data, WriteArgs args) override {
+    return impl_->Write(std::move(on_writable), data, std::move(args));
   }
 
   const EventEngine::ResolvedAddress& GetPeerAddress() const override {
@@ -124,6 +124,14 @@ class CFStreamEndpoint : public EventEngine::Endpoint {
     return impl_->GetLocalAddress();
   }
 
+  std::vector<size_t> AllWriteMetrics() override { return {}; }
+  std::optional<absl::string_view> GetMetricName(size_t) override {
+    return std::nullopt;
+  }
+  std::optional<size_t> GetMetricKey(absl::string_view) override {
+    return std::nullopt;
+  }
+
  public:
   void Connect(absl::AnyInvocable<void(absl::Status)> on_connect,
                EventEngine::ResolvedAddress addr) {

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

@@ -45,7 +45,7 @@ std::shared_ptr<EventEngine> DefaultEventEngineFactory() {
 namespace grpc_event_engine::experimental {
 
 std::shared_ptr<EventEngine> DefaultEventEngineFactory() {
-  return std::make_shared<PosixEventEngine>();
+  return PosixEventEngine::MakePosixEventEngine();
 }
 
 }  // namespace grpc_event_engine::experimental

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

@@ -0,0 +1,46 @@
+// 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_BLOCKING_DNS_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_BLOCKING_DNS_H
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_event_engine::experimental {
+
+class ResolverSupportsBlockingLookups {
+ public:
+  virtual ~ResolverSupportsBlockingLookups() = default;
+
+  static constexpr absl::string_view EndpointExtensionName() {
+    return "io.grpc.event_engine.extension.can_track_errors";
+  }
+
+  virtual absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
+  LookupHostnameBlocking(absl::string_view name,
+                         absl::string_view default_port) = 0;
+
+  virtual absl::StatusOr<std::vector<EventEngine::DNSResolver::SRVRecord>>
+  LookupSRVBlocking(absl::string_view name) = 0;
+
+  virtual absl::StatusOr<std::vector<std::string>> LookupTXTBlocking(
+      absl::string_view name) = 0;
+};
+
+}  // namespace grpc_event_engine::experimental
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_BLOCKING_DNS_H

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

@@ -0,0 +1,62 @@
+// 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_CHANNELZ_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_CHANNELZ_H
+
+#include <memory>
+#include <utility>
+
+#include "absl/strings/string_view.h"
+#include "src/core/channelz/channelz.h"
+#include "src/core/util/ref_counted_ptr.h"
+
+namespace grpc_event_engine::experimental {
+
+class ChannelzExtension {
+ public:
+  virtual ~ChannelzExtension() = default;
+  static absl::string_view EndpointExtensionName() {
+    return "io.grpc.event_engine.extension.channelz";
+  }
+  virtual void AddJson(grpc_core::channelz::DataSink& sink) = 0;
+
+  void SetSocketNode(
+      grpc_core::RefCountedPtr<grpc_core::channelz::SocketNode> socket_node) {
+    data_source_ =
+        std::make_unique<EndpointDataSource>(std::move(socket_node), this);
+  }
+
+ private:
+  class EndpointDataSource final : public grpc_core::channelz::DataSource {
+   public:
+    EndpointDataSource(
+        grpc_core::RefCountedPtr<grpc_core::channelz::SocketNode> socket_node,
+        ChannelzExtension* ep)
+        : grpc_core::channelz::DataSource(std::move(socket_node)), ep_(ep) {}
+    ~EndpointDataSource() { ResetDataSource(); }
+    void AddData(grpc_core::channelz::DataSink& sink) override {
+      ep_->AddJson(sink);
+    }
+
+   private:
+    ChannelzExtension* ep_;
+  };
+
+  std::unique_ptr<EndpointDataSource> data_source_;
+};
+
+}  // namespace grpc_event_engine::experimental
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_CHANNELZ_H

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

@@ -31,8 +31,8 @@ class TcpTraceExtension {
   static absl::string_view EndpointExtensionName() {
     return "io.grpc.event_engine.extension.tcp_trace";
   }
-  virtual std::shared_ptr<grpc_core::TcpConnectionTracer>
-  InitializeAndReturnTcpTracer() = 0;
+  virtual void SetTcpTracer(
+      std::shared_ptr<grpc_core::TcpConnectionTracer> tracer) = 0;
 };
 
 }  // namespace grpc_event_engine::experimental

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

@@ -37,7 +37,6 @@
 #include "src/core/util/useful.h"
 
 namespace grpc_event_engine::experimental {
-namespace {
 
 absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
 LookupHostnameBlocking(absl::string_view name, absl::string_view default_port) {
@@ -89,8 +88,6 @@ LookupHostnameBlocking(absl::string_view name, absl::string_view default_port) {
   return addresses;
 }
 
-}  // namespace
-
 NativePosixDNSResolver::NativePosixDNSResolver(
     std::shared_ptr<EventEngine> event_engine)
     : event_engine_(std::move(event_engine)) {}
@@ -98,10 +95,10 @@ NativePosixDNSResolver::NativePosixDNSResolver(
 void NativePosixDNSResolver::LookupHostname(
     EventEngine::DNSResolver::LookupHostnameCallback on_resolved,
     absl::string_view name, absl::string_view default_port) {
-  event_engine_->Run(
-      [name, default_port, on_resolved = std::move(on_resolved)]() mutable {
-        on_resolved(LookupHostnameBlocking(name, default_port));
-      });
+  event_engine_->Run([name = std::string(name), default_port,
+                      on_resolved = std::move(on_resolved)]() mutable {
+    on_resolved(LookupHostnameBlocking(name, default_port));
+  });
 }
 
 void NativePosixDNSResolver::LookupSRV(

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

@@ -28,6 +28,9 @@
 
 namespace grpc_event_engine::experimental {
 
+absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
+LookupHostnameBlocking(absl::string_view name, absl::string_view default_port);
+
 // An asynchronous DNS resolver which uses the native platform's getaddrinfo
 // API. Only supports A/AAAA records.
 class NativePosixDNSResolver : public EventEngine::DNSResolver {

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

@@ -593,7 +593,7 @@ void PosixEndpointImpl::HandleRead(absl::Status status) {
 
 bool PosixEndpointImpl::Read(absl::AnyInvocable<void(absl::Status)> on_read,
                              SliceBuffer* buffer,
-                             const EventEngine::Endpoint::ReadArgs* args) {
+                             EventEngine::Endpoint::ReadArgs args) {
   grpc_core::ReleasableMutexLock lock(&read_mu_);
   GRPC_TRACE_LOG(event_engine_endpoint, INFO)
       << "Endpoint[" << this << "]: Read";
@@ -601,8 +601,8 @@ bool PosixEndpointImpl::Read(absl::AnyInvocable<void(absl::Status)> on_read,
   incoming_buffer_ = buffer;
   incoming_buffer_->Clear();
   incoming_buffer_->Swap(last_read_buffer_);
-  if (args != nullptr && grpc_core::IsTcpFrameSizeTuningEnabled()) {
-    min_progress_size_ = std::max(static_cast<int>(args->read_hint_bytes), 1);
+  if (grpc_core::IsTcpFrameSizeTuningEnabled()) {
+    min_progress_size_ = std::max(static_cast<int>(args.read_hint_bytes()), 1);
   } else {
     min_progress_size_ = 1;
   }
@@ -1160,7 +1160,7 @@ void PosixEndpointImpl::HandleWrite(absl::Status status) {
 
 bool PosixEndpointImpl::Write(
     absl::AnyInvocable<void(absl::Status)> on_writable, SliceBuffer* data,
-    const EventEngine::Endpoint::WriteArgs* args) {
+    EventEngine::Endpoint::WriteArgs args) {
   absl::Status status = absl::OkStatus();
   TcpZerocopySendRecord* zerocopy_send_record = nullptr;
 
@@ -1194,9 +1194,8 @@ bool PosixEndpointImpl::Write(
     outgoing_buffer_ = data;
     outgoing_byte_idx_ = 0;
   }
-  if (args != nullptr) {
-    outgoing_buffer_arg_ = args->google_specific;
-  }
+  outgoing_buffer_arg_ =
+      args.GetDeprecatedAndDiscouragedGoogleSpecificPointer();
   if (outgoing_buffer_arg_) {
     CHECK(poller_->CanTrackErrors());
   }

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

@@ -28,6 +28,7 @@
 #include <cstdint>
 #include <memory>
 #include <new>
+#include <optional>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
@@ -473,13 +474,11 @@ class PosixEndpointImpl : public grpc_core::RefCounted<PosixEndpointImpl> {
   bool Read(
       absl::AnyInvocable<void(absl::Status)> on_read,
       grpc_event_engine::experimental::SliceBuffer* buffer,
-      const grpc_event_engine::experimental::EventEngine::Endpoint::ReadArgs*
-          args);
+      grpc_event_engine::experimental::EventEngine::Endpoint::ReadArgs args);
   bool Write(
       absl::AnyInvocable<void(absl::Status)> on_writable,
       grpc_event_engine::experimental::SliceBuffer* data,
-      const grpc_event_engine::experimental::EventEngine::Endpoint::WriteArgs*
-          args);
+      grpc_event_engine::experimental::EventEngine::Endpoint::WriteArgs args);
   const grpc_event_engine::experimental::EventEngine::ResolvedAddress&
   GetPeerAddress() const {
     return peer_address_;
@@ -610,20 +609,26 @@ class PosixEndpoint : public PosixEndpointWithFdSupport {
       : impl_(new PosixEndpointImpl(handle, on_shutdown, std::move(engine),
                                     std::move(allocator), options)) {}
 
-  bool Read(
-      absl::AnyInvocable<void(absl::Status)> on_read,
-      grpc_event_engine::experimental::SliceBuffer* buffer,
-      const grpc_event_engine::experimental::EventEngine::Endpoint::ReadArgs*
-          args) override {
-    return impl_->Read(std::move(on_read), buffer, args);
+  bool Read(absl::AnyInvocable<void(absl::Status)> on_read,
+            grpc_event_engine::experimental::SliceBuffer* buffer,
+            grpc_event_engine::experimental::EventEngine::Endpoint::ReadArgs
+                args) override {
+    return impl_->Read(std::move(on_read), buffer, std::move(args));
   }
 
-  bool Write(
-      absl::AnyInvocable<void(absl::Status)> on_writable,
-      grpc_event_engine::experimental::SliceBuffer* data,
-      const grpc_event_engine::experimental::EventEngine::Endpoint::WriteArgs*
-          args) override {
-    return impl_->Write(std::move(on_writable), data, args);
+  bool Write(absl::AnyInvocable<void(absl::Status)> on_writable,
+             grpc_event_engine::experimental::SliceBuffer* data,
+             grpc_event_engine::experimental::EventEngine::Endpoint::WriteArgs
+                 args) override {
+    return impl_->Write(std::move(on_writable), data, std::move(args));
+  }
+
+  std::vector<size_t> AllWriteMetrics() override { return {}; }
+  std::optional<absl::string_view> GetMetricName(size_t) override {
+    return std::nullopt;
+  }
+  std::optional<size_t> GetMetricKey(absl::string_view) override {
+    return std::nullopt;
   }
 
   const grpc_event_engine::experimental::EventEngine::ResolvedAddress&
@@ -665,17 +670,18 @@ class PosixEndpoint : public PosixEndpointWithFdSupport {
  public:
   PosixEndpoint() = default;
 
-  bool Read(absl::AnyInvocable<void(absl::Status)> /*on_read*/,
-            grpc_event_engine::experimental::SliceBuffer* /*buffer*/,
-            const grpc_event_engine::experimental::EventEngine::Endpoint::
-                ReadArgs* /*args*/) override {
+  bool Read(
+      absl::AnyInvocable<void(absl::Status)> /*on_read*/,
+      grpc_event_engine::experimental::SliceBuffer* /*buffer*/,
+      grpc_event_engine::experimental::EventEngine::Endpoint::ReadArgs /*args*/)
+      override {
     grpc_core::Crash("PosixEndpoint::Read not supported on this platform");
   }
 
   bool Write(absl::AnyInvocable<void(absl::Status)> /*on_writable*/,
              grpc_event_engine::experimental::SliceBuffer* /*data*/,
-             const grpc_event_engine::experimental::EventEngine::Endpoint::
-                 WriteArgs* /*args*/) override {
+             grpc_event_engine::experimental::EventEngine::Endpoint::
+                 WriteArgs /*args*/) override {
     grpc_core::Crash("PosixEndpoint::Write not supported on this platform");
   }
 

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

@@ -352,6 +352,28 @@ void PosixEnginePollerManager::TriggerShutdown() {
   poller_->Kick();
 }
 
+std::shared_ptr<PosixEventEngine> PosixEventEngine::MakePosixEventEngine() {
+  // Constructor is private, can't use std::make_shared
+  return std::shared_ptr<PosixEventEngine>(new PosixEventEngine());
+}
+
+#ifdef GRPC_POSIX_SOCKET_TCP
+
+// The posix EventEngine returned by this method would have a shared ownership
+// of the poller and would not be in-charge of driving the poller by calling
+// its Work(..) method. Instead its up to the test to drive the poller. The
+// returned posix EventEngine will also not attempt to shutdown the poller
+// since it does not own it.
+std::shared_ptr<PosixEventEngine>
+PosixEventEngine::MakeTestOnlyPosixEventEngine(
+    std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller>
+        test_only_poller) {
+  // Constructor is private, can't use std::make_shared
+  return std::shared_ptr<PosixEventEngine>(
+      new PosixEventEngine(std::move(test_only_poller)));
+}
+#endif  // GRPC_POSIX_SOCKET_TCP
+
 PosixEnginePollerManager::~PosixEnginePollerManager() {
   if (poller_ != nullptr) {
     poller_->Shutdown();

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

@@ -150,18 +150,7 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
     grpc_core::OrphanablePtr<RefCountedDNSResolverInterface> dns_resolver_;
   };
 
-#ifdef GRPC_POSIX_SOCKET_TCP
-  // Constructs an EventEngine which has a shared ownership of the poller. Do
-  // not call this constructor directly. Instead use the
-  // MakeTestOnlyPosixEventEngine static method. Its expected to be used only in
-  // tests.
-  explicit PosixEventEngine(
-      std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller>
-          poller);
-  PosixEventEngine();
-#else   // GRPC_POSIX_SOCKET_TCP
-  PosixEventEngine();
-#endif  // GRPC_POSIX_SOCKET_TCP
+  static std::shared_ptr<PosixEventEngine> MakePosixEventEngine();
 
   ~PosixEventEngine() override;
 
@@ -216,13 +205,24 @@ class PosixEventEngine final : public PosixEventEngineWithFdSupport,
   // since it does not own it.
   static std::shared_ptr<PosixEventEngine> MakeTestOnlyPosixEventEngine(
       std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller>
-          test_only_poller) {
-    return std::make_shared<PosixEventEngine>(std::move(test_only_poller));
-  }
+          test_only_poller);
 #endif  // GRPC_POSIX_SOCKET_TCP
 
  private:
   struct ClosureData;
+
+  PosixEventEngine();
+
+#ifdef GRPC_POSIX_SOCKET_TCP
+  // Constructs an EventEngine which has a shared ownership of the poller. Do
+  // not call this constructor directly. Instead use the
+  // MakeTestOnlyPosixEventEngine static method. Its expected to be used only in
+  // tests.
+  explicit PosixEventEngine(
+      std::shared_ptr<grpc_event_engine::experimental::PosixEventPoller>
+          poller);
+#endif  // GRPC_POSIX_SOCKET_TCP
+
   EventEngine::TaskHandle RunAfterInternal(Duration when,
                                            absl::AnyInvocable<void()> cb);
 

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

@@ -17,6 +17,8 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/port_platform.h>
 
+#include <type_traits>
+
 #include "absl/strings/string_view.h"
 
 namespace grpc_event_engine::experimental {
@@ -56,27 +58,14 @@ class ExtendedType : public EEClass, public Exports... {
 };
 
 /// A helper method which returns a valid pointer if the extension is
-/// supported by the endpoint.
-template <typename T>
-T* QueryExtension(EventEngine::Endpoint* endpoint) {
-  if (endpoint == nullptr) return nullptr;
-  return static_cast<T*>(endpoint->QueryExtension(T::EndpointExtensionName()));
-}
-
-/// A helper method which returns a valid pointer if the extension is
-/// supported by the listener.
-template <typename T>
-T* QueryExtension(EventEngine::Listener* listener) {
-  if (listener == nullptr) return nullptr;
-  return static_cast<T*>(listener->QueryExtension(T::EndpointExtensionName()));
-}
-
-/// A helper method which returns a valid pointer if the extension is
-/// supported by the EventEngine.
-template <typename T>
-T* QueryExtension(EventEngine* engine) {
-  if (engine == nullptr) return nullptr;
-  return static_cast<T*>(engine->QueryExtension(T::EndpointExtensionName()));
+/// supported by the extending object. Returns nullptr if the extension is not
+/// supported.
+template <typename Extension, class ExtensibleClass>
+std::enable_if_t<std::is_base_of_v<Extensible, ExtensibleClass>, Extension*>
+QueryExtension(ExtensibleClass* extending_obj) {
+  if (extending_obj == nullptr) return nullptr;
+  return static_cast<Extension*>(
+      extending_obj->QueryExtension(Extension::EndpointExtensionName()));
 }
 
 }  // namespace grpc_event_engine::experimental

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

@@ -133,9 +133,10 @@ absl::StatusOr<std::string> ResolvedAddrToUriUnixIfPossible(
     path_string = std::move(*path);
   }
 
-  absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Create(
-      std::move(scheme), /*authority=*/"", std::move(path_string),
-      /*query_parameter_pairs=*/{}, /*fragment=*/"");
+  absl::StatusOr<grpc_core::URI> uri =
+      grpc_core::URI::Create(std::move(scheme), /*user_info=*/"",
+                             /*host_port=*/"", std::move(path_string),
+                             /*query_parameter_pairs=*/{}, /*fragment=*/"");
   if (!uri.ok()) return uri.status();
   return uri->ToString();
 }
@@ -161,9 +162,9 @@ absl::StatusOr<std::string> ResolvedAddrToVsockPathIfPossible(
 absl::StatusOr<std::string> ResolvedAddrToUriVsockIfPossible(
     const EventEngine::ResolvedAddress* resolved_addr) {
   auto path = ResolvedAddrToVsockPathIfPossible(resolved_addr);
-  absl::StatusOr<grpc_core::URI> uri =
-      grpc_core::URI::Create("vsock", /*authority=*/"", std::move(*path),
-                             /*query_parameter_pairs=*/{}, /*fragment=*/"");
+  absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Create(
+      "vsock", /*user_info=*/"", /*host_port=*/"", std::move(*path),
+      /*query_parameter_pairs=*/{}, /*fragment=*/"");
   if (!uri.ok()) return uri.status();
   return uri->ToString();
 }
@@ -425,9 +426,9 @@ absl::StatusOr<std::string> ResolvedAddressToURI(
   }
   auto path = ResolvedAddressToString(addr);
   GRPC_RETURN_IF_ERROR(path.status());
-  absl::StatusOr<grpc_core::URI> uri =
-      grpc_core::URI::Create(*scheme, /*authority=*/"", std::move(path.value()),
-                             /*query_parameter_pairs=*/{}, /*fragment=*/"");
+  absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Create(
+      *scheme, /*user_info=*/"", /*host_port=*/"", std::move(path.value()),
+      /*query_parameter_pairs=*/{}, /*fragment=*/"");
   if (!uri.ok()) return uri.status();
   return uri->ToString();
 }