grpc 1.49.0.pre1 → 1.50.0.pre1

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

@@ -21,15 +21,14 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <sys/socket.h>
-#include <unistd.h>
-
+#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/impl/codegen/grpc_types.h>
 
 #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/socket_mutator.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
 
 #ifdef GRPC_LINUX_ERRQUEUE
 #ifndef SO_ZEROCOPY
@@ -40,6 +39,98 @@
 #endif
 #endif /* ifdef GRPC_LINUX_ERRQUEUE */
 
+namespace grpc_core {
+
+struct PosixTcpOptions {
+  static constexpr int kDefaultReadChunkSize = 8192;
+  static constexpr int kDefaultMinReadChunksize = 256;
+  static constexpr int kDefaultMaxReadChunksize = 4 * 1024 * 1024;
+  static constexpr int kZerocpTxEnabledDefault = 0;
+  static constexpr int kMaxChunkSize = 32 * 1024 * 1024;
+  static constexpr int kDefaultMaxSends = 4;
+  static constexpr size_t kDefaultSendBytesThreshold = 16 * 1024;
+  int tcp_read_chunk_size = kDefaultReadChunkSize;
+  int tcp_min_read_chunk_size = kDefaultMinReadChunksize;
+  int tcp_max_read_chunk_size = kDefaultMaxReadChunksize;
+  int tcp_tx_zerocopy_send_bytes_threshold = kDefaultSendBytesThreshold;
+  int tcp_tx_zerocopy_max_simultaneous_sends = kDefaultMaxSends;
+  bool tcp_tx_zero_copy_enabled = kZerocpTxEnabledDefault;
+  int keep_alive_time_ms = 0;
+  int keep_alive_timeout_ms = 0;
+  bool expand_wildcard_addrs = false;
+  bool allow_reuse_port = false;
+  RefCountedPtr<ResourceQuota> resource_quota;
+  struct grpc_socket_mutator* socket_mutator = nullptr;
+  PosixTcpOptions() = default;
+  // Move ctor
+  PosixTcpOptions(PosixTcpOptions&& other) noexcept {
+    socket_mutator = absl::exchange(other.socket_mutator, nullptr);
+    resource_quota = std::move(other.resource_quota);
+    CopyIntegerOptions(other);
+  }
+  // Move assignment
+  PosixTcpOptions& operator=(PosixTcpOptions&& other) noexcept {
+    if (socket_mutator != nullptr) {
+      grpc_socket_mutator_unref(socket_mutator);
+    }
+    socket_mutator = absl::exchange(other.socket_mutator, nullptr);
+    resource_quota = std::move(other.resource_quota);
+    CopyIntegerOptions(other);
+    return *this;
+  }
+  // Copy ctor
+  PosixTcpOptions(const PosixTcpOptions& other) {
+    if (other.socket_mutator != nullptr) {
+      socket_mutator = grpc_socket_mutator_ref(other.socket_mutator);
+    }
+    resource_quota = other.resource_quota;
+    CopyIntegerOptions(other);
+  }
+  // Copy assignment
+  PosixTcpOptions& operator=(const PosixTcpOptions& other) {
+    if (&other == this) {
+      return *this;
+    }
+    if (socket_mutator != nullptr) {
+      grpc_socket_mutator_unref(socket_mutator);
+      socket_mutator = nullptr;
+    }
+    if (other.socket_mutator != nullptr) {
+      socket_mutator = grpc_socket_mutator_ref(other.socket_mutator);
+    }
+    resource_quota = other.resource_quota;
+    CopyIntegerOptions(other);
+    return *this;
+  }
+  // Destructor.
+  ~PosixTcpOptions() {
+    if (socket_mutator != nullptr) {
+      grpc_socket_mutator_unref(socket_mutator);
+    }
+  }
+
+ private:
+  void CopyIntegerOptions(const PosixTcpOptions& other) {
+    tcp_read_chunk_size = other.tcp_read_chunk_size;
+    tcp_min_read_chunk_size = other.tcp_min_read_chunk_size;
+    tcp_max_read_chunk_size = other.tcp_max_read_chunk_size;
+    tcp_tx_zerocopy_send_bytes_threshold =
+        other.tcp_tx_zerocopy_send_bytes_threshold;
+    tcp_tx_zerocopy_max_simultaneous_sends =
+        other.tcp_tx_zerocopy_max_simultaneous_sends;
+    tcp_tx_zero_copy_enabled = other.tcp_tx_zero_copy_enabled;
+    keep_alive_time_ms = other.keep_alive_time_ms;
+    keep_alive_timeout_ms = other.keep_alive_timeout_ms;
+    expand_wildcard_addrs = other.expand_wildcard_addrs;
+    allow_reuse_port = other.allow_reuse_port;
+  }
+};
+
+}  // namespace grpc_core
+
+grpc_core::PosixTcpOptions TcpOptionsFromEndpointConfig(
+    const grpc_event_engine::experimental::EndpointConfig& config);
+
 /* a wrapper for accept or accept4 */
 int grpc_accept4(int sockfd, grpc_resolved_address* resolved_addr, int nonblock,
                  int cloexec);
@@ -70,7 +161,7 @@ void config_default_tcp_user_timeout(bool enable, int timeout, bool is_client);
 
 /* Set TCP_USER_TIMEOUT */
 grpc_error_handle grpc_set_socket_tcp_user_timeout(
-    int fd, const grpc_channel_args* channel_args, bool is_client);
+    int fd, const grpc_core::PosixTcpOptions& options, bool is_client);
 
 /* Returns true if this system can create AF_INET6 sockets bound to ::1.
    The value is probed once, and cached for the life of the process.
@@ -104,9 +195,10 @@ grpc_error_handle grpc_set_socket_rcvbuf(int fd, int buffer_size_bytes);
 grpc_error_handle grpc_set_socket_with_mutator(int fd, grpc_fd_usage usage,
                                                grpc_socket_mutator* mutator);
 
-/* Extracts the first socket mutator from args if any and applies on the fd. */
+/* Extracts the first socket mutator from config if any and applies on the fd.
+ */
 grpc_error_handle grpc_apply_socket_mutator_in_args(
-    int fd, grpc_fd_usage usage, const grpc_channel_args* args);
+    int fd, grpc_fd_usage usage, const grpc_core::PosixTcpOptions& options);
 
 /* An enum to keep track of IPv4/IPv6 socket modes.
 

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

@@ -22,14 +22,13 @@
 
 grpc_tcp_client_vtable* grpc_tcp_client_impl;
 
-int64_t grpc_tcp_client_connect(grpc_closure* on_connect,
-                                grpc_endpoint** endpoint,
-                                grpc_pollset_set* interested_parties,
-                                const grpc_channel_args* channel_args,
-                                const grpc_resolved_address* addr,
-                                grpc_core::Timestamp deadline) {
+int64_t grpc_tcp_client_connect(
+    grpc_closure* on_connect, grpc_endpoint** endpoint,
+    grpc_pollset_set* interested_parties,
+    const grpc_event_engine::experimental::EndpointConfig& config,
+    const grpc_resolved_address* addr, grpc_core::Timestamp deadline) {
   return grpc_tcp_client_impl->connect(on_connect, endpoint, interested_parties,
-                                       channel_args, addr, deadline);
+                                       config, addr, deadline);
 }
 
 bool grpc_tcp_client_cancel_connect(int64_t connection_handle) {

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

@@ -21,6 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/time.h>
 
@@ -30,11 +31,11 @@
 #include "src/core/lib/resource_quota/memory_quota.h"
 
 typedef struct grpc_tcp_client_vtable {
-  int64_t (*connect)(grpc_closure* on_connect, grpc_endpoint** endpoint,
-                     grpc_pollset_set* interested_parties,
-                     const grpc_channel_args* channel_args,
-                     const grpc_resolved_address* addr,
-                     grpc_core::Timestamp deadline);
+  int64_t (*connect)(
+      grpc_closure* on_connect, grpc_endpoint** endpoint,
+      grpc_pollset_set* interested_parties,
+      const grpc_event_engine::experimental::EndpointConfig& config,
+      const grpc_resolved_address* addr, grpc_core::Timestamp deadline);
   bool (*cancel_connect)(int64_t connection_handle);
 } grpc_tcp_client_vtable;
 
@@ -45,12 +46,11 @@ typedef struct grpc_tcp_client_vtable {
    in this connection being established (in order to continue their work). It
    returns a handle to the connect operation which can be used to cancel the
    connection attempt. */
-int64_t grpc_tcp_client_connect(grpc_closure* on_connect,
-                                grpc_endpoint** endpoint,
-                                grpc_pollset_set* interested_parties,
-                                const grpc_channel_args* channel_args,
-                                const grpc_resolved_address* addr,
-                                grpc_core::Timestamp deadline);
+int64_t grpc_tcp_client_connect(
+    grpc_closure* on_connect, grpc_endpoint** endpoint,
+    grpc_pollset_set* interested_parties,
+    const grpc_event_engine::experimental::EndpointConfig& config,
+    const grpc_resolved_address* addr, grpc_core::Timestamp deadline);
 
 // Returns true if a connect attempt corresponding to the provided handle
 // is successfully cancelled. Otherwise it returns false. If the connect

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

@@ -27,12 +27,12 @@
 #include <netinet/in.h>
 #include <string.h>
 
+#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/cfstream_handle.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -149,11 +149,11 @@ static void ParseResolvedAddress(const grpc_resolved_address* addr,
   *port = grpc_sockaddr_get_port(addr);
 }
 
-static int64_t CFStreamClientConnect(grpc_closure* closure, grpc_endpoint** ep,
-                                     grpc_pollset_set* interested_parties,
-                                     const grpc_channel_args* channel_args,
-                                     const grpc_resolved_address* resolved_addr,
-                                     grpc_core::Timestamp deadline) {
+static int64_t CFStreamClientConnect(
+    grpc_closure* closure, grpc_endpoint** ep,
+    grpc_pollset_set* interested_parties,
+    const grpc_event_engine::experimental::EndpointConfig& /*config*/,
+    const grpc_resolved_address* resolved_addr, grpc_core::Timestamp deadline) {
   auto addr_uri = grpc_sockaddr_to_uri(resolved_addr);
   if (!addr_uri.ok()) {
     grpc_error_handle error =

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

@@ -35,7 +35,6 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/executor.h"
@@ -51,6 +50,8 @@
 
 extern grpc_core::TraceFlag grpc_tcp_trace;
 
+using ::grpc_event_engine::experimental::EndpointConfig;
+
 struct async_connect {
   gpr_mu mu;
   grpc_fd* fd;
@@ -62,9 +63,9 @@ struct async_connect {
   std::string addr_str;
   grpc_endpoint** ep;
   grpc_closure* closure;
-  grpc_channel_args* channel_args;
   int64_t connection_handle;
   bool connect_cancelled;
+  grpc_core::PosixTcpOptions options;
 };
 
 struct ConnectionShard {
@@ -90,9 +91,9 @@ void grpc_tcp_client_global_init() {
   gpr_once_init(&g_tcp_client_posix_init, do_tcp_client_global_init);
 }
 
-static grpc_error_handle prepare_socket(const grpc_resolved_address* addr,
-                                        int fd,
-                                        const grpc_channel_args* channel_args) {
+static grpc_error_handle prepare_socket(
+    const grpc_resolved_address* addr, int fd,
+    const grpc_core::PosixTcpOptions& options) {
   grpc_error_handle err = GRPC_ERROR_NONE;
 
   GPR_ASSERT(fd >= 0);
@@ -106,15 +107,14 @@ static grpc_error_handle prepare_socket(const grpc_resolved_address* addr,
     if (!GRPC_ERROR_IS_NONE(err)) goto error;
     err = grpc_set_socket_reuse_addr(fd, 1);
     if (!GRPC_ERROR_IS_NONE(err)) goto error;
-    err = grpc_set_socket_tcp_user_timeout(fd, channel_args,
-                                           true /* is_client */);
+    err = grpc_set_socket_tcp_user_timeout(fd, options, true /* is_client */);
     if (!GRPC_ERROR_IS_NONE(err)) goto error;
   }
   err = grpc_set_socket_no_sigpipe_if_possible(fd);
   if (!GRPC_ERROR_IS_NONE(err)) goto error;
 
   err = grpc_apply_socket_mutator_in_args(fd, GRPC_FD_CLIENT_CONNECTION_USAGE,
-                                          channel_args);
+                                          options);
   if (!GRPC_ERROR_IS_NONE(err)) goto error;
 
   goto done;
@@ -143,15 +143,20 @@ static void tc_on_alarm(void* acp, grpc_error_handle error) {
   gpr_mu_unlock(&ac->mu);
   if (done) {
     gpr_mu_destroy(&ac->mu);
-    grpc_channel_args_destroy(ac->channel_args);
     delete ac;
   }
 }
 
-grpc_endpoint* grpc_tcp_client_create_from_fd(
-    grpc_fd* fd, const grpc_channel_args* channel_args,
+static grpc_endpoint* grpc_tcp_client_create_from_fd(
+    grpc_fd* fd, const grpc_core::PosixTcpOptions& options,
+    absl::string_view addr_str) {
+  return grpc_tcp_create(fd, options, addr_str);
+}
+
+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, channel_args, addr_str);
+  return grpc_tcp_create(fd, TcpOptionsFromEndpointConfig(config), addr_str);
 }
 
 static void on_writable(void* acp, grpc_error_handle error) {
@@ -207,7 +212,7 @@ static void on_writable(void* acp, grpc_error_handle error) {
   switch (so_error) {
     case 0:
       grpc_pollset_set_del_fd(ac->interested_parties, fd);
-      *ep = grpc_tcp_client_create_from_fd(fd, ac->channel_args, ac->addr_str);
+      *ep = grpc_tcp_client_create_from_fd(fd, ac->options, ac->addr_str);
       fd = nullptr;
       break;
     case ENOBUFS:
@@ -269,7 +274,6 @@ finish:
     // This is safe even outside the lock, because "done", the sentinel, is
     // populated *inside* the lock.
     gpr_mu_destroy(&ac->mu);
-    grpc_channel_args_destroy(ac->channel_args);
     delete ac;
   }
   // Push async connect closure to the executor since this may actually be
@@ -284,8 +288,9 @@ finish:
 }
 
 grpc_error_handle grpc_tcp_client_prepare_fd(
-    const grpc_channel_args* channel_args, const grpc_resolved_address* addr,
-    grpc_resolved_address* mapped_addr, int* fd) {
+    const grpc_core::PosixTcpOptions& options,
+    const grpc_resolved_address* addr, grpc_resolved_address* mapped_addr,
+    int* fd) {
   grpc_dualstack_mode dsmode;
   grpc_error_handle error;
   *fd = -1;
@@ -306,8 +311,7 @@ grpc_error_handle grpc_tcp_client_prepare_fd(
       memcpy(mapped_addr, addr, sizeof(*mapped_addr));
     }
   }
-  if ((error = prepare_socket(mapped_addr, *fd, channel_args)) !=
-      GRPC_ERROR_NONE) {
+  if ((error = prepare_socket(mapped_addr, *fd, options)) != GRPC_ERROR_NONE) {
     return error;
   }
   return GRPC_ERROR_NONE;
@@ -315,8 +319,9 @@ 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_channel_args* channel_args, const grpc_resolved_address* addr,
-    grpc_core::Timestamp deadline, grpc_endpoint** ep) {
+    const grpc_core::PosixTcpOptions& options,
+    const grpc_resolved_address* addr, grpc_core::Timestamp deadline,
+    grpc_endpoint** ep) {
   int err;
   do {
     err = connect(fd, reinterpret_cast<const grpc_sockaddr*>(addr->addr),
@@ -342,7 +347,7 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
   if (err >= 0) {
     // Connection already succeded. Return 0 to discourage any cancellation
     // attempts.
-    *ep = grpc_tcp_client_create_from_fd(fdobj, channel_args, addr_uri.value());
+    *ep = grpc_tcp_client_create_from_fd(fdobj, options, addr_uri.value());
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
     return 0;
   }
@@ -371,7 +376,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->channel_args = grpc_channel_args_copy(channel_args);
+  ac->options = options;
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: asynchronously connecting fd %p",
@@ -395,21 +400,21 @@ int64_t grpc_tcp_client_create_from_prepared_fd(
 
 static int64_t tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
                            grpc_pollset_set* interested_parties,
-                           const grpc_channel_args* channel_args,
+                           const EndpointConfig& config,
                            const grpc_resolved_address* addr,
                            grpc_core::Timestamp 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(channel_args, addr, &mapped_addr,
-                                          &fd)) != GRPC_ERROR_NONE) {
+  if ((error = grpc_tcp_client_prepare_fd(options, addr, &mapped_addr, &fd)) !=
+      GRPC_ERROR_NONE) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
     return 0;
   }
-  return grpc_tcp_client_create_from_prepared_fd(interested_parties, closure,
-                                                 fd, channel_args, &mapped_addr,
-                                                 deadline, ep);
+  return grpc_tcp_client_create_from_prepared_fd(
+      interested_parties, closure, fd, options, &mapped_addr, deadline, ep);
 }
 
 static bool tcp_cancel_connect(int64_t connection_handle) {
@@ -458,7 +463,6 @@ static bool tcp_cancel_connect(int64_t connection_handle) {
     // This is safe even outside the lock, because "done", the sentinel, is
     // populated *inside* the lock.
     gpr_mu_destroy(&ac->mu);
-    grpc_channel_args_destroy(ac->channel_args);
     delete ac;
   }
   return connection_cancel_success;

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

@@ -23,23 +23,24 @@
 
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/ev_posix.h"
+#include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 
 /* Create an endpoint from a connected grpc_fd.
 
    fd: a connected FD. Ownership is taken.
-   channel_args: may contain custom settings for the endpoint
+   config: may contain custom settings for the endpoint
    addr_str: destination address in printable format
    slice_allocator: ownership is taken by client.
    Returns: a new endpoint
 */
-grpc_endpoint* grpc_tcp_client_create_from_fd(
-    grpc_fd* fd, const grpc_channel_args* channel_args,
+grpc_endpoint* grpc_tcp_create_from_fd(
+    grpc_fd* fd, const grpc_event_engine::experimental::EndpointConfig& config,
     absl::string_view addr_str);
 
 /* Return a configured, unbound, unconnected TCP client fd.
 
-   channel_args: may contain custom settings for the fd
+   options: may contain custom settings for the fd
    addr: the destination address
    mapped_addr: out parameter. addr mapped to an address appropriate to the
      type of socket FD created. For example, if addr is IPv4 and dual stack
@@ -48,8 +49,9 @@ grpc_endpoint* grpc_tcp_client_create_from_fd(
    Returns: error, if any. Out parameters are not set on error
 */
 grpc_error_handle grpc_tcp_client_prepare_fd(
-    const grpc_channel_args* channel_args, const grpc_resolved_address* addr,
-    grpc_resolved_address* mapped_addr, int* fd);
+    const grpc_core::PosixTcpOptions& options,
+    const grpc_resolved_address* addr, grpc_resolved_address* mapped_addr,
+    int* fd);
 
 /* Connect a configured TCP client fd.
 
@@ -57,13 +59,14 @@ grpc_error_handle grpc_tcp_client_prepare_fd(
      connection being established (in order to continue their work
    closure: called when complete. On success, *ep will be set.
    fd: an FD returned from grpc_tcp_client_prepare_fd().
-   channel_args: may contain custom settings for the endpoint
+   options: may contain custom settings for the endpoint
    deadline: connection deadline
    ep: out parameter. Set before closure is called if successful
 */
 int64_t grpc_tcp_client_create_from_prepared_fd(
     grpc_pollset_set* interested_parties, grpc_closure* closure, const int fd,
-    const grpc_channel_args* channel_args, const grpc_resolved_address* addr,
-    grpc_core::Timestamp deadline, grpc_endpoint** ep);
+    const grpc_core::PosixTcpOptions& options,
+    const grpc_resolved_address* addr, grpc_core::Timestamp deadline,
+    grpc_endpoint** ep);
 
 #endif /* GRPC_CORE_LIB_IOMGR_TCP_CLIENT_POSIX_H */

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

@@ -24,13 +24,13 @@
 
 #ifdef GRPC_WINSOCK_SOCKET
 
+#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/log_windows.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/sockaddr_windows.h"
@@ -38,8 +38,11 @@
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_windows.h"
 #include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/slice/slice_internal.h"
 
+using ::grpc_event_engine::experimental::EndpointConfig;
+
 struct async_connect {
   grpc_closure* on_done;
   gpr_mu mu;
@@ -50,7 +53,6 @@ struct async_connect {
   int refs;
   grpc_closure on_connect;
   grpc_endpoint** endpoint;
-  grpc_channel_args* channel_args;
 };
 
 static void async_connect_unlock_and_cleanup(async_connect* ac,
@@ -58,7 +60,6 @@ static void async_connect_unlock_and_cleanup(async_connect* ac,
   int done = (--ac->refs == 0);
   gpr_mu_unlock(&ac->mu);
   if (done) {
-    grpc_channel_args_destroy(ac->channel_args);
     gpr_mu_destroy(&ac->mu);
     delete ac;
   }
@@ -105,7 +106,7 @@ static void on_connect(void* acp, grpc_error_handle error) {
         error = GRPC_WSA_ERROR(WSAGetLastError(), "ConnectEx");
         closesocket(socket->socket);
       } else {
-        *ep = grpc_tcp_create(socket, ac->channel_args, ac->addr_name);
+        *ep = grpc_tcp_create(socket, ac->addr_name);
         socket = nullptr;
       }
     } else {
@@ -123,7 +124,7 @@ static void on_connect(void* acp, grpc_error_handle error) {
    notification request for the connection, and one timeout alert. */
 static int64_t tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
                            grpc_pollset_set* interested_parties,
-                           const grpc_channel_args* channel_args,
+                           const EndpointConfig& config,
                            const grpc_resolved_address* addr,
                            grpc_core::Timestamp deadline) {
   SOCKET sock = INVALID_SOCKET;
@@ -208,7 +209,6 @@ static int64_t tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
   ac->refs = 2;
   ac->addr_name = addr_uri.value();
   ac->endpoint = endpoint;
-  ac->channel_args = grpc_channel_args_copy(channel_args);
   GRPC_CLOSURE_INIT(&ac->on_connect, on_connect, ac, grpc_schedule_on_exec_ctx);
 
   GRPC_CLOSURE_INIT(&ac->on_alarm, on_alarm, ac, grpc_schedule_on_exec_ctx);