grpc 1.41.1 → 1.42.0.pre1

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

@@ -25,6 +25,7 @@
 #include <string>
 
 #include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -41,187 +42,228 @@
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/slice/slice_internal.h"
 
-struct internal_request {
-  grpc_slice request_text;
-  grpc_http_parser parser;
-  grpc_resolved_addresses* addresses;
-  size_t next_address;
-  grpc_endpoint* ep;
-  grpc_resource_quota* resource_quota;
-  char* host;
-  char* ssl_host_override;
-  grpc_millis deadline;
-  int have_read_byte;
-  const grpc_httpcli_handshaker* handshaker;
-  grpc_closure* on_done;
-  grpc_httpcli_context* context;
-  grpc_polling_entity* pollent;
-  grpc_iomgr_object iomgr_obj;
-  grpc_slice_buffer incoming;
-  grpc_slice_buffer outgoing;
-  grpc_closure on_read;
-  grpc_closure done_write;
-  grpc_closure connected;
-  grpc_error_handle overall_error;
-};
-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*/,
-                                void (*on_done)(void* arg,
-                                                grpc_endpoint* endpoint)) {
-  on_done(arg, endpoint);
-}
-
-const grpc_httpcli_handshaker grpc_httpcli_plaintext = {"http",
-                                                        plaintext_handshake};
+namespace grpc_core {
+namespace {
+
+class InternalRequest {
+ public:
+  InternalRequest(const grpc_slice& request_text,
+                  grpc_httpcli_response* response,
+                  grpc_resource_quota* resource_quota, absl::string_view host,
+                  absl::string_view ssl_host_override, grpc_millis deadline,
+                  const grpc_httpcli_handshaker* handshaker,
+                  grpc_closure* on_done, grpc_httpcli_context* context,
+                  grpc_polling_entity* pollent, const char* name)
+      : request_text_(request_text),
+        resource_quota_(resource_quota),
+        host_(host),
+        ssl_host_override_(ssl_host_override),
+        deadline_(deadline),
+        handshaker_(handshaker),
+        on_done_(on_done),
+        context_(context),
+        pollent_(pollent) {
+    grpc_http_parser_init(&parser_, GRPC_HTTP_RESPONSE, response);
+    grpc_slice_buffer_init(&incoming_);
+    grpc_slice_buffer_init(&outgoing_);
+    grpc_iomgr_register_object(&iomgr_obj_, name);
+
+    GRPC_CLOSURE_INIT(&on_read_, OnRead, this, grpc_schedule_on_exec_ctx);
+    GRPC_CLOSURE_INIT(&done_write_, DoneWrite, this, grpc_schedule_on_exec_ctx);
+    GPR_ASSERT(pollent);
+    grpc_polling_entity_add_to_pollset_set(pollent_, context->pollset_set);
+    grpc_resolve_address(
+        host_.c_str(), handshaker_->default_port, context_->pollset_set,
+        GRPC_CLOSURE_CREATE(OnResolved, this, grpc_schedule_on_exec_ctx),
+        &addresses_);
+  }
 
-void grpc_httpcli_context_init(grpc_httpcli_context* context) {
-  context->pollset_set = grpc_pollset_set_create();
-}
+  ~InternalRequest() {
+    grpc_http_parser_destroy(&parser_);
+    if (addresses_ != nullptr) {
+      grpc_resolved_addresses_destroy(addresses_);
+    }
+    if (ep_ != nullptr) {
+      grpc_endpoint_destroy(ep_);
+    }
+    grpc_slice_unref_internal(request_text_);
+    grpc_iomgr_unregister_object(&iomgr_obj_);
+    grpc_slice_buffer_destroy_internal(&incoming_);
+    grpc_slice_buffer_destroy_internal(&outgoing_);
+    GRPC_ERROR_UNREF(overall_error_);
+    grpc_resource_quota_unref_internal(resource_quota_);
+  }
 
-void grpc_httpcli_context_destroy(grpc_httpcli_context* context) {
-  grpc_pollset_set_destroy(context->pollset_set);
-}
+ private:
+  void Finish(grpc_error_handle error) {
+    grpc_polling_entity_del_from_pollset_set(pollent_, context_->pollset_set);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_done_, error);
+    delete this;
+  }
 
-static void next_address(internal_request* req, grpc_error_handle due_to_error);
+  void AppendError(grpc_error_handle error) {
+    if (overall_error_ == GRPC_ERROR_NONE) {
+      overall_error_ =
+          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed HTTP/1 client request");
+    }
+    grpc_resolved_address* addr = &addresses_->addrs[next_address_ - 1];
+    std::string addr_text = grpc_sockaddr_to_uri(addr);
+    overall_error_ = grpc_error_add_child(
+        overall_error_,
+        grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS, addr_text));
+  }
 
-static void finish(internal_request* req, grpc_error_handle error) {
-  grpc_polling_entity_del_from_pollset_set(req->pollent,
-                                           req->context->pollset_set);
-  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);
+  void DoRead() {
+    grpc_endpoint_read(ep_, &incoming_, &on_read_, /*urgent=*/true);
   }
-  if (req->ep != nullptr) {
-    grpc_endpoint_destroy(req->ep);
+
+  static void OnRead(void* user_data, grpc_error_handle error) {
+    InternalRequest* req = static_cast<InternalRequest*>(user_data);
+    req->OnReadInternal(error);
   }
-  grpc_slice_unref_internal(req->request_text);
-  gpr_free(req->host);
-  gpr_free(req->ssl_host_override);
-  grpc_iomgr_unregister_object(&req->iomgr_obj);
-  grpc_slice_buffer_destroy_internal(&req->incoming);
-  grpc_slice_buffer_destroy_internal(&req->outgoing);
-  GRPC_ERROR_UNREF(req->overall_error);
-  grpc_resource_quota_unref_internal(req->resource_quota);
-  gpr_free(req);
-}
 
-static void append_error(internal_request* req, grpc_error_handle error) {
-  if (req->overall_error == GRPC_ERROR_NONE) {
-    req->overall_error =
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed HTTP/1 client request");
+  void OnReadInternal(grpc_error_handle error) {
+    size_t i;
+
+    for (i = 0; i < incoming_.count; i++) {
+      if (GRPC_SLICE_LENGTH(incoming_.slices[i])) {
+        have_read_byte_ = 1;
+        grpc_error_handle err =
+            grpc_http_parser_parse(&parser_, incoming_.slices[i], nullptr);
+        if (err != GRPC_ERROR_NONE) {
+          Finish(err);
+          return;
+        }
+      }
+    }
+
+    if (error == GRPC_ERROR_NONE) {
+      DoRead();
+    } else if (!have_read_byte_) {
+      NextAddress(GRPC_ERROR_REF(error));
+    } else {
+      Finish(grpc_http_parser_eof(&parser_));
+    }
   }
-  grpc_resolved_address* addr = &req->addresses->addrs[req->next_address - 1];
-  std::string addr_text = grpc_sockaddr_to_uri(addr);
-  req->overall_error = grpc_error_add_child(
-      req->overall_error,
-      grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS,
-                         grpc_slice_from_cpp_string(std::move(addr_text))));
-}
 
-static void do_read(internal_request* req) {
-  grpc_endpoint_read(req->ep, &req->incoming, &req->on_read, /*urgent=*/true);
-}
+  void OnWritten() { DoRead(); }
 
-static void on_read(void* user_data, grpc_error_handle error) {
-  internal_request* req = static_cast<internal_request*>(user_data);
-  size_t i;
-
-  for (i = 0; i < req->incoming.count; i++) {
-    if (GRPC_SLICE_LENGTH(req->incoming.slices[i])) {
-      req->have_read_byte = 1;
-      grpc_error_handle err = grpc_http_parser_parse(
-          &req->parser, req->incoming.slices[i], nullptr);
-      if (err != GRPC_ERROR_NONE) {
-        finish(req, err);
-        return;
-      }
+  static void DoneWrite(void* arg, grpc_error_handle error) {
+    InternalRequest* req = static_cast<InternalRequest*>(arg);
+    if (error == GRPC_ERROR_NONE) {
+      req->OnWritten();
+    } else {
+      req->NextAddress(GRPC_ERROR_REF(error));
     }
   }
 
-  if (error == GRPC_ERROR_NONE) {
-    do_read(req);
-  } else if (!req->have_read_byte) {
-    next_address(req, GRPC_ERROR_REF(error));
-  } else {
-    finish(req, grpc_http_parser_eof(&req->parser));
+  void StartWrite() {
+    grpc_slice_ref_internal(request_text_);
+    grpc_slice_buffer_add(&outgoing_, request_text_);
+    grpc_endpoint_write(ep_, &outgoing_, &done_write_, nullptr);
   }
-}
 
-static void on_written(internal_request* req) { do_read(req); }
+  static void OnHandshakeDone(void* arg, grpc_endpoint* ep) {
+    InternalRequest* req = static_cast<InternalRequest*>(arg);
 
-static void done_write(void* arg, grpc_error_handle error) {
-  internal_request* req = static_cast<internal_request*>(arg);
-  if (error == GRPC_ERROR_NONE) {
-    on_written(req);
-  } else {
-    next_address(req, GRPC_ERROR_REF(error));
+    if (!ep) {
+      req->NextAddress(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "Unexplained handshake failure"));
+      return;
+    }
+
+    req->ep_ = ep;
+    req->StartWrite();
   }
-}
 
-static void start_write(internal_request* req) {
-  grpc_slice_ref_internal(req->request_text);
-  grpc_slice_buffer_add(&req->outgoing, req->request_text);
-  grpc_endpoint_write(req->ep, &req->outgoing, &req->done_write, nullptr);
-}
+  static void OnConnected(void* arg, grpc_error_handle error) {
+    InternalRequest* req = static_cast<InternalRequest*>(arg);
 
-static void on_handshake_done(void* arg, grpc_endpoint* ep) {
-  internal_request* req = static_cast<internal_request*>(arg);
+    if (!req->ep_) {
+      req->NextAddress(GRPC_ERROR_REF(error));
+      return;
+    }
+    req->handshaker_->handshake(req, req->ep_,
+                                req->ssl_host_override_.empty()
+                                    ? req->host_.c_str()
+                                    : req->ssl_host_override_.c_str(),
+                                req->deadline_, OnHandshakeDone);
+  }
 
-  if (!ep) {
-    next_address(req, GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                          "Unexplained handshake failure"));
-    return;
+  void NextAddress(grpc_error_handle error) {
+    grpc_resolved_address* addr;
+    if (error != GRPC_ERROR_NONE) {
+      AppendError(error);
+    }
+    if (next_address_ == addresses_->naddrs) {
+      Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+          "Failed HTTP requests to all targets", &overall_error_, 1));
+      return;
+    }
+    addr = &addresses_->addrs[next_address_++];
+    GRPC_CLOSURE_INIT(&connected_, OnConnected, this,
+                      grpc_schedule_on_exec_ctx);
+    grpc_tcp_client_connect(&connected_, &ep_,
+                            grpc_slice_allocator_create(
+                                resource_quota_, grpc_sockaddr_to_uri(addr)),
+                            context_->pollset_set, nullptr, addr, deadline_);
   }
 
-  req->ep = ep;
-  start_write(req);
-}
+  static void OnResolved(void* arg, grpc_error_handle error) {
+    InternalRequest* req = static_cast<InternalRequest*>(arg);
+    if (error != GRPC_ERROR_NONE) {
+      req->Finish(GRPC_ERROR_REF(error));
+      return;
+    }
+    req->next_address_ = 0;
+    req->NextAddress(GRPC_ERROR_NONE);
+  }
 
-static void on_connected(void* arg, grpc_error_handle error) {
-  internal_request* req = static_cast<internal_request*>(arg);
+  grpc_slice request_text_;
+  grpc_http_parser parser_;
+  grpc_resolved_addresses* addresses_ = nullptr;
+  size_t next_address_ = 0;
+  grpc_endpoint* ep_ = nullptr;
+  grpc_resource_quota* resource_quota_;
+  std::string host_;
+  std::string ssl_host_override_;
+  grpc_millis deadline_;
+  int have_read_byte_ = 0;
+  const grpc_httpcli_handshaker* handshaker_;
+  grpc_closure* on_done_;
+  grpc_httpcli_context* context_;
+  grpc_polling_entity* pollent_;
+  grpc_iomgr_object iomgr_obj_;
+  grpc_slice_buffer incoming_;
+  grpc_slice_buffer outgoing_;
+  grpc_closure on_read_;
+  grpc_closure done_write_;
+  grpc_closure connected_;
+  grpc_error_handle overall_error_ = GRPC_ERROR_NONE;
+};
 
-  if (!req->ep) {
-    next_address(req, GRPC_ERROR_REF(error));
-    return;
-  }
-  req->handshaker->handshake(
-      req, req->ep, req->ssl_host_override ? req->ssl_host_override : req->host,
-      req->deadline, on_handshake_done);
+}  // namespace
+}  // namespace grpc_core
+
+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*/,
+                                void (*on_done)(void* arg,
+                                                grpc_endpoint* endpoint)) {
+  on_done(arg, endpoint);
 }
 
-static void next_address(internal_request* req, grpc_error_handle error) {
-  grpc_resolved_address* addr;
-  if (error != GRPC_ERROR_NONE) {
-    append_error(req, error);
-  }
-  if (req->next_address == req->addresses->naddrs) {
-    finish(req,
-           GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-               "Failed HTTP requests to all targets", &req->overall_error, 1));
-    return;
-  }
-  addr = &req->addresses->addrs[req->next_address++];
-  GRPC_CLOSURE_INIT(&req->connected, on_connected, req,
-                    grpc_schedule_on_exec_ctx);
-  grpc_tcp_client_connect(&req->connected, &req->ep,
-                          grpc_slice_allocator_create(
-                              req->resource_quota, grpc_sockaddr_to_uri(addr)),
-                          req->context->pollset_set, nullptr, addr,
-                          req->deadline);
+const grpc_httpcli_handshaker grpc_httpcli_plaintext = {"http",
+                                                        plaintext_handshake};
+
+void grpc_httpcli_context_init(grpc_httpcli_context* context) {
+  context->pollset_set = grpc_pollset_set_create();
 }
 
-static void on_resolved(void* arg, grpc_error_handle error) {
-  internal_request* req = static_cast<internal_request*>(arg);
-  if (error != GRPC_ERROR_NONE) {
-    finish(req, GRPC_ERROR_REF(error));
-    return;
-  }
-  req->next_address = 0;
-  next_address(req, GRPC_ERROR_NONE);
+void grpc_httpcli_context_destroy(grpc_httpcli_context* context) {
+  grpc_pollset_set_destroy(context->pollset_set);
 }
 
 static void internal_request_begin(grpc_httpcli_context* context,
@@ -232,35 +274,11 @@ static void internal_request_begin(grpc_httpcli_context* context,
                                    grpc_httpcli_response* response,
                                    const char* name,
                                    const grpc_slice& request_text) {
-  internal_request* req =
-      static_cast<internal_request*>(gpr_malloc(sizeof(internal_request)));
-  memset(req, 0, sizeof(*req));
-  req->request_text = request_text;
-  grpc_http_parser_init(&req->parser, GRPC_HTTP_RESPONSE, response);
-  req->on_done = on_done;
-  req->deadline = deadline;
-  req->handshaker =
-      request->handshaker ? request->handshaker : &grpc_httpcli_plaintext;
-  req->context = context;
-  req->pollent = pollent;
-  req->overall_error = GRPC_ERROR_NONE;
-  req->resource_quota = resource_quota;
-  GRPC_CLOSURE_INIT(&req->on_read, on_read, req, grpc_schedule_on_exec_ctx);
-  GRPC_CLOSURE_INIT(&req->done_write, done_write, req,
-                    grpc_schedule_on_exec_ctx);
-  grpc_slice_buffer_init(&req->incoming);
-  grpc_slice_buffer_init(&req->outgoing);
-  grpc_iomgr_register_object(&req->iomgr_obj, name);
-  req->host = gpr_strdup(request->host);
-  req->ssl_host_override = gpr_strdup(request->ssl_host_override);
-
-  GPR_ASSERT(pollent);
-  grpc_polling_entity_add_to_pollset_set(req->pollent,
-                                         req->context->pollset_set);
-  grpc_resolve_address(
-      request->host, req->handshaker->default_port, req->context->pollset_set,
-      GRPC_CLOSURE_CREATE(on_resolved, req, grpc_schedule_on_exec_ctx),
-      &req->addresses);
+  new grpc_core::InternalRequest(
+      request_text, response, resource_quota, request->host,
+      request->ssl_host_override, deadline,
+      request->handshaker ? request->handshaker : &grpc_httpcli_plaintext,
+      on_done, context, pollent, name);
 }
 
 void grpc_httpcli_get(grpc_httpcli_context* context,

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

@@ -221,7 +221,7 @@ static grpc_error_handle add_header(grpc_http_parser* parser) {
 
   if (*hdr_count == parser->hdr_capacity) {
     parser->hdr_capacity =
-        GPR_MAX(parser->hdr_capacity + 1, parser->hdr_capacity * 3 / 2);
+        std::max(parser->hdr_capacity + 1, parser->hdr_capacity * 3 / 2);
     *hdrs = static_cast<grpc_http_header*>(
         gpr_realloc(*hdrs, parser->hdr_capacity * sizeof(**hdrs)));
   }
@@ -280,7 +280,7 @@ static grpc_error_handle addbyte_body(grpc_http_parser* parser, uint8_t byte) {
   }
 
   if (*body_length == parser->body_capacity) {
-    parser->body_capacity = GPR_MAX(8, parser->body_capacity * 3 / 2);
+    parser->body_capacity = std::max(size_t(8), parser->body_capacity * 3 / 2);
     *body = static_cast<char*>(gpr_realloc(*body, parser->body_capacity));
   }
   (*body)[*body_length] = static_cast<char>(byte);

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

@@ -33,18 +33,20 @@ DebugOnlyTraceFlag grpc_call_combiner_trace(false, "call_combiner");
 
 namespace {
 
+// grpc_error LSB can be used
+constexpr static intptr_t kErrorBit = 1;
+
 grpc_error_handle DecodeCancelStateError(gpr_atm cancel_state) {
-  if (cancel_state & 1) {
-    return reinterpret_cast<grpc_error_handle>(cancel_state &
-                                               ~static_cast<gpr_atm>(1));
+  if (cancel_state & kErrorBit) {
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+    return internal::StatusGetFromHeapPtr(cancel_state & ~kErrorBit);
+#else
+    return reinterpret_cast<grpc_error_handle>(cancel_state & ~kErrorBit);
+#endif
   }
   return GRPC_ERROR_NONE;
 }
 
-gpr_atm EncodeCancelStateError(grpc_error_handle error) {
-  return static_cast<gpr_atm>(1) | reinterpret_cast<gpr_atm>(error);
-}
-
 }  // namespace
 
 CallCombiner::CallCombiner() {
@@ -57,7 +59,14 @@ CallCombiner::CallCombiner() {
 }
 
 CallCombiner::~CallCombiner() {
-  GRPC_ERROR_UNREF(DecodeCancelStateError(cancel_state_));
+  if (cancel_state_ & kErrorBit) {
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+    internal::StatusFreeHeapPtr(cancel_state_ & ~kErrorBit);
+#else
+    GRPC_ERROR_UNREF(reinterpret_cast<grpc_error_handle>(
+        cancel_state_ & ~static_cast<gpr_atm>(kErrorBit)));
+#endif
+  }
 }
 
 #ifdef GRPC_TSAN_ENABLED
@@ -235,15 +244,24 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
 
 void CallCombiner::Cancel(grpc_error_handle error) {
   GRPC_STATS_INC_CALL_COMBINER_CANCELLED();
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+  intptr_t status_ptr = internal::StatusAllocHeapPtr(error);
+  gpr_atm new_state = kErrorBit | status_ptr;
+#else
+  gpr_atm new_state = kErrorBit | reinterpret_cast<gpr_atm>(error);
+#endif
   while (true) {
     gpr_atm original_state = gpr_atm_acq_load(&cancel_state_);
     grpc_error_handle original_error = DecodeCancelStateError(original_state);
     if (original_error != GRPC_ERROR_NONE) {
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+      internal::StatusFreeHeapPtr(status_ptr);
+#else
       GRPC_ERROR_UNREF(error);
+#endif
       break;
     }
-    if (gpr_atm_full_cas(&cancel_state_, original_state,
-                         EncodeCancelStateError(error))) {
+    if (gpr_atm_full_cas(&cancel_state_, original_state, new_state)) {
       if (original_state != 0) {
         grpc_closure* notify_on_cancel =
             reinterpret_cast<grpc_closure*>(original_state);

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

@@ -27,11 +27,9 @@
 #include <grpc/support/alloc.h>
 #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"
+#include "src/core/lib/iomgr/iomgr_internal.h"
 
 grpc_core::DebugOnlyTraceFlag grpc_combiner_trace(false, "combiner");
 
@@ -128,15 +126,11 @@ static void push_first_on_exec_ctx(grpc_core::Combiner* lock) {
 
 static void combiner_exec(grpc_core::Combiner* lock, grpc_closure* cl,
                           grpc_error_handle error) {
-  GPR_TIMER_SCOPE("combiner.execute", 0);
-  GRPC_STATS_INC_COMBINER_LOCKS_SCHEDULED_ITEMS();
   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,
                               lock, cl, last));
   if (last == 1) {
-    GRPC_STATS_INC_COMBINER_LOCKS_INITIATED();
-    GPR_TIMER_MARK("combiner.initiated", 0);
     gpr_atm_no_barrier_store(
         &lock->initiating_exec_ctx_or_null,
         reinterpret_cast<gpr_atm>(grpc_core::ExecCtx::Get()));
@@ -175,14 +169,12 @@ static void offload(void* arg, grpc_error_handle /*error*/) {
 }
 
 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));
   grpc_core::Executor::Run(&lock->offload, GRPC_ERROR_NONE);
 }
 
 bool grpc_combiner_continue_exec_ctx() {
-  GPR_TIMER_SCOPE("combiner.continue_exec_ctx", 0);
   grpc_core::Combiner* lock =
       grpc_core::ExecCtx::Get()->combiner_data()->active_combiner;
   if (lock == nullptr) {
@@ -207,9 +199,8 @@ bool grpc_combiner_continue_exec_ctx() {
   // 3. the current thread is not a worker for any background poller
   // 4. the DEFAULT executor is threaded
   if (contended && grpc_core::ExecCtx::Get()->IsReadyToFinish() &&
-      !grpc_iomgr_is_any_background_poller_thread() &&
+      !grpc_iomgr_platform_is_any_background_poller_thread() &&
       grpc_core::Executor::IsThreadedDefault()) {
-    GPR_TIMER_MARK("offload_from_finished_exec_ctx", 0);
     // this execution context wants to move on: schedule remaining work to be
     // picked up on the executor
     queue_offload(lock);
@@ -226,11 +217,9 @@ bool grpc_combiner_continue_exec_ctx() {
     if (n == nullptr) {
       // queue is in an inconsistent state: use this as a cue that we should
       // go off and do something else for a while (and come back later)
-      GPR_TIMER_MARK("delay_busy", 0);
       queue_offload(lock);
       return true;
     }
-    GPR_TIMER_SCOPE("combiner.exec1", 0);
     grpc_closure* cl = reinterpret_cast<grpc_closure*>(n);
     grpc_error_handle cl_err = cl->error_data.error;
 #ifndef NDEBUG
@@ -244,7 +233,6 @@ bool grpc_combiner_continue_exec_ctx() {
     grpc_closure_list_init(&lock->final_list);
     int loops = 0;
     while (c != nullptr) {
-      GPR_TIMER_SCOPE("combiner.exec_1final", 0);
       GRPC_COMBINER_TRACE(
           gpr_log(GPR_INFO, "C:%p execute_final[%d] c=%p", lock, loops, c));
       grpc_closure* next = c->next_data.next;
@@ -258,7 +246,6 @@ bool grpc_combiner_continue_exec_ctx() {
     }
   }
 
-  GPR_TIMER_MARK("unref", 0);
   move_next();
   lock->time_to_execute_final_list = false;
   gpr_atm old_state =
@@ -305,13 +292,10 @@ static void combiner_finally_exec(grpc_core::Combiner* lock,
                                   grpc_closure* closure,
                                   grpc_error_handle error) {
   GPR_ASSERT(lock != nullptr);
-  GPR_TIMER_SCOPE("combiner.execute_finally", 0);
-  GRPC_STATS_INC_COMBINER_LOCKS_SCHEDULED_FINAL_ITEMS();
   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);
     // Using error_data.scratch to store the combiner so that it can be accessed
     // in enqueue_finally.
     closure->error_data.scratch = reinterpret_cast<uintptr_t>(lock);
@@ -327,9 +311,10 @@ static void combiner_finally_exec(grpc_core::Combiner* lock,
 
 static void enqueue_finally(void* closure, grpc_error_handle error) {
   grpc_closure* cl = static_cast<grpc_closure*>(closure);
-  combiner_finally_exec(
-      reinterpret_cast<grpc_core::Combiner*>(cl->error_data.scratch), cl,
-      GRPC_ERROR_REF(error));
+  grpc_core::Combiner* lock =
+      reinterpret_cast<grpc_core::Combiner*>(cl->error_data.scratch);
+  cl->error_data.scratch = 0;
+  combiner_finally_exec(lock, cl, GRPC_ERROR_REF(error));
 }
 
 namespace grpc_core {