grpc 1.71.0 → 1.72.0

data/src/core/lib/iomgr/endpoint_pair_posix.cc

@@ -22,10 +22,9 @@
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 
-#include <errno.h>
 #include <fcntl.h>
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/support/alloc.h>
-#include <string.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 
@@ -33,16 +32,27 @@
 
 #include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/event_engine/channel_args_endpoint_config.h"
+#include "src/core/lib/event_engine/extensions/supports_fd.h"
+#include "src/core/lib/event_engine/query_extensions.h"
+#include "src/core/lib/event_engine/shim.h"
 #include "src/core/lib/iomgr/endpoint_pair.h"
+#include "src/core/lib/iomgr/ev_posix.h"
+#include "src/core/lib/iomgr/event_engine_shims/endpoint.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
-#include "src/core/lib/resource_quota/api.h"
 #include "src/core/util/crash.h"
-#include "src/core/util/string.h"
 
-static void create_sockets(int sv[2]) {
+namespace {
+using grpc_event_engine::experimental::ChannelArgsEndpointConfig;
+using grpc_event_engine::experimental::EventEngine;
+using grpc_event_engine::experimental::EventEngineSupportsFdExtension;
+using grpc_event_engine::experimental::QueryExtension;
+using grpc_event_engine::experimental::UsePollsetAlternative;
+
+void create_sockets(int sv[2]) {
   int flags;
   grpc_create_socketpair_if_unix(sv);
   flags = fcntl(sv[0], F_GETFL, 0);
@@ -53,27 +63,44 @@ static void create_sockets(int sv[2]) {
   CHECK(grpc_set_socket_no_sigpipe_if_possible(sv[1]) == absl::OkStatus());
 }
 
+}  // namespace
+
 grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(
     const char* name, const grpc_channel_args* args) {
   int sv[2];
   grpc_endpoint_pair p;
   create_sockets(sv);
   grpc_core::ExecCtx exec_ctx;
-  std::string final_name = absl::StrCat(name, ":client");
   auto new_args = grpc_core::CoreConfiguration::Get()
                       .channel_args_preconditioning()
                       .PreconditionChannelArgs(args);
-  p.client = grpc_tcp_create(
-      grpc_fd_create(sv[1], final_name.c_str(), false),
-      TcpOptionsFromEndpointConfig(
-          grpc_event_engine::experimental::ChannelArgsEndpointConfig(new_args)),
-      "socketpair-server");
+  if (UsePollsetAlternative()) {
+    // Return iomgr-wrapped EE endpoints if a Posix-compatible EventEngine is
+    // present. If an endpoint cannot be created from an fd, crash.
+    auto* event_engine_supports_fd =
+        QueryExtension<EventEngineSupportsFdExtension>(
+            new_args.GetObjectRef<EventEngine>().get());
+    if (event_engine_supports_fd == nullptr) {
+      grpc_core::Crash(
+          "EventEngine does not support fds, so an endpoint pair cannot be "
+          "created.");
+    }
+    p.client = grpc_event_engine_endpoint_create(
+        event_engine_supports_fd->CreateEndpointFromFd(
+            sv[1], ChannelArgsEndpointConfig(new_args)));
+    p.server = grpc_event_engine_endpoint_create(
+        event_engine_supports_fd->CreateEndpointFromFd(
+            sv[0], ChannelArgsEndpointConfig(new_args)));
+    return p;
+  }
+  std::string final_name = absl::StrCat(name, ":client");
+  p.client =
+      grpc_tcp_create(grpc_fd_create(sv[1], final_name.c_str(), false),
+                      ChannelArgsEndpointConfig(new_args), "socketpair-server");
   final_name = absl::StrCat(name, ":server");
-  p.server = grpc_tcp_create(
-      grpc_fd_create(sv[0], final_name.c_str(), false),
-      TcpOptionsFromEndpointConfig(
-          grpc_event_engine::experimental::ChannelArgsEndpointConfig(new_args)),
-      "socketpair-client");
+  p.server =
+      grpc_tcp_create(grpc_fd_create(sv[0], final_name.c_str(), false),
+                      ChannelArgsEndpointConfig(new_args), "socketpair-client");
   return p;
 }
 

data/src/core/lib/iomgr/endpoint_pair_windows.cc

@@ -27,8 +27,13 @@
 
 #include "absl/log/check.h"
 #include "absl/log/log.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/event_engine/channel_args_endpoint_config.h"
+#include "src/core/lib/event_engine/extensions/supports_win_sockets.h"
+#include "src/core/lib/event_engine/query_extensions.h"
 #include "src/core/lib/iomgr/endpoint_pair.h"
+#include "src/core/lib/iomgr/event_engine_shims/endpoint.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_windows.h"
 #include "src/core/lib/iomgr/tcp_windows.h"
@@ -57,10 +62,11 @@ static void create_sockets(SOCKET sv[2]) {
                        grpc_get_default_wsa_socket_flags());
   CHECK(cli_sock != INVALID_SOCKET);
 
-  CHECK(WSAConnect(cli_sock, (grpc_sockaddr*)&addr, addr_len, NULL, NULL, NULL,
-                   NULL) == 0);
+  CHECK_EQ(WSAConnect(cli_sock, (grpc_sockaddr*)&addr, addr_len, NULL, NULL,
+                      NULL, NULL),
+           0);
   svr_sock = accept(lst_sock, (grpc_sockaddr*)&addr, &addr_len);
-  CHECK(svr_sock != INVALID_SOCKET);
+  CHECK_NE(svr_sock, INVALID_SOCKET);
 
   closesocket(lst_sock);
   grpc_error_handle error = grpc_tcp_prepare_socket(cli_sock);
@@ -79,15 +85,44 @@ static void create_sockets(SOCKET sv[2]) {
 }
 
 grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(
-    const char*, const grpc_channel_args* /* channel_args */) {
+    const char*, const grpc_channel_args* channel_args) {
   SOCKET sv[2];
   grpc_endpoint_pair p;
   create_sockets(sv);
   grpc_core::ExecCtx exec_ctx;
-  p.client = grpc_tcp_create(grpc_winsocket_create(sv[1], "endpoint:client"),
-                             "endpoint:server");
-  p.server = grpc_tcp_create(grpc_winsocket_create(sv[0], "endpoint:server"),
-                             "endpoint:client");
+  if (grpc_core::IsPollsetAlternativeEnabled()) {
+    auto new_args = grpc_core::CoreConfiguration::Get()
+                        .channel_args_preconditioning()
+                        .PreconditionChannelArgs(channel_args);
+    auto* event_engine_supports_win_sockets =
+        grpc_event_engine::experimental::QueryExtension<
+            grpc_event_engine::experimental::EventEngineWindowsSocketSupport>(
+            new_args
+                .GetObjectRef<grpc_event_engine::experimental::EventEngine>()
+                .get());
+    CHECK_NE(event_engine_supports_win_sockets, nullptr)
+        << "EventEngine does not support windows SOCKETS, so an endpoint pair "
+           "cannot be created.";
+    auto client_endpoint =
+        event_engine_supports_win_sockets->CreateEndpointFromWinSocket(
+            sv[1], grpc_event_engine::experimental::ChannelArgsEndpointConfig(
+                       new_args));
+    CHECK_NE(client_endpoint.get(), nullptr)
+        << "Failed to create client endpoint";
+    auto server_endpoint =
+        event_engine_supports_win_sockets->CreateEndpointFromWinSocket(
+            sv[0], grpc_event_engine::experimental::ChannelArgsEndpointConfig(
+                       new_args));
+    CHECK_NE(server_endpoint.get(), nullptr)
+        << "Failed to create server endpoint";
+    p.client = grpc_event_engine_endpoint_create(std::move(client_endpoint));
+    p.server = grpc_event_engine_endpoint_create(std::move(server_endpoint));
+  } else {
+    p.client = grpc_tcp_create(grpc_winsocket_create(sv[1], "endpoint:client"),
+                               "endpoint:server");
+    p.server = grpc_tcp_create(grpc_winsocket_create(sv[0], "endpoint:server"),
+                               "endpoint:client");
+  }
   return p;
 }
 

data/src/core/lib/iomgr/error.cc

@@ -35,6 +35,7 @@
 #endif
 
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/util/strerror.h"
 #include "src/core/util/useful.h"
@@ -109,7 +110,7 @@ absl::Status grpc_wsa_error(const grpc_core::DebugLocation& location, int err,
 grpc_error_handle grpc_error_set_int(grpc_error_handle src,
                                      grpc_core::StatusIntProperty which,
                                      intptr_t value) {
-  if (src.ok()) {
+  if (!grpc_core::IsErrorFlattenEnabled() && src.ok()) {
     src = absl::UnknownError("");
     StatusSetInt(&src, grpc_core::StatusIntProperty::kRpcStatus,
                  GRPC_STATUS_OK);
@@ -126,7 +127,8 @@ bool grpc_error_get_int(grpc_error_handle error,
     return true;
   } else {
     // TODO(veblush): Remove this once absl::Status migration is done
-    if (which == grpc_core::StatusIntProperty::kRpcStatus) {
+    if (!grpc_core::IsErrorFlattenEnabled() &&
+        which == grpc_core::StatusIntProperty::kRpcStatus) {
       switch (error.code()) {
         case absl::StatusCode::kOk:
           *p = GRPC_STATUS_OK;
@@ -148,64 +150,46 @@ bool grpc_error_get_int(grpc_error_handle error,
 grpc_error_handle grpc_error_set_str(grpc_error_handle src,
                                      grpc_core::StatusStrProperty which,
                                      absl::string_view str) {
-  if (src.ok()) {
+  if (!grpc_core::IsErrorFlattenEnabled() && src.ok()) {
     src = absl::UnknownError("");
     StatusSetInt(&src, grpc_core::StatusIntProperty::kRpcStatus,
                  GRPC_STATUS_OK);
   }
-  if (which == grpc_core::StatusStrProperty::kDescription) {
-    // To change the message of absl::Status, a new instance should be created
-    // with a code and payload because it doesn't have a setter for it.
-    absl::Status s = absl::Status(src.code(), str);
-    src.ForEachPayload(
-        [&](absl::string_view type_url, const absl::Cord& payload) {
-          s.SetPayload(type_url, payload);
-        });
-    return s;
-  } else {
-    grpc_core::StatusSetStr(&src, which, str);
-  }
+  grpc_core::StatusSetStr(&src, which, str);
   return src;
 }
 
 bool grpc_error_get_str(grpc_error_handle error,
                         grpc_core::StatusStrProperty which, std::string* s) {
-  if (which == grpc_core::StatusStrProperty::kDescription) {
-    // absl::Status uses the message field for
-    // grpc_core::StatusStrProperty::kDescription instead of using payload.
-    absl::string_view msg = error.message();
-    if (msg.empty()) {
-      return false;
-    } else {
-      *s = std::string(msg);
-      return true;
-    }
+  std::optional<std::string> value = grpc_core::StatusGetStr(error, which);
+  if (value.has_value()) {
+    *s = std::move(*value);
+    return true;
   } else {
-    std::optional<std::string> value = grpc_core::StatusGetStr(error, which);
-    if (value.has_value()) {
-      *s = std::move(*value);
-      return true;
-    } else {
-      // TODO(veblush): Remove this once absl::Status migration is done
-      if (which == grpc_core::StatusStrProperty::kGrpcMessage) {
-        switch (error.code()) {
-          case absl::StatusCode::kOk:
-            *s = "";
-            return true;
-          case absl::StatusCode::kCancelled:
-            *s = "CANCELLED";
-            return true;
-          default:
-            break;
-        }
+    // TODO(veblush): Remove this once absl::Status migration is done
+    if (!grpc_core::IsErrorFlattenEnabled() &&
+        which == grpc_core::StatusStrProperty::kGrpcMessage) {
+      switch (error.code()) {
+        case absl::StatusCode::kOk:
+          *s = "";
+          return true;
+        case absl::StatusCode::kCancelled:
+          *s = "CANCELLED";
+          return true;
+        default:
+          break;
       }
-      return false;
     }
+    return false;
   }
 }
 
 grpc_error_handle grpc_error_add_child(grpc_error_handle src,
                                        grpc_error_handle child) {
+  if (grpc_core::IsErrorFlattenEnabled()) {
+    grpc_core::StatusAddChild(&src, child);
+    return src;
+  }
   if (src.ok()) {
     return child;
   } else {

data/src/core/lib/iomgr/ev_epoll1_linux.cc

@@ -45,6 +45,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/block_annotate.h"
 #include "src/core/lib/iomgr/ev_epoll1_linux.h"
 #include "src/core/lib/iomgr/ev_posix.h"
@@ -332,7 +333,11 @@ static void fork_fd_list_remove_grpc_fd(grpc_fd* fd) {
 
 static grpc_fd* fd_create(int fd, const char* name, bool track_err) {
   grpc_fd* new_fd = nullptr;
-
+  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled()) {
+    grpc_fd* new_fd = static_cast<grpc_fd*>(gpr_malloc(sizeof(grpc_fd)));
+    new_fd->fd = fd;
+    return new_fd;
+  }
   gpr_mu_lock(&fd_freelist_mu);
   if (fd_freelist != nullptr) {
     new_fd = fd_freelist;
@@ -410,6 +415,13 @@ static void fd_shutdown(grpc_fd* fd, grpc_error_handle why) {
 
 static void fd_orphan(grpc_fd* fd, grpc_closure* on_done, int* release_fd,
                       const char* reason) {
+  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled()) {
+    CHECK_NE(release_fd, nullptr);
+    CHECK_EQ(on_done, nullptr);
+    *release_fd = fd->fd;
+    gpr_free(fd);
+    return;
+  }
   grpc_error_handle error;
   bool is_release_fd = (release_fd != nullptr);
 

data/src/core/lib/iomgr/ev_poll_posix.cc

@@ -38,6 +38,7 @@
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/block_annotate.h"
 #include "src/core/lib/iomgr/ev_poll_posix.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
@@ -377,6 +378,11 @@ static void unref_by(grpc_fd* fd, int n) {
 }
 
 static grpc_fd* fd_create(int fd, const char* name, bool track_err) {
+  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled()) {
+    grpc_fd* new_fd = static_cast<grpc_fd*>(gpr_malloc(sizeof(grpc_fd)));
+    new_fd->fd = fd;
+    return new_fd;
+  }
   // Avoid unused-parameter warning for debug-only parameter
   (void)track_err;
   DCHECK(track_err == false);
@@ -467,6 +473,13 @@ static int fd_wrapped_fd(grpc_fd* fd) {
 
 static void fd_orphan(grpc_fd* fd, grpc_closure* on_done, int* release_fd,
                       const char* reason) {
+  if (grpc_core::IsEventEngineForAllOtherEndpointsEnabled()) {
+    CHECK_NE(release_fd, nullptr);
+    CHECK_EQ(on_done, nullptr);
+    *release_fd = fd->fd;
+    gpr_free(fd);
+    return;
+  }
   fd->on_done_closure = on_done;
   fd->released = release_fd != nullptr;
   if (release_fd != nullptr) {

data/src/core/lib/iomgr/polling_entity.cc

@@ -67,8 +67,7 @@ bool grpc_polling_entity_is_empty(const grpc_polling_entity* pollent) {
 void grpc_polling_entity_add_to_pollset_set(grpc_polling_entity* pollent,
                                             grpc_pollset_set* pss_dst) {
   if (pollent->tag == GRPC_POLLS_POLLSET) {
-    // CFStream does not use file destriptors. When CFStream is used, the fd
-    // pollset is possible to be null.
+    // CFStream and EventEngine-based cqs do not use file descriptors.
     if (pollent->pollent.pollset != nullptr) {
       grpc_pollset_set_add_pollset(pss_dst, pollent->pollent.pollset);
     }
@@ -86,14 +85,10 @@ void grpc_polling_entity_add_to_pollset_set(grpc_polling_entity* pollent,
 void grpc_polling_entity_del_from_pollset_set(grpc_polling_entity* pollent,
                                               grpc_pollset_set* pss_dst) {
   if (pollent->tag == GRPC_POLLS_POLLSET) {
-#ifdef GRPC_CFSTREAM
+    // CFStream and EventEngine-based cqs do not use file descriptors.
     if (pollent->pollent.pollset != nullptr) {
       grpc_pollset_set_del_pollset(pss_dst, pollent->pollent.pollset);
     }
-#else
-    CHECK_NE(pollent->pollent.pollset, nullptr);
-    grpc_pollset_set_del_pollset(pss_dst, pollent->pollent.pollset);
-#endif
   } else if (pollent->tag == GRPC_POLLS_POLLSET_SET) {
     CHECK_NE(pollent->pollent.pollset_set, nullptr);
     grpc_pollset_set_del_pollset_set(pss_dst, pollent->pollent.pollset_set);

data/src/core/lib/iomgr/socket_utils_common_posix.cc

@@ -51,6 +51,7 @@
 #include "absl/strings/str_cat.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/iomgr/socket_factory_posix.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/strerror.h"
 #include "src/core/util/string.h"

data/src/core/lib/iomgr/socket_utils_posix.cc

@@ -18,33 +18,37 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <optional>
-
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKETUTILS
 #include <fcntl.h>
-#include <grpc/impl/grpc_types.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
+#include <climits>
+#include <optional>
+
 #include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/util/crash.h"
 #endif
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 
-#include "src/core/lib/event_engine/channel_args_endpoint_config.h"
-#include "src/core/lib/iomgr/socket_utils_posix.h"
-#include "src/core/util/strerror.h"
-
-using ::grpc_event_engine::experimental::EndpointConfig;
+#include <grpc/event_engine/endpoint_config.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/grpc.h>
+#include <grpc/impl/grpc_types.h>
 
-using ::grpc_core::PosixTcpOptions;
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/iomgr/socket_mutator.h"
+#include "src/core/lib/iomgr/socket_utils_posix.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
+#include "src/core/util/useful.h"
 
 namespace {
 
+using grpc_core::PosixTcpOptions;
+
 int AdjustValue(int default_value, int min_value, int max_value,
                 std::optional<int> actual_value) {
   if (!actual_value.has_value() || *actual_value < min_value ||
@@ -55,7 +59,8 @@ int AdjustValue(int default_value, int min_value, int max_value,
 }
 }  // namespace
 
-PosixTcpOptions TcpOptionsFromEndpointConfig(const EndpointConfig& config) {
+PosixTcpOptions TcpOptionsFromEndpointConfig(
+    const grpc_event_engine::experimental::EndpointConfig& config) {
   void* value;
   PosixTcpOptions options;
   options.tcp_read_chunk_size = AdjustValue(
@@ -111,6 +116,12 @@ PosixTcpOptions TcpOptionsFromEndpointConfig(const EndpointConfig& config) {
     options.socket_mutator =
         grpc_socket_mutator_ref(static_cast<grpc_socket_mutator*>(value));
   }
+  value = config.GetVoidPointer(GRPC_INTERNAL_ARG_EVENT_ENGINE);
+  if (value != nullptr) {
+    options.event_engine =
+        reinterpret_cast<grpc_event_engine::experimental::EventEngine*>(value)
+            ->shared_from_this();
+  }
   return options;
 }
 

data/src/core/lib/iomgr/socket_utils_posix.h

@@ -20,14 +20,19 @@
 #define GRPC_SRC_CORE_LIB_IOMGR_SOCKET_UTILS_POSIX_H
 
 #include <grpc/event_engine/endpoint_config.h>
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/grpc_types.h>
 #include <grpc/support/port_platform.h>
 
+#include <cstddef>
+#include <memory>
+#include <utility>
+
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/socket_factory_posix.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/iomgr/socket_mutator.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
+#include "src/core/util/ref_counted_ptr.h"
 
 #ifdef GRPC_LINUX_ERRQUEUE
 #ifndef SO_ZEROCOPY
@@ -65,11 +70,13 @@ struct PosixTcpOptions {
   bool allow_reuse_port = false;
   RefCountedPtr<ResourceQuota> resource_quota;
   struct grpc_socket_mutator* socket_mutator = nullptr;
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine;
   PosixTcpOptions() = default;
   // Move ctor
   PosixTcpOptions(PosixTcpOptions&& other) noexcept {
     socket_mutator = std::exchange(other.socket_mutator, nullptr);
     resource_quota = std::move(other.resource_quota);
+    event_engine = std::move(other.event_engine);
     CopyIntegerOptions(other);
   }
   // Move assignment
@@ -79,6 +86,7 @@ struct PosixTcpOptions {
     }
     socket_mutator = std::exchange(other.socket_mutator, nullptr);
     resource_quota = std::move(other.resource_quota);
+    event_engine = std::move(other.event_engine);
     CopyIntegerOptions(other);
     return *this;
   }
@@ -88,6 +96,7 @@ struct PosixTcpOptions {
       socket_mutator = grpc_socket_mutator_ref(other.socket_mutator);
     }
     resource_quota = other.resource_quota;
+    event_engine = other.event_engine;
     CopyIntegerOptions(other);
   }
   // Copy assignment
@@ -103,6 +112,7 @@ struct PosixTcpOptions {
       socket_mutator = grpc_socket_mutator_ref(other.socket_mutator);
     }
     resource_quota = other.resource_quota;
+    event_engine = other.event_engine;
     CopyIntegerOptions(other);
     return *this;
   }

data/src/core/lib/iomgr/tcp_client_cfstream.cc

@@ -147,11 +147,10 @@ static int64_t CFStreamClientConnect(
     grpc_pollset_set* /*interested_parties*/,
     const grpc_event_engine::experimental::EndpointConfig& config,
     const grpc_resolved_address* resolved_addr, grpc_core::Timestamp deadline) {
-  if (grpc_event_engine::experimental::UseEventEngineClient()) {
-    return grpc_event_engine::experimental::event_engine_tcp_client_connect(
-        closure, ep, config, resolved_addr, deadline);
-  }
-
+#if GRPC_IOS_EVENT_ENGINE_CLIENT
+  return grpc_event_engine::experimental::event_engine_tcp_client_connect(
+      closure, ep, config, resolved_addr, deadline);
+#endif
   auto addr_uri = grpc_sockaddr_to_uri(resolved_addr);
   if (!addr_uri.ok()) {
     grpc_error_handle error = GRPC_ERROR_CREATE(addr_uri.status().ToString());
@@ -198,10 +197,10 @@ static int64_t CFStreamClientConnect(
 }
 
 static bool CFStreamClientCancelConnect(int64_t connection_handle) {
-  if (grpc_event_engine::experimental::UseEventEngineClient()) {
-    return grpc_event_engine::experimental::
-        event_engine_tcp_client_cancel_connect(connection_handle);
-  }
+#if GRPC_IOS_EVENT_ENGINE_CLIENT
+  return grpc_event_engine::experimental::
+      event_engine_tcp_client_cancel_connect(connection_handle);
+#endif
   return false;
 }
 

data/src/core/lib/iomgr/tcp_client_posix.cc

@@ -51,6 +51,7 @@
 #include "src/core/lib/iomgr/vsock.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/util/crash.h"
+#include "src/core/util/status_helper.h"
 #include "src/core/util/string.h"
 
 using ::grpc_event_engine::experimental::EndpointConfig;
@@ -154,6 +155,7 @@ static void tc_on_alarm(void* acp, grpc_error_handle error) {
   }
 }
 
+// Deprecated. This is internal-only, no new uses permitted.
 static grpc_endpoint* grpc_tcp_client_create_from_fd(
     grpc_fd* fd, const grpc_core::PosixTcpOptions& options,
     absl::string_view addr_str) {
@@ -163,7 +165,7 @@ static grpc_endpoint* grpc_tcp_client_create_from_fd(
 grpc_endpoint* grpc_tcp_create_from_fd(
     grpc_fd* fd, const grpc_event_engine::experimental::EndpointConfig& config,
     absl::string_view addr_str) {
-  return grpc_tcp_create(fd, TcpOptionsFromEndpointConfig(config), addr_str);
+  return grpc_tcp_create(fd, config, addr_str);
 }
 
 static void on_writable(void* acp, grpc_error_handle error) {
@@ -265,14 +267,8 @@ finish:
   done = (--ac->refs == 0);
   gpr_mu_unlock(&ac->mu);
   if (!error.ok()) {
-    std::string str;
-    bool ret = grpc_error_get_str(
-        error, grpc_core::StatusStrProperty::kDescription, &str);
-    CHECK(ret);
-    std::string description =
-        absl::StrCat("Failed to connect to remote host: ", str);
-    error = grpc_error_set_str(
-        error, grpc_core::StatusStrProperty::kDescription, description);
+    error =
+        grpc_core::AddMessagePrefix("Failed to connect to remote host", error);
   }
   if (done) {
     // This is safe even outside the lock, because "done", the sentinel, is
@@ -320,7 +316,7 @@ grpc_error_handle grpc_tcp_client_prepare_fd(
 
 int64_t grpc_tcp_client_create_from_prepared_fd(
     grpc_pollset_set* interested_parties, grpc_closure* closure, const int fd,
-    const grpc_core::PosixTcpOptions& options,
+    const grpc_event_engine::experimental::EndpointConfig& config,
     const grpc_resolved_address* addr, grpc_core::Timestamp deadline,
     grpc_endpoint** ep) {
   int err;
@@ -348,7 +344,7 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
   if (err >= 0) {
     // Connection already succeeded. Return 0 to discourage any cancellation
     // attempts.
-    *ep = grpc_tcp_client_create_from_fd(fdobj, options, *addr_uri);
+    *ep = grpc_tcp_create_from_fd(fdobj, config, *addr_uri);
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, absl::OkStatus());
     return 0;
   }
@@ -375,7 +371,7 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
   ac->refs = 2;
   GRPC_CLOSURE_INIT(&ac->write_closure, on_writable, ac,
                     grpc_schedule_on_exec_ctx);
-  ac->options = options;
+  ac->options = TcpOptionsFromEndpointConfig(config);
 
   GRPC_TRACE_LOG(tcp, INFO) << "CLIENT_CONNECT: " << ac->addr_str
                             << ": asynchronously connecting fd " << fdobj;
@@ -405,17 +401,17 @@ static int64_t tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
         closure, ep, config, addr, deadline);
   }
   grpc_resolved_address mapped_addr;
-  grpc_core::PosixTcpOptions options(TcpOptionsFromEndpointConfig(config));
   int fd = -1;
   grpc_error_handle error;
   *ep = nullptr;
-  if ((error = grpc_tcp_client_prepare_fd(options, addr, &mapped_addr, &fd)) !=
+  if ((error = grpc_tcp_client_prepare_fd(TcpOptionsFromEndpointConfig(config),
+                                          addr, &mapped_addr, &fd)) !=
       absl::OkStatus()) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
     return 0;
   }
   return grpc_tcp_client_create_from_prepared_fd(
-      interested_parties, closure, fd, options, &mapped_addr, deadline, ep);
+      interested_parties, closure, fd, config, &mapped_addr, deadline, ep);
 }
 
 static bool tcp_cancel_connect(int64_t connection_handle) {

data/src/core/lib/iomgr/tcp_client_posix.h

@@ -65,7 +65,7 @@ grpc_error_handle grpc_tcp_client_prepare_fd(
 //
 int64_t grpc_tcp_client_create_from_prepared_fd(
     grpc_pollset_set* interested_parties, grpc_closure* closure, const int fd,
-    const grpc_core::PosixTcpOptions& options,
+    const grpc_event_engine::experimental::EndpointConfig& config,
     const grpc_resolved_address* addr, grpc_core::Timestamp deadline,
     grpc_endpoint** ep);