RubyGems - grpc - Versions diffs - 1.45.0 → 1.47.0 - Mend

grpc 1.45.0 → 1.47.0

Potentially problematic release.

This version of grpc might be problematic. Click here for more details.

Files changed (859) hide show

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

@@ -1,37 +0,0 @@
-// Copyright 2021 The gRPC Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#ifndef GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_RESOLVED_ADDRESS_INTERNAL_H
-#define GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_RESOLVED_ADDRESS_INTERNAL_H
-#include <grpc/support/port_platform.h>
-#include <grpc/event_engine/event_engine.h>
-#include "src/core/lib/iomgr/resolve_address.h"
-namespace grpc_event_engine {
-namespace experimental {
-EventEngine::ResolvedAddress CreateResolvedAddress(
-    const grpc_resolved_address& addr);
-grpc_resolved_address CreateGRPCResolvedAddress(
-    const EventEngine::ResolvedAddress& ra);
-std::string ResolvedAddressToURI(const EventEngine::ResolvedAddress& addr);
-}  // namespace experimental
-}  // namespace grpc_event_engine
-#endif  // GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_RESOLVED_ADDRESS_INTERNAL_H

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

@@ -1,133 +0,0 @@
-// Copyright 2021 The gRPC Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#include <grpc/support/port_platform.h>
-#ifdef GRPC_USE_EVENT_ENGINE
-#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/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 EventEngineDNSRequest : DNSRequest {
- public:
-  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)),
-        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(&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) {
-    ExecCtx exec_ctx;
-    // Convert addresses to iomgr form.
-    std::vector<grpc_resolved_address> result;
-    results.reserve(addresses->size());
-    for (size_t i = 0; i < addresses->size(); ++i) {
-      results.push_back(CreateGRPCResolvedAddress(addresses[i]));
-    }
-    if (addresses.ok()) {
-      on_done_(std::move(result));
-    } else {
-      on_done_(addresses.status());
-    }
-    Unref();
-  }
-  std::unique_ptr<EventEngine::DNSResolver> dns_resolver_;
-  const std::string name_;
-  const std::string default_port_;
-  std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-      on_done_;
-};
-}  // namespace
-DNSResolver* EventEngineDNSResolver::GetOrCreate() {
-  static EventEngineDNSResolver* instance = new EventEngineDNSResolver();
-  return instance;
-}
-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));
-}
-absl::StatusOr<std::vector<grpc_resolved_address>>
-EventEngineDNSResolver::ResolveNameBlocking(absl::string_view name,
-                                            absl::string_view default_port) {
-  grpc_closure on_done;
-  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 experimental
-}  // namespace grpc_core
-#endif  // GRPC_USE_EVENT_ENGINE

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

@@ -1,56 +0,0 @@
-//
-// 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 DELETED Viewed

@@ -1,296 +0,0 @@
-// Copyright 2021 The gRPC Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#include <grpc/support/port_platform.h>
-#ifdef GRPC_USE_EVENT_ENGINE
-#include <grpc/event_engine/event_engine.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/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/pollset.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/tcp_client.h"
-#include "src/core/lib/iomgr/tcp_server.h"
-#include "src/core/lib/surface/init.h"
-#include "src/core/lib/transport/error_utils.h"
-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::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
-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) 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 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) 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 {
-  explicit grpc_tcp_server(std::unique_ptr<EventEngine::Listener> listener)
-      : refcount(1, GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) ? "tcp" : nullptr),
-        listener(std::move(listener)) {
-    shutdown_starting.head = nullptr;
-    shutdown_starting.tail = nullptr;
-  };
-  ~grpc_tcp_server() {
-    grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &shutdown_starting);
-    grpc_core::ExecCtx::Get()->Flush();
-  }
-  grpc_core::RefCount refcount;
-  grpc_core::Mutex mu;
-  std::unique_ptr<EventEngine::Listener> listener;
-  grpc_closure_list shutdown_starting ABSL_GUARDED_BY(mu);
-  grpc_tcp_server_cb on_accept_internal;
-  void* on_accept_internal_arg;
-};
-namespace {
-/// Converts a grpc_closure to an EventEngine Callback. The closure is expected
-/// to already be initialized.
-EventEngine::OnConnectCallback GrpcClosureToOnConnectCallback(
-    grpc_closure* closure, grpc_endpoint** endpoint_ptr) {
-  return [closure, endpoint_ptr](
-             absl::StatusOr<std::unique_ptr<EventEngine::Endpoint>> endpoint) {
-    grpc_core::ExecCtx exec_ctx;
-    if (endpoint.ok()) {
-      auto* grpc_endpoint_out =
-          reinterpret_cast<grpc_event_engine_endpoint*>(*endpoint_ptr);
-      grpc_endpoint_out->endpoint = std::move(*endpoint);
-    } else {
-      grpc_endpoint_destroy(*endpoint_ptr);
-      *endpoint_ptr = nullptr;
-    }
-    grpc_core::Closure::Run(DEBUG_LOCATION, closure,
-                            absl_status_to_grpc_error(endpoint.status()));
-    exec_ctx.Flush();
-    grpc_pollset_ee_broadcast_event();
-  };
-}
-/// 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_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);
-  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(deadline.as_timespec(GPR_CLOCK_MONOTONIC));
-  ChannelArgsEndpointConfig endpoint_config(channel_args);
-  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);
-    *endpoint = nullptr;
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_connect,
-                            absl_status_to_grpc_error(connected));
-  }
-}
-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);
-  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,
-                   const SliceAllocator& /*slice_allocator*/) {
-            grpc_core::ExecCtx exec_ctx;
-            GPR_ASSERT((*server)->on_accept_internal != nullptr);
-            grpc_event_engine_endpoint* iomgr_endpoint =
-                grpc_tcp_server_endpoint_create(std::move(ee_endpoint));
-            grpc_tcp_server_acceptor* acceptor =
-                static_cast<grpc_tcp_server_acceptor*>(
-                    gpr_zalloc(sizeof(*acceptor)));
-            acceptor->from_server = *server;
-            acceptor->external_connection = false;
-            (*server)->on_accept_internal((*server)->on_accept_internal_arg,
-                                          &iomgr_endpoint->base, nullptr,
-                                          acceptor);
-            exec_ctx.Flush();
-            grpc_pollset_ee_broadcast_event();
-          },
-          GrpcClosureToStatusCallback(shutdown_complete), endpoint_config,
-          std::move(ee_slice_allocator_factory));
-  if (!listener.ok()) {
-    return absl_status_to_grpc_error(listener.status());
-  }
-  *server = new grpc_tcp_server(std::move(*listener));
-  return GRPC_ERROR_NONE;
-}
-void tcp_server_start(grpc_tcp_server* server,
-                      const std::vector<grpc_pollset*>* /* pollsets */,
-                      grpc_tcp_server_cb on_accept_cb, void* cb_arg) {
-  server->on_accept_internal = on_accept_cb;
-  server->on_accept_internal_arg = cb_arg;
-  // The iomgr API does not handle situations where the server cannot start, so
-  // a crash may be preferable for now.
-  GPR_ASSERT(server->listener->Start().ok());
-}
-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);
-  if (!port.ok()) {
-    return absl_status_to_grpc_error(port.status());
-  }
-  *out_port = *port;
-  return GRPC_ERROR_NONE;
-}
-grpc_core::TcpServerFdHandler* tcp_server_create_fd_handler(
-    grpc_tcp_server* /* s */) {
-  // EventEngine-iomgr does not support fds.
-  return nullptr;
-}
-unsigned tcp_server_port_fd_count(grpc_tcp_server* /* s */,
-                                  unsigned /* port_index */) {
-  return 0;
-}
-int tcp_server_port_fd(grpc_tcp_server* /* s */, unsigned /* port_index */,
-                       unsigned /* fd_index */) {
-  // Note: only used internally
-  return -1;
-}
-grpc_tcp_server* tcp_server_ref(grpc_tcp_server* s) {
-  s->refcount.Ref(DEBUG_LOCATION, "server ref");
-  return s;
-}
-void tcp_server_shutdown_starting_add(grpc_tcp_server* s,
-                                      grpc_closure* shutdown_starting) {
-  grpc_core::MutexLock lock(&s->mu);
-  grpc_closure_list_append(&s->shutdown_starting, shutdown_starting,
-                           GRPC_ERROR_NONE);
-}
-void tcp_server_unref(grpc_tcp_server* s) {
-  if (GPR_UNLIKELY(s->refcount.Unref(DEBUG_LOCATION, "server unref"))) {
-    delete s;
-  }
-}
-// No-op, all are handled on listener unref
-void tcp_server_shutdown_listeners(grpc_tcp_server* /* s */) {}
-}  // namespace
-grpc_tcp_client_vtable grpc_event_engine_tcp_client_vtable = {tcp_connect};
-grpc_tcp_server_vtable grpc_event_engine_tcp_server_vtable = {
-    tcp_server_create,        tcp_server_start,
-    tcp_server_add_port,      tcp_server_create_fd_handler,
-    tcp_server_port_fd_count, tcp_server_port_fd,
-    tcp_server_ref,           tcp_server_shutdown_starting_add,
-    tcp_server_unref,         tcp_server_shutdown_listeners};
-// Methods that are expected to exist elsewhere in the codebase.
-struct grpc_fd {
-  int fd;
-};
-grpc_fd* grpc_fd_create(int /* fd */, const char* /* name */,
-                        bool /* track_err */) {
-  return nullptr;
-}
-grpc_endpoint* grpc_tcp_client_create_from_fd(
-    grpc_fd* /* fd */, const grpc_channel_args* /* channel_args */,
-    absl::string_view /* addr_str */,
-    grpc_slice_allocator* slice_allocator /* slice_allocator */) {
-  grpc_slice_allocator_destroy(slice_allocator);
-  return nullptr;
-}
-#endif  // GRPC_USE_EVENT_ENGINE

data/src/core/lib/iomgr/event_engine/timer.cc DELETED Viewed

@@ -1,62 +0,0 @@
-// Copyright 2021 The gRPC Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#include <grpc/support/port_platform.h>
-#ifdef GRPC_USE_EVENT_ENGINE
-#include <grpc/event_engine/event_engine.h>
-#include "src/core/lib/event_engine/event_engine_factory.h"
-#include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/event_engine/closure.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/surface/init.h"
-#include "src/core/lib/transport/error_utils.h"
-namespace {
-using ::grpc_event_engine::experimental::EventEngine;
-using ::grpc_event_engine::experimental::GetDefaultEventEngine;
-using ::grpc_event_engine::experimental::GrpcClosureToCallback;
-void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
-                grpc_closure* closure) {
-  timer->ee_task_handle = GetDefaultEventEngine()->RunAt(
-      grpc_core::ToAbslTime(deadline.as_timespec(GPR_CLOCK_REALTIME)),
-      GrpcClosureToCallback(closure));
-  timer->closure = closure;
-}
-void timer_cancel(grpc_timer* timer) {
-  auto handle = timer->ee_task_handle;
-  if (!GetDefaultEventEngine()->Cancel(handle)) {
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, timer->closure,
-                            GRPC_ERROR_CANCELLED);
-  }
-}
-/* Internal API */
-grpc_timer_check_result timer_check(grpc_core::Timestamp* /* next */) {
-  return GRPC_TIMERS_NOT_CHECKED;
-}
-void timer_list_init() {}
-void timer_list_shutdown(void) {}
-void timer_consume_kick(void) {}
-}  // namespace
-grpc_timer_vtable grpc_event_engine_timer_vtable = {
-    timer_init,      timer_cancel,        timer_check,
-    timer_list_init, timer_list_shutdown, timer_consume_kick};
-#endif  // GRPC_USE_EVENT_ENGINE