grpc 1.24.0 → 1.25.0.pre1

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

@@ -0,0 +1,33 @@
+//
+// Copyright 2017 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_GPRPP_SET_H
+#define GRPC_CORE_LIB_GPRPP_SET_H
+
+#include <grpc/support/port_platform.h>
+
+#include <set>
+
+#include "src/core/lib/gprpp/memory.h"
+
+namespace grpc_core {
+
+template <typename T, typename Compare = std::less<T>>
+using Set = std::set<T, Compare, Allocator<T>>;
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_GPRPP_SET_H */

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

@@ -28,7 +28,6 @@
 #include <grpc/support/thd_id.h>
 #include <grpc/support/time.h>
 
-#include "src/core/lib/gprpp/abstract.h"
 #include "src/core/lib/gprpp/memory.h"
 
 namespace grpc_core {
@@ -38,9 +37,8 @@ namespace internal {
 class ThreadInternalsInterface {
  public:
   virtual ~ThreadInternalsInterface() {}
-  virtual void Start() GRPC_ABSTRACT;
-  virtual void Join() GRPC_ABSTRACT;
-  GRPC_ABSTRACT_BASE_CLASS
+  virtual void Start() = 0;
+  virtual void Join() = 0;
 };
 
 }  // namespace internal

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

@@ -66,7 +66,7 @@ static grpc_httpcli_get_override g_get_override = nullptr;
 static grpc_httpcli_post_override g_post_override = nullptr;
 
 static void plaintext_handshake(void* arg, grpc_endpoint* endpoint,
-                                const char* host, grpc_millis deadline,
+                                const char* /*host*/, grpc_millis /*deadline*/,
                                 void (*on_done)(void* arg,
                                                 grpc_endpoint* endpoint)) {
   on_done(arg, endpoint);

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

@@ -41,7 +41,7 @@
 class grpc_httpcli_ssl_channel_security_connector final
     : public grpc_channel_security_connector {
  public:
-  explicit grpc_httpcli_ssl_channel_security_connector(char* secure_peer_name)
+  grpc_httpcli_ssl_channel_security_connector(char* secure_peer_name)
       : grpc_channel_security_connector(
             /*url_scheme=*/nullptr,
             /*channel_creds=*/nullptr,
@@ -66,7 +66,8 @@ class grpc_httpcli_ssl_channel_security_connector final
         &options, &handshaker_factory_);
   }
 
-  void add_handshakers(grpc_pollset_set* interested_parties,
+  void add_handshakers(const grpc_channel_args* args,
+                       grpc_pollset_set* /*interested_parties*/,
                        grpc_core::HandshakeManager* handshake_mgr) override {
     tsi_handshaker* handshaker = nullptr;
     if (handshaker_factory_ != nullptr) {
@@ -77,14 +78,15 @@ class grpc_httpcli_ssl_channel_security_connector final
                 tsi_result_to_string(result));
       }
     }
-    handshake_mgr->Add(grpc_core::SecurityHandshakerCreate(handshaker, this));
+    handshake_mgr->Add(
+        grpc_core::SecurityHandshakerCreate(handshaker, this, args));
   }
 
   tsi_ssl_client_handshaker_factory* handshaker_factory() const {
     return handshaker_factory_;
   }
 
-  void check_peer(tsi_peer peer, grpc_endpoint* ep,
+  void check_peer(tsi_peer peer, grpc_endpoint* /*ep*/,
                   grpc_core::RefCountedPtr<grpc_auth_context>* /*auth_context*/,
                   grpc_closure* on_peer_checked) override {
     grpc_error* error = GRPC_ERROR_NONE;
@@ -109,15 +111,15 @@ class grpc_httpcli_ssl_channel_security_connector final
     return strcmp(secure_peer_name_, other->secure_peer_name_);
   }
 
-  bool check_call_host(grpc_core::StringView host,
-                       grpc_auth_context* auth_context,
-                       grpc_closure* on_call_host_checked,
+  bool check_call_host(grpc_core::StringView /*host*/,
+                       grpc_auth_context* /*auth_context*/,
+                       grpc_closure* /*on_call_host_checked*/,
                        grpc_error** error) override {
     *error = GRPC_ERROR_NONE;
     return true;
   }
 
-  void cancel_check_call_host(grpc_closure* on_call_host_checked,
+  void cancel_check_call_host(grpc_closure* /*on_call_host_checked*/,
                               grpc_error* error) override {
     GRPC_ERROR_UNREF(error);
   }
@@ -132,7 +134,7 @@ class grpc_httpcli_ssl_channel_security_connector final
 static grpc_core::RefCountedPtr<grpc_channel_security_connector>
 httpcli_ssl_channel_security_connector_create(
     const char* pem_root_certs, const tsi_ssl_root_certs_store* root_store,
-    const char* secure_peer_name) {
+    const char* secure_peer_name, grpc_channel_args* /*channel_args*/) {
   if (secure_peer_name != nullptr && pem_root_certs == nullptr) {
     gpr_log(GPR_ERROR,
             "Cannot assert a secure peer name without a trust root.");
@@ -192,8 +194,10 @@ static void ssl_handshake(void* arg, grpc_endpoint* tcp, const char* host,
   c->func = on_done;
   c->arg = arg;
   grpc_core::RefCountedPtr<grpc_channel_security_connector> sc =
-      httpcli_ssl_channel_security_connector_create(pem_root_certs, root_store,
-                                                    host);
+      httpcli_ssl_channel_security_connector_create(
+          pem_root_certs, root_store, host,
+          static_cast<grpc_core::HandshakerArgs*>(arg)->args);
+
   GPR_ASSERT(sc != nullptr);
   grpc_arg channel_arg = grpc_security_connector_to_arg(sc.get());
   grpc_channel_args args = {1, &channel_arg};

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

@@ -327,7 +327,7 @@ void grpc_http_parser_init(grpc_http_parser* parser, grpc_http_type type,
   parser->cur_line_end_length = 2;
 }
 
-void grpc_http_parser_destroy(grpc_http_parser* parser) {}
+void grpc_http_parser_destroy(grpc_http_parser* /*parser*/) {}
 
 void grpc_http_request_destroy(grpc_http_request* request) {
   size_t i;

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

@@ -39,8 +39,8 @@ void fill_gpr_from_timestamp(gpr_timespec* gts, const struct timespec* ts) {
   gts->clock_type = GPR_CLOCK_REALTIME;
 }
 
-void default_timestamps_callback(void* arg, grpc_core::Timestamps* ts,
-                                 grpc_error* shudown_err) {
+void default_timestamps_callback(void* /*arg*/, grpc_core::Timestamps* /*ts*/,
+                                 grpc_error* /*shudown_err*/) {
   gpr_log(GPR_DEBUG, "Timestamps callback has not been registered");
 }
 
@@ -293,9 +293,8 @@ 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)) {
   gpr_log(GPR_DEBUG, "Timestamps callback is not enabled for this platform");
 }
 } /* namespace grpc_core */

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

@@ -114,6 +114,10 @@ struct Timestamps {
 #ifdef GRPC_LINUX_ERRQUEUE
 class TracedBuffer {
  public:
+  /** Use AddNewEntry function instead of using this directly. */
+  TracedBuffer(uint32_t seq_no, void* arg)
+      : seq_no_(seq_no), arg_(arg), next_(nullptr) {}
+
   /** Add a new entry in the TracedBuffer list pointed to by head. Also saves
    * sendmsg_time with the current timestamp. */
   static void AddNewEntry(grpc_core::TracedBuffer** head, uint32_t seq_no,
@@ -133,11 +137,6 @@ class TracedBuffer {
                        grpc_error* shutdown_err);
 
  private:
-  GRPC_ALLOW_CLASS_TO_USE_NON_PUBLIC_NEW
-
-  TracedBuffer(uint32_t seq_no, void* arg)
-      : seq_no_(seq_no), arg_(arg), next_(nullptr) {}
-
   uint32_t seq_no_; /* The sequence number for the last byte in the buffer */
   void* arg_;       /* The arg to pass to timestamps_callback */
   grpc_core::Timestamps ts_; /* The timestamps corresponding to this buffer */
@@ -147,7 +146,7 @@ class TracedBuffer {
 class TracedBuffer {
  public:
   /* Dummy shutdown function */
-  static void Shutdown(grpc_core::TracedBuffer** head, void* remaining,
+  static void Shutdown(grpc_core::TracedBuffer** /*head*/, void* /*remaining*/,
                        grpc_error* shutdown_err) {
     GRPC_ERROR_UNREF(shutdown_err);
   }

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

@@ -48,7 +48,6 @@ gpr_atm EncodeCancelStateError(grpc_error* error) {
 CallCombiner::CallCombiner() {
   gpr_atm_no_barrier_store(&cancel_state_, 0);
   gpr_atm_no_barrier_store(&size_, 0);
-  gpr_mpscq_init(&queue_);
 #ifdef GRPC_TSAN_ENABLED
   GRPC_CLOSURE_INIT(&tsan_closure_, TsanClosure, this,
                     grpc_schedule_on_exec_ctx);
@@ -56,7 +55,6 @@ CallCombiner::CallCombiner() {
 }
 
 CallCombiner::~CallCombiner() {
-  gpr_mpscq_destroy(&queue_);
   GRPC_ERROR_UNREF(DecodeCancelStateError(cancel_state_));
 }
 
@@ -140,7 +138,8 @@ void CallCombiner::Start(grpc_closure* closure, grpc_error* error,
     }
     // Queue was not empty, so add closure to queue.
     closure->error_data.error = error;
-    gpr_mpscq_push(&queue_, reinterpret_cast<gpr_mpscq_node*>(closure));
+    queue_.Push(
+        reinterpret_cast<MultiProducerSingleConsumerQueue::Node*>(closure));
   }
 }
 
@@ -163,8 +162,8 @@ void CallCombiner::Stop(DEBUG_ARGS const char* reason) {
         gpr_log(GPR_INFO, "  checking queue");
       }
       bool empty;
-      grpc_closure* closure = reinterpret_cast<grpc_closure*>(
-          gpr_mpscq_pop_and_check_end(&queue_, &empty));
+      grpc_closure* closure =
+          reinterpret_cast<grpc_closure*>(queue_.PopAndCheckEnd(&empty));
       if (closure == nullptr) {
         // This can happen either due to a race condition within the mpscq
         // code or because of a race with Start().

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

@@ -25,8 +25,8 @@
 
 #include <grpc/support/atm.h>
 
-#include "src/core/lib/gpr/mpscq.h"
 #include "src/core/lib/gprpp/inlined_vector.h"
+#include "src/core/lib/gprpp/mpscq.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -108,7 +108,7 @@ class CallCombiner {
 #endif
 
   gpr_atm size_ = 0;  // size_t, num closures in queue or currently executing
-  gpr_mpscq queue_;
+  MultiProducerSingleConsumerQueue queue_;
   // Either 0 (if not cancelled and no cancellation closure set),
   // a grpc_closure* (if the lowest bit is 0),
   // or a grpc_error* (if the lowest bit is 1).

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

@@ -43,10 +43,12 @@ class CFStreamHandle : public GrpcLibraryInitHolder {
  public:
   static CFStreamHandle* CreateStreamHandle(CFReadStreamRef read_stream,
                                             CFWriteStreamRef write_stream);
-  ~CFStreamHandle() override;
+  /** Use CreateStreamHandle function instead of using this directly. */
+  CFStreamHandle(CFReadStreamRef read_stream, CFWriteStreamRef write_stream);
   CFStreamHandle(const CFStreamHandle& ref) = delete;
   CFStreamHandle(CFStreamHandle&& ref) = delete;
   CFStreamHandle& operator=(const CFStreamHandle& rhs) = delete;
+  ~CFStreamHandle() override;
 
   void NotifyOnOpen(grpc_closure* closure);
   void NotifyOnRead(grpc_closure* closure);
@@ -57,7 +59,6 @@ class CFStreamHandle : public GrpcLibraryInitHolder {
   void Unref(const char* file = "", int line = 0, const char* reason = nullptr);
 
  private:
-  CFStreamHandle(CFReadStreamRef read_stream, CFWriteStreamRef write_stream);
   static void ReadCallback(CFReadStreamRef stream, CFStreamEventType type,
                            void* client_callback_info);
   static void WriteCallback(CFWriteStreamRef stream, CFStreamEventType type,
@@ -72,9 +73,6 @@ class CFStreamHandle : public GrpcLibraryInitHolder {
   dispatch_queue_t dispatch_queue_;
 
   gpr_refcount refcount_;
-
-  GRPC_ALLOW_CLASS_TO_USE_NON_PUBLIC_NEW
-  GRPC_ALLOW_CLASS_TO_USE_NON_PUBLIC_DELETE
 };
 
 #ifdef DEBUG

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

@@ -22,10 +22,13 @@
 #include <grpc/support/port_platform.h>
 
 #include <assert.h>
+#include <stdbool.h>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <stdbool.h>
-#include "src/core/lib/gpr/mpscq.h"
+
+#include "src/core/lib/gprpp/manual_constructor.h"
+#include "src/core/lib/gprpp/mpscq.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/profiling/timers.h"
 
@@ -69,7 +72,9 @@ struct grpc_closure {
    *  space */
   union {
     grpc_closure* next;
-    gpr_mpscq_node atm_next;
+    grpc_core::ManualConstructor<
+        grpc_core::MultiProducerSingleConsumerQueue::Node>
+        mpscq_node;
     uintptr_t scratch;
   } next_data;
 

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

@@ -28,6 +28,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/debug/stats.h"
+#include "src/core/lib/gprpp/mpscq.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/profiling/timers.h"
@@ -44,44 +45,17 @@ grpc_core::DebugOnlyTraceFlag grpc_combiner_trace(false, "combiner");
 #define STATE_UNORPHANED 1
 #define STATE_ELEM_COUNT_LOW_BIT 2
 
-struct grpc_combiner {
-  grpc_combiner* next_combiner_on_this_exec_ctx;
-  grpc_closure_scheduler scheduler;
-  grpc_closure_scheduler finally_scheduler;
-  gpr_mpscq queue;
-  // either:
-  // a pointer to the initiating exec ctx if that is the only exec_ctx that has
-  // ever queued to this combiner, or NULL. If this is non-null, it's not
-  // dereferencable (since the initiating exec_ctx may have gone out of scope)
-  gpr_atm initiating_exec_ctx_or_null;
-  // state is:
-  // lower bit - zero if orphaned (STATE_UNORPHANED)
-  // other bits - number of items queued on the lock (STATE_ELEM_COUNT_LOW_BIT)
-  gpr_atm state;
-  bool time_to_execute_final_list;
-  grpc_closure_list final_list;
-  grpc_closure offload;
-  gpr_refcount refs;
-};
-
-static void combiner_run(grpc_closure* closure, grpc_error* error);
-static void combiner_exec(grpc_closure* closure, grpc_error* error);
-static void combiner_finally_exec(grpc_closure* closure, grpc_error* error);
-
-static const grpc_closure_scheduler_vtable scheduler = {
-    combiner_run, combiner_exec, "combiner:immediately"};
-static const grpc_closure_scheduler_vtable finally_scheduler = {
-    combiner_finally_exec, combiner_finally_exec, "combiner:finally"};
+static void combiner_exec(grpc_core::Combiner* lock, grpc_closure* closure,
+                          grpc_error* error);
+static void combiner_finally_exec(grpc_core::Combiner* lock,
+                                  grpc_closure* closure, grpc_error* error);
 
 static void offload(void* arg, grpc_error* error);
 
-grpc_combiner* grpc_combiner_create(void) {
-  grpc_combiner* lock = static_cast<grpc_combiner*>(gpr_zalloc(sizeof(*lock)));
+grpc_core::Combiner* grpc_combiner_create(void) {
+  grpc_core::Combiner* lock = grpc_core::New<grpc_core::Combiner>();
   gpr_ref_init(&lock->refs, 1);
-  lock->scheduler.vtable = &scheduler;
-  lock->finally_scheduler.vtable = &finally_scheduler;
   gpr_atm_no_barrier_store(&lock->state, STATE_UNORPHANED);
-  gpr_mpscq_init(&lock->queue);
   grpc_closure_list_init(&lock->final_list);
   GRPC_CLOSURE_INIT(
       &lock->offload, offload, lock,
@@ -90,14 +64,13 @@ grpc_combiner* grpc_combiner_create(void) {
   return lock;
 }
 
-static void really_destroy(grpc_combiner* lock) {
+static void really_destroy(grpc_core::Combiner* lock) {
   GRPC_COMBINER_TRACE(gpr_log(GPR_INFO, "C:%p really_destroy", lock));
   GPR_ASSERT(gpr_atm_no_barrier_load(&lock->state) == 0);
-  gpr_mpscq_destroy(&lock->queue);
-  gpr_free(lock);
+  grpc_core::Delete(lock);
 }
 
-static void start_destroy(grpc_combiner* lock) {
+static void start_destroy(grpc_core::Combiner* lock) {
   gpr_atm old_state = gpr_atm_full_fetch_add(&lock->state, -STATE_UNORPHANED);
   GRPC_COMBINER_TRACE(gpr_log(
       GPR_INFO, "C:%p really_destroy old_state=%" PRIdPTR, lock, old_state));
@@ -118,20 +91,21 @@ static void start_destroy(grpc_combiner* lock) {
 #define GRPC_COMBINER_DEBUG_SPAM(op, delta)
 #endif
 
-void grpc_combiner_unref(grpc_combiner* lock GRPC_COMBINER_DEBUG_ARGS) {
+void grpc_combiner_unref(grpc_core::Combiner* lock GRPC_COMBINER_DEBUG_ARGS) {
   GRPC_COMBINER_DEBUG_SPAM("UNREF", -1);
   if (gpr_unref(&lock->refs)) {
     start_destroy(lock);
   }
 }
 
-grpc_combiner* grpc_combiner_ref(grpc_combiner* lock GRPC_COMBINER_DEBUG_ARGS) {
+grpc_core::Combiner* grpc_combiner_ref(
+    grpc_core::Combiner* lock GRPC_COMBINER_DEBUG_ARGS) {
   GRPC_COMBINER_DEBUG_SPAM("  REF", 1);
   gpr_ref(&lock->refs);
   return lock;
 }
 
-static void push_last_on_exec_ctx(grpc_combiner* lock) {
+static void push_last_on_exec_ctx(grpc_core::Combiner* lock) {
   lock->next_combiner_on_this_exec_ctx = nullptr;
   if (grpc_core::ExecCtx::Get()->combiner_data()->active_combiner == nullptr) {
     grpc_core::ExecCtx::Get()->combiner_data()->active_combiner =
@@ -144,7 +118,7 @@ static void push_last_on_exec_ctx(grpc_combiner* lock) {
   }
 }
 
-static void push_first_on_exec_ctx(grpc_combiner* lock) {
+static void push_first_on_exec_ctx(grpc_core::Combiner* lock) {
   lock->next_combiner_on_this_exec_ctx =
       grpc_core::ExecCtx::Get()->combiner_data()->active_combiner;
   grpc_core::ExecCtx::Get()->combiner_data()->active_combiner = lock;
@@ -153,14 +127,10 @@ static void push_first_on_exec_ctx(grpc_combiner* lock) {
   }
 }
 
-#define COMBINER_FROM_CLOSURE_SCHEDULER(closure, scheduler_name) \
-  ((grpc_combiner*)(((char*)((closure)->scheduler)) -            \
-                    offsetof(grpc_combiner, scheduler_name)))
-
-static void combiner_exec(grpc_closure* cl, grpc_error* error) {
+static void combiner_exec(grpc_core::Combiner* lock, grpc_closure* cl,
+                          grpc_error* error) {
   GPR_TIMER_SCOPE("combiner.execute", 0);
   GRPC_STATS_INC_COMBINER_LOCKS_SCHEDULED_ITEMS();
-  grpc_combiner* lock = COMBINER_FROM_CLOSURE_SCHEDULER(cl, scheduler);
   gpr_atm last = gpr_atm_full_fetch_add(&lock->state, STATE_ELEM_COUNT_LOW_BIT);
   GRPC_COMBINER_TRACE(gpr_log(GPR_INFO,
                               "C:%p grpc_combiner_execute c=%p last=%" PRIdPTR,
@@ -185,7 +155,7 @@ static void combiner_exec(grpc_closure* cl, grpc_error* error) {
   GPR_ASSERT(last & STATE_UNORPHANED);  // ensure lock has not been destroyed
   assert(cl->cb);
   cl->error_data.error = error;
-  gpr_mpscq_push(&lock->queue, &cl->next_data.atm_next);
+  lock->queue.Push(cl->next_data.mpscq_node.get());
 }
 
 static void move_next() {
@@ -198,12 +168,12 @@ static void move_next() {
   }
 }
 
-static void offload(void* arg, grpc_error* error) {
-  grpc_combiner* lock = static_cast<grpc_combiner*>(arg);
+static void offload(void* arg, grpc_error* /*error*/) {
+  grpc_core::Combiner* lock = static_cast<grpc_core::Combiner*>(arg);
   push_last_on_exec_ctx(lock);
 }
 
-static void queue_offload(grpc_combiner* lock) {
+static void queue_offload(grpc_core::Combiner* lock) {
   GRPC_STATS_INC_COMBINER_LOCKS_OFFLOADED();
   move_next();
   GRPC_COMBINER_TRACE(gpr_log(GPR_INFO, "C:%p queue_offload", lock));
@@ -212,7 +182,7 @@ static void queue_offload(grpc_combiner* lock) {
 
 bool grpc_combiner_continue_exec_ctx() {
   GPR_TIMER_SCOPE("combiner.continue_exec_ctx", 0);
-  grpc_combiner* lock =
+  grpc_core::Combiner* lock =
       grpc_core::ExecCtx::Get()->combiner_data()->active_combiner;
   if (lock == nullptr) {
     return false;
@@ -249,7 +219,7 @@ bool grpc_combiner_continue_exec_ctx() {
       // peek to see if something new has shown up, and execute that with
       // priority
       (gpr_atm_acq_load(&lock->state) >> 1) > 1) {
-    gpr_mpscq_node* n = gpr_mpscq_pop(&lock->queue);
+    grpc_core::MultiProducerSingleConsumerQueue::Node* n = lock->queue.Pop();
     GRPC_COMBINER_TRACE(
         gpr_log(GPR_INFO, "C:%p maybe_finish_one n=%p", lock, n));
     if (n == nullptr) {
@@ -330,19 +300,20 @@ bool grpc_combiner_continue_exec_ctx() {
 
 static void enqueue_finally(void* closure, grpc_error* error);
 
-static void combiner_finally_exec(grpc_closure* closure, grpc_error* error) {
+static void combiner_finally_exec(grpc_core::Combiner* lock,
+                                  grpc_closure* closure, grpc_error* error) {
+  GPR_ASSERT(lock != nullptr);
   GPR_TIMER_SCOPE("combiner.execute_finally", 0);
   GRPC_STATS_INC_COMBINER_LOCKS_SCHEDULED_FINAL_ITEMS();
-  grpc_combiner* lock =
-      COMBINER_FROM_CLOSURE_SCHEDULER(closure, finally_scheduler);
   GRPC_COMBINER_TRACE(gpr_log(
       GPR_INFO, "C:%p grpc_combiner_execute_finally c=%p; ac=%p", lock, closure,
       grpc_core::ExecCtx::Get()->combiner_data()->active_combiner));
   if (grpc_core::ExecCtx::Get()->combiner_data()->active_combiner != lock) {
     GPR_TIMER_MARK("slowpath", 0);
-    GRPC_CLOSURE_SCHED(GRPC_CLOSURE_CREATE(enqueue_finally, closure,
-                                           grpc_combiner_scheduler(lock)),
-                       error);
+    // Reusing scheduler to store the combiner so that it can be accessed in
+    // enqueue_finally
+    closure->scheduler = reinterpret_cast<grpc_closure_scheduler*>(lock);
+    lock->Run(GRPC_CLOSURE_CREATE(enqueue_finally, closure, nullptr), error);
     return;
   }
 
@@ -352,32 +323,24 @@ static void combiner_finally_exec(grpc_closure* closure, grpc_error* error) {
   grpc_closure_list_append(&lock->final_list, closure, error);
 }
 
-static void combiner_run(grpc_closure* closure, grpc_error* error) {
-  grpc_combiner* lock = COMBINER_FROM_CLOSURE_SCHEDULER(closure, scheduler);
-#ifndef NDEBUG
-  closure->scheduled = false;
-  GRPC_COMBINER_TRACE(gpr_log(
-      GPR_DEBUG,
-      "Combiner:%p grpc_combiner_run closure:%p created [%s:%d] run [%s:%d]",
-      lock, closure, closure->file_created, closure->line_created,
-      closure->file_initiated, closure->line_initiated));
-#endif
-  GPR_ASSERT(grpc_core::ExecCtx::Get()->combiner_data()->active_combiner ==
-             lock);
-  closure->cb(closure->cb_arg, error);
-  GRPC_ERROR_UNREF(error);
-}
-
 static void enqueue_finally(void* closure, grpc_error* error) {
-  combiner_finally_exec(static_cast<grpc_closure*>(closure),
-                        GRPC_ERROR_REF(error));
+  grpc_closure* cl = static_cast<grpc_closure*>(closure);
+  combiner_finally_exec(reinterpret_cast<grpc_core::Combiner*>(cl->scheduler),
+                        cl, GRPC_ERROR_REF(error));
 }
 
-grpc_closure_scheduler* grpc_combiner_scheduler(grpc_combiner* combiner) {
-  return &combiner->scheduler;
+namespace grpc_core {
+void Combiner::Run(grpc_closure* closure, grpc_error* error) {
+  GPR_ASSERT(closure->scheduler == nullptr ||
+             closure->scheduler ==
+                 reinterpret_cast<grpc_closure_scheduler*>(this));
+  combiner_exec(this, closure, error);
 }
 
-grpc_closure_scheduler* grpc_combiner_finally_scheduler(
-    grpc_combiner* combiner) {
-  return &combiner->finally_scheduler;
+void Combiner::FinallyRun(grpc_closure* closure, grpc_error* error) {
+  GPR_ASSERT(closure->scheduler == nullptr ||
+             closure->scheduler ==
+                 reinterpret_cast<grpc_closure_scheduler*>(this));
+  combiner_finally_exec(this, closure, error);
 }
+}  // namespace grpc_core