grpc 1.43.1 → 1.44.0.pre2

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

@@ -17,8 +17,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gprpp/arena.h"
+#include <cstddef>
+
 #include "src/core/lib/gprpp/manual_constructor.h"
+#include "src/core/lib/resource_quota/arena.h"
 
 namespace grpc_core {
 
@@ -48,8 +50,9 @@ class ChunkedVector {
   }
   ChunkedVector(const ChunkedVector& other)
       : ChunkedVector(other.arena_, other.begin(), other.end()) {}
-  ChunkedVector& operator=(ChunkedVector other) {
-    Swap(&other);
+  ChunkedVector& operator=(const ChunkedVector& other) {
+    ChunkedVector tmp(other);
+    Swap(&tmp);
     return *this;
   }
   ChunkedVector(ChunkedVector&& other) noexcept
@@ -113,6 +116,12 @@ class ChunkedVector {
    public:
     ForwardIterator(Chunk* chunk, size_t n) : chunk_(chunk), n_(n) {}
 
+    using difference_type = std::ptrdiff_t;
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = T;
+    using pointer = T*;
+    using reference = T&;
+
     T& operator*() const { return *chunk_->data[n_]; }
     T* operator->() const { return &*chunk_->data[n_]; }
     ForwardIterator& operator++() {
@@ -123,6 +132,11 @@ class ChunkedVector {
       }
       return *this;
     }
+    ForwardIterator& operator++(int) {
+      ForwardIterator tmp = *this;
+      ++*this;
+      return tmp;
+    }
     bool operator==(const ForwardIterator& other) const {
       return chunk_ == other.chunk_ && n_ == other.n_;
     }
@@ -131,6 +145,8 @@ class ChunkedVector {
     }
 
    private:
+    friend class ChunkedVector;
+
     Chunk* chunk_;
     size_t n_;
   };
@@ -140,6 +156,8 @@ class ChunkedVector {
    public:
     ConstForwardIterator(const Chunk* chunk, size_t n) : chunk_(chunk), n_(n) {}
 
+    using iterator_category = std::forward_iterator_tag;
+
     const T& operator*() const { return *chunk_->data[n_]; }
     const T* operator->() const { return &*chunk_->data[n_]; }
     ConstForwardIterator& operator++() {
@@ -150,6 +168,11 @@ class ChunkedVector {
       }
       return *this;
     }
+    ConstForwardIterator& operator++(int) {
+      ConstForwardIterator tmp = *this;
+      ++*this;
+      return tmp;
+    }
     bool operator==(const ConstForwardIterator& other) const {
       return chunk_ == other.chunk_ && n_ == other.n_;
     }
@@ -186,6 +209,25 @@ class ChunkedVector {
     return n;
   }
 
+  // Return true if the vector is empty.
+  bool empty() const { return first_ == nullptr || first_->count == 0; }
+
+  void SetEnd(ForwardIterator it) {
+    if (it == end()) return;
+    Chunk* chunk = it.chunk_;
+    for (size_t i = it.n_; i < chunk->count; i++) {
+      chunk->data[i].Destroy();
+    }
+    chunk->count = it.n_;
+    append_ = chunk;
+    while ((chunk = chunk->next) != nullptr) {
+      for (size_t i = 0; i < chunk->count; i++) {
+        chunk->data[i].Destroy();
+      }
+      chunk->count = 0;
+    }
+  }
+
  private:
   ManualConstructor<T>* AppendSlot() {
     if (append_ == nullptr) {

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

@@ -83,6 +83,8 @@ const char* GetStatusIntPropertyUrl(StatusIntProperty key) {
       return TYPE_URL(TYPE_INT_TAG "channel_connectivity_state");
     case StatusIntProperty::kLbPolicyDrop:
       return TYPE_URL(TYPE_INT_TAG "lb_policy_drop");
+    case StatusIntProperty::kStreamNetworkState:
+      return TYPE_URL(TYPE_INT_TAG "stream_network_state");
   }
   GPR_UNREACHABLE_CODE(return "unknown");
 }
@@ -159,7 +161,7 @@ std::vector<absl::Status> ParseChildren(absl::Cord children) {
 
 absl::Status StatusCreate(absl::StatusCode code, absl::string_view msg,
                           const DebugLocation& location,
-                          std::initializer_list<absl::Status> children) {
+                          std::vector<absl::Status> children) {
   absl::Status s(code, msg);
   if (location.file() != nullptr) {
     StatusSetStr(&s, StatusStrProperty::kFile, location.file());
@@ -230,7 +232,10 @@ absl::optional<absl::Time> StatusGetTime(const absl::Status& status,
   if (p.has_value()) {
     absl::optional<absl::string_view> sv = p->TryFlat();
     if (sv.has_value()) {
-      return *reinterpret_cast<const absl::Time*>(sv->data());
+      // copy the content before casting to avoid misaligned address access
+      alignas(absl::Time) char buf[sizeof(const absl::Time)];
+      memcpy(buf, sv->data(), sizeof(const absl::Time));
+      return *reinterpret_cast<const absl::Time*>(buf);
     } else {
       std::string s = std::string(*p);
       return *reinterpret_cast<const absl::Time*>(s.c_str());
@@ -379,32 +384,8 @@ absl::Status StatusFromProto(google_rpc_Status* msg) {
   return status;
 }
 
-uintptr_t StatusAllocPtr(absl::Status s) {
-  // This relies the fact that absl::Status has only one member, StatusRep*
-  // so the sizeof(absl::Status) has the same size of intptr_t and StatusRep*
-  // can be stolen using placement allocation.
-  static_assert(sizeof(intptr_t) == sizeof(absl::Status),
-                "absl::Status should be as big as intptr_t");
-  // This does two things;
-  // 1. Copies StatusRep* of absl::Status to ptr
-  // 2. Increases the counter of StatusRep if it's not inlined
-  uintptr_t ptr;
-  new (&ptr) absl::Status(s);
-  return ptr;
-}
-
-void StatusFreePtr(uintptr_t ptr) {
-  // Decreases the counter of StatusRep if it's not inlined.
-  reinterpret_cast<absl::Status*>(&ptr)->~Status();
-}
-
-absl::Status StatusGetFromPtr(uintptr_t ptr) {
-  // Constructs Status from ptr having the address of StatusRep.
-  return *reinterpret_cast<absl::Status*>(&ptr);
-}
-
 uintptr_t StatusAllocHeapPtr(absl::Status s) {
-  if (s.ok()) return kOkStatusPtr;
+  if (s.ok()) return 0;
   absl::Status* ptr = new absl::Status(s);
   return reinterpret_cast<uintptr_t>(ptr);
 }
@@ -415,13 +396,24 @@ void StatusFreeHeapPtr(uintptr_t ptr) {
 }
 
 absl::Status StatusGetFromHeapPtr(uintptr_t ptr) {
-  if (ptr == kOkStatusPtr) {
+  if (ptr == 0) {
     return absl::OkStatus();
   } else {
     return *reinterpret_cast<absl::Status*>(ptr);
   }
 }
 
+absl::Status StatusMoveFromHeapPtr(uintptr_t ptr) {
+  if (ptr == 0) {
+    return absl::OkStatus();
+  } else {
+    absl::Status* s = reinterpret_cast<absl::Status*>(ptr);
+    absl::Status ret = std::move(*s);
+    delete s;
+    return ret;
+  }
+}
+
 }  // namespace internal
 
 }  // namespace grpc_core

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

@@ -37,7 +37,6 @@ struct upb_arena;
 namespace grpc_core {
 
 /// This enum should have the same value of grpc_error_ints
-// TODO(veblush): Use camel-case names once migration to absl::Status is done.
 enum class StatusIntProperty {
   /// 'errno' from the operating system
   kErrorNo,
@@ -72,10 +71,11 @@ enum class StatusIntProperty {
   ChannelConnectivityState,
   /// LB policy drop
   kLbPolicyDrop,
+  /// stream network state
+  kStreamNetworkState,
 };
 
 /// This enum should have the same value of grpc_error_strs
-// TODO(veblush): Use camel-case names once migration to absl::Status is done.
 enum class StatusStrProperty {
   /// top-level textual description of this error
   kDescription,
@@ -110,7 +110,7 @@ enum class StatusTimeProperty {
 /// Creates a status with given additional information
 absl::Status StatusCreate(
     absl::StatusCode code, absl::string_view msg, const DebugLocation& location,
-    std::initializer_list<absl::Status> children) GRPC_MUST_USE_RESULT;
+    std::vector<absl::Status> children) GRPC_MUST_USE_RESULT;
 
 /// Sets the int property to the status
 void StatusSetInt(absl::Status* status, StatusIntProperty key, intptr_t value);
@@ -160,22 +160,6 @@ google_rpc_Status* StatusToProto(const absl::Status& status,
 /// This is for internal implementation & test only
 absl::Status StatusFromProto(google_rpc_Status* msg) GRPC_MUST_USE_RESULT;
 
-/// The same value of internal::StatusAllocPtr(absl::OkStatus())
-static constexpr uintptr_t kOkStatusPtr = 0;
-
-/// Returns ptr where the given status is copied into.
-/// This ptr can be used to get Status later and should be freed by
-/// StatusFreePtr. This shouldn't be used except migration purpose.
-uintptr_t StatusAllocPtr(absl::Status s);
-
-/// Frees the allocated status at ptr.
-/// This shouldn't be used except migration purpose.
-void StatusFreePtr(uintptr_t ptr);
-
-/// Get the status from ptr.
-/// This shouldn't be used except migration purpose.
-absl::Status StatusGetFromPtr(uintptr_t ptr);
-
 /// Returns ptr that is allocated in the heap memory and the given status is
 /// copied into. This ptr can be used to get Status later and should be
 /// freed by StatusFreeHeapPtr. This can be 0 in case of OkStatus.
@@ -187,6 +171,9 @@ void StatusFreeHeapPtr(uintptr_t ptr);
 /// Get the status from a heap ptr.
 absl::Status StatusGetFromHeapPtr(uintptr_t ptr);
 
+/// Move the status from a heap ptr. (GetFrom & FreeHeap)
+absl::Status StatusMoveFromHeapPtr(uintptr_t ptr);
+
 }  // namespace internal
 
 }  // namespace grpc_core

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

@@ -311,6 +311,12 @@ class Table {
   // Count the number of set fields in the table
   size_t count() const { return present_bits_.count(); }
 
+  // Check if the table is completely empty
+  bool empty() const { return present_bits_.none(); }
+
+  // Clear all elements in the table.
+  void ClearAll() { ClearAllImpl(absl::make_index_sequence<sizeof...(Ts)>()); }
+
  private:
   // Bit field for which elements of the table are set (true) or un-set (false,
   // the default) -- one bit for each type in Ts.
@@ -412,6 +418,11 @@ class Table {
     table_detail::do_these_things<int>({(CallIf<I>(&f), 1)...});
   }
 
+  template <size_t... I>
+  void ClearAllImpl(absl::index_sequence<I...>) {
+    table_detail::do_these_things<int>({(clear<I>(), 1)...});
+  }
+
   // Bit field indicating which elements are set.
   GPR_NO_UNIQUE_ADDRESS PresentBits present_bits_;
   // The memory to store the elements themselves.

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

@@ -24,6 +24,7 @@
 
 #include <string>
 
+#include "absl/functional/bind_front.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 
@@ -44,6 +45,7 @@
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/transport/error_utils.h"
 
 namespace grpc_core {
 namespace {
@@ -55,8 +57,8 @@ class InternalRequest {
                   ResourceQuotaRefPtr 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)
+                  grpc_closure* on_done, grpc_polling_entity* pollent,
+                  const char* name)
       : request_text_(request_text),
         resource_quota_(std::move(resource_quota)),
         host_(host),
@@ -64,8 +66,8 @@ class InternalRequest {
         deadline_(deadline),
         handshaker_(handshaker),
         on_done_(on_done),
-        context_(context),
-        pollent_(pollent) {
+        pollent_(pollent),
+        pollset_set_(grpc_pollset_set_create()) {
     grpc_http_parser_init(&parser_, GRPC_HTTP_RESPONSE, response);
     grpc_slice_buffer_init(&incoming_);
     grpc_slice_buffer_init(&outgoing_);
@@ -74,18 +76,15 @@ class InternalRequest {
     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_);
+    grpc_polling_entity_add_to_pollset_set(pollent, pollset_set_);
+    dns_request_ = GetDNSResolver()->ResolveName(
+        host_.c_str(), handshaker_->default_port, pollset_set_,
+        absl::bind_front(&InternalRequest::OnResolved, this));
+    dns_request_->Start();
   }
 
   ~InternalRequest() {
     grpc_http_parser_destroy(&parser_);
-    if (addresses_ != nullptr) {
-      grpc_resolved_addresses_destroy(addresses_);
-    }
     if (ep_ != nullptr) {
       grpc_endpoint_destroy(ep_);
     }
@@ -94,11 +93,12 @@ class InternalRequest {
     grpc_slice_buffer_destroy_internal(&incoming_);
     grpc_slice_buffer_destroy_internal(&outgoing_);
     GRPC_ERROR_UNREF(overall_error_);
+    grpc_pollset_set_destroy(pollset_set_);
   }
 
  private:
   void Finish(grpc_error_handle error) {
-    grpc_polling_entity_del_from_pollset_set(pollent_, context_->pollset_set);
+    grpc_polling_entity_del_from_pollset_set(pollent_, pollset_set_);
     ExecCtx::Run(DEBUG_LOCATION, on_done_, error);
     delete this;
   }
@@ -108,7 +108,7 @@ class InternalRequest {
       overall_error_ =
           GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed HTTP/1 client request");
     }
-    grpc_resolved_address* addr = &addresses_->addrs[next_address_ - 1];
+    const grpc_resolved_address* addr = &addresses_[next_address_ - 1];
     std::string addr_text = grpc_sockaddr_to_uri(addr);
     overall_error_ = grpc_error_add_child(
         overall_error_,
@@ -193,16 +193,15 @@ class InternalRequest {
   }
 
   void NextAddress(grpc_error_handle error) {
-    grpc_resolved_address* addr;
     if (error != GRPC_ERROR_NONE) {
       AppendError(error);
     }
-    if (next_address_ == addresses_->naddrs) {
+    if (next_address_ == addresses_.size()) {
       Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
           "Failed HTTP requests to all targets", &overall_error_, 1));
       return;
     }
-    addr = &addresses_->addrs[next_address_++];
+    const grpc_resolved_address* addr = &addresses_[next_address_++];
     GRPC_CLOSURE_INIT(&connected_, OnConnected, this,
                       grpc_schedule_on_exec_ctx);
     grpc_arg rq_arg = grpc_channel_arg_pointer_create(
@@ -212,24 +211,26 @@ class InternalRequest {
     auto* args = CoreConfiguration::Get()
                      .channel_args_preconditioning()
                      .PreconditionChannelArgs(&channel_args);
-    grpc_tcp_client_connect(&connected_, &ep_, context_->pollset_set, args,
-                            addr, deadline_);
+    grpc_tcp_client_connect(&connected_, &ep_, pollset_set_, args, addr,
+                            deadline_);
     grpc_channel_args_destroy(args);
   }
 
-  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));
+  void OnResolved(
+      absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or) {
+    dns_request_.reset();
+    if (!addresses_or.ok()) {
+      Finish(absl_status_to_grpc_error(addresses_or.status()));
       return;
     }
-    req->next_address_ = 0;
-    req->NextAddress(GRPC_ERROR_NONE);
+    addresses_ = std::move(*addresses_or);
+    next_address_ = 0;
+    NextAddress(GRPC_ERROR_NONE);
   }
 
   grpc_slice request_text_;
   grpc_http_parser parser_;
-  grpc_resolved_addresses* addresses_ = nullptr;
+  std::vector<grpc_resolved_address> addresses_;
   size_t next_address_ = 0;
   grpc_endpoint* ep_ = nullptr;
   ResourceQuotaRefPtr resource_quota_;
@@ -239,8 +240,8 @@ class InternalRequest {
   int have_read_byte_ = 0;
   const grpc_httpcli_handshaker* handshaker_;
   grpc_closure* on_done_;
-  grpc_httpcli_context* context_;
   grpc_polling_entity* pollent_;
+  grpc_pollset_set* pollset_set_;
   grpc_iomgr_object iomgr_obj_;
   grpc_slice_buffer incoming_;
   grpc_slice_buffer outgoing_;
@@ -248,6 +249,7 @@ class InternalRequest {
   grpc_closure done_write_;
   grpc_closure connected_;
   grpc_error_handle overall_error_ = GRPC_ERROR_NONE;
+  OrphanablePtr<DNSResolver::Request> dns_request_;
 };
 
 }  // namespace
@@ -266,17 +268,8 @@ static void plaintext_handshake(void* arg, grpc_endpoint* endpoint,
 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();
-}
-
-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, grpc_polling_entity* pollent,
-    grpc_core::ResourceQuotaRefPtr resource_quota,
+    grpc_polling_entity* pollent, grpc_core::ResourceQuotaRefPtr resource_quota,
     const grpc_httpcli_request* request, grpc_millis deadline,
     grpc_closure* on_done, grpc_httpcli_response* response, const char* name,
     const grpc_slice& request_text) {
@@ -284,11 +277,10 @@ static void internal_request_begin(
       request_text, response, std::move(resource_quota), request->host,
       request->ssl_host_override, deadline,
       request->handshaker ? request->handshaker : &grpc_httpcli_plaintext,
-      on_done, context, pollent, name);
+      on_done, pollent, name);
 }
 
-void grpc_httpcli_get(grpc_httpcli_context* context,
-                      grpc_polling_entity* pollent,
+void grpc_httpcli_get(grpc_polling_entity* pollent,
                       grpc_core::ResourceQuotaRefPtr resource_quota,
                       const grpc_httpcli_request* request, grpc_millis deadline,
                       grpc_closure* on_done, grpc_httpcli_response* response) {
@@ -297,13 +289,12 @@ void grpc_httpcli_get(grpc_httpcli_context* context,
   }
   std::string name =
       absl::StrFormat("HTTP:GET:%s:%s", request->host, request->http.path);
-  internal_request_begin(context, pollent, std::move(resource_quota), request,
-                         deadline, on_done, response, name.c_str(),
+  internal_request_begin(pollent, std::move(resource_quota), request, deadline,
+                         on_done, response, name.c_str(),
                          grpc_httpcli_format_get_request(request));
 }
 
-void grpc_httpcli_post(grpc_httpcli_context* context,
-                       grpc_polling_entity* pollent,
+void grpc_httpcli_post(grpc_polling_entity* pollent,
                        grpc_core::ResourceQuotaRefPtr resource_quota,
                        const grpc_httpcli_request* request,
                        const char* body_bytes, size_t body_size,
@@ -316,8 +307,8 @@ void grpc_httpcli_post(grpc_httpcli_context* context,
   std::string name =
       absl::StrFormat("HTTP:POST:%s:%s", request->host, request->http.path);
   internal_request_begin(
-      context, pollent, std::move(resource_quota), request, deadline, on_done,
-      response, name.c_str(),
+      pollent, std::move(resource_quota), request, deadline, on_done, response,
+      name.c_str(),
       grpc_httpcli_format_post_request(request, body_bytes, body_size));
 }
 

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

@@ -35,13 +35,8 @@
 /* User agent this library reports */
 #define GRPC_HTTPCLI_USER_AGENT "grpc-httpcli/0.0"
 
-/* Tracks in-progress http requests
-   TODO(ctiller): allow caching and capturing multiple requests for the
+/* TODO(ctiller): allow caching and capturing multiple requests for the
                   same content and combining them */
-typedef struct grpc_httpcli_context {
-  grpc_pollset_set* pollset_set;
-} grpc_httpcli_context;
-
 struct grpc_httpcli_handshaker {
   const char* default_port;
   void (*handshake)(void* arg, grpc_endpoint* endpoint, const char* host,
@@ -68,11 +63,7 @@ typedef struct grpc_httpcli_request {
 /* Expose the parser response type as a httpcli response too */
 typedef struct grpc_http_response grpc_httpcli_response;
 
-void grpc_httpcli_context_init(grpc_httpcli_context* context);
-void grpc_httpcli_context_destroy(grpc_httpcli_context* context);
-
 /* Asynchronously perform a HTTP GET.
-   'context' specifies the http context under which to do the get
    'pollent' indicates a grpc_polling_entity that is interested in the result
      of the get - work on this entity may be used to progress the get
      operation
@@ -82,14 +73,12 @@ void grpc_httpcli_context_destroy(grpc_httpcli_context* context);
    can be destroyed once the call returns 'deadline' contains a deadline for the
    request (or gpr_inf_future)
    'on_response' is a callback to report results to */
-void grpc_httpcli_get(grpc_httpcli_context* context,
-                      grpc_polling_entity* pollent,
+void grpc_httpcli_get(grpc_polling_entity* pollent,
                       grpc_core::ResourceQuotaRefPtr resource_quota,
                       const grpc_httpcli_request* request, grpc_millis deadline,
                       grpc_closure* on_done, grpc_httpcli_response* response);
 
 /* Asynchronously perform a HTTP POST.
-   'context' specifies the http context under which to do the post
    'pollent' indicates a grpc_polling_entity that is interested in the result
      of the post - work on this entity may be used to progress the post
      operation
@@ -104,8 +93,7 @@ void grpc_httpcli_get(grpc_httpcli_context* context,
      lifetime of the request
    'on_response' is a callback to report results to
    Does not support ?var1=val1&var2=val2 in the path. */
-void grpc_httpcli_post(grpc_httpcli_context* context,
-                       grpc_polling_entity* pollent,
+void grpc_httpcli_post(grpc_polling_entity* pollent,
                        grpc_core::ResourceQuotaRefPtr resource_quota,
                        const grpc_httpcli_request* request,
                        const char* body_bytes, size_t body_size,

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

@@ -150,7 +150,11 @@ void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
       gpr_log(GPR_INFO, "  QUEUING");
     }
     // Queue was not empty, so add closure to queue.
-    closure->error_data.error = error;
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+    closure->error_data.error = internal::StatusAllocHeapPtr(error);
+#else
+    closure->error_data.error = reinterpret_cast<intptr_t>(error);
+#endif
     queue_.Push(
         reinterpret_cast<MultiProducerSingleConsumerQueue::Node*>(closure));
   }
@@ -185,12 +189,19 @@ void CallCombiner::Stop(DEBUG_ARGS const char* reason) {
         }
         continue;
       }
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+      grpc_error_handle error =
+          internal::StatusMoveFromHeapPtr(closure->error_data.error);
+#else
+      grpc_error_handle error =
+          reinterpret_cast<grpc_error_handle>(closure->error_data.error);
+#endif
+      closure->error_data.error = 0;
       if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
         gpr_log(GPR_INFO, "  EXECUTING FROM QUEUE: closure=%p error=%s",
-                closure,
-                grpc_error_std_string(closure->error_data.error).c_str());
+                closure, grpc_error_std_string(error).c_str());
       }
-      ScheduleClosure(closure, closure->error_data.error);
+      ScheduleClosure(closure, error);
       break;
     }
   } else if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {

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

@@ -72,7 +72,7 @@ struct grpc_closure {
 
   /** Once queued, the result of the closure. Before then: scratch space */
   union {
-    grpc_error_handle error;
+    uintptr_t error;
     uintptr_t scratch;
   } error_data;
 
@@ -98,7 +98,7 @@ inline grpc_closure* grpc_closure_init(grpc_closure* closure,
 #endif
   closure->cb = cb;
   closure->cb_arg = cb_arg;
-  closure->error_data.error = GRPC_ERROR_NONE;
+  closure->error_data.error = 0;
 #ifndef NDEBUG
   closure->scheduled = false;
   closure->file_initiated = nullptr;
@@ -172,16 +172,12 @@ inline void grpc_closure_list_init(grpc_closure_list* closure_list) {
 }
 
 /** add \a closure to the end of \a list
-    and set \a closure's result to \a error
     Returns true if \a list becomes non-empty */
 inline bool grpc_closure_list_append(grpc_closure_list* closure_list,
-                                     grpc_closure* closure,
-                                     grpc_error_handle error) {
+                                     grpc_closure* closure) {
   if (closure == nullptr) {
-    GRPC_ERROR_UNREF(error);
     return false;
   }
-  closure->error_data.error = error;
   closure->next_data.next = nullptr;
   bool was_empty = (closure_list->head == nullptr);
   if (was_empty) {
@@ -193,12 +189,36 @@ inline bool grpc_closure_list_append(grpc_closure_list* closure_list,
   return was_empty;
 }
 
+/** add \a closure to the end of \a list
+    and set \a closure's result to \a error
+    Returns true if \a list becomes non-empty */
+inline bool grpc_closure_list_append(grpc_closure_list* closure_list,
+                                     grpc_closure* closure,
+                                     grpc_error_handle error) {
+  if (closure == nullptr) {
+    GRPC_ERROR_UNREF(error);
+    return false;
+  }
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+  closure->error_data.error = grpc_core::internal::StatusAllocHeapPtr(error);
+#else
+  closure->error_data.error = reinterpret_cast<intptr_t>(error);
+#endif
+  return grpc_closure_list_append(closure_list, closure);
+}
+
 /** force all success bits in \a list to false */
 inline void grpc_closure_list_fail_all(grpc_closure_list* list,
                                        grpc_error_handle forced_failure) {
   for (grpc_closure* c = list->head; c != nullptr; c = c->next_data.next) {
-    if (c->error_data.error == GRPC_ERROR_NONE) {
-      c->error_data.error = GRPC_ERROR_REF(forced_failure);
+    if (c->error_data.error == 0) {
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+      c->error_data.error =
+          grpc_core::internal::StatusAllocHeapPtr(forced_failure);
+#else
+      c->error_data.error =
+          reinterpret_cast<intptr_t>(GRPC_ERROR_REF(forced_failure));
+#endif
     }
   }
   GRPC_ERROR_UNREF(forced_failure);