grpc 1.40.0 → 1.46.3

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

@@ -14,19 +14,19 @@
 #include <grpc/support/port_platform.h>
 
 #ifdef GRPC_USE_EVENT_ENGINE
-#include "src/core/lib/iomgr/event_engine/endpoint.h"
+#include "absl/strings/string_view.h"
 
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/time.h>
-#include "absl/strings/string_view.h"
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/event_engine/closure.h"
+#include "src/core/lib/iomgr/event_engine/endpoint.h"
 #include "src/core/lib/iomgr/event_engine/pollset.h"
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/iomgr/pollset_set.h"
@@ -95,28 +95,21 @@ void endpoint_delete_from_pollset_set(grpc_endpoint* /* ep */,
 /// and will return some kind of sane default (empty strings, nullptrs, etc). It
 /// is the caller's responsibility to ensure that calls to endpoint_shutdown are
 /// synchronized.
-void endpoint_shutdown(grpc_endpoint* ep, grpc_error* why) {
+void endpoint_shutdown(grpc_endpoint* ep, grpc_error_handle why) {
   auto* eeep = reinterpret_cast<grpc_event_engine_endpoint*>(ep);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-    const char* str = grpc_error_string(why);
+    std::string str = grpc_error_std_string(why);
     gpr_log(GPR_INFO, "TCP Endpoint %p shutdown why=%s", eeep->endpoint.get(),
-            str);
+            str.c_str());
   }
-  grpc_resource_user_shutdown(eeep->ru);
   eeep->endpoint.reset();
 }
 
 void endpoint_destroy(grpc_endpoint* ep) {
   auto* eeep = reinterpret_cast<grpc_event_engine_endpoint*>(ep);
-  grpc_resource_user_unref(eeep->ru);
   delete eeep;
 }
 
-grpc_resource_user* endpoint_get_resource_user(grpc_endpoint* ep) {
-  auto* eeep = reinterpret_cast<grpc_event_engine_endpoint*>(ep);
-  return eeep->ru;
-}
-
 absl::string_view endpoint_get_peer(grpc_endpoint* ep) {
   auto* eeep = reinterpret_cast<grpc_event_engine_endpoint*>(ep);
   if (eeep->endpoint == nullptr) {
@@ -154,7 +147,6 @@ grpc_endpoint_vtable grpc_event_engine_endpoint_vtable = {
     endpoint_delete_from_pollset_set,
     endpoint_shutdown,
     endpoint_destroy,
-    endpoint_get_resource_user,
     endpoint_get_peer,
     endpoint_get_local_address,
     endpoint_get_fd,
@@ -166,26 +158,14 @@ grpc_event_engine_endpoint* grpc_tcp_server_endpoint_create(
     std::unique_ptr<EventEngine::Endpoint> ee_endpoint) {
   auto endpoint = new grpc_event_engine_endpoint;
   endpoint->base.vtable = &grpc_event_engine_endpoint_vtable;
-  // TODO(hork): populate endpoint->ru from the uvEngine's subclass
   endpoint->endpoint = std::move(ee_endpoint);
   return endpoint;
 }
 
-grpc_endpoint* grpc_tcp_create(const grpc_channel_args* channel_args,
-                               absl::string_view peer_address) {
+grpc_endpoint* grpc_tcp_create(const grpc_channel_args* /* channel_args */,
+                               absl::string_view /* peer_address */) {
   auto endpoint = new grpc_event_engine_endpoint;
   endpoint->base.vtable = &grpc_event_engine_endpoint_vtable;
-  grpc_resource_quota* resource_quota =
-      grpc_channel_args_find_pointer<grpc_resource_quota>(
-          channel_args, GRPC_ARG_RESOURCE_QUOTA);
-  if (resource_quota != nullptr) {
-    grpc_resource_quota_ref_internal(resource_quota);
-  } else {
-    resource_quota = grpc_resource_quota_create(nullptr);
-  }
-  endpoint->ru = grpc_resource_user_create(resource_quota,
-                                           std::string(peer_address).c_str());
-  grpc_resource_quota_unref_internal(resource_quota);
   return &endpoint->base;
 }
 

data/src/core/lib/iomgr/event_engine/endpoint.h

@@ -28,7 +28,6 @@ struct grpc_event_engine_endpoint {
       endpoint;
   std::string peer_address;
   std::string local_address;
-  grpc_resource_user* ru = nullptr;
   std::aligned_storage<
       sizeof(grpc_event_engine::experimental::SliceBuffer),
       alignof(grpc_event_engine::experimental::SliceBuffer)>::type read_buffer;
@@ -45,7 +44,7 @@ grpc_event_engine_endpoint* grpc_tcp_server_endpoint_create(
 
 /// Creates a new internal grpc_endpoint struct, when no EventEngine Endpoint
 /// has yet been created. This is used in client code before connections are
-/// established.
+/// established. Takes ownership of the slice_allocator.
 grpc_endpoint* grpc_tcp_create(const grpc_channel_args* channel_args,
                                absl::string_view peer_address);
 

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

@@ -14,13 +14,11 @@
 #include <grpc/support/port_platform.h>
 
 #ifdef GRPC_USE_EVENT_ENGINE
-#include "src/core/lib/iomgr/event_engine/iomgr.h"
-
 #include <grpc/event_engine/event_engine.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/event_engine/promise.h"
+#include "src/core/lib/iomgr/event_engine/resolver.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_server.h"
@@ -32,7 +30,6 @@ extern grpc_tcp_server_vtable grpc_event_engine_tcp_server_vtable;
 extern grpc_timer_vtable grpc_event_engine_timer_vtable;
 extern grpc_pollset_vtable grpc_event_engine_pollset_vtable;
 extern grpc_pollset_set_vtable grpc_event_engine_pollset_set_vtable;
-extern grpc_address_resolver_vtable grpc_event_engine_resolver_vtable;
 
 // Disabled by default. grpc_polling_trace must be defined in all iomgr
 // implementations due to its usage in lockfree_event.
@@ -40,39 +37,25 @@ grpc_core::DebugOnlyTraceFlag grpc_polling_trace(false, "polling");
 
 namespace {
 
-using ::grpc_event_engine::experimental::DefaultEventEngineFactory;
 using ::grpc_event_engine::experimental::EventEngine;
-using ::grpc_event_engine::experimental::Promise;
-
-// Note: This is a pointer to a shared_ptr, so it's trivially destructible.
-std::shared_ptr<EventEngine>* g_event_engine;
+using ::grpc_event_engine::experimental::GetDefaultEventEngine;
 
-void iomgr_platform_init(void) {
-  g_event_engine =
-      new std::shared_ptr<EventEngine>(DefaultEventEngineFactory());
-}
+// TODO(nnoble): Instantiate the default EventEngine if none have been provided.
+void iomgr_platform_init(void) {}
 
 void iomgr_platform_flush(void) {}
 
-void iomgr_platform_shutdown(void) {
-  Promise<absl::Status> shutdown_status_promise;
-  (*g_event_engine)->Shutdown([&shutdown_status_promise](absl::Status status) {
-    shutdown_status_promise.Set(std::move(status));
-  });
-  auto shutdown_status = shutdown_status_promise.Get();
-  GPR_ASSERT(shutdown_status.ok());
-  delete g_event_engine;
-  g_event_engine = nullptr;
-}
+void iomgr_platform_shutdown(void) {}
 
 void iomgr_platform_shutdown_background_closure(void) {}
 
 bool iomgr_platform_is_any_background_poller_thread(void) {
-  return (*g_event_engine)->IsWorkerThread();
+  return grpc_event_engine::experimental::GetDefaultEventEngine()
+      ->IsWorkerThread();
 }
 
 bool iomgr_platform_add_closure_to_background_poller(
-    grpc_closure* /* closure */, grpc_error* /* error */) {
+    grpc_closure* /* closure */, grpc_error_handle /* error */) {
   return false;
 }
 
@@ -92,14 +75,11 @@ void grpc_set_default_iomgr_platform() {
   grpc_set_timer_impl(&grpc_event_engine_timer_vtable);
   grpc_set_pollset_vtable(&grpc_event_engine_pollset_vtable);
   grpc_set_pollset_set_vtable(&grpc_event_engine_pollset_set_vtable);
-  grpc_set_resolver_impl(&grpc_event_engine_resolver_vtable);
+  grpc_core::SetDNSResolver(
+      grpc_core::experimental::EventEngineDNSResolver::GetOrCreate());
   grpc_set_iomgr_platform_vtable(&vtable);
 }
 
 bool grpc_iomgr_run_in_background() { return false; }
 
-grpc_event_engine::experimental::EventEngine* grpc_iomgr_event_engine() {
-  return g_event_engine->get();
-}
-
 #endif  // GRPC_USE_EVENT_ENGINE

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

@@ -40,15 +40,15 @@ void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
   grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
 }
 void pollset_destroy(grpc_pollset* pollset) {}
-grpc_error* pollset_work(grpc_pollset* pollset, grpc_pollset_worker** worker,
-                         grpc_millis deadline) {
+grpc_error_handle pollset_work(grpc_pollset* pollset,
+                               grpc_pollset_worker** worker,
+                               grpc_core::Timestamp deadline) {
   (void)worker;
-  gpr_cv_wait(&g_cv, &g_mu,
-              grpc_millis_to_timespec(deadline, GPR_CLOCK_REALTIME));
+  gpr_cv_wait(&g_cv, &g_mu, deadline.as_timespec(GPR_CLOCK_REALTIME));
   return GRPC_ERROR_NONE;
 }
-grpc_error* pollset_kick(grpc_pollset* pollset,
-                         grpc_pollset_worker* specific_worker) {
+grpc_error_handle pollset_kick(grpc_pollset* pollset,
+                               grpc_pollset_worker* specific_worker) {
   (void)pollset;
   (void)specific_worker;
   return GRPC_ERROR_NONE;

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

@@ -37,5 +37,11 @@ grpc_resolved_address CreateGRPCResolvedAddress(
   return grpc_addr;
 }
 
+// TODO(ctiller): Move this to somewhere more permanent as we're deleting iomgr.
+std::string ResolvedAddressToURI(const EventEngine::ResolvedAddress& addr) {
+  auto gra = CreateGRPCResolvedAddress(addr);
+  return grpc_sockaddr_to_uri(&gra);
+}
+
 }  // namespace experimental
 }  // namespace grpc_event_engine

data/src/core/lib/iomgr/event_engine/resolved_address_internal.h

@@ -29,6 +29,8 @@ EventEngine::ResolvedAddress CreateResolvedAddress(
 grpc_resolved_address CreateGRPCResolvedAddress(
     const EventEngine::ResolvedAddress& ra);
 
+std::string ResolvedAddressToURI(const EventEngine::ResolvedAddress& addr);
+
 }  // namespace experimental
 }  // namespace grpc_event_engine
 

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

@@ -14,97 +14,120 @@
 #include <grpc/support/port_platform.h>
 
 #ifdef GRPC_USE_EVENT_ENGINE
-#include <grpc/event_engine/event_engine.h>
 #include "absl/functional/bind_front.h"
 
+#include <grpc/event_engine/event_engine.h>
+
 #include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/event_engine/event_engine_factory.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/event_engine/iomgr.h"
 #include "src/core/lib/iomgr/event_engine/promise.h"
 #include "src/core/lib/iomgr/event_engine/resolved_address_internal.h"
+#include "src/core/lib/iomgr/event_engine/resolver.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolve_address_impl.h"
 #include "src/core/lib/iomgr/work_serializer.h"
 #include "src/core/lib/surface/init.h"
 #include "src/core/lib/transport/error_utils.h"
 
+namespace grpc_core {
+namespace experimental {
 namespace {
 using ::grpc_event_engine::experimental::CreateGRPCResolvedAddress;
 using ::grpc_event_engine::experimental::EventEngine;
+using ::grpc_event_engine::experimental::GetDefaultEventEngine;
 using ::grpc_event_engine::experimental::Promise;
 
 /// A fire-and-forget class representing an individual DNS request.
 ///
 /// This provides a place to store the ownership of the DNSResolver object until
 /// the request is complete.
-class DnsRequest {
+class EventEngineDNSRequest : DNSRequest {
  public:
-  DnsRequest(std::unique_ptr<EventEngine::DNSResolver> dns_resolver,
-             absl::string_view address, absl::string_view default_port,
-             grpc_closure* on_done, grpc_resolved_addresses** addresses)
+  EventEngineDNSRequest(std::unique_ptr<EventEngine::DNSResolver> dns_resolver,
+                        absl::string_view name, absl::string_view default_port,
+                        grpc_closure* on_done,
+                        std::vector<grpc_resolved_address>* addresses)
       : dns_resolver_(std::move(dns_resolver)),
-        cb_(on_done),
-        addresses_(addresses) {
+        name_(std::string(name)),
+        default_port_(std::string(default_port)),
+        on_done_(std::move(on_done)) {}
+
+  void Start() override {
+    if (dns_resolver_ == nullptr) {
+      new DNSCallbackExecCtxScheduler(
+          std::move(on_done_),
+          absl::UnknownError("Failed to get DNS Resolver."));
+      return;
+    }
+    Ref().release();  // ref held by pending resolution
     dns_resolver_->LookupHostname(
-        absl::bind_front(&DnsRequest::OnLookupComplete, this), address,
-        default_port, absl::InfiniteFuture());
+        absl::bind_front(&EventEngineDNSRequest::OnLookupComplete, this), name_,
+        default_port_, absl::InfiniteFuture());
   }
 
+  // TODO(hork): implement cancellation; currently it's a no-op
+  void Orphan() override { Unref(); }
+
  private:
   void OnLookupComplete(
       absl::StatusOr<std::vector<EventEngine::ResolvedAddress>> addresses) {
-    grpc_core::ExecCtx exec_ctx;
+    ExecCtx exec_ctx;
     // Convert addresses to iomgr form.
-    *addresses_ = static_cast<grpc_resolved_addresses*>(
-        gpr_malloc(sizeof(grpc_resolved_addresses)));
-    (*addresses_)->naddrs = addresses->size();
-    (*addresses_)->addrs = static_cast<grpc_resolved_address*>(
-        gpr_malloc(sizeof(grpc_resolved_address) * addresses->size()));
+    std::vector<grpc_resolved_address> result;
+    results.reserve(addresses->size());
     for (size_t i = 0; i < addresses->size(); ++i) {
-      (*addresses_)->addrs[i] = CreateGRPCResolvedAddress((*addresses)[i]);
+      results.push_back(CreateGRPCResolvedAddress(addresses[i]));
     }
-    grpc_closure* cb = cb_;
-    delete this;
-    grpc_core::Closure::Run(DEBUG_LOCATION, cb,
-                            absl_status_to_grpc_error(addresses.status()));
+    if (addresses.ok()) {
+      on_done_(std::move(result));
+    } else {
+      on_done_(addresses.status());
+    }
+    Unref();
   }
 
   std::unique_ptr<EventEngine::DNSResolver> dns_resolver_;
-  grpc_closure* cb_;
-  grpc_resolved_addresses** addresses_;
+  const std::string name_;
+  const std::string default_port_;
+  std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+      on_done_;
 };
 
-void resolve_address(const char* addr, const char* default_port,
-                     grpc_pollset_set* /* interested_parties */,
-                     grpc_closure* on_done,
-                     grpc_resolved_addresses** addresses) {
-  auto dns_resolver = grpc_iomgr_event_engine()->GetDNSResolver();
-  if (!dns_resolver.ok()) {
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_done,
-                            absl_status_to_grpc_error(dns_resolver.status()));
-    return;
-  }
-  new DnsRequest(std::move(*dns_resolver), addr, default_port, on_done,
-                 addresses);
+}  // namespace
+
+DNSResolver* EventEngineDNSResolver::GetOrCreate() {
+  static EventEngineDNSResolver* instance = new EventEngineDNSResolver();
+  return instance;
 }
 
-void blocking_handle_async_resolve_done(void* arg, grpc_error_handle error) {
-  static_cast<Promise<grpc_error_handle>*>(arg)->Set(std::move(error));
+OrphanablePtr<DNSResolver::Request> EventEngineDNSResolver::ResolveName(
+    absl::string_view name, absl::string_view default_port,
+    grpc_pollset_set* /* interested_parties */,
+    std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+        on_done) {
+  std::unique_ptr<EventEngine::DNSResolver> dns_resolver =
+      GetDefaultEventEngine()->GetDNSResolver();
+  return MakeOrphanable<EventEngineDNSRequest>(
+      std::move(dns_resolver), name, default_port, std::move(on_done));
 }
 
-grpc_error* blocking_resolve_address(const char* name, const char* default_port,
-                                     grpc_resolved_addresses** addresses) {
+absl::StatusOr<std::vector<grpc_resolved_address>>
+EventEngineDNSResolver::ResolveNameBlocking(absl::string_view name,
+                                            absl::string_view default_port) {
   grpc_closure on_done;
-  Promise<grpc_error_handle> evt;
-  GRPC_CLOSURE_INIT(&on_done, blocking_handle_async_resolve_done, &evt,
-                    grpc_schedule_on_exec_ctx);
-  resolve_address(name, default_port, nullptr, &on_done, addresses);
+  Promise<absl::StatusOr<std::vector<grpc_resolved_address>>> evt;
+  auto r = ResolveName(
+      name, default_port,
+      [&evt](void(absl::StatusOr<std::vector<grpc_resolved_address>> result) {
+        evt.Set(std::move(result));
+      }));
+  r->Start();
   return evt.Get();
 }
 
-}  // namespace
-
-grpc_address_resolver_vtable grpc_event_engine_resolver_vtable{
-    resolve_address, blocking_resolve_address};
+}  // namespace experimental
+}  // namespace grpc_core
 
 #endif  // GRPC_USE_EVENT_ENGINE

data/src/core/lib/iomgr/event_engine/resolver.h

@@ -0,0 +1,56 @@
+//
+// Copyright 2015 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_CORE_LIB_IOMGR_EVENT_ENGINE_RESOLVER_H
+#define GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_RESOLVER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string.h>
+#include <sys/types.h>
+
+#include <functional>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+#include <grpc/support/time.h>
+
+#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/resolve_address.h"
+
+namespace grpc_core {
+namespace experimental {
+
+class EventEngineDNSResolver : public DNSResolver {
+ public:
+  // Gets the singleton instance, creating it first if it doesn't exist
+  static EventEngineDNSResolver* GetOrCreate();
+
+  OrphanablePtr<DNSResolver::Request> ResolveName(
+      absl::string_view name, absl::string_view default_port,
+      grpc_pollset_set* interested_parties,
+      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+          on_done) override;
+
+  absl::StatusOr<std::vector<grpc_resolved_address>> ResolveNameBlocking(
+      absl::string_view name, absl::string_view default_port) override;
+};
+
+}  // namespace experimental
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_RESOLVER_H

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

@@ -17,12 +17,12 @@
 #include <grpc/event_engine/event_engine.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/event_engine/endpoint_config_internal.h"
+#include "src/core/lib/event_engine/channel_args_endpoint_config.h"
+#include "src/core/lib/event_engine/event_engine_factory.h"
 #include "src/core/lib/event_engine/sockaddr.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/iomgr/event_engine/closure.h"
 #include "src/core/lib/iomgr/event_engine/endpoint.h"
-#include "src/core/lib/iomgr/event_engine/iomgr.h"
 #include "src/core/lib/iomgr/event_engine/pollset.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/tcp_client.h"
@@ -35,29 +35,60 @@ extern grpc_core::TraceFlag grpc_tcp_trace;
 namespace {
 using ::grpc_event_engine::experimental::ChannelArgsEndpointConfig;
 using ::grpc_event_engine::experimental::EventEngine;
-using ::grpc_event_engine::experimental::GrpcClosureToCallback;
+using ::grpc_event_engine::experimental::GetDefaultEventEngine;
+using ::grpc_event_engine::experimental::GrpcClosureToStatusCallback;
 using ::grpc_event_engine::experimental::SliceAllocator;
 using ::grpc_event_engine::experimental::SliceAllocatorFactory;
 using ::grpc_event_engine::experimental::SliceBuffer;
 }  // namespace
 
-// TODO(hork): remove these classes in PR #26643, when the iomgr APIs change to
-// accept SliceAllocators and SliceAllocatorFactory(ie)s. In the meantime, the
-// libuv work has temporary implementations as well.
-class NoopSliceAllocator : public SliceAllocator {
+class WrappedInternalSliceAllocator : public SliceAllocator {
  public:
+  explicit WrappedInternalSliceAllocator(grpc_slice_allocator* slice_allocator)
+      : slice_allocator_(slice_allocator) {}
+
+  ~WrappedInternalSliceAllocator() {
+    grpc_slice_allocator_destroy(slice_allocator_);
+  }
+
   absl::Status Allocate(size_t size, SliceBuffer* dest,
-                        SliceAllocator::AllocateCallback cb) {
+                        SliceAllocator::AllocateCallback cb) override {
+    // TODO(nnoble): requires the SliceBuffer definition.
+    grpc_slice_allocator_allocate(
+        slice_allocator_, size, 1, grpc_slice_allocator_intent::kReadBuffer,
+        dest->RawSliceBuffer(),
+        [](void* arg, grpc_error_handle error) {
+          auto cb = static_cast<SliceAllocator::AllocateCallback*>(arg);
+          (*cb)(grpc_error_to_absl_status(error));
+          delete cb;
+        },
+        new SliceAllocator::AllocateCallback(cb));
     return absl::OkStatus();
   }
+
+ private:
+  grpc_slice_allocator* slice_allocator_;
 };
 
-class NoopSliceAllocatorFactory : public SliceAllocatorFactory {
+class WrappedInternalSliceAllocatorFactory : public SliceAllocatorFactory {
  public:
+  explicit WrappedInternalSliceAllocatorFactory(
+      grpc_slice_allocator_factory* slice_allocator_factory)
+      : slice_allocator_factory_(slice_allocator_factory) {}
+
+  ~WrappedInternalSliceAllocatorFactory() {
+    grpc_slice_allocator_factory_destroy(slice_allocator_factory_);
+  }
+
   std::unique_ptr<SliceAllocator> CreateSliceAllocator(
-      absl::string_view peer_name) {
-    return absl::make_unique<NoopSliceAllocator>();
+      absl::string_view peer_name) override {
+    return absl::make_unique<WrappedInternalSliceAllocator>(
+        grpc_slice_allocator_factory_create_slice_allocator(
+            slice_allocator_factory_, peer_name));
   };
+
+ private:
+  grpc_slice_allocator_factory* slice_allocator_factory_;
 };
 
 struct grpc_tcp_server {
@@ -105,25 +136,27 @@ EventEngine::OnConnectCallback GrpcClosureToOnConnectCallback(
 
 /// Usage note: this method does not take ownership of any pointer arguments.
 void tcp_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) {
+                 const grpc_resolved_address* addr,
+                 grpc_core::Timestamp deadline) {
   grpc_event_engine_endpoint* ee_endpoint =
       reinterpret_cast<grpc_event_engine_endpoint*>(
           grpc_tcp_create(channel_args, grpc_sockaddr_to_uri(addr)));
   *endpoint = &ee_endpoint->base;
   EventEngine::OnConnectCallback ee_on_connect =
       GrpcClosureToOnConnectCallback(on_connect, endpoint);
-  // TODO(hork): tcp_connect will change to accept a SliceAllocator. This is
-  // temporary.
-  auto sa = absl::make_unique<NoopSliceAllocator>();
+  auto ee_slice_allocator =
+      absl::make_unique<WrappedInternalSliceAllocator>(slice_allocator);
   EventEngine::ResolvedAddress ra(reinterpret_cast<const sockaddr*>(addr->addr),
                                   addr->len);
-  absl::Time ee_deadline = grpc_core::ToAbslTime(
-      grpc_millis_to_timespec(deadline, GPR_CLOCK_MONOTONIC));
+  absl::Time ee_deadline =
+      grpc_core::ToAbslTime(deadline.as_timespec(GPR_CLOCK_MONOTONIC));
   ChannelArgsEndpointConfig endpoint_config(channel_args);
-  absl::Status connected = grpc_iomgr_event_engine()->Connect(
-      ee_on_connect, ra, endpoint_config, std::move(sa), ee_deadline);
+  absl::Status connected = GetDefaultEventEngine()->Connect(
+      ee_on_connect, ra, endpoint_config, std::move(ee_slice_allocator),
+      ee_deadline);
   if (!connected.ok()) {
     // EventEngine failed to start an asynchronous connect.
     grpc_endpoint_destroy(*endpoint);
@@ -133,21 +166,19 @@ void tcp_connect(grpc_closure* on_connect, grpc_endpoint** endpoint,
   }
 }
 
-grpc_error* tcp_server_create(grpc_closure* shutdown_complete,
-                              const grpc_channel_args* args,
-                              grpc_tcp_server** server) {
+grpc_error_handle tcp_server_create(
+    grpc_closure* shutdown_complete, const grpc_channel_args* args,
+    grpc_slice_allocator_factory* slice_allocator_factory,
+    grpc_tcp_server** server) {
   ChannelArgsEndpointConfig endpoint_config(args);
-  grpc_resource_quota* rq = grpc_resource_quota_from_channel_args(args);
-  if (rq == nullptr) {
-    rq = grpc_resource_quota_create(nullptr);
-  }
-  // TODO(hork): tcp_server_create will change to accept a
-  // SliceAllocatorFactory. This is temporary.
-  auto saf = absl::make_unique<NoopSliceAllocatorFactory>();
-  EventEngine* event_engine = grpc_iomgr_event_engine();
+  auto ee_slice_allocator_factory =
+      absl::make_unique<WrappedInternalSliceAllocatorFactory>(
+          slice_allocator_factory);
+  EventEngine* event_engine = GetDefaultEventEngine();
   absl::StatusOr<std::unique_ptr<EventEngine::Listener>> listener =
       event_engine->CreateListener(
-          [server](std::unique_ptr<EventEngine::Endpoint> ee_endpoint) {
+          [server](std::unique_ptr<EventEngine::Endpoint> ee_endpoint,
+                   const SliceAllocator& /*slice_allocator*/) {
             grpc_core::ExecCtx exec_ctx;
             GPR_ASSERT((*server)->on_accept_internal != nullptr);
             grpc_event_engine_endpoint* iomgr_endpoint =
@@ -163,8 +194,8 @@ grpc_error* tcp_server_create(grpc_closure* shutdown_complete,
             exec_ctx.Flush();
             grpc_pollset_ee_broadcast_event();
           },
-          GrpcClosureToCallback(shutdown_complete, GRPC_ERROR_NONE),
-          endpoint_config, std::move(saf));
+          GrpcClosureToStatusCallback(shutdown_complete), endpoint_config,
+          std::move(ee_slice_allocator_factory));
   if (!listener.ok()) {
     return absl_status_to_grpc_error(listener.status());
   }
@@ -182,9 +213,9 @@ void tcp_server_start(grpc_tcp_server* server,
   GPR_ASSERT(server->listener->Start().ok());
 }
 
-grpc_error* tcp_server_add_port(grpc_tcp_server* s,
-                                const grpc_resolved_address* addr,
-                                int* out_port) {
+grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
+                                      const grpc_resolved_address* addr,
+                                      int* out_port) {
   EventEngine::ResolvedAddress ra(reinterpret_cast<const sockaddr*>(addr->addr),
                                   addr->len);
   auto port = s->listener->Bind(ra);
@@ -256,7 +287,9 @@ grpc_fd* grpc_fd_create(int /* fd */, const char* /* name */,
 
 grpc_endpoint* grpc_tcp_client_create_from_fd(
     grpc_fd* /* fd */, const grpc_channel_args* /* channel_args */,
-    const char* /* addr_str */) {
+    absl::string_view /* addr_str */,
+    grpc_slice_allocator* slice_allocator /* slice_allocator */) {
+  grpc_slice_allocator_destroy(slice_allocator);
   return nullptr;
 }