grpc 1.25.0 → 1.26.0

data/src/core/lib/gprpp/orphanable.h

@@ -69,7 +69,7 @@ using OrphanablePtr = std::unique_ptr<T, Deleter>;
 
 template <typename T, typename... Args>
 inline OrphanablePtr<T> MakeOrphanable(Args&&... args) {
-  return OrphanablePtr<T>(New<T>(std::forward<Args>(args)...));
+  return OrphanablePtr<T>(new T(std::forward<Args>(args)...));
 }
 
 // A type of Orphanable with internal ref-counting.
@@ -106,12 +106,12 @@ class InternallyRefCounted : public Orphanable {
 
   void Unref() {
     if (GPR_UNLIKELY(refs_.Unref())) {
-      Delete(static_cast<Child*>(this));
+      delete this;
     }
   }
   void Unref(const DebugLocation& location, const char* reason) {
     if (GPR_UNLIKELY(refs_.Unref(location, reason))) {
-      Delete(static_cast<Child*>(this));
+      delete this;
     }
   }
 

data/src/core/lib/gprpp/ref_counted.h

@@ -220,7 +220,7 @@ class RefCount {
 
 // A base class for reference-counted objects.
 // New objects should be created via New() and start with a refcount of 1.
-// When the refcount reaches 0, the object will be deleted via Delete().
+// When the refcount reaches 0, the object will be deleted via delete .
 //
 // This will commonly be used by CRTP (curiously-recurring template pattern)
 // e.g., class MyClass : public RefCounted<MyClass>
@@ -267,12 +267,12 @@ class RefCounted : public Impl {
   // friend of this class.
   void Unref() {
     if (GPR_UNLIKELY(refs_.Unref())) {
-      Delete(static_cast<Child*>(this));
+      delete static_cast<Child*>(this);
     }
   }
   void Unref(const DebugLocation& location, const char* reason) {
     if (GPR_UNLIKELY(refs_.Unref(location, reason))) {
-      Delete(static_cast<Child*>(this));
+      delete static_cast<Child*>(this);
     }
   }
 

data/src/core/lib/gprpp/ref_counted_ptr.h

@@ -179,7 +179,7 @@ class RefCountedPtr {
 
 template <typename T, typename... Args>
 inline RefCountedPtr<T> MakeRefCounted(Args&&... args) {
-  return RefCountedPtr<T>(New<T>(std::forward<Args>(args)...));
+  return RefCountedPtr<T>(new T(std::forward<Args>(args)...));
 }
 
 }  // namespace grpc_core

data/src/core/lib/gprpp/string_view.h

@@ -28,13 +28,24 @@
 #include <cstdint>
 #include <cstring>
 #include <limits>
+#include <string>
 
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/memory.h"
 
+#if GRPC_USE_ABSL
+#include "absl/strings/string_view.h"
+#endif
+
 namespace grpc_core {
 
+#if GRPC_USE_ABSL
+
+using StringView = absl::string_view;
+
+#else
+
 // Provides a light-weight view over a char array or a slice, similar but not
 // identical to absl::string_view.
 //
@@ -62,10 +73,6 @@ class StringView final {
   constexpr StringView(const char* ptr, size_t size) : ptr_(ptr), size_(size) {}
   constexpr StringView(const char* ptr)
       : StringView(ptr, ptr == nullptr ? 0 : strlen(ptr)) {}
-  // Not part of absl::string_view API.
-  StringView(const grpc_slice& slice)
-      : StringView(reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(slice)),
-                   GRPC_SLICE_LENGTH(slice)) {}
   constexpr StringView() : StringView(nullptr, 0) {}
 
   constexpr const char* data() const { return ptr_; }
@@ -105,25 +112,13 @@ class StringView final {
     size_ = 0;
   }
 
-  // Creates a dup of the string viewed by this class.
-  // Return value is null-terminated and never nullptr.
-  //
-  // Not part of absl::string_view API.
-  grpc_core::UniquePtr<char> dup() const {
-    char* str = static_cast<char*>(gpr_malloc(size_ + 1));
-    if (size_ > 0) memcpy(str, ptr_, size_);
-    str[size_] = '\0';
-    return grpc_core::UniquePtr<char>(str);
-  }
-
-  // Not part of absl::string_view API.
-  int cmp(StringView other) const {
-    const size_t len = GPR_MIN(size(), other.size());
-    const int ret = strncmp(data(), other.data(), len);
-    if (ret != 0) return ret;
-    if (size() == other.size()) return 0;
-    if (size() < other.size()) return -1;
-    return 1;
+  // Converts to `std::basic_string`.
+  template <typename Allocator>
+  explicit operator std::basic_string<char, std::char_traits<char>, Allocator>()
+      const {
+    if (data() == nullptr) return {};
+    return std::basic_string<char, std::char_traits<char>, Allocator>(data(),
+                                                                      size());
   }
 
  private:
@@ -138,6 +133,33 @@ inline bool operator==(StringView lhs, StringView rhs) {
 
 inline bool operator!=(StringView lhs, StringView rhs) { return !(lhs == rhs); }
 
+#endif  // GRPC_USE_ABSL
+
+// Converts grpc_slice to StringView.
+inline StringView StringViewFromSlice(const grpc_slice& slice) {
+  return StringView(reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(slice)),
+                    GRPC_SLICE_LENGTH(slice));
+}
+
+// Creates a dup of the string viewed by this class.
+// Return value is null-terminated and never nullptr.
+inline grpc_core::UniquePtr<char> StringViewToCString(const StringView sv) {
+  char* str = static_cast<char*>(gpr_malloc(sv.size() + 1));
+  if (sv.size() > 0) memcpy(str, sv.data(), sv.size());
+  str[sv.size()] = '\0';
+  return grpc_core::UniquePtr<char>(str);
+}
+
+// Compares lhs and rhs.
+inline int StringViewCmp(const StringView lhs, const StringView rhs) {
+  const size_t len = GPR_MIN(lhs.size(), rhs.size());
+  const int ret = strncmp(lhs.data(), rhs.data(), len);
+  if (ret != 0) return ret;
+  if (lhs.size() == rhs.size()) return 0;
+  if (lhs.size() < rhs.size()) return -1;
+  return 1;
+}
+
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_GPRPP_STRING_VIEW_H */

data/src/core/lib/gprpp/thd.h

@@ -144,7 +144,7 @@ class Thread {
   void Join() {
     if (impl_ != nullptr) {
       impl_->Join();
-      grpc_core::Delete(impl_);
+      delete impl_;
       state_ = DONE;
       impl_ = nullptr;
     } else {

data/src/core/lib/gprpp/thd_posix.cc

@@ -59,8 +59,9 @@ size_t RoundUpToPageSize(size_t size) {
 // Returns the minimum valid stack size that can be passed to
 // pthread_attr_setstacksize.
 size_t MinValidStackSize(size_t request_size) {
-  if (request_size < _SC_THREAD_STACK_MIN) {
-    request_size = _SC_THREAD_STACK_MIN;
+  size_t min_stacksize = sysconf(_SC_THREAD_STACK_MIN);
+  if (request_size < min_stacksize) {
+    request_size = min_stacksize;
   }
 
   // On some systems, pthread_attr_setstacksize() can fail if stacksize is
@@ -133,7 +134,7 @@ class ThreadInternalsPosix : public internal::ThreadInternalsInterface {
                           gpr_mu_unlock(&arg.thread->mu_);
 
                           if (!arg.joinable) {
-                            Delete(arg.thread);
+                            delete arg.thread;
                           }
 
                           (*arg.body)(arg.arg);
@@ -182,12 +183,12 @@ Thread::Thread(const char* thd_name, void (*thd_body)(void* arg), void* arg,
                bool* success, const Options& options)
     : options_(options) {
   bool outcome = false;
-  impl_ = New<ThreadInternalsPosix>(thd_name, thd_body, arg, &outcome, options);
+  impl_ = new ThreadInternalsPosix(thd_name, thd_body, arg, &outcome, options);
   if (outcome) {
     state_ = ALIVE;
   } else {
     state_ = FAILED;
-    Delete(impl_);
+    delete impl_;
     impl_ = nullptr;
   }
 

data/src/core/lib/gprpp/thd_windows.cc

@@ -121,7 +121,7 @@ class ThreadInternalsWindows
     }
     gpr_mu_unlock(&g_thd_info->thread->mu_);
     if (!g_thd_info->joinable) {
-      grpc_core::Delete(g_thd_info->thread);
+      delete g_thd_info->thread;
       g_thd_info->thread = nullptr;
     }
     g_thd_info->body(g_thd_info->arg);
@@ -155,12 +155,12 @@ Thread::Thread(const char* thd_name, void (*thd_body)(void* arg), void* arg,
                bool* success, const Options& options)
     : options_(options) {
   bool outcome = false;
-  impl_ = New<ThreadInternalsWindows>(thd_body, arg, &outcome, options);
+  impl_ = new ThreadInternalsWindows(thd_body, arg, &outcome, options);
   if (outcome) {
     state_ = ALIVE;
   } else {
     state_ = FAILED;
-    Delete(impl_);
+    delete impl_;
     impl_ = nullptr;
   }
 

data/src/core/lib/http/httpcli.cc

@@ -88,7 +88,7 @@ static void next_address(internal_request* req, grpc_error* due_to_error);
 static void finish(internal_request* req, grpc_error* error) {
   grpc_polling_entity_del_from_pollset_set(req->pollent,
                                            req->context->pollset_set);
-  GRPC_CLOSURE_SCHED(req->on_done, error);
+  grpc_core::ExecCtx::Run(DEBUG_LOCATION, req->on_done, error);
   grpc_http_parser_destroy(&req->parser);
   if (req->addresses != nullptr) {
     grpc_resolved_addresses_destroy(req->addresses);

data/src/core/lib/http/httpcli_security_connector.cc

@@ -100,7 +100,7 @@ class grpc_httpcli_ssl_channel_security_connector final
       error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
       gpr_free(msg);
     }
-    GRPC_CLOSURE_SCHED(on_peer_checked, error);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error);
     tsi_peer_destruct(&peer);
   }
 
@@ -174,13 +174,13 @@ static void on_handshake_done(void* arg, grpc_error* error) {
     gpr_free(args->read_buffer);
     c->func(c->arg, args->endpoint);
   }
-  grpc_core::Delete<on_done_closure>(c);
+  delete c;
 }
 
 static void ssl_handshake(void* arg, grpc_endpoint* tcp, const char* host,
                           grpc_millis deadline,
                           void (*on_done)(void* arg, grpc_endpoint* endpoint)) {
-  auto* c = grpc_core::New<on_done_closure>();
+  auto* c = new on_done_closure();
   const char* pem_root_certs =
       grpc_core::DefaultSslRootStore::GetPemRootCerts();
   const tsi_ssl_root_certs_store* root_store =

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

@@ -197,7 +197,7 @@ static int get_socket_tcp_info(grpc_core::tcp_info* info, int fd) {
 void TracedBuffer::AddNewEntry(TracedBuffer** head, uint32_t seq_no, int fd,
                                void* arg) {
   GPR_DEBUG_ASSERT(head != nullptr);
-  TracedBuffer* new_elem = New<TracedBuffer>(seq_no, arg);
+  TracedBuffer* new_elem = new TracedBuffer(seq_no, arg);
   /* Store the current time as the sendmsg time. */
   new_elem->ts_.sendmsg_time.time = gpr_now(GPR_CLOCK_REALTIME);
   new_elem->ts_.scheduled_time.time = gpr_inf_past(GPR_CLOCK_REALTIME);
@@ -254,7 +254,7 @@ void TracedBuffer::ProcessTimestamp(TracedBuffer** head,
            * restriction on the lifetime. */
           timestamps_callback(elem->arg_, &(elem->ts_), GRPC_ERROR_NONE);
           next = elem->next_;
-          Delete<TracedBuffer>(elem);
+          delete static_cast<TracedBuffer*>(elem);
           *head = elem = next;
           break;
         default:
@@ -273,7 +273,7 @@ void TracedBuffer::Shutdown(TracedBuffer** head, void* remaining,
   while (elem != nullptr) {
     timestamps_callback(elem->arg_, &(elem->ts_), shutdown_err);
     auto* next = elem->next_;
-    Delete<TracedBuffer>(elem);
+    delete elem;
     elem = next;
   }
   *head = nullptr;
@@ -293,8 +293,13 @@ void grpc_tcp_set_write_timestamps_callback(void (*fn)(void*,
 #else /* GRPC_LINUX_ERRQUEUE */
 
 namespace grpc_core {
-void grpc_tcp_set_write_timestamps_callback(
-    void (*/*fn*/)(void*, grpc_core::Timestamps*, grpc_error* error)) {
+void grpc_tcp_set_write_timestamps_callback(void (*fn)(void*,
+                                                       grpc_core::Timestamps*,
+                                                       grpc_error* error)) {
+  // Cast value of fn to void to avoid unused parameter warning.
+  // Can't comment out the name because some compilers and formatters don't
+  // like the sequence */* , which would arise from */*fn*/.
+  (void)fn;
   gpr_log(GPR_DEBUG, "Timestamps callback is not enabled for this platform");
 }
 } /* namespace grpc_core */

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

@@ -80,7 +80,8 @@ void CallCombiner::TsanClosure(void* arg, grpc_error* error) {
   } else {
     lock.reset();
   }
-  GRPC_CLOSURE_RUN(self->original_closure_, GRPC_ERROR_REF(error));
+  grpc_core::Closure::Run(DEBUG_LOCATION, self->original_closure_,
+                          GRPC_ERROR_REF(error));
   if (lock != nullptr) {
     TSAN_ANNOTATE_RWLOCK_RELEASED(&lock->taken, true);
     bool prev = true;
@@ -92,9 +93,9 @@ void CallCombiner::TsanClosure(void* arg, grpc_error* error) {
 void CallCombiner::ScheduleClosure(grpc_closure* closure, grpc_error* error) {
 #ifdef GRPC_TSAN_ENABLED
   original_closure_ = closure;
-  GRPC_CLOSURE_SCHED(&tsan_closure_, error);
+  ExecCtx::Run(DEBUG_LOCATION, &tsan_closure_, error);
 #else
-  GRPC_CLOSURE_SCHED(closure, error);
+  ExecCtx::Run(DEBUG_LOCATION, closure, error);
 #endif
 }
 
@@ -199,7 +200,7 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
                 "for pre-existing cancellation",
                 this, closure);
       }
-      GRPC_CLOSURE_SCHED(closure, GRPC_ERROR_REF(original_error));
+      ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_REF(original_error));
       break;
     } else {
       if (gpr_atm_full_cas(&cancel_state_, original_state, (gpr_atm)closure)) {
@@ -217,7 +218,7 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
                     "call_combiner=%p: scheduling old cancel callback=%p", this,
                     closure);
           }
-          GRPC_CLOSURE_SCHED(closure, GRPC_ERROR_NONE);
+          ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
         }
         break;
       }
@@ -244,7 +245,7 @@ void CallCombiner::Cancel(grpc_error* error) {
                   "call_combiner=%p: scheduling notify_on_cancel callback=%p",
                   this, notify_on_cancel);
         }
-        GRPC_CLOSURE_SCHED(notify_on_cancel, GRPC_ERROR_REF(error));
+        ExecCtx::Run(DEBUG_LOCATION, notify_on_cancel, GRPC_ERROR_REF(error));
       }
       break;
     }

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

@@ -31,6 +31,7 @@
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/dynamic_annotations.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 
 // A simple, lock-free mechanism for serializing activity related to a
 // single call.  This is similar to a combiner but is more lightweight.
@@ -156,8 +157,8 @@ class CallCombinerClosureList {
   //
   // All but one of the closures in the list will be scheduled via
   // GRPC_CALL_COMBINER_START(), and the remaining closure will be
-  // scheduled via GRPC_CLOSURE_SCHED(), which will eventually result in
-  // yielding the call combiner.  If the list is empty, then the call
+  // scheduled via ExecCtx::Run(), which will eventually result
+  // in yielding the call combiner.  If the list is empty, then the call
   // combiner will be yielded immediately.
   void RunClosures(CallCombiner* call_combiner) {
     if (closures_.empty()) {
@@ -177,7 +178,7 @@ class CallCombinerClosureList {
               grpc_error_string(closures_[0].error), closures_[0].reason);
     }
     // This will release the call combiner.
-    GRPC_CLOSURE_SCHED(closures_[0].closure, closures_[0].error);
+    ExecCtx::Run(DEBUG_LOCATION, closures_[0].closure, closures_[0].error);
     closures_.clear();
   }
 

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

@@ -53,7 +53,7 @@ void CFStreamHandle::Release(void* info) {
 
 CFStreamHandle* CFStreamHandle::CreateStreamHandle(
     CFReadStreamRef read_stream, CFWriteStreamRef write_stream) {
-  return grpc_core::New<CFStreamHandle>(read_stream, write_stream);
+  return new CFStreamHandle(read_stream, write_stream);
 }
 
 void CFStreamHandle::ReadCallback(CFReadStreamRef stream,
@@ -194,7 +194,7 @@ void CFStreamHandle::Unref(const char* file, int line, const char* reason) {
             reason, val, val - 1);
   }
   if (gpr_unref(&refcount_)) {
-    grpc_core::Delete<CFStreamHandle>(this);
+    delete this;
   }
 }
 

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

@@ -27,6 +27,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/mpscq.h"
 #include "src/core/lib/iomgr/error.h"
@@ -51,21 +52,6 @@ typedef struct grpc_closure_list {
  *              the closure scheduler will do that after the cb returns */
 typedef void (*grpc_iomgr_cb_func)(void* arg, grpc_error* error);
 
-typedef struct grpc_closure_scheduler grpc_closure_scheduler;
-
-typedef struct grpc_closure_scheduler_vtable {
-  /* NOTE: for all these functions, closure->scheduler == the scheduler that was
-           used to find this vtable */
-  void (*run)(grpc_closure* closure, grpc_error* error);
-  void (*sched)(grpc_closure* closure, grpc_error* error);
-  const char* name;
-} grpc_closure_scheduler_vtable;
-
-/** Abstract type that can schedule closures for execution */
-struct grpc_closure_scheduler {
-  const grpc_closure_scheduler_vtable* vtable;
-};
-
 /** A closure over a grpc_iomgr_cb_func. */
 struct grpc_closure {
   /** Once queued, next indicates the next queued closure; before then, scratch
@@ -84,10 +70,6 @@ struct grpc_closure {
   /** Arguments to be passed to "cb". */
   void* cb_arg;
 
-  /** Scheduler to schedule against: nullptr to schedule against current
-     execution context */
-  grpc_closure_scheduler* scheduler;
-
   /** Once queued, the result of the closure. Before then: scratch space */
   union {
     grpc_error* error;
@@ -109,16 +91,13 @@ struct grpc_closure {
 #ifndef NDEBUG
 inline grpc_closure* grpc_closure_init(const char* file, int line,
                                        grpc_closure* closure,
-                                       grpc_iomgr_cb_func cb, void* cb_arg,
-                                       grpc_closure_scheduler* scheduler) {
+                                       grpc_iomgr_cb_func cb, void* cb_arg) {
 #else
 inline grpc_closure* grpc_closure_init(grpc_closure* closure,
-                                       grpc_iomgr_cb_func cb, void* cb_arg,
-                                       grpc_closure_scheduler* scheduler) {
+                                       grpc_iomgr_cb_func cb, void* cb_arg) {
 #endif
   closure->cb = cb;
   closure->cb_arg = cb_arg;
-  closure->scheduler = scheduler;
   closure->error_data.error = GRPC_ERROR_NONE;
 #ifndef NDEBUG
   closure->scheduled = false;
@@ -134,10 +113,10 @@ inline grpc_closure* grpc_closure_init(grpc_closure* closure,
 /** Initializes \a closure with \a cb and \a cb_arg. Returns \a closure. */
 #ifndef NDEBUG
 #define GRPC_CLOSURE_INIT(closure, cb, cb_arg, scheduler) \
-  grpc_closure_init(__FILE__, __LINE__, closure, cb, cb_arg, scheduler)
+  grpc_closure_init(__FILE__, __LINE__, closure, cb, cb_arg)
 #else
 #define GRPC_CLOSURE_INIT(closure, cb, cb_arg, scheduler) \
-  grpc_closure_init(closure, cb, cb_arg, scheduler)
+  grpc_closure_init(closure, cb, cb_arg)
 #endif
 
 namespace closure_impl {
@@ -160,21 +139,19 @@ inline void closure_wrapper(void* arg, grpc_error* error) {
 
 #ifndef NDEBUG
 inline grpc_closure* grpc_closure_create(const char* file, int line,
-                                         grpc_iomgr_cb_func cb, void* cb_arg,
-                                         grpc_closure_scheduler* scheduler) {
+                                         grpc_iomgr_cb_func cb, void* cb_arg) {
 #else
-inline grpc_closure* grpc_closure_create(grpc_iomgr_cb_func cb, void* cb_arg,
-                                         grpc_closure_scheduler* scheduler) {
+inline grpc_closure* grpc_closure_create(grpc_iomgr_cb_func cb, void* cb_arg) {
 #endif
   closure_impl::wrapped_closure* wc =
       static_cast<closure_impl::wrapped_closure*>(gpr_malloc(sizeof(*wc)));
   wc->cb = cb;
   wc->cb_arg = cb_arg;
 #ifndef NDEBUG
-  grpc_closure_init(file, line, &wc->wrapper, closure_impl::closure_wrapper, wc,
-                    scheduler);
+  grpc_closure_init(file, line, &wc->wrapper, closure_impl::closure_wrapper,
+                    wc);
 #else
-  grpc_closure_init(&wc->wrapper, closure_impl::closure_wrapper, wc, scheduler);
+  grpc_closure_init(&wc->wrapper, closure_impl::closure_wrapper, wc);
 #endif
   return &wc->wrapper;
 }
@@ -182,10 +159,10 @@ inline grpc_closure* grpc_closure_create(grpc_iomgr_cb_func cb, void* cb_arg,
 /* Create a heap allocated closure: try to avoid except for very rare events */
 #ifndef NDEBUG
 #define GRPC_CLOSURE_CREATE(cb, cb_arg, scheduler) \
-  grpc_closure_create(__FILE__, __LINE__, cb, cb_arg, scheduler)
+  grpc_closure_create(__FILE__, __LINE__, cb, cb_arg)
 #else
 #define GRPC_CLOSURE_CREATE(cb, cb_arg, scheduler) \
-  grpc_closure_create(cb, cb_arg, scheduler)
+  grpc_closure_create(cb, cb_arg)
 #endif
 
 #define GRPC_CLOSURE_LIST_INIT \
@@ -247,112 +224,33 @@ inline bool grpc_closure_list_empty(grpc_closure_list closure_list) {
   return closure_list.head == nullptr;
 }
 
-#ifndef NDEBUG
-inline void grpc_closure_run(const char* file, int line, grpc_closure* c,
-                             grpc_error* error) {
-#else
-inline void grpc_closure_run(grpc_closure* c, grpc_error* error) {
-#endif
-  GPR_TIMER_SCOPE("grpc_closure_run", 0);
-  if (c != nullptr) {
-#ifndef NDEBUG
-    c->file_initiated = file;
-    c->line_initiated = line;
-    c->run = true;
-    GPR_ASSERT(c->cb != nullptr);
-#endif
-    c->scheduler->vtable->run(c, error);
-  } else {
-    GRPC_ERROR_UNREF(error);
-  }
-}
-
-/** Run a closure directly. Caller ensures that no locks are being held above.
- *  Note that calling this at the end of a closure callback function itself is
- *  by definition safe. */
-#ifndef NDEBUG
-#define GRPC_CLOSURE_RUN(closure, error) \
-  grpc_closure_run(__FILE__, __LINE__, closure, error)
-#else
-#define GRPC_CLOSURE_RUN(closure, error) grpc_closure_run(closure, error)
-#endif
-
-#ifndef NDEBUG
-inline void grpc_closure_sched(const char* file, int line, grpc_closure* c,
-                               grpc_error* error) {
-#else
-inline void grpc_closure_sched(grpc_closure* c, grpc_error* error) {
-#endif
-  GPR_TIMER_SCOPE("grpc_closure_sched", 0);
-  if (c != nullptr) {
-#ifndef NDEBUG
-    if (c->scheduled) {
-      gpr_log(GPR_ERROR,
-              "Closure already scheduled. (closure: %p, created: [%s:%d], "
-              "previously scheduled at: [%s: %d], newly scheduled at [%s: %d], "
-              "run?: %s",
-              c, c->file_created, c->line_created, c->file_initiated,
-              c->line_initiated, file, line, c->run ? "true" : "false");
-      abort();
+namespace grpc_core {
+class Closure {
+ public:
+  static void Run(const DebugLocation& location, grpc_closure* closure,
+                  grpc_error* error) {
+    (void)location;
+    if (closure == nullptr) {
+      GRPC_ERROR_UNREF(error);
+      return;
     }
-    c->scheduled = true;
-    c->file_initiated = file;
-    c->line_initiated = line;
-    c->run = false;
-    GPR_ASSERT(c->cb != nullptr);
-#endif
-    c->scheduler->vtable->sched(c, error);
-  } else {
-    GRPC_ERROR_UNREF(error);
-  }
-}
-
-/** Schedule a closure to be run. Does not need to be run from a safe point. */
 #ifndef NDEBUG
-#define GRPC_CLOSURE_SCHED(closure, error) \
-  grpc_closure_sched(__FILE__, __LINE__, closure, error)
-#else
-#define GRPC_CLOSURE_SCHED(closure, error) grpc_closure_sched(closure, error)
-#endif
-
-#ifndef NDEBUG
-inline void grpc_closure_list_sched(const char* file, int line,
-                                    grpc_closure_list* list) {
-#else
-inline void grpc_closure_list_sched(grpc_closure_list* list) {
+    if (grpc_trace_closure.enabled()) {
+      gpr_log(GPR_DEBUG, "running closure %p: created [%s:%d]: run [%s:%d]",
+              closure, closure->file_created, closure->line_created,
+              location.file(), location.line());
+    }
+    GPR_ASSERT(closure->cb != nullptr);
 #endif
-  grpc_closure* c = list->head;
-  while (c != nullptr) {
-    grpc_closure* next = c->next_data.next;
+    closure->cb(closure->cb_arg, error);
 #ifndef NDEBUG
-    if (c->scheduled) {
-      gpr_log(GPR_ERROR,
-              "Closure already scheduled. (closure: %p, created: [%s:%d], "
-              "previously scheduled at: [%s: %d] run?: %s",
-              c, c->file_created, c->line_created, c->file_initiated,
-              c->line_initiated, c->run ? "true" : "false");
-      abort();
+    if (grpc_trace_closure.enabled()) {
+      gpr_log(GPR_DEBUG, "closure %p finished", closure);
     }
-    c->scheduled = true;
-    c->file_initiated = file;
-    c->line_initiated = line;
-    c->run = false;
-    GPR_ASSERT(c->cb != nullptr);
 #endif
-    c->scheduler->vtable->sched(c, c->error_data.error);
-    c = next;
+    GRPC_ERROR_UNREF(error);
   }
-  list->head = list->tail = nullptr;
-}
-
-/** Schedule all closures in a list to be run. Does not need to be run from a
- * safe point. */
-#ifndef NDEBUG
-#define GRPC_CLOSURE_LIST_SCHED(closure_list) \
-  grpc_closure_list_sched(__FILE__, __LINE__, closure_list)
-#else
-#define GRPC_CLOSURE_LIST_SCHED(closure_list) \
-  grpc_closure_list_sched(closure_list)
-#endif
+};
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_IOMGR_CLOSURE_H */