grpc 1.36.0 → 1.38.0

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

@@ -59,7 +59,7 @@ static bool iomgr_platform_is_any_background_poller_thread(void) {
 }
 
 static bool iomgr_platform_add_closure_to_background_poller(
-    grpc_closure* closure, grpc_error* error) {
+    grpc_closure* closure, grpc_error_handle error) {
   return grpc_add_closure_to_background_poller(closure, error);
 }
 

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

@@ -72,7 +72,7 @@ static bool apple_iomgr_platform_is_any_background_poller_thread(void) {
 }
 
 static bool apple_iomgr_platform_add_closure_to_background_poller(
-    grpc_closure* closure, grpc_error* error) {
+    grpc_closure* closure, grpc_error_handle error) {
   return false;
 }
 
@@ -105,7 +105,7 @@ static bool iomgr_platform_is_any_background_poller_thread(void) {
 }
 
 static bool iomgr_platform_add_closure_to_background_poller(
-    grpc_closure* closure, grpc_error* error) {
+    grpc_closure* closure, grpc_error_handle error) {
   return grpc_add_closure_to_background_poller(closure, error);
 }
 

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

@@ -79,7 +79,7 @@ static bool iomgr_platform_is_any_background_poller_thread(void) {
 }
 
 static bool iomgr_platform_add_closure_to_background_poller(
-    grpc_closure* closure, grpc_error* error) {
+    grpc_closure* closure, grpc_error_handle error) {
   return false;
 }
 

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

@@ -30,14 +30,14 @@
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/block_annotate.h"
 
-grpc_error* grpc_load_file(const char* filename, int add_null_terminator,
-                           grpc_slice* output) {
+grpc_error_handle grpc_load_file(const char* filename, int add_null_terminator,
+                                 grpc_slice* output) {
   unsigned char* contents = nullptr;
   size_t contents_size = 0;
   grpc_slice result = grpc_empty_slice();
   FILE* file;
   size_t bytes_read = 0;
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
 
   GRPC_SCHEDULING_START_BLOCKING_REGION;
   file = fopen(filename, "rb");
@@ -67,7 +67,7 @@ end:
   *output = result;
   if (file != nullptr) fclose(file);
   if (error != GRPC_ERROR_NONE) {
-    grpc_error* error_out =
+    grpc_error_handle error_out =
         grpc_error_set_str(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                                "Failed to load file", &error, 1),
                            GRPC_ERROR_STR_FILENAME,

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

@@ -29,7 +29,7 @@
 
 /* Loads the content of a file into a slice. add_null_terminator will add
    a NULL terminator if non-zero. */
-grpc_error* grpc_load_file(const char* filename, int add_null_terminator,
-                           grpc_slice* output);
+grpc_error_handle grpc_load_file(const char* filename, int add_null_terminator,
+                                 grpc_slice* output);
 
 #endif /* GRPC_CORE_LIB_IOMGR_LOAD_FILE_H */

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

@@ -77,7 +77,7 @@ void LockfreeEvent::DestroyEvent() {
   do {
     curr = gpr_atm_no_barrier_load(&state_);
     if (curr & kShutdownBit) {
-      GRPC_ERROR_UNREF((grpc_error*)(curr & ~kShutdownBit));
+      GRPC_ERROR_UNREF((grpc_error_handle)(curr & ~kShutdownBit));
     } else {
       GPR_ASSERT(curr == kClosureNotReady || curr == kClosureReady);
     }
@@ -139,8 +139,8 @@ void LockfreeEvent::NotifyOn(grpc_closure* closure) {
            contains a pointer to the shutdown-error). If the fd is shutdown,
            schedule the closure with the shutdown error */
         if ((curr & kShutdownBit) > 0) {
-          grpc_error* shutdown_err =
-              reinterpret_cast<grpc_error*>(curr & ~kShutdownBit);
+          grpc_error_handle shutdown_err =
+              reinterpret_cast<grpc_error_handle>(curr & ~kShutdownBit);
           ExecCtx::Run(DEBUG_LOCATION, closure,
                        GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                            "FD Shutdown", &shutdown_err, 1));
@@ -159,7 +159,7 @@ void LockfreeEvent::NotifyOn(grpc_closure* closure) {
   GPR_UNREACHABLE_CODE(return );
 }
 
-bool LockfreeEvent::SetShutdown(grpc_error* shutdown_error) {
+bool LockfreeEvent::SetShutdown(grpc_error_handle shutdown_error) {
   gpr_atm new_state = reinterpret_cast<gpr_atm>(shutdown_error) | kShutdownBit;
 
   while (true) {
@@ -167,7 +167,7 @@ bool LockfreeEvent::SetShutdown(grpc_error* shutdown_error) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
       gpr_log(GPR_DEBUG,
               "LockfreeEvent::SetShutdown: %p curr=%" PRIxPTR " err=%s",
-              &state_, curr, grpc_error_string(shutdown_error));
+              &state_, curr, grpc_error_std_string(shutdown_error).c_str());
     }
     switch (curr) {
       case kClosureReady:

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

@@ -56,7 +56,7 @@ class LockfreeEvent {
 
   // Sets the shutdown state. If a closure had been provided by NotifyOn and has
   // not yet been scheduled, it will be scheduled with \a shutdown_error.
-  bool SetShutdown(grpc_error* shutdown_error);
+  bool SetShutdown(grpc_error_handle shutdown_error);
 
   // Signals that the event has been received.
   void SetReady();

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

@@ -42,14 +42,14 @@ void grpc_pollset_destroy(grpc_pollset* pollset) {
   grpc_pollset_impl->destroy(pollset);
 }
 
-grpc_error* grpc_pollset_work(grpc_pollset* pollset,
-                              grpc_pollset_worker** worker,
-                              grpc_millis deadline) {
+grpc_error_handle grpc_pollset_work(grpc_pollset* pollset,
+                                    grpc_pollset_worker** worker,
+                                    grpc_millis deadline) {
   return grpc_pollset_impl->work(pollset, worker, deadline);
 }
 
-grpc_error* grpc_pollset_kick(grpc_pollset* pollset,
-                              grpc_pollset_worker* specific_worker) {
+grpc_error_handle grpc_pollset_kick(grpc_pollset* pollset,
+                                    grpc_pollset_worker* specific_worker) {
   return grpc_pollset_impl->kick(pollset, specific_worker);
 }
 

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

@@ -44,10 +44,10 @@ typedef struct grpc_pollset_vtable {
   void (*init)(grpc_pollset* pollset, gpr_mu** mu);
   void (*shutdown)(grpc_pollset* pollset, grpc_closure* closure);
   void (*destroy)(grpc_pollset* pollset);
-  grpc_error* (*work)(grpc_pollset* pollset, grpc_pollset_worker** worker,
-                      grpc_millis deadline);
-  grpc_error* (*kick)(grpc_pollset* pollset,
-                      grpc_pollset_worker* specific_worker);
+  grpc_error_handle (*work)(grpc_pollset* pollset, grpc_pollset_worker** worker,
+                            grpc_millis deadline);
+  grpc_error_handle (*kick)(grpc_pollset* pollset,
+                            grpc_pollset_worker* specific_worker);
   size_t (*pollset_size)(void);
 } grpc_pollset_vtable;
 
@@ -86,14 +86,14 @@ void grpc_pollset_destroy(grpc_pollset* pollset);
    May call grpc_closure_list_run on grpc_closure_list, without holding the
    pollset
    lock */
-grpc_error* grpc_pollset_work(grpc_pollset* pollset,
-                              grpc_pollset_worker** worker,
-                              grpc_millis deadline) GRPC_MUST_USE_RESULT;
+grpc_error_handle grpc_pollset_work(grpc_pollset* pollset,
+                                    grpc_pollset_worker** worker,
+                                    grpc_millis deadline) GRPC_MUST_USE_RESULT;
 
 /* Break one polling thread out of polling work for this pollset.
    If specific_worker is non-NULL, then kick that worker. */
-grpc_error* grpc_pollset_kick(grpc_pollset* pollset,
-                              grpc_pollset_worker* specific_worker)
+grpc_error_handle grpc_pollset_kick(grpc_pollset* pollset,
+                                    grpc_pollset_worker* specific_worker)
     GRPC_MUST_USE_RESULT;
 
 #endif /* GRPC_CORE_LIB_IOMGR_POLLSET_H */

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

@@ -63,9 +63,9 @@ static void pollset_destroy(grpc_pollset* pollset) {
   gpr_mu_destroy(&pollset->mu);
 }
 
-static grpc_error* pollset_work(grpc_pollset* pollset,
-                                grpc_pollset_worker** /*worker_hdl*/,
-                                grpc_millis deadline) {
+static grpc_error_handle pollset_work(grpc_pollset* pollset,
+                                      grpc_pollset_worker** /*worker_hdl*/,
+                                      grpc_millis deadline) {
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
   gpr_mu_unlock(&pollset->mu);
   grpc_millis now = grpc_core::ExecCtx::Get()->Now();
@@ -87,8 +87,8 @@ static grpc_error* pollset_work(grpc_pollset* pollset,
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* pollset_kick(grpc_pollset* /*pollset*/,
-                                grpc_pollset_worker* /*specific_worker*/) {
+static grpc_error_handle pollset_kick(
+    grpc_pollset* /*pollset*/, grpc_pollset_worker* /*specific_worker*/) {
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
   poller_vtable->kick();
   return GRPC_ERROR_NONE;

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

@@ -106,9 +106,9 @@ static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
 
 static void pollset_destroy(grpc_pollset* pollset) {}
 
-static grpc_error* pollset_work(grpc_pollset* pollset,
-                                grpc_pollset_worker** worker_hdl,
-                                grpc_millis deadline) {
+static grpc_error_handle pollset_work(grpc_pollset* pollset,
+                                      grpc_pollset_worker** worker_hdl,
+                                      grpc_millis deadline) {
   grpc_pollset_worker worker;
   if (worker_hdl) *worker_hdl = &worker;
 
@@ -183,8 +183,8 @@ done:
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* pollset_kick(grpc_pollset* p,
-                                grpc_pollset_worker* specific_worker) {
+static grpc_error_handle pollset_kick(grpc_pollset* p,
+                                      grpc_pollset_worker* specific_worker) {
   bool should_kick_global = false;
   if (specific_worker != NULL) {
     if (specific_worker == GRPC_POLLSET_KICK_BROADCAST) {

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

@@ -192,7 +192,7 @@
         defined(GRPC_CUSTOM_SOCKET) + defined(GRPC_CFSTREAM) != \
     1
 #error \
-    "Must define exactly one of GRPC_POSIX_SOCKET, GRPC_WINSOCK_SOCKET, GRPC_CUSTOM_SOCKET"
+    "Must define exactly one of GRPC_POSIX_SOCKET, GRPC_WINSOCK_SOCKET, GRPC_CUSTOM_SOCKET, GRPC_CFSTREAM"
 #endif
 
 #ifdef GRPC_POSIX_SOCKET

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

@@ -29,7 +29,7 @@
 // They are easier to define here (rather than in Cython)
 // because Cython doesn't handle #defines well.
 
-inline grpc_error* grpc_socket_error(char* error) {
+inline grpc_error_handle grpc_socket_error(char* error) {
   return grpc_error_set_int(GRPC_ERROR_CREATE_FROM_COPIED_STRING(error),
                             GRPC_ERROR_INT_GRPC_STATUS,
                             GRPC_STATUS_UNAVAILABLE);

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

@@ -42,9 +42,9 @@ void grpc_resolved_addresses_destroy(grpc_resolved_addresses* addresses) {
   gpr_free(addresses);
 }
 
-grpc_error* grpc_blocking_resolve_address(const char* name,
-                                          const char* default_port,
-                                          grpc_resolved_addresses** addresses) {
+grpc_error_handle grpc_blocking_resolve_address(
+    const char* name, const char* default_port,
+    grpc_resolved_addresses** addresses) {
   return grpc_resolve_address_impl->blocking_resolve_address(name, default_port,
                                                              addresses);
 }

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

@@ -54,9 +54,9 @@ typedef struct grpc_address_resolver_vtable {
                           grpc_pollset_set* interested_parties,
                           grpc_closure* on_done,
                           grpc_resolved_addresses** addresses);
-  grpc_error* (*blocking_resolve_address)(const char* name,
-                                          const char* default_port,
-                                          grpc_resolved_addresses** addresses);
+  grpc_error_handle (*blocking_resolve_address)(
+      const char* name, const char* default_port,
+      grpc_resolved_addresses** addresses);
 } grpc_address_resolver_vtable;
 
 void grpc_set_resolver_impl(grpc_address_resolver_vtable* vtable);
@@ -74,8 +74,8 @@ void grpc_resolved_addresses_destroy(grpc_resolved_addresses* addresses);
 
 /* Resolve addr in a blocking fashion. On success,
    result must be freed with grpc_resolved_addresses_destroy. */
-grpc_error* grpc_blocking_resolve_address(const char* name,
-                                          const char* default_port,
-                                          grpc_resolved_addresses** addresses);
+grpc_error_handle grpc_blocking_resolve_address(
+    const char* name, const char* default_port,
+    grpc_resolved_addresses** addresses);
 
 #endif /* GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_H */

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

@@ -29,12 +29,12 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/iomgr_custom.h"
 #include "src/core/lib/iomgr/port.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
 
 struct grpc_custom_resolver {
   grpc_closure* on_done = nullptr;
@@ -53,7 +53,7 @@ static int retry_named_port_failure(grpc_custom_resolver* r,
     if (r->port == svc[i][0]) {
       r->port = svc[i][1];
       if (res) {
-        grpc_error* error = resolve_address_vtable->resolve(
+        grpc_error_handle error = resolve_address_vtable->resolve(
             r->host.c_str(), r->port.c_str(), res);
         if (error != GRPC_ERROR_NONE) {
           GRPC_ERROR_UNREF(error);
@@ -71,7 +71,7 @@ static int retry_named_port_failure(grpc_custom_resolver* r,
 
 void grpc_custom_resolve_callback(grpc_custom_resolver* r,
                                   grpc_resolved_addresses* result,
-                                  grpc_error* error) {
+                                  grpc_error_handle error) {
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
@@ -86,9 +86,10 @@ void grpc_custom_resolve_callback(grpc_custom_resolver* r,
   delete r;
 }
 
-static grpc_error* try_split_host_port(const char* name,
-                                       const char* default_port,
-                                       std::string* host, std::string* port) {
+static grpc_error_handle try_split_host_port(const char* name,
+                                             const char* default_port,
+                                             std::string* host,
+                                             std::string* port) {
   /* parse name, splitting it into host and port parts */
   grpc_core::SplitHostPort(name, host, port);
   if (host->empty()) {
@@ -106,13 +107,13 @@ static grpc_error* try_split_host_port(const char* name,
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error* blocking_resolve_address_impl(
+static grpc_error_handle blocking_resolve_address_impl(
     const char* name, const char* default_port,
     grpc_resolved_addresses** addresses) {
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
 
   grpc_custom_resolver resolver;
-  grpc_error* err =
+  grpc_error_handle err =
       try_split_host_port(name, default_port, &resolver.host, &resolver.port);
   if (err != GRPC_ERROR_NONE) {
     return err;
@@ -144,7 +145,7 @@ static void resolve_address_impl(const char* name, const char* default_port,
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
   std::string host;
   std::string port;
-  grpc_error* err = try_split_host_port(name, default_port, &host, &port);
+  grpc_error_handle err = try_split_host_port(name, default_port, &host, &port);
   if (err != GRPC_ERROR_NONE) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_done, err);
     return;

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

@@ -29,15 +29,15 @@
 typedef struct grpc_custom_resolver grpc_custom_resolver;
 
 typedef struct grpc_custom_resolver_vtable {
-  grpc_error* (*resolve)(const char* host, const char* port,
-                         grpc_resolved_addresses** res);
+  grpc_error_handle (*resolve)(const char* host, const char* port,
+                               grpc_resolved_addresses** res);
   void (*resolve_async)(grpc_custom_resolver* resolver, const char* host,
                         const char* port);
 } grpc_custom_resolver_vtable;
 
 void grpc_custom_resolve_callback(grpc_custom_resolver* resolver,
                                   grpc_resolved_addresses* result,
-                                  grpc_error* error);
+                                  grpc_error_handle error);
 
 /* Internal APIs */
 void grpc_custom_resolver_init(grpc_custom_resolver_vtable* impl);

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

@@ -42,7 +42,7 @@
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 
-static grpc_error* posix_blocking_resolve_address(
+static grpc_error_handle posix_blocking_resolve_address(
     const char* name, const char* default_port,
     grpc_resolved_addresses** addresses) {
   grpc_core::ExecCtx exec_ctx;
@@ -50,7 +50,7 @@ static grpc_error* posix_blocking_resolve_address(
   struct addrinfo *result = nullptr, *resp;
   int s;
   size_t i;
-  grpc_error* err;
+  grpc_error_handle err;
 
   std::string host;
   std::string port;
@@ -145,7 +145,7 @@ struct request {
 };
 /* Callback to be passed to grpc Executor to asynch-ify
  * grpc_blocking_resolve_address */
-static void do_request_thread(void* rp, grpc_error* /*error*/) {
+static void do_request_thread(void* rp, grpc_error_handle /*error*/) {
   request* r = static_cast<request*>(rp);
   grpc_core::ExecCtx::Run(
       DEBUG_LOCATION, r->on_done,

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

@@ -39,13 +39,13 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
 
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/thd.h"
 #include "src/core/lib/iomgr/block_annotate.h"
 #include "src/core/lib/iomgr/executor.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
 
 struct request {
   char* name;
@@ -54,7 +54,7 @@ struct request {
   grpc_closure* on_done;
   grpc_resolved_addresses** addresses;
 };
-static grpc_error* windows_blocking_resolve_address(
+static grpc_error_handle windows_blocking_resolve_address(
     const char* name, const char* default_port,
     grpc_resolved_addresses** addresses) {
   grpc_core::ExecCtx exec_ctx;
@@ -62,7 +62,7 @@ static grpc_error* windows_blocking_resolve_address(
   struct addrinfo *result = NULL, *resp;
   int s;
   size_t i;
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
 
   /* parse name, splitting it into host and port parts */
   std::string host;
@@ -121,7 +121,7 @@ done:
 
 /* Callback to be passed to grpc_executor to asynch-ify
  * grpc_blocking_resolve_address */
-static void do_request_thread(void* rp, grpc_error* error) {
+static void do_request_thread(void* rp, grpc_error_handle error) {
   request* r = (request*)rp;
   if (error == GRPC_ERROR_NONE) {
     error =