grpc 1.40.0 → 1.46.3

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

@@ -177,6 +177,7 @@ static grpc_error_handle add_header(grpc_http_parser* parser) {
   uint8_t* cur = beg;
   uint8_t* end = beg + parser->cur_line_length;
   size_t* hdr_count = nullptr;
+  size_t size = 0;
   grpc_http_header** hdrs = nullptr;
   grpc_http_header hdr = {nullptr, nullptr};
   grpc_error_handle error = GRPC_ERROR_NONE;
@@ -205,13 +206,20 @@ static grpc_error_handle add_header(grpc_http_parser* parser) {
     cur++;
   }
   GPR_ASSERT((size_t)(end - cur) >= parser->cur_line_end_length);
-  hdr.value = buf2str(
-      cur, static_cast<size_t>(end - cur) - parser->cur_line_end_length);
+  size = static_cast<size_t>(end - cur) - parser->cur_line_end_length;
+  if ((size != 0) && (cur[size - 1] == '\r')) {
+    size--;
+  }
+  hdr.value = buf2str(cur, size);
 
   switch (parser->type) {
     case GRPC_HTTP_RESPONSE:
       hdr_count = &parser->http.response->hdr_count;
       hdrs = &parser->http.response->hdrs;
+      if ((strcmp(hdr.key, "Transfer-Encoding") == 0) &&
+          (strcmp(hdr.value, "chunked") == 0)) {
+        parser->http.response->chunked_state = GRPC_HTTP_CHUNKED_LENGTH;
+      }
       break;
     case GRPC_HTTP_REQUEST:
       hdr_count = &parser->http.request->hdr_count;
@@ -221,7 +229,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)));
   }
@@ -245,17 +253,24 @@ static grpc_error_handle finish_line(grpc_http_parser* parser,
       parser->state = GRPC_HTTP_HEADERS;
       break;
     case GRPC_HTTP_HEADERS:
+    case GRPC_HTTP_TRAILERS:
       if (parser->cur_line_length == parser->cur_line_end_length) {
-        parser->state = GRPC_HTTP_BODY;
-        *found_body_start = true;
+        if (parser->state == GRPC_HTTP_HEADERS) {
+          parser->state = GRPC_HTTP_BODY;
+          *found_body_start = true;
+        } else {
+          parser->state = GRPC_HTTP_END;
+        }
         break;
-      }
-      err = add_header(parser);
-      if (err != GRPC_ERROR_NONE) {
-        return err;
+      } else {
+        err = add_header(parser);
+        if (err != GRPC_ERROR_NONE) {
+          return err;
+        }
       }
       break;
     case GRPC_HTTP_BODY:
+    case GRPC_HTTP_END:
       GPR_UNREACHABLE_CODE(return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "Should never reach here"));
   }
@@ -269,6 +284,59 @@ static grpc_error_handle addbyte_body(grpc_http_parser* parser, uint8_t byte) {
   char** body = nullptr;
 
   if (parser->type == GRPC_HTTP_RESPONSE) {
+    switch (parser->http.response->chunked_state) {
+      case GRPC_HTTP_CHUNKED_LENGTH:
+        if ((byte == '\r') || (byte == ';')) {
+          parser->http.response->chunked_state =
+              GRPC_HTTP_CHUNKED_IGNORE_ALL_UNTIL_LF;
+        } else if ((byte >= '0') && (byte <= '9')) {
+          parser->http.response->chunk_length *= 16;
+          parser->http.response->chunk_length += byte - '0';
+        } else if ((byte >= 'a') && (byte <= 'f')) {
+          parser->http.response->chunk_length *= 16;
+          parser->http.response->chunk_length += byte - 'a' + 10;
+        } else if ((byte >= 'A') && (byte <= 'F')) {
+          parser->http.response->chunk_length *= 16;
+          parser->http.response->chunk_length += byte - 'A' + 10;
+        } else {
+          return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+              "Expected chunk size in hexadecimal");
+        }
+        return GRPC_ERROR_NONE;
+      case GRPC_HTTP_CHUNKED_IGNORE_ALL_UNTIL_LF:
+        if (byte == '\n') {
+          if (parser->http.response->chunk_length == 0) {
+            parser->state = GRPC_HTTP_TRAILERS;
+          } else {
+            parser->http.response->chunked_state = GRPC_HTTP_CHUNKED_BODY;
+          }
+        }
+        return GRPC_ERROR_NONE;
+      case GRPC_HTTP_CHUNKED_BODY:
+        if (parser->http.response->chunk_length == 0) {
+          if (byte != '\r') {
+            return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                "Expected '\\r\\n' after chunk body");
+          }
+          parser->http.response->chunked_state = GRPC_HTTP_CHUNKED_CONSUME_LF;
+          parser->http.response->chunk_length = 0;
+          return GRPC_ERROR_NONE;
+        } else {
+          parser->http.response->chunk_length--;
+          /* fallback to the normal body appending code below */
+        }
+        break;
+      case GRPC_HTTP_CHUNKED_CONSUME_LF:
+        if (byte != '\n') {
+          return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+              "Expected '\\r\\n' after chunk body");
+        }
+        parser->http.response->chunked_state = GRPC_HTTP_CHUNKED_LENGTH;
+        return GRPC_ERROR_NONE;
+      case GRPC_HTTP_CHUNKED_PLAIN:
+        /* avoiding warning; just fallback to normal codepath */
+        break;
+    }
     body_length = &parser->http.response->body_length;
     body = &parser->http.response->body;
   } else if (parser->type == GRPC_HTTP_REQUEST) {
@@ -280,7 +348,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);
@@ -318,6 +386,7 @@ static grpc_error_handle addbyte(grpc_http_parser* parser, uint8_t byte,
   switch (parser->state) {
     case GRPC_HTTP_FIRST_LINE:
     case GRPC_HTTP_HEADERS:
+    case GRPC_HTTP_TRAILERS:
       if (parser->cur_line_length >= GRPC_HTTP_PARSER_MAX_HEADER_LENGTH) {
         if (GRPC_TRACE_FLAG_ENABLED(grpc_http1_trace)) {
           gpr_log(GPR_ERROR, "HTTP header max line length (%d) exceeded",
@@ -334,6 +403,8 @@ static grpc_error_handle addbyte(grpc_http_parser* parser, uint8_t byte,
       return GRPC_ERROR_NONE;
     case GRPC_HTTP_BODY:
       return addbyte_body(parser, byte);
+    case GRPC_HTTP_END:
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Unexpected byte after end");
   }
   GPR_UNREACHABLE_CODE(return GRPC_ERROR_NONE);
 }
@@ -385,7 +456,7 @@ grpc_error_handle grpc_http_parser_parse(grpc_http_parser* parser,
 }
 
 grpc_error_handle grpc_http_parser_eof(grpc_http_parser* parser) {
-  if (parser->state != GRPC_HTTP_BODY) {
+  if ((parser->state != GRPC_HTTP_BODY) && (parser->state != GRPC_HTTP_END)) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Did not finish headers");
   }
   return GRPC_ERROR_NONE;

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

@@ -22,6 +22,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <grpc/slice.h>
+
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/error.h"
 
@@ -37,9 +38,19 @@ typedef struct grpc_http_header {
 typedef enum {
   GRPC_HTTP_FIRST_LINE,
   GRPC_HTTP_HEADERS,
-  GRPC_HTTP_BODY
+  GRPC_HTTP_BODY,
+  GRPC_HTTP_TRAILERS,
+  GRPC_HTTP_END,
 } grpc_http_parser_state;
 
+typedef enum {
+  GRPC_HTTP_CHUNKED_PLAIN,
+  GRPC_HTTP_CHUNKED_LENGTH,
+  GRPC_HTTP_CHUNKED_IGNORE_ALL_UNTIL_LF,
+  GRPC_HTTP_CHUNKED_BODY,
+  GRPC_HTTP_CHUNKED_CONSUME_LF,
+} grpc_http_parser_chunked_state;
+
 typedef enum {
   GRPC_HTTP_HTTP10,
   GRPC_HTTP_HTTP11,
@@ -55,7 +66,7 @@ typedef enum {
 typedef struct grpc_http_request {
   /* Method of the request (e.g. GET, POST) */
   char* method;
-  /* The path of the resource to fetch */
+  /* The path of the resource to fetch (only used for parsed requests) */
   char* path;
   /* HTTP version to use */
   grpc_http_version version;
@@ -76,6 +87,9 @@ typedef struct grpc_http_response {
   grpc_http_header* hdrs = nullptr;
   /* Body: length and contents; contents are NOT null-terminated */
   size_t body_length = 0;
+  /* State of the chunked parser. Only valid for the response. */
+  grpc_http_parser_chunked_state chunked_state = GRPC_HTTP_CHUNKED_PLAIN;
+  size_t chunk_length = 0;
   char* body = nullptr;
 } grpc_http_response;
 

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

@@ -19,10 +19,11 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/iomgr/buffer_list.h"
-#include "src/core/lib/iomgr/port.h"
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/iomgr/port.h"
+
 #ifdef GRPC_LINUX_ERRQUEUE
 #include <netinet/in.h>
 #include <string.h>
@@ -39,14 +40,14 @@ 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*/,
+void default_timestamps_callback(void* /*arg*/, Timestamps* /*ts*/,
                                  grpc_error_handle /*shudown_err*/) {
   gpr_log(GPR_DEBUG, "Timestamps callback has not been registered");
 }
 
 /** The saved callback function that will be invoked when we get all the
  * timestamps that we are going to get for a TracedBuffer. */
-void (*timestamps_callback)(void*, grpc_core::Timestamps*,
+void (*timestamps_callback)(void*, Timestamps*,
                             grpc_error_handle shutdown_err) =
     default_timestamps_callback;
 
@@ -61,11 +62,11 @@ T read_unaligned(const void* ptr) {
 
 /* Extracts opt stats from the tcp_info struct \a info to \a metrics */
 void extract_opt_stats_from_tcp_info(ConnectionMetrics* metrics,
-                                     const grpc_core::tcp_info* info) {
+                                     const tcp_info* info) {
   if (info == nullptr) {
     return;
   }
-  if (info->length > offsetof(grpc_core::tcp_info, tcpi_sndbuf_limited)) {
+  if (info->length > offsetof(tcp_info, tcpi_sndbuf_limited)) {
     metrics->recurring_retrans.emplace(info->tcpi_retransmits);
     metrics->is_delivery_rate_app_limited.emplace(
         info->tcpi_delivery_rate_app_limited);
@@ -83,7 +84,7 @@ void extract_opt_stats_from_tcp_info(ConnectionMetrics* metrics,
     metrics->rwnd_limited_usec.emplace(info->tcpi_rwnd_limited);
     metrics->sndbuf_limited_usec.emplace(info->tcpi_sndbuf_limited);
   }
-  if (info->length > offsetof(grpc_core::tcp_info, tcpi_dsack_dups)) {
+  if (info->length > offsetof(tcp_info, tcpi_dsack_dups)) {
     metrics->data_sent.emplace(info->tcpi_bytes_sent);
     metrics->data_retx.emplace(info->tcpi_bytes_retrans);
     metrics->packet_spurious_retx.emplace(info->tcpi_dsack_dups);
@@ -188,9 +189,9 @@ void extract_opt_stats_from_cmsg(ConnectionMetrics* metrics,
   }
 }
 
-static int get_socket_tcp_info(grpc_core::tcp_info* info, int fd) {
+int get_socket_tcp_info(tcp_info* info, int fd) {
   memset(info, 0, sizeof(*info));
-  info->length = offsetof(grpc_core::tcp_info, length);
+  info->length = offsetof(tcp_info, length);
   return getsockopt(fd, IPPROTO_TCP, TCP_INFO, info, &(info->length));
 }
 } /* namespace */
@@ -285,7 +286,7 @@ void TracedBuffer::Shutdown(TracedBuffer** head, void* remaining,
 }
 
 void grpc_tcp_set_write_timestamps_callback(
-    void (*fn)(void*, grpc_core::Timestamps*, grpc_error_handle error)) {
+    void (*fn)(void*, Timestamps*, grpc_error_handle error)) {
   timestamps_callback = fn;
 }
 } /* namespace grpc_core */
@@ -294,7 +295,7 @@ void grpc_tcp_set_write_timestamps_callback(
 
 namespace grpc_core {
 void grpc_tcp_set_write_timestamps_callback(
-    void (*fn)(void*, grpc_core::Timestamps*, grpc_error_handle error)) {
+    void (*fn)(void*, Timestamps*, grpc_error_handle 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*/.

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

@@ -23,13 +23,12 @@
 
 #include "absl/types/optional.h"
 
-#include "src/core/lib/iomgr/port.h"
-
 #include <grpc/support/time.h>
 
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/internal_errqueue.h"
+#include "src/core/lib/iomgr/port.h"
 
 namespace grpc_core {
 
@@ -83,22 +82,22 @@ struct ConnectionMetrics {
   absl::optional<uint64_t> sndbuf_limited_usec;
 };
 
-struct Timestamp {
+struct BufferTimestamp {
   gpr_timespec time;
   ConnectionMetrics metrics; /* Metrics collected with this timestamp */
 };
 
 struct Timestamps {
-  Timestamp sendmsg_time;
-  Timestamp scheduled_time;
-  Timestamp sent_time;
-  Timestamp acked_time;
+  BufferTimestamp sendmsg_time;
+  BufferTimestamp scheduled_time;
+  BufferTimestamp sent_time;
+  BufferTimestamp acked_time;
 
   uint32_t byte_offset; /* byte offset relative to the start of the RPC */
 
 #ifdef GRPC_LINUX_ERRQUEUE
-  grpc_core::tcp_info info; /* tcp_info collected on sendmsg */
-#endif                      /* GRPC_LINUX_ERRQUEUE */
+  tcp_info info; /* tcp_info collected on sendmsg */
+#endif           /* GRPC_LINUX_ERRQUEUE */
 };
 
 /** TracedBuffer is a class to keep track of timestamps for a specific buffer in
@@ -106,7 +105,7 @@ struct Timestamps {
  * this class would only be used by Linux platforms. For all other platforms,
  * TracedBuffer would be an empty class.
  *
- * The timestamps collected are according to grpc_core::Timestamps declared
+ * The timestamps collected are according to Timestamps declared
  * above.
  *
  * A TracedBuffer list is kept track of using the head element of the list. If
@@ -121,33 +120,33 @@ class TracedBuffer {
 
   /** 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,
-                          int fd, void* arg);
+  static void AddNewEntry(TracedBuffer** head, uint32_t seq_no, int fd,
+                          void* arg);
 
   /** Processes a received timestamp based on sock_extended_err and
    * scm_timestamping structures. It will invoke the timestamps callback if the
    * timestamp type is SCM_TSTAMP_ACK. */
-  static void ProcessTimestamp(grpc_core::TracedBuffer** head,
+  static void ProcessTimestamp(TracedBuffer** head,
                                struct sock_extended_err* serr,
                                struct cmsghdr* opt_stats,
                                struct scm_timestamping* tss);
 
   /** Cleans the list by calling the callback for each traced buffer in the list
    * with timestamps that it has. */
-  static void Shutdown(grpc_core::TracedBuffer** head, void* remaining,
+  static void Shutdown(TracedBuffer** head, void* remaining,
                        grpc_error_handle shutdown_err);
 
  private:
-  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 */
-  grpc_core::TracedBuffer* next_; /* The next TracedBuffer in the list */
+  uint32_t seq_no_;    /* The sequence number for the last byte in the buffer */
+  void* arg_;          /* The arg to pass to timestamps_callback */
+  Timestamps ts_;      /* The timestamps corresponding to this buffer */
+  TracedBuffer* next_; /* The next TracedBuffer in the list */
 };
 #else  /* GRPC_LINUX_ERRQUEUE */
 class TracedBuffer {
  public:
   /* Phony shutdown function */
-  static void Shutdown(grpc_core::TracedBuffer** /*head*/, void* /*remaining*/,
+  static void Shutdown(TracedBuffer** /*head*/, void* /*remaining*/,
                        grpc_error_handle shutdown_err) {
     GRPC_ERROR_UNREF(shutdown_err);
   }
@@ -157,7 +156,7 @@ class TracedBuffer {
 /** Sets the callback function to call when timestamps for a write are
  *  collected. The callback does not own a reference to error. */
 void grpc_tcp_set_write_timestamps_callback(
-    void (*fn)(void*, grpc_core::Timestamps*, grpc_error_handle error));
+    void (*fn)(void*, Timestamps*, grpc_error_handle error));
 
 } /* namespace grpc_core */
 

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

@@ -23,6 +23,7 @@
 #include <inttypes.h>
 
 #include <grpc/support/log.h>
+
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/profiling/timers.h"
 
@@ -32,18 +33,20 @@ DebugOnlyTraceFlag grpc_call_combiner_trace(false, "call_combiner");
 
 namespace {
 
+// grpc_error LSB can be used
+constexpr 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() {
@@ -56,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
@@ -81,8 +91,7 @@ void CallCombiner::TsanClosure(void* arg, grpc_error_handle error) {
   } else {
     lock.reset();
   }
-  grpc_core::Closure::Run(DEBUG_LOCATION, self->original_closure_,
-                          GRPC_ERROR_REF(error));
+  Closure::Run(DEBUG_LOCATION, self->original_closure_, GRPC_ERROR_REF(error));
   if (lock != nullptr) {
     TSAN_ANNOTATE_RWLOCK_RELEASED(&lock->taken, true);
     bool prev = true;
@@ -141,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));
   }
@@ -176,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)) {
@@ -234,15 +254,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/cfstream_handle.cc

@@ -23,13 +23,13 @@
 
 #ifdef GRPC_CFSTREAM
 #import <CoreFoundation/CoreFoundation.h>
-#import "src/core/lib/iomgr/cfstream_handle.h"
 
 #include <grpc/grpc.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/debug/trace.h"
+#import "src/core/lib/iomgr/cfstream_handle.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error_cfstream.h"
 #include "src/core/lib/iomgr/ev_apple.h"

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);