grpc 1.41.0 → 1.43.1

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

@@ -27,12 +27,11 @@
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
-#include "src/core/lib/debug/stats.h"
 #include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/iomgr.h"
+#include "src/core/lib/iomgr/iomgr_internal.h"
 
 #define MAX_DEPTH 2
 
@@ -53,7 +52,7 @@
 namespace grpc_core {
 namespace {
 
-static GPR_THREAD_LOCAL(ThreadState*) g_this_thread_state;
+GPR_THREAD_LOCAL(ThreadState*) g_this_thread_state;
 
 Executor* executors[static_cast<size_t>(ExecutorType::NUM_EXECUTORS)];
 
@@ -92,7 +91,7 @@ TraceFlag executor_trace(false, "executor");
 Executor::Executor(const char* name) : name_(name) {
   adding_thread_lock_ = GPR_SPINLOCK_STATIC_INITIALIZER;
   gpr_atm_rel_store(&num_threads_, 0);
-  max_threads_ = GPR_MAX(1, 2 * gpr_cpu_num_cores());
+  max_threads_ = std::max(1u, 2 * gpr_cpu_num_cores());
 }
 
 void Executor::Init() { SetThreading(true); }
@@ -109,7 +108,7 @@ size_t Executor::RunClosures(const char* executor_name,
   // invoked on its destruction, which will be after completing any closures in
   // the executor's closure list (which were explicitly scheduled onto the
   // executor).
-  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx(
+  ApplicationCallbackExecCtx callback_exec_ctx(
       GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD);
 
   grpc_closure* c = list.head;
@@ -127,7 +126,7 @@ size_t Executor::RunClosures(const char* executor_name,
     GRPC_ERROR_UNREF(error);
     c = next;
     n++;
-    grpc_core::ExecCtx::Get()->Flush();
+    ExecCtx::Get()->Flush();
   }
 
   return n;
@@ -157,12 +156,11 @@ void Executor::SetThreading(bool threading) {
       gpr_cv_init(&thd_state_[i].cv);
       thd_state_[i].id = i;
       thd_state_[i].name = name_;
-      thd_state_[i].thd = grpc_core::Thread();
+      thd_state_[i].thd = Thread();
       thd_state_[i].elems = GRPC_CLOSURE_LIST_INIT;
     }
 
-    thd_state_[0].thd =
-        grpc_core::Thread(name_, &Executor::ThreadMain, &thd_state_[0]);
+    thd_state_[0].thd = Thread(name_, &Executor::ThreadMain, &thd_state_[0]);
     thd_state_[0].thd.Start();
   } else {  // !threading
     if (curr_num_threads == 0) {
@@ -203,8 +201,8 @@ void Executor::SetThreading(bool threading) {
     // finish. Thus, never call Executor::SetThreading(false) in the middle of
     // an application.
     // TODO(guantaol): create another method to finish all the pending closures
-    // registered in the background poller by grpc_core::Executor.
-    grpc_iomgr_shutdown_background_closure();
+    // registered in the background poller by Executor.
+    grpc_iomgr_platform_shutdown_background_closure();
   }
 
   EXECUTOR_TRACE("(%s) SetThreading(%d) done", name_, threading);
@@ -216,7 +214,7 @@ void Executor::ThreadMain(void* arg) {
   ThreadState* ts = static_cast<ThreadState*>(arg);
   g_this_thread_state = ts;
 
-  grpc_core::ExecCtx exec_ctx(GRPC_EXEC_CTX_FLAG_IS_INTERNAL_THREAD);
+  ExecCtx exec_ctx(GRPC_EXEC_CTX_FLAG_IS_INTERNAL_THREAD);
 
   size_t subtract_depth = 0;
   for (;;) {
@@ -237,14 +235,13 @@ void Executor::ThreadMain(void* arg) {
       break;
     }
 
-    GRPC_STATS_INC_EXECUTOR_QUEUE_DRAINED();
     grpc_closure_list closures = ts->elems;
     ts->elems = GRPC_CLOSURE_LIST_INIT;
     gpr_mu_unlock(&ts->mu);
 
     EXECUTOR_TRACE("(%s) [%" PRIdPTR "]: execute", ts->name, ts->id);
 
-    grpc_core::ExecCtx::Get()->InvalidateNow();
+    ExecCtx::Get()->InvalidateNow();
     subtract_depth = RunClosures(ts->name, closures);
   }
 
@@ -254,11 +251,6 @@ void Executor::ThreadMain(void* arg) {
 void Executor::Enqueue(grpc_closure* closure, grpc_error_handle error,
                        bool is_short) {
   bool retry_push;
-  if (is_short) {
-    GRPC_STATS_INC_EXECUTOR_SCHEDULED_SHORT_ITEMS();
-  } else {
-    GRPC_STATS_INC_EXECUTOR_SCHEDULED_LONG_ITEMS();
-  }
 
   do {
     retry_push = false;
@@ -274,21 +266,17 @@ void Executor::Enqueue(grpc_closure* closure, grpc_error_handle error,
 #else
       EXECUTOR_TRACE("(%s) schedule %p inline", name_, closure);
 #endif
-      grpc_closure_list_append(grpc_core::ExecCtx::Get()->closure_list(),
-                               closure, error);
+      grpc_closure_list_append(ExecCtx::Get()->closure_list(), closure, error);
       return;
     }
 
-    if (grpc_iomgr_add_closure_to_background_poller(closure, error)) {
+    if (grpc_iomgr_platform_add_closure_to_background_poller(closure, error)) {
       return;
     }
 
     ThreadState* ts = g_this_thread_state;
     if (ts == nullptr) {
-      ts = &thd_state_[GPR_HASH_POINTER(grpc_core::ExecCtx::Get(),
-                                        cur_thread_count)];
-    } else {
-      GRPC_STATS_INC_EXECUTOR_SCHEDULED_TO_SELF();
+      ts = &thd_state_[HashPointer(ExecCtx::Get(), cur_thread_count)];
     }
 
     ThreadState* orig_ts = ts;
@@ -341,7 +329,6 @@ void Executor::Enqueue(grpc_closure* closure, grpc_error_handle error,
       // - Note that gpr_cv_signal() won't immediately wakeup the thread. That
       //   happens after we release the mutex &ts->mu a few lines below
       if (grpc_closure_list_empty(ts->elems) && !ts->shutdown) {
-        GRPC_STATS_INC_EXECUTOR_WAKEUP_INITIATED();
         gpr_cv_signal(&ts->cv);
       }
 
@@ -366,16 +353,12 @@ void Executor::Enqueue(grpc_closure* closure, grpc_error_handle error,
         // always increment num_threads under the 'adding_thread_lock')
         gpr_atm_rel_store(&num_threads_, cur_thread_count + 1);
 
-        thd_state_[cur_thread_count].thd = grpc_core::Thread(
-            name_, &Executor::ThreadMain, &thd_state_[cur_thread_count]);
+        thd_state_[cur_thread_count].thd =
+            Thread(name_, &Executor::ThreadMain, &thd_state_[cur_thread_count]);
         thd_state_[cur_thread_count].thd.Start();
       }
       gpr_spinlock_unlock(&adding_thread_lock_);
     }
-
-    if (retry_push) {
-      GRPC_STATS_INC_EXECUTOR_PUSH_RETRIES();
-    }
   } while (retry_push);
 }
 

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

@@ -36,7 +36,7 @@ struct ThreadState {
   size_t depth;  // Number of closures in the closure list
   bool shutdown;
   bool queued_long_job;
-  grpc_core::Thread thd;
+  Thread thd;
 };
 
 enum class ExecutorType {

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

@@ -53,7 +53,9 @@ static bool g_grpc_abort_on_leaks;
 
 void grpc_iomgr_init() {
   grpc_core::ExecCtx exec_ctx;
-  grpc_determine_iomgr_platform();
+  if (!grpc_have_determined_iomgr_platform()) {
+    grpc_set_default_iomgr_platform();
+  }
   g_shutdown = 0;
   gpr_mu_init(&g_mu);
   gpr_cv_init(&g_rcv);

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

@@ -22,19 +22,14 @@
 
 #include <stddef.h>
 
-#include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/iomgr/timer_manager.h"
-
 static grpc_iomgr_platform_vtable* iomgr_platform_vtable = nullptr;
 
-void grpc_set_iomgr_platform_vtable(grpc_iomgr_platform_vtable* vtable) {
-  iomgr_platform_vtable = vtable;
+bool grpc_have_determined_iomgr_platform() {
+  return iomgr_platform_vtable != nullptr;
 }
 
-void grpc_determine_iomgr_platform() {
-  if (iomgr_platform_vtable == nullptr) {
-    grpc_set_default_iomgr_platform();
-  }
+void grpc_set_iomgr_platform_vtable(grpc_iomgr_platform_vtable* vtable) {
+  iomgr_platform_vtable = vtable;
 }
 
 void grpc_iomgr_platform_init() { iomgr_platform_vtable->init(); }

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

@@ -23,7 +23,8 @@
 
 #include <stdbool.h>
 
-#include "src/core/lib/iomgr/iomgr.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
 
 typedef struct grpc_iomgr_object {
   char* name;
@@ -44,7 +45,7 @@ typedef struct grpc_iomgr_platform_vtable {
 void grpc_iomgr_register_object(grpc_iomgr_object* obj, const char* name);
 void grpc_iomgr_unregister_object(grpc_iomgr_object* obj);
 
-void grpc_determine_iomgr_platform();
+bool grpc_have_determined_iomgr_platform();
 
 void grpc_set_iomgr_platform_vtable(grpc_iomgr_platform_vtable* vtable);
 

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

@@ -71,8 +71,8 @@ end:
         grpc_error_set_str(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                                "Failed to load file", &error, 1),
                            GRPC_ERROR_STR_FILENAME,
-                           grpc_slice_from_copied_string(
-                               filename));  // TODO(ncteisen), always static?
+
+                           filename);
     GRPC_ERROR_UNREF(error);
     error = error_out;
   }

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

@@ -77,7 +77,11 @@ void LockfreeEvent::DestroyEvent() {
   do {
     curr = gpr_atm_no_barrier_load(&state_);
     if (curr & kShutdownBit) {
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+      internal::StatusFreeHeapPtr(curr & ~kShutdownBit);
+#else
       GRPC_ERROR_UNREF((grpc_error_handle)(curr & ~kShutdownBit));
+#endif
     } else {
       GPR_ASSERT(curr == kClosureNotReady || curr == kClosureReady);
     }
@@ -139,8 +143,13 @@ void LockfreeEvent::NotifyOn(grpc_closure* closure) {
            contains a pointer to the shutdown-error). If the fd is shutdown,
            schedule the closure with the shutdown error */
         if ((curr & kShutdownBit) > 0) {
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+          grpc_error_handle shutdown_err =
+              internal::StatusGetFromHeapPtr(curr & ~kShutdownBit);
+#else
           grpc_error_handle shutdown_err =
               reinterpret_cast<grpc_error_handle>(curr & ~kShutdownBit);
+#endif
           ExecCtx::Run(DEBUG_LOCATION, closure,
                        GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                            "FD Shutdown", &shutdown_err, 1));
@@ -160,7 +169,12 @@ void LockfreeEvent::NotifyOn(grpc_closure* closure) {
 }
 
 bool LockfreeEvent::SetShutdown(grpc_error_handle shutdown_error) {
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+  intptr_t status_ptr = internal::StatusAllocHeapPtr(shutdown_error);
+  gpr_atm new_state = status_ptr | kShutdownBit;
+#else
   gpr_atm new_state = reinterpret_cast<gpr_atm>(shutdown_error) | kShutdownBit;
+#endif
 
   while (true) {
     gpr_atm curr = gpr_atm_no_barrier_load(&state_);
@@ -184,7 +198,11 @@ bool LockfreeEvent::SetShutdown(grpc_error_handle shutdown_error) {
 
         /* If fd is already shutdown, we are done */
         if ((curr & kShutdownBit) > 0) {
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+          internal::StatusFreeHeapPtr(status_ptr);
+#else
           GRPC_ERROR_UNREF(shutdown_error);
+#endif
           return false;
         }
 

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

@@ -76,7 +76,7 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
   // control back to the application
   grpc_core::ExecCtx* curr = grpc_core::ExecCtx::Get();
   grpc_core::ExecCtx::Set(nullptr);
-  grpc_error* err = poller_vtable->poll(static_cast<size_t>(timeout));
+  grpc_error_handle err = poller_vtable->poll(static_cast<size_t>(timeout));
   grpc_core::ExecCtx::Set(curr);
   grpc_core::ExecCtx::Get()->InvalidateNow();
   if (grpc_core::ExecCtx::Get()->HasWork()) {

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

@@ -27,7 +27,7 @@
 
 typedef struct grpc_custom_poller_vtable {
   void (*init)();
-  grpc_error* (*poll)(size_t timeout_ms);
+  grpc_error_handle (*poll)(size_t timeout_ms);
   void (*kick)();
   void (*shutdown)();
 } grpc_custom_poller_vtable;

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

@@ -57,7 +57,7 @@ static grpc_error_handle posix_blocking_resolve_address(
   if (host.empty()) {
     err = grpc_error_set_str(
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("unparseable host:port"),
-        GRPC_ERROR_STR_TARGET_ADDRESS, grpc_slice_from_copied_string(name));
+        GRPC_ERROR_STR_TARGET_ADDRESS, name);
     goto done;
   }
 
@@ -65,7 +65,7 @@ static grpc_error_handle posix_blocking_resolve_address(
     if (default_port == nullptr) {
       err = grpc_error_set_str(
           GRPC_ERROR_CREATE_FROM_STATIC_STRING("no port in name"),
-          GRPC_ERROR_STR_TARGET_ADDRESS, grpc_slice_from_copied_string(name));
+          GRPC_ERROR_STR_TARGET_ADDRESS, name);
       goto done;
     }
     port = default_port;
@@ -101,11 +101,9 @@ static grpc_error_handle posix_blocking_resolve_address(
                 grpc_error_set_int(
                     GRPC_ERROR_CREATE_FROM_STATIC_STRING(gai_strerror(s)),
                     GRPC_ERROR_INT_ERRNO, s),
-                GRPC_ERROR_STR_OS_ERROR,
-                grpc_slice_from_static_string(gai_strerror(s))),
-            GRPC_ERROR_STR_SYSCALL,
-            grpc_slice_from_static_string("getaddrinfo")),
-        GRPC_ERROR_STR_TARGET_ADDRESS, grpc_slice_from_copied_string(name));
+                GRPC_ERROR_STR_OS_ERROR, gai_strerror(s)),
+            GRPC_ERROR_STR_SYSCALL, "getaddrinfo"),
+        GRPC_ERROR_STR_TARGET_ADDRESS, name);
     goto done;
   }
 

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

@@ -47,11 +47,11 @@ int grpc_socket_factory_bind(grpc_socket_factory* factory, int sockfd,
 
 int grpc_socket_factory_compare(grpc_socket_factory* a,
                                 grpc_socket_factory* b) {
-  int c = GPR_ICMP(a, b);
+  int c = grpc_core::QsortCompare(a, b);
   if (c != 0) {
     grpc_socket_factory* sma = a;
     grpc_socket_factory* smb = b;
-    c = GPR_ICMP(sma->vtable, smb->vtable);
+    c = grpc_core::QsortCompare(sma->vtable, smb->vtable);
     if (c == 0) {
       c = sma->vtable->compare(sma, smb);
     }

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

@@ -56,11 +56,11 @@ bool grpc_socket_mutator_mutate_fd(grpc_socket_mutator* mutator, int fd,
 
 int grpc_socket_mutator_compare(grpc_socket_mutator* a,
                                 grpc_socket_mutator* b) {
-  int c = GPR_ICMP(a, b);
+  int c = grpc_core::QsortCompare(a, b);
   if (c != 0) {
     grpc_socket_mutator* sma = a;
     grpc_socket_mutator* smb = b;
-    c = GPR_ICMP(sma->vtable, smb->vtable);
+    c = grpc_core::QsortCompare(sma->vtable, smb->vtable);
     if (c == 0) {
       c = sma->vtable->compare(sma, smb);
     }

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

@@ -443,8 +443,7 @@ static grpc_error_handle error_for_fd(int fd,
   if (fd >= 0) return GRPC_ERROR_NONE;
   std::string addr_str = grpc_sockaddr_to_string(addr, false);
   grpc_error_handle err = grpc_error_set_str(
-      GRPC_OS_ERROR(errno, "socket"), GRPC_ERROR_STR_TARGET_ADDRESS,
-      grpc_slice_from_copied_string(addr_str.c_str()));
+      GRPC_OS_ERROR(errno, "socket"), GRPC_ERROR_STR_TARGET_ADDRESS, addr_str);
   return err;
 }
 

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

@@ -23,14 +23,12 @@
 grpc_tcp_client_vtable* grpc_tcp_client_impl;
 
 void grpc_tcp_client_connect(grpc_closure* on_connect, grpc_endpoint** endpoint,
-                             grpc_slice_allocator* slice_allocator,
                              grpc_pollset_set* interested_parties,
                              const grpc_channel_args* channel_args,
                              const grpc_resolved_address* addr,
                              grpc_millis deadline) {
-  grpc_tcp_client_impl->connect(on_connect, endpoint, slice_allocator,
-                                interested_parties, channel_args, addr,
-                                deadline);
+  grpc_tcp_client_impl->connect(on_connect, endpoint, interested_parties,
+                                channel_args, addr, deadline);
 }
 
 void grpc_set_tcp_client_impl(grpc_tcp_client_vtable* impl) {

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

@@ -27,11 +27,10 @@
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/resource_quota.h"
+#include "src/core/lib/resource_quota/memory_quota.h"
 
 typedef struct grpc_tcp_client_vtable {
   void (*connect)(grpc_closure* on_connect, grpc_endpoint** endpoint,
-                  grpc_slice_allocator* slice_allocator,
                   grpc_pollset_set* interested_parties,
                   const grpc_channel_args* channel_args,
                   const grpc_resolved_address* addr, grpc_millis deadline);
@@ -43,7 +42,6 @@ typedef struct grpc_tcp_client_vtable {
    interested_parties points to a set of pollsets that would be interested
    in this connection being established (in order to continue their work) */
 void grpc_tcp_client_connect(grpc_closure* on_connect, grpc_endpoint** endpoint,
-                             grpc_slice_allocator* slice_allocator,
                              grpc_pollset_set* interested_parties,
                              const grpc_channel_args* channel_args,
                              const grpc_resolved_address* addr,

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

@@ -64,16 +64,12 @@ struct CFStreamConnect {
   grpc_endpoint** endpoint;
   int refs;
   std::string addr_name;
-  grpc_slice_allocator* slice_allocator;
 };
 
 static void CFStreamConnectCleanup(CFStreamConnect* connect) {
   CFSTREAM_HANDLE_UNREF(connect->stream_handle, "async connect clean up");
   CFRelease(connect->read_stream);
   CFRelease(connect->write_stream);
-  if (connect->slice_allocator != nullptr) {
-    grpc_slice_allocator_destroy(connect->slice_allocator);
-  }
   gpr_mu_destroy(&connect->mu);
   delete connect;
 }
@@ -81,7 +77,8 @@ static void CFStreamConnectCleanup(CFStreamConnect* connect) {
 static void OnAlarm(void* arg, grpc_error_handle error) {
   CFStreamConnect* connect = static_cast<CFStreamConnect*>(arg);
   if (grpc_tcp_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "CLIENT_CONNECT :%p OnAlarm, error:%p", connect, error);
+    gpr_log(GPR_DEBUG, "CLIENT_CONNECT :%p OnAlarm, error:%s", connect,
+            grpc_error_std_string(error).c_str());
   }
   gpr_mu_lock(&connect->mu);
   grpc_closure* closure = connect->closure;
@@ -102,7 +99,8 @@ static void OnAlarm(void* arg, grpc_error_handle error) {
 static void OnOpen(void* arg, grpc_error_handle error) {
   CFStreamConnect* connect = static_cast<CFStreamConnect*>(arg);
   if (grpc_tcp_trace.enabled()) {
-    gpr_log(GPR_DEBUG, "CLIENT_CONNECT :%p OnOpen, error:%p", connect, error);
+    gpr_log(GPR_DEBUG, "CLIENT_CONNECT :%p OnOpen, error:%s", connect,
+            grpc_error_std_string(error).c_str());
   }
   gpr_mu_lock(&connect->mu);
   grpc_timer_cancel(&connect->alarm);
@@ -130,12 +128,10 @@ static void OnOpen(void* arg, grpc_error_handle error) {
       if (error == GRPC_ERROR_NONE) {
         *endpoint = grpc_cfstream_endpoint_create(
             connect->read_stream, connect->write_stream,
-            connect->addr_name.c_str(), connect->slice_allocator,
-            connect->stream_handle);
-        connect->slice_allocator = nullptr;
+            connect->addr_name.c_str(), connect->stream_handle);
       }
     } else {
-      GRPC_ERROR_REF(error);
+      (void)GRPC_ERROR_REF(error);
     }
     gpr_mu_unlock(&connect->mu);
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
@@ -154,7 +150,6 @@ static void ParseResolvedAddress(const grpc_resolved_address* addr,
 }
 
 static void CFStreamClientConnect(grpc_closure* closure, grpc_endpoint** ep,
-                                  grpc_slice_allocator* slice_allocator,
                                   grpc_pollset_set* interested_parties,
                                   const grpc_channel_args* channel_args,
                                   const grpc_resolved_address* resolved_addr,
@@ -171,7 +166,6 @@ static void CFStreamClientConnect(grpc_closure* closure, grpc_endpoint** ep,
     gpr_log(GPR_DEBUG, "CLIENT_CONNECT: %p, %s: asynchronously connecting",
             connect, connect->addr_name.c_str());
   }
-  connect->slice_allocator = slice_allocator;
 
   CFReadStreamRef read_stream;
   CFWriteStreamRef write_stream;

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

@@ -42,16 +42,11 @@ struct grpc_custom_tcp_connect {
   grpc_endpoint** endpoint;
   int refs;
   std::string addr_name;
-  grpc_slice_allocator* slice_allocator;
 };
 
 static void custom_tcp_connect_cleanup(grpc_custom_tcp_connect* connect) {
-  if (connect->slice_allocator != nullptr) {
-    grpc_slice_allocator_destroy(connect->slice_allocator);
-  }
   grpc_custom_socket* socket = connect->socket;
   delete connect;
-  socket->refs--;
   if (socket->refs == 0) {
     grpc_custom_socket_vtable->destroy(socket);
     gpr_free(socket);
@@ -75,6 +70,7 @@ static void on_alarm(void* acp, grpc_error_handle error) {
     grpc_custom_socket_vtable->close(socket, custom_close_callback);
   }
   done = (--connect->refs == 0);
+  socket->refs--;
   if (done) {
     custom_tcp_connect_cleanup(connect);
   }
@@ -87,11 +83,11 @@ static void custom_connect_callback_internal(grpc_custom_socket* socket,
   grpc_closure* closure = connect->closure;
   grpc_timer_cancel(&connect->alarm);
   if (error == GRPC_ERROR_NONE) {
-    *connect->endpoint = custom_tcp_endpoint_create(
-        socket, connect->slice_allocator, connect->addr_name.c_str());
-    connect->slice_allocator = nullptr;
+    *connect->endpoint =
+        custom_tcp_endpoint_create(socket, connect->addr_name.c_str());
   }
   done = (--connect->refs == 0);
+  socket->refs--;
   if (done) {
     grpc_core::ExecCtx::Get()->Flush();
     custom_tcp_connect_cleanup(connect);
@@ -113,7 +109,6 @@ static void custom_connect_callback(grpc_custom_socket* socket,
 }
 
 static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
-                        grpc_slice_allocator* slice_allocator,
                         grpc_pollset_set* interested_parties,
                         const grpc_channel_args* channel_args,
                         const grpc_resolved_address* resolved_addr,
@@ -124,12 +119,11 @@ static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
   grpc_custom_socket* socket =
       static_cast<grpc_custom_socket*>(gpr_malloc(sizeof(grpc_custom_socket)));
   socket->refs = 2;
-  grpc_custom_socket_vtable->init(socket, GRPC_AF_UNSPEC);
+  (void)grpc_custom_socket_vtable->init(socket, GRPC_AF_UNSPEC);
   grpc_custom_tcp_connect* connect = new grpc_custom_tcp_connect();
   connect->closure = closure;
   connect->endpoint = ep;
   connect->addr_name = grpc_sockaddr_to_uri(resolved_addr);
-  connect->slice_allocator = slice_allocator;
   connect->socket = socket;
   socket->connector = connect;
   socket->endpoint = nullptr;