grpc 1.71.0 → 1.73.0

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

@@ -37,7 +37,7 @@ DebugOnlyTraceFlag fd_trace_trace(false, "fd_trace");
 DebugOnlyTraceFlag lb_policy_refcount_trace(false, "lb_policy_refcount");
 DebugOnlyTraceFlag party_state_trace(false, "party_state");
 DebugOnlyTraceFlag pending_tags_trace(false, "pending_tags");
-DebugOnlyTraceFlag ph2_trace(false, "ph2");
+DebugOnlyTraceFlag http2_ph2_transport_trace(false, "http2_ph2_transport");
 DebugOnlyTraceFlag polling_trace(false, "polling");
 DebugOnlyTraceFlag polling_api_trace(false, "polling_api");
 DebugOnlyTraceFlag promise_primitives_trace(false, "promise_primitives");
@@ -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");
@@ -69,7 +70,6 @@ TraceFlag client_channel_lb_call_trace(false, "client_channel_lb_call");
 TraceFlag client_idle_filter_trace(false, "client_idle_filter");
 TraceFlag compression_trace(false, "compression");
 TraceFlag connectivity_state_trace(false, "connectivity_state");
-TraceFlag cronet_trace(false, "cronet");
 TraceFlag dns_resolver_trace(false, "dns_resolver");
 TraceFlag environment_autodetect_trace(false, "environment_autodetect");
 TraceFlag event_engine_trace(false, "event_engine");
@@ -79,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");
@@ -153,7 +152,6 @@ const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags() {
           {"client_idle_filter", &client_idle_filter_trace},
           {"compression", &compression_trace},
           {"connectivity_state", &connectivity_state_trace},
-          {"cronet", &cronet_trace},
           {"dns_resolver", &dns_resolver_trace},
           {"environment_autodetect", &environment_autodetect_trace},
           {"event_engine", &event_engine_trace},
@@ -163,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},
@@ -227,7 +224,7 @@ const absl::flat_hash_map<std::string, TraceFlag*>& GetAllTraceFlags() {
           {"lb_policy_refcount", &lb_policy_refcount_trace},
           {"party_state", &party_state_trace},
           {"pending_tags", &pending_tags_trace},
-          {"ph2", &ph2_trace},
+          {"http2_ph2_transport", &http2_ph2_transport_trace},
           {"polling", &polling_trace},
           {"polling_api", &polling_api_trace},
           {"promise_primitives", &promise_primitives_trace},
@@ -237,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

@@ -37,7 +37,7 @@ extern DebugOnlyTraceFlag fd_trace_trace;
 extern DebugOnlyTraceFlag lb_policy_refcount_trace;
 extern DebugOnlyTraceFlag party_state_trace;
 extern DebugOnlyTraceFlag pending_tags_trace;
-extern DebugOnlyTraceFlag ph2_trace;
+extern DebugOnlyTraceFlag http2_ph2_transport_trace;
 extern DebugOnlyTraceFlag polling_trace;
 extern DebugOnlyTraceFlag polling_api_trace;
 extern DebugOnlyTraceFlag promise_primitives_trace;
@@ -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;
@@ -68,7 +69,6 @@ extern TraceFlag client_channel_lb_call_trace;
 extern TraceFlag client_idle_filter_trace;
 extern TraceFlag compression_trace;
 extern TraceFlag connectivity_state_trace;
-extern TraceFlag cronet_trace;
 extern TraceFlag dns_resolver_trace;
 extern TraceFlag environment_autodetect_trace;
 extern TraceFlag event_engine_trace;
@@ -77,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

@@ -24,8 +24,8 @@
 
 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 grpc_event_engine::experimental
@@ -34,8 +34,8 @@ std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
 
 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 grpc_event_engine::experimental
@@ -44,8 +44,8 @@ std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
 
 namespace grpc_event_engine::experimental {
 
-std::unique_ptr<EventEngine> DefaultEventEngineFactory() {
-  return std::make_unique<PosixEventEngine>();
+std::shared_ptr<EventEngine> DefaultEventEngineFactory() {
+  return PosixEventEngine::MakePosixEventEngine();
 }
 
 }  // namespace grpc_event_engine::experimental

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

@@ -23,7 +23,7 @@
 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 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/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

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

@@ -0,0 +1,48 @@
+// 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_SUPPORTS_WIN_SOCKETS_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_SUPPORTS_WIN_SOCKETS_H
+
+#include <grpc/support/port_platform.h>
+
+#ifdef GRPC_WINSOCK_SOCKET
+#include <grpc/event_engine/event_engine.h>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_event_engine::experimental {
+
+class EventEngineWindowsSocketSupport {
+ public:
+  virtual ~EventEngineWindowsSocketSupport() = default;
+  static absl::string_view EndpointExtensionName() {
+    return "io.grpc.event_engine.extension.event_engine_supports_win_sockets";
+  }
+  /// Creates an EventEngine::Endpoint from a windows SOCKET which is already
+  /// assumed to be connected to a remote peer.
+  /// Parameters:
+  /// \a fd - The connected socket.
+  /// \a config - Additional configuration to applied to the endpoint.
+  virtual std::unique_ptr<EventEngine::Endpoint> CreateEndpointFromWinSocket(
+      SOCKET socket, const EndpointConfig& config) = 0;
+};
+
+}  // namespace grpc_event_engine::experimental
+
+#endif  // GRPC_WINSOCK_SOCKET
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_EXTENSIONS_SUPPORTS_WIN_SOCKETS_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::TcpTracerInterface>
-  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

@@ -277,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;
@@ -595,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";
@@ -603,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;
   }
@@ -1162,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;
 
@@ -1196,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

@@ -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
@@ -354,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();