grpc 1.46.2 → 1.48.0.pre1

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

@@ -23,18 +23,34 @@
 
 #include <stddef.h>
 
-#include <grpc/support/time.h>
+#include <functional>
+#include <vector>
 
-#include "src/core/lib/channel/handshaker.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/status/statusor.h"
+#include "absl/types/optional.h"
+
+#include <grpc/grpc.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/slice.h>
+
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/http/parser.h"
+#include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/polling_entity.h"
-#include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
-#include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/transport/handshaker.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 /* User agent this library reports */
@@ -50,6 +66,10 @@ typedef int (*grpc_httpcli_post_override)(
     const grpc_http_request* request, const char* host, const char* path,
     const char* body_bytes, size_t body_size, grpc_core::Timestamp deadline,
     grpc_closure* on_complete, grpc_http_response* response);
+typedef int (*grpc_httpcli_put_override)(
+    const grpc_http_request* request, const char* host, const char* path,
+    const char* body_bytes, size_t body_size, grpc_core::Timestamp deadline,
+    grpc_closure* on_complete, grpc_http_response* response);
 
 namespace grpc_core {
 
@@ -112,6 +132,32 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
       RefCountedPtr<grpc_channel_credentials> channel_creds)
       GRPC_MUST_USE_RESULT;
 
+  // Asynchronously perform a HTTP PUT.
+  // 'uri' is the target to make the request to. The scheme field is used to
+  //  determine the port number. The authority field is the target host. The
+  //  path field determines the path of the request. No other fields are used.
+  // 'args' are optional channel args for the request.
+  // '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
+  // 'request' contains request parameters - these are caller owned and can be
+  //   destroyed once the call returns
+  // 'deadline' contains a deadline for the request (or gpr_inf_future)
+  // 'on_done' is a callback to report results to
+  // 'channel_creds' are used to configurably secure the connection.
+  //   For insecure requests, use grpc_insecure_credentials_create.
+  //   For secure requests, use CreateHttpRequestSSLCredentials().
+  //   nullptr is treated as insecure credentials.
+  //   TODO(apolcyn): disallow nullptr as a value after unsecure builds
+  //   are removed.
+  // Does not support ?var1=val1&var2=val2 in the path.
+  static OrphanablePtr<HttpRequest> Put(
+      URI uri, const grpc_channel_args* args, grpc_polling_entity* pollent,
+      const grpc_http_request* request, Timestamp deadline,
+      grpc_closure* on_done, grpc_http_response* response,
+      RefCountedPtr<grpc_channel_credentials> channel_creds)
+      GRPC_MUST_USE_RESULT;
+
   HttpRequest(URI uri, const grpc_slice& request_text,
               grpc_http_response* response, Timestamp deadline,
               const grpc_channel_args* channel_args, grpc_closure* on_done,
@@ -126,7 +172,8 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   void Orphan() override;
 
   static void SetOverride(grpc_httpcli_get_override get,
-                          grpc_httpcli_post_override post);
+                          grpc_httpcli_post_override post,
+                          grpc_httpcli_put_override put);
 
   static void TestOnlySetOnHandshakeDoneIntercept(
       void (*intercept)(HttpRequest* req));
@@ -141,7 +188,8 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
 
   void DoRead() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
     Ref().release();  // ref held by pending read
-    grpc_endpoint_read(ep_, &incoming_, &on_read_, /*urgent=*/true);
+    grpc_endpoint_read(ep_, &incoming_, &on_read_, /*urgent=*/true,
+                       /*min_progress_size=*/1);
   }
 
   static void OnRead(void* user_data, grpc_error_handle error) {
@@ -179,7 +227,8 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
 
   static void OnHandshakeDone(void* arg, grpc_error_handle error);
 
-  static void OnConnected(void* arg, grpc_error_handle error);
+  void DoHandshake(const grpc_resolved_address* addr)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
   void NextAddress(grpc_error_handle error) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
@@ -195,7 +244,6 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   grpc_closure continue_on_read_after_schedule_on_exec_ctx_;
   grpc_closure done_write_;
   grpc_closure continue_done_write_after_schedule_on_exec_ctx_;
-  grpc_closure connected_;
   grpc_endpoint* ep_ = nullptr;
   grpc_closure* on_done_;
   ResourceQuotaRefPtr resource_quota_;
@@ -206,7 +254,6 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   RefCountedPtr<HandshakeManager> handshake_mgr_ ABSL_GUARDED_BY(mu_);
   bool own_endpoint_ ABSL_GUARDED_BY(mu_) = true;
   bool cancelled_ ABSL_GUARDED_BY(mu_) = false;
-  bool connecting_ ABSL_GUARDED_BY(mu_) = false;
   grpc_http_parser parser_ ABSL_GUARDED_BY(mu_);
   std::vector<grpc_resolved_address> addresses_ ABSL_GUARDED_BY(mu_);
   size_t next_address_ ABSL_GUARDED_BY(mu_) = 0;
@@ -215,7 +262,8 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
   grpc_slice_buffer incoming_ ABSL_GUARDED_BY(mu_);
   grpc_slice_buffer outgoing_ ABSL_GUARDED_BY(mu_);
   grpc_error_handle overall_error_ ABSL_GUARDED_BY(mu_) = GRPC_ERROR_NONE;
-  OrphanablePtr<DNSResolver::Request> dns_request_ ABSL_GUARDED_BY(mu_);
+  absl::optional<DNSResolver::TaskHandle> dns_request_handle_
+      ABSL_GUARDED_BY(mu_) = DNSResolver::kNullHandle;
 };
 
 }  // namespace grpc_core

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

@@ -20,24 +20,36 @@
 
 #include <string.h>
 
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/iomgr/pollset.h"
+#include "src/core/lib/gprpp/unique_type_name.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/security/security_connector/security_connector.h"
 #include "src/core/lib/security/security_connector/ssl_utils.h"
 #include "src/core/lib/security/transport/security_handshaker.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/transport/handshaker.h"
 #include "src/core/tsi/ssl_transport_security.h"
+#include "src/core/tsi/transport_security_interface.h"
 
 namespace grpc_core {
 
@@ -178,12 +190,11 @@ class HttpRequestSSLCredentials : public grpc_channel_credentials {
     return Ref();
   }
 
-  grpc_channel_args* update_arguments(grpc_channel_args* args) override {
-    return args;
+  UniqueTypeName type() const override {
+    static UniqueTypeName::Factory kFactory("HttpRequestSSL");
+    return kFactory.Create();
   }
 
-  const char* type() const override { return "HttpRequestSSL"; }
-
  private:
   int cmp_impl(const grpc_channel_credentials* /* other */) const override {
     // There's no differentiating factor between two HttpRequestSSLCredentials

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

@@ -19,7 +19,9 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/security/credentials/credentials.h"
+#include <grpc/grpc.h>
+
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 
 namespace grpc_core {
 

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

@@ -20,14 +20,13 @@
 
 #include "src/core/lib/http/parser.h"
 
-#include <stdbool.h>
 #include <string.h>
 
+#include <algorithm>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gpr/useful.h"
-
 grpc_core::TraceFlag grpc_http1_trace(false, "http1");
 
 static char* buf2str(void* buffer, size_t length) {
@@ -236,7 +235,7 @@ static grpc_error_handle add_header(grpc_http_parser* parser) {
   (*hdrs)[(*hdr_count)++] = hdr;
 
 done:
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_free(hdr.key);
     gpr_free(hdr.value);
   }
@@ -249,7 +248,7 @@ static grpc_error_handle finish_line(grpc_http_parser* parser,
   switch (parser->state) {
     case GRPC_HTTP_FIRST_LINE:
       err = handle_first_line(parser);
-      if (err != GRPC_ERROR_NONE) return err;
+      if (!GRPC_ERROR_IS_NONE(err)) return err;
       parser->state = GRPC_HTTP_HEADERS;
       break;
     case GRPC_HTTP_HEADERS:
@@ -264,7 +263,7 @@ static grpc_error_handle finish_line(grpc_http_parser* parser,
         break;
       } else {
         err = add_header(parser);
-        if (err != GRPC_ERROR_NONE) {
+        if (!GRPC_ERROR_IS_NONE(err)) {
           return err;
         }
       }
@@ -449,7 +448,7 @@ grpc_error_handle grpc_http_parser_parse(grpc_http_parser* parser,
     bool found_body_start = false;
     grpc_error_handle err =
         addbyte(parser, GRPC_SLICE_START_PTR(slice)[i], &found_body_start);
-    if (err != GRPC_ERROR_NONE) return err;
+    if (!GRPC_ERROR_IS_NONE(err)) return err;
     if (found_body_start && start_of_body != nullptr) *start_of_body = i + 1;
   }
   return GRPC_ERROR_NONE;

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

@@ -21,6 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <grpc/slice.h>
 
 #include "src/core/lib/debug/trace.h"

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

@@ -217,7 +217,7 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
     grpc_error_handle original_error = DecodeCancelStateError(original_state);
     // If error is set, invoke the cancellation closure immediately.
     // Otherwise, store the new closure.
-    if (original_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(original_error)) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
         gpr_log(GPR_INFO,
                 "call_combiner=%p: scheduling notify_on_cancel callback=%p "
@@ -263,7 +263,7 @@ void CallCombiner::Cancel(grpc_error_handle error) {
   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) {
+    if (!GRPC_ERROR_IS_NONE(original_error)) {
 #ifdef GRPC_ERROR_IS_ABSEIL_STATUS
       internal::StatusFreeHeapPtr(status_ptr);
 #else

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

@@ -23,13 +23,13 @@
 grpc_core::TraceFlag grpc_tcp_trace(false, "tcp");
 
 void grpc_endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                        grpc_closure* cb, bool urgent) {
-  ep->vtable->read(ep, slices, cb, urgent);
+                        grpc_closure* cb, bool urgent, int min_progress_size) {
+  ep->vtable->read(ep, slices, cb, urgent, min_progress_size);
 }
 
 void grpc_endpoint_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                         grpc_closure* cb, void* arg) {
-  ep->vtable->write(ep, slices, cb, arg);
+                         grpc_closure* cb, void* arg, int max_frame_size) {
+  ep->vtable->write(ep, slices, cb, arg, max_frame_size);
 }
 
 void grpc_endpoint_add_to_pollset(grpc_endpoint* ep, grpc_pollset* pollset) {

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

@@ -38,9 +38,9 @@ typedef struct grpc_endpoint_vtable grpc_endpoint_vtable;
 
 struct grpc_endpoint_vtable {
   void (*read)(grpc_endpoint* ep, grpc_slice_buffer* slices, grpc_closure* cb,
-               bool urgent);
+               bool urgent, int min_progress_size);
   void (*write)(grpc_endpoint* ep, grpc_slice_buffer* slices, grpc_closure* cb,
-                void* arg);
+                void* arg, int max_frame_size);
   void (*add_to_pollset)(grpc_endpoint* ep, grpc_pollset* pollset);
   void (*add_to_pollset_set)(grpc_endpoint* ep, grpc_pollset_set* pollset);
   void (*delete_from_pollset_set)(grpc_endpoint* ep, grpc_pollset_set* pollset);
@@ -56,9 +56,9 @@ struct grpc_endpoint_vtable {
    Callback success indicates that the endpoint can accept more reads, failure
    indicates the endpoint is closed.
    Valid slices may be placed into \a slices even when the callback is
-   invoked with error != GRPC_ERROR_NONE. */
+   invoked with !GRPC_ERROR_IS_NONE(error). */
 void grpc_endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                        grpc_closure* cb, bool urgent);
+                        grpc_closure* cb, bool urgent, int min_progress_size);
 
 absl::string_view grpc_endpoint_get_peer(grpc_endpoint* ep);
 
@@ -79,9 +79,11 @@ int grpc_endpoint_get_fd(grpc_endpoint* ep);
    it is a valid slice buffer.
    \a arg is platform specific. It is currently only used by TCP on linux
    platforms as an argument that would be forwarded to the timestamps callback.
+   \a max_frame_size. A hint to the endpoint implementation to construct
+   frames which do not exceed the specified size.
    */
 void grpc_endpoint_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                         grpc_closure* cb, void* arg);
+                         grpc_closure* cb, void* arg, int max_frame_size);
 
 /* Causes any pending and future read/write callbacks to run immediately with
    success==0 */

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

@@ -147,7 +147,7 @@ static void CallWriteCb(CFStreamEndpoint* ep, grpc_error_handle error) {
 static void ReadAction(void* arg, grpc_error_handle error) {
   CFStreamEndpoint* ep = static_cast<CFStreamEndpoint*>(arg);
   GPR_ASSERT(ep->read_cb != nullptr);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_slice_buffer_reset_and_unref_internal(ep->read_slices);
     CallReadCb(ep, GRPC_ERROR_REF(error));
     EP_UNREF(ep, "read");
@@ -189,7 +189,7 @@ static void ReadAction(void* arg, grpc_error_handle error) {
 static void WriteAction(void* arg, grpc_error_handle error) {
   CFStreamEndpoint* ep = static_cast<CFStreamEndpoint*>(arg);
   GPR_ASSERT(ep->write_cb != nullptr);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_slice_buffer_reset_and_unref_internal(ep->write_slices);
     CallWriteCb(ep, GRPC_ERROR_REF(error));
     EP_UNREF(ep, "write");
@@ -237,7 +237,8 @@ static void WriteAction(void* arg, grpc_error_handle error) {
 }
 
 static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                         grpc_closure* cb, bool urgent) {
+                         grpc_closure* cb, bool urgent,
+                         int /*min_progress_size*/) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p read (%p, %p) length:%zu", ep_impl,
@@ -254,7 +255,7 @@ static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
 }
 
 static void CFStreamWrite(grpc_endpoint* ep, grpc_slice_buffer* slices,
-                          grpc_closure* cb, void* arg) {
+                          grpc_closure* cb, void* arg, int /*max_frame_size*/) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p write (%p, %p) length:%zu",
@@ -351,11 +352,13 @@ grpc_endpoint* grpc_cfstream_endpoint_create(CFReadStreamRef read_stream,
   if (native_handle) {
     CFRelease(native_handle);
   }
+  absl::StatusOr<std::string> addr_uri;
   if (getsockname(sockfd, reinterpret_cast<sockaddr*>(resolved_local_addr.addr),
-                  &resolved_local_addr.len) < 0) {
+                  &resolved_local_addr.len) < 0 ||
+      !(addr_uri = grpc_sockaddr_to_uri(&resolved_local_addr)).ok()) {
     ep_impl->local_address = "";
   } else {
-    ep_impl->local_address = grpc_sockaddr_to_uri(&resolved_local_addr);
+    ep_impl->local_address = addr_uri.value();
   }
   ep_impl->read_cb = nil;
   ep_impl->write_cb = nil;

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

@@ -62,7 +62,8 @@ grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(const char* name,
   std::string final_name = absl::StrCat(name, ":client");
   const grpc_channel_args* new_args = grpc_core::CoreConfiguration::Get()
                                           .channel_args_preconditioning()
-                                          .PreconditionChannelArgs(args);
+                                          .PreconditionChannelArgs(args)
+                                          .ToC();
   p.client = grpc_tcp_create(grpc_fd_create(sv[1], final_name.c_str(), false),
                              new_args, "socketpair-server");
   final_name = absl::StrCat(name, ":server");

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

@@ -71,7 +71,7 @@ std::string grpc_error_std_string(absl::Status error) {
 absl::Status grpc_os_error(const grpc_core::DebugLocation& location, int err,
                            const char* call_name) {
   absl::Status s =
-      StatusCreate(absl::StatusCode::kUnknown, "OS Error", location, {});
+      StatusCreate(absl::StatusCode::kUnknown, strerror(err), location, {});
   grpc_core::StatusSetInt(&s, grpc_core::StatusIntProperty::kErrorNo, err);
   grpc_core::StatusSetStr(&s, grpc_core::StatusStrProperty::kOsError,
                           strerror(err));
@@ -87,6 +87,8 @@ absl::Status grpc_wsa_error(const grpc_core::DebugLocation& location, int err,
   absl::Status s =
       StatusCreate(absl::StatusCode::kUnavailable, "WSA Error", location, {});
   StatusSetInt(&s, grpc_core::StatusIntProperty::kWsaError, err);
+  StatusSetInt(&s, grpc_core::StatusIntProperty::kRpcStatus,
+               GRPC_STATUS_UNAVAILABLE);
   StatusSetStr(&s, grpc_core::StatusStrProperty::kOsError, utf8_message);
   StatusSetStr(&s, grpc_core::StatusStrProperty::kSyscall, call_name);
   return s;
@@ -95,7 +97,7 @@ absl::Status grpc_wsa_error(const grpc_core::DebugLocation& location, int err,
 
 grpc_error_handle grpc_error_set_int(grpc_error_handle src,
                                      grpc_error_ints which, intptr_t value) {
-  if (src == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(src)) {
     src = absl::UnknownError("");
     StatusSetInt(&src, grpc_core::StatusIntProperty::kRpcStatus,
                  GRPC_STATUS_OK);
@@ -136,7 +138,7 @@ bool grpc_error_get_int(grpc_error_handle error, grpc_error_ints which,
 grpc_error_handle grpc_error_set_str(grpc_error_handle src,
                                      grpc_error_strs which,
                                      absl::string_view str) {
-  if (src == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(src)) {
     src = absl::UnknownError("");
     StatusSetInt(&src, grpc_core::StatusIntProperty::kRpcStatus,
                  GRPC_STATUS_OK);
@@ -211,7 +213,7 @@ grpc_error_handle grpc_error_add_child(grpc_error_handle src,
 
 bool grpc_log_error(const char* what, grpc_error_handle error, const char* file,
                     int line) {
-  GPR_DEBUG_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_DEBUG_ASSERT(!GRPC_ERROR_IS_NONE(error));
   gpr_log(file, line, GPR_LOG_SEVERITY_ERROR, "%s: %s", what,
           grpc_core::StatusToString(error).c_str());
   return false;
@@ -562,7 +564,7 @@ static grpc_error_handle copy_error_and_unref(grpc_error_handle in) {
   grpc_error_handle out;
   if (grpc_error_is_special(in)) {
     out = GRPC_ERROR_CREATE_FROM_STATIC_STRING("unknown");
-    if (in == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(in)) {
       internal_set_str(&out, GRPC_ERROR_STR_DESCRIPTION,
                        grpc_slice_from_static_string("no error"));
       internal_set_int(&out, GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_OK);
@@ -675,8 +677,8 @@ bool grpc_error_get_str(grpc_error_handle err, grpc_error_strs which,
 
 grpc_error_handle grpc_error_add_child(grpc_error_handle src,
                                        grpc_error_handle child) {
-  if (src != GRPC_ERROR_NONE) {
-    if (child == GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(src)) {
+    if (GRPC_ERROR_IS_NONE(child)) {
       /* \a child is empty. Simply return the ref to \a src */
       return src;
     } else if (child != src) {
@@ -906,7 +908,7 @@ static char* finish_kvs(kv_pairs* kvs) {
 }
 
 const char* grpc_error_string(grpc_error_handle err) {
-  if (err == GRPC_ERROR_NONE) return no_error_string;
+  if (GRPC_ERROR_IS_NONE(err)) return no_error_string;
   if (err == GRPC_ERROR_OOM) return oom_error_string;
   if (err == GRPC_ERROR_CANCELLED) return cancelled_error_string;
 
@@ -978,7 +980,7 @@ grpc_error_handle grpc_wsa_error(const char* file, int line, int err,
 
 bool grpc_log_error(const char* what, grpc_error_handle error, const char* file,
                     int line) {
-  GPR_DEBUG_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_DEBUG_ASSERT(!GRPC_ERROR_IS_NONE(error));
   const char* msg = grpc_error_string(error);
   gpr_log(file, line, GPR_LOG_SEVERITY_ERROR, "%s: %s", what, msg);
   GRPC_ERROR_UNREF(error);

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

@@ -161,6 +161,8 @@ void grpc_enable_error_creation();
 #define GRPC_ERROR_REF(err) (err)
 #define GRPC_ERROR_UNREF(err) (void)(err)
 
+#define GRPC_ERROR_IS_NONE(err) (err).ok()
+
 #define GRPC_ERROR_CREATE_FROM_STATIC_STRING(desc) \
   StatusCreate(absl::StatusCode::kUnknown, desc, DEBUG_LOCATION, {})
 #define GRPC_ERROR_CREATE_FROM_COPIED_STRING(desc) \
@@ -208,7 +210,7 @@ absl::Status grpc_os_error(const grpc_core::DebugLocation& location, int err,
                            const char* call_name) GRPC_MUST_USE_RESULT;
 
 inline absl::Status grpc_assert_never_ok(absl::Status error) {
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
   return error;
 }
 
@@ -236,6 +238,8 @@ absl::Status grpc_wsa_error(const grpc_core::DebugLocation& location, int err,
 #define GRPC_ERROR_CANCELLED ((grpc_error_handle)4)
 #define GRPC_ERROR_SPECIAL_MAX GRPC_ERROR_CANCELLED
 
+#define GRPC_ERROR_IS_NONE(err) ((err) == GRPC_ERROR_NONE)
+
 inline bool grpc_error_is_special(grpc_error_handle err) {
   return err <= GRPC_ERROR_SPECIAL_MAX;
 }
@@ -340,7 +344,7 @@ grpc_error_handle grpc_os_error(const char* file, int line, int err,
                                 const char* call_name) GRPC_MUST_USE_RESULT;
 
 inline grpc_error_handle grpc_assert_never_ok(grpc_error_handle error) {
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
   return error;
 }
 
@@ -387,8 +391,8 @@ bool grpc_log_error(const char* what, grpc_error_handle error, const char* file,
                     int line);
 inline bool grpc_log_if_error(const char* what, grpc_error_handle error,
                               const char* file, int line) {
-  return error == GRPC_ERROR_NONE ? true
-                                  : grpc_log_error(what, error, file, line);
+  return GRPC_ERROR_IS_NONE(error) ? true
+                                   : grpc_log_error(what, error, file, line);
 }
 
 #define GRPC_LOG_IF_ERROR(what, error) \
@@ -413,7 +417,7 @@ class AtomicError {
   /// returns get() == GRPC_ERROR_NONE
   bool ok() {
     gpr_spinlock_lock(&lock_);
-    bool ret = error_ == GRPC_ERROR_NONE;
+    bool ret = GRPC_ERROR_IS_NONE(error_);
     gpr_spinlock_unlock(&lock_);
     return ret;
   }