grpc 1.50.0 → 1.51.0

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

@@ -81,15 +81,14 @@ void CFStreamHandle::ReadCallback(CFReadStreamRef stream,
       stream_error = CFReadStreamCopyError(stream);
       error = grpc_error_set_int(
           GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "read error"),
-          GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
+          grpc_core::StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE);
       CFRelease(stream_error);
-      handle->open_event_.SetShutdown(GRPC_ERROR_REF(error));
-      handle->write_event_.SetShutdown(GRPC_ERROR_REF(error));
-      handle->read_event_.SetShutdown(GRPC_ERROR_REF(error));
-      GRPC_ERROR_UNREF(error);
+      handle->open_event_.SetShutdown(error);
+      handle->write_event_.SetShutdown(error);
+      handle->read_event_.SetShutdown(error);
       break;
     default:
-      GPR_UNREACHABLE_CODE(return );
+      GPR_UNREACHABLE_CODE(return);
   }
 }
 void CFStreamHandle::WriteCallback(CFWriteStreamRef stream,
@@ -116,15 +115,14 @@ void CFStreamHandle::WriteCallback(CFWriteStreamRef stream,
       stream_error = CFWriteStreamCopyError(stream);
       error = grpc_error_set_int(
           GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "write error"),
-          GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
+          grpc_core::StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE);
       CFRelease(stream_error);
-      handle->open_event_.SetShutdown(GRPC_ERROR_REF(error));
-      handle->write_event_.SetShutdown(GRPC_ERROR_REF(error));
-      handle->read_event_.SetShutdown(GRPC_ERROR_REF(error));
-      GRPC_ERROR_UNREF(error);
+      handle->open_event_.SetShutdown(error);
+      handle->write_event_.SetShutdown(error);
+      handle->read_event_.SetShutdown(error);
       break;
     default:
-      GPR_UNREACHABLE_CODE(return );
+      GPR_UNREACHABLE_CODE(return);
   }
 }
 
@@ -172,10 +170,9 @@ void CFStreamHandle::NotifyOnWrite(grpc_closure* closure) {
 }
 
 void CFStreamHandle::Shutdown(grpc_error_handle error) {
-  open_event_.SetShutdown(GRPC_ERROR_REF(error));
-  read_event_.SetShutdown(GRPC_ERROR_REF(error));
-  write_event_.SetShutdown(GRPC_ERROR_REF(error));
-  GRPC_ERROR_UNREF(error);
+  open_event_.SetShutdown(error);
+  read_event_.SetShutdown(error);
+  write_event_.SetShutdown(error);
 }
 
 void CFStreamHandle::Ref(const char* file, int line, const char* reason) {

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

@@ -45,7 +45,7 @@ typedef struct grpc_closure_list {
 /** gRPC Callback definition.
  *
  * \param arg Arbitrary input.
- * \param error GRPC_ERROR_NONE if no error occurred, otherwise some grpc_error
+ * \param error absl::OkStatus() if no error occurred, otherwise some grpc_error
  *              describing what went wrong.
  *              Error contract: it is not the cb's job to unref this error;
  *              the closure scheduler will do that after the cb returns */
@@ -118,6 +118,54 @@ inline grpc_closure* grpc_closure_init(grpc_closure* closure,
   grpc_closure_init(closure, cb, cb_arg)
 #endif
 
+namespace grpc_core {
+template <typename T, void (T::*cb)(grpc_error_handle)>
+grpc_closure MakeMemberClosure(T* p, DebugLocation location = DebugLocation()) {
+  grpc_closure out;
+  GRPC_CLOSURE_INIT(
+      &out, [](void* p, grpc_error_handle e) { (static_cast<T*>(p)->*cb)(e); },
+      p, nullptr);
+#ifndef NDEBUG
+  out.file_created = location.file();
+  out.line_created = location.line();
+#else
+  (void)location;
+#endif
+  return out;
+}
+
+template <typename T, void (T::*cb)()>
+grpc_closure MakeMemberClosure(T* p, DebugLocation location = DebugLocation()) {
+  grpc_closure out;
+  GRPC_CLOSURE_INIT(
+      &out, [](void* p, grpc_error_handle) { (static_cast<T*>(p)->*cb)(); }, p,
+      nullptr);
+#ifndef NDEBUG
+  out.file_created = location.file();
+  out.line_created = location.line();
+#else
+  (void)location;
+#endif
+  return out;
+}
+
+template <typename F>
+grpc_closure* NewClosure(F f) {
+  struct Closure : public grpc_closure {
+    explicit Closure(F f) : f(std::move(f)) {}
+    F f;
+    static void Run(void* arg, grpc_error_handle error) {
+      auto self = static_cast<Closure*>(arg);
+      self->f(error);
+      delete self;
+    }
+  };
+  Closure* c = new Closure(std::move(f));
+  GRPC_CLOSURE_INIT(c, Closure::Run, c, nullptr);
+  return c;
+}
+}  // namespace grpc_core
+
 namespace closure_impl {
 
 struct wrapped_closure {
@@ -195,7 +243,6 @@ 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;
   }
   closure->error_data.error = grpc_core::internal::StatusAllocHeapPtr(error);
@@ -211,7 +258,6 @@ inline void grpc_closure_list_fail_all(grpc_closure_list* list,
           grpc_core::internal::StatusAllocHeapPtr(forced_failure);
     }
   }
-  GRPC_ERROR_UNREF(forced_failure);
 }
 
 /** append all closures from \a src to \a dst and empty \a src. */
@@ -241,7 +287,6 @@ class Closure {
                   grpc_error_handle error) {
     (void)location;
     if (closure == nullptr) {
-      GRPC_ERROR_UNREF(error);
       return;
     }
 #ifndef NDEBUG
@@ -258,7 +303,6 @@ class Closure {
       gpr_log(GPR_DEBUG, "closure %p finished", closure);
     }
 #endif
-    GRPC_ERROR_UNREF(error);
   }
 };
 }  // namespace grpc_core

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

@@ -171,7 +171,7 @@ static void offload(void* arg, grpc_error_handle /*error*/) {
 static void queue_offload(grpc_core::Combiner* lock) {
   move_next();
   GRPC_COMBINER_TRACE(gpr_log(GPR_INFO, "C:%p queue_offload", lock));
-  grpc_core::Executor::Run(&lock->offload, GRPC_ERROR_NONE);
+  grpc_core::Executor::Run(&lock->offload, absl::OkStatus());
 }
 
 bool grpc_combiner_continue_exec_ctx() {
@@ -316,7 +316,7 @@ static void enqueue_finally(void* closure, grpc_error_handle error) {
   grpc_core::Combiner* lock =
       reinterpret_cast<grpc_core::Combiner*>(cl->error_data.scratch);
   cl->error_data.scratch = 0;
-  combiner_finally_exec(lock, cl, GRPC_ERROR_REF(error));
+  combiner_finally_exec(lock, cl, error);
 }
 
 namespace grpc_core {

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

@@ -56,7 +56,7 @@ 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 !GRPC_ERROR_IS_NONE(error). */
+   invoked with !error.ok(). */
 void grpc_endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* slices,
                         grpc_closure* cb, bool urgent, int min_progress_size);
 

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

@@ -36,6 +36,7 @@
 #import "src/core/lib/iomgr/endpoint_cfstream.h"
 #include "src/core/lib/iomgr/error_cfstream.h"
 #include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 
@@ -106,9 +107,9 @@ static void CFStreamRef(CFStreamEndpoint* ep) { gpr_ref(&ep->refcount); }
 static grpc_error_handle CFStreamAnnotateError(grpc_error_handle src_error,
                                                CFStreamEndpoint* ep) {
   return grpc_error_set_str(
-      grpc_error_set_int(src_error, GRPC_ERROR_INT_GRPC_STATUS,
+      grpc_error_set_int(src_error, grpc_core::StatusIntProperty::kRpcStatus,
                          GRPC_STATUS_UNAVAILABLE),
-      GRPC_ERROR_STR_TARGET_ADDRESS, ep->peer_string);
+      grpc_core::StatusStrProperty::kTargetAddress, ep->peer_string);
 }
 
 static void CallReadCb(CFStreamEndpoint* ep, grpc_error_handle error) {
@@ -116,7 +117,8 @@ static void CallReadCb(CFStreamEndpoint* ep, grpc_error_handle error) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p call_read_cb %p %p:%p", ep,
             ep->read_cb, ep->read_cb->cb, ep->read_cb->cb_arg);
     size_t i;
-    gpr_log(GPR_DEBUG, "read: error=%s", grpc_error_std_string(error).c_str());
+    gpr_log(GPR_DEBUG, "read: error=%s",
+            grpc_core::StatusToString(error).c_str());
 
     for (i = 0; i < ep->read_slices->count; i++) {
       char* dump = grpc_dump_slice(ep->read_slices->slices[i],
@@ -136,7 +138,8 @@ static void CallWriteCb(CFStreamEndpoint* ep, grpc_error_handle error) {
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p call_write_cb %p %p:%p", ep,
             ep->write_cb, ep->write_cb->cb, ep->write_cb->cb_arg);
-    gpr_log(GPR_DEBUG, "write: error=%s", grpc_error_std_string(error).c_str());
+    gpr_log(GPR_DEBUG, "write: error=%s",
+            grpc_core::StatusToString(error).c_str());
   }
   grpc_closure* cb = ep->write_cb;
   ep->write_cb = nullptr;
@@ -147,9 +150,9 @@ 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 (!GRPC_ERROR_IS_NONE(error)) {
-    grpc_slice_buffer_reset_and_unref_internal(ep->read_slices);
-    CallReadCb(ep, GRPC_ERROR_REF(error));
+  if (!error.ok()) {
+    grpc_slice_buffer_reset_and_unref(ep->read_slices);
+    CallReadCb(ep, error);
     EP_UNREF(ep, "read");
     return;
   }
@@ -160,28 +163,27 @@ static void ReadAction(void* arg, grpc_error_handle error) {
   CFIndex read_size =
       CFReadStreamRead(ep->read_stream, GRPC_SLICE_START_PTR(slice), len);
   if (read_size == -1) {
-    grpc_slice_buffer_reset_and_unref_internal(ep->read_slices);
+    grpc_slice_buffer_reset_and_unref(ep->read_slices);
     CFErrorRef stream_error = CFReadStreamCopyError(ep->read_stream);
     if (stream_error != nullptr) {
       error = CFStreamAnnotateError(
           GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "Read error"), ep);
       CFRelease(stream_error);
     } else {
-      error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Read error");
+      error = GRPC_ERROR_CREATE("Read error");
     }
     CallReadCb(ep, error);
     EP_UNREF(ep, "read");
   } else if (read_size == 0) {
-    grpc_slice_buffer_reset_and_unref_internal(ep->read_slices);
+    grpc_slice_buffer_reset_and_unref(ep->read_slices);
     CallReadCb(ep,
-               CFStreamAnnotateError(
-                   GRPC_ERROR_CREATE_FROM_STATIC_STRING("Socket closed"), ep));
+               CFStreamAnnotateError(GRPC_ERROR_CREATE("Socket closed"), ep));
     EP_UNREF(ep, "read");
   } else {
     if (read_size < static_cast<CFIndex>(len)) {
       grpc_slice_buffer_trim_end(ep->read_slices, len - read_size, nullptr);
     }
-    CallReadCb(ep, GRPC_ERROR_NONE);
+    CallReadCb(ep, absl::OkStatus());
     EP_UNREF(ep, "read");
   }
 }
@@ -189,26 +191,25 @@ 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 (!GRPC_ERROR_IS_NONE(error)) {
-    grpc_slice_buffer_reset_and_unref_internal(ep->write_slices);
-    CallWriteCb(ep, GRPC_ERROR_REF(error));
+  if (!error.ok()) {
+    grpc_slice_buffer_reset_and_unref(ep->write_slices);
+    CallWriteCb(ep, error);
     EP_UNREF(ep, "write");
     return;
   }
-
   grpc_slice slice = grpc_slice_buffer_take_first(ep->write_slices);
   size_t slice_len = GRPC_SLICE_LENGTH(slice);
   CFIndex write_size = CFWriteStreamWrite(
       ep->write_stream, GRPC_SLICE_START_PTR(slice), slice_len);
   if (write_size == -1) {
-    grpc_slice_buffer_reset_and_unref_internal(ep->write_slices);
+    grpc_slice_buffer_reset_and_unref(ep->write_slices);
     CFErrorRef stream_error = CFWriteStreamCopyError(ep->write_stream);
     if (stream_error != nullptr) {
       error = CFStreamAnnotateError(
           GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "write failed."), ep);
       CFRelease(stream_error);
     } else {
-      error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("write failed.");
+      error = GRPC_ERROR_CREATE("write failed.");
     }
     CallWriteCb(ep, error);
     EP_UNREF(ep, "write");
@@ -220,7 +221,7 @@ static void WriteAction(void* arg, grpc_error_handle error) {
     if (ep->write_slices->length > 0) {
       ep->stream_sync->NotifyOnWrite(&ep->write_action);
     } else {
-      CallWriteCb(ep, GRPC_ERROR_NONE);
+      CallWriteCb(ep, absl::OkStatus());
       EP_UNREF(ep, "write");
     }
 
@@ -230,10 +231,10 @@ static void WriteAction(void* arg, grpc_error_handle error) {
       gpr_log(GPR_DEBUG, "WRITE %p (peer=%s): %s", ep, ep->peer_string.c_str(),
               dump);
       gpr_free(dump);
-      grpc_slice_unref_internal(trace_slice);
+      grpc_core::CSliceUnref(trace_slice);
     }
   }
-  grpc_slice_unref_internal(slice);
+  grpc_core::CSliceUnref(slice);
 }
 
 static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
@@ -247,7 +248,7 @@ static void CFStreamRead(grpc_endpoint* ep, grpc_slice_buffer* slices,
   GPR_ASSERT(ep_impl->read_cb == nullptr);
   ep_impl->read_cb = cb;
   ep_impl->read_slices = slices;
-  grpc_slice_buffer_reset_and_unref_internal(slices);
+  grpc_slice_buffer_reset_and_unref(slices);
   grpc_slice_buffer_add_indexed(
       slices, GRPC_SLICE_MALLOC(GRPC_TCP_DEFAULT_READ_SLICE_SIZE));
   EP_REF(ep_impl, "read");
@@ -272,14 +273,14 @@ void CFStreamShutdown(grpc_endpoint* ep, grpc_error_handle why) {
   CFStreamEndpoint* ep_impl = reinterpret_cast<CFStreamEndpoint*>(ep);
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p shutdown (%s)", ep_impl,
-            grpc_error_std_string(why).c_str());
+            grpc_core::StatusToString(why).c_str());
   }
   CFReadStreamClose(ep_impl->read_stream);
   CFWriteStreamClose(ep_impl->write_stream);
   ep_impl->stream_sync->Shutdown(why);
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CFStream endpoint:%p shutdown DONE (%s)", ep_impl,
-            grpc_error_std_string(why).c_str());
+            grpc_core::StatusToString(why).c_str());
   }
 }
 

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

@@ -50,8 +50,8 @@ static void create_sockets(int sv[2]) {
   GPR_ASSERT(fcntl(sv[0], F_SETFL, flags | O_NONBLOCK) == 0);
   flags = fcntl(sv[1], F_GETFL, 0);
   GPR_ASSERT(fcntl(sv[1], F_SETFL, flags | O_NONBLOCK) == 0);
-  GPR_ASSERT(grpc_set_socket_no_sigpipe_if_possible(sv[0]) == GRPC_ERROR_NONE);
-  GPR_ASSERT(grpc_set_socket_no_sigpipe_if_possible(sv[1]) == GRPC_ERROR_NONE);
+  GPR_ASSERT(grpc_set_socket_no_sigpipe_if_possible(sv[0]) == absl::OkStatus());
+  GPR_ASSERT(grpc_set_socket_no_sigpipe_if_possible(sv[1]) == absl::OkStatus());
 }
 
 grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(const char* name,

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

@@ -22,6 +22,8 @@
 #include <inttypes.h>
 #include <string.h>
 
+#include "absl/strings/str_format.h"
+
 #include <grpc/impl/codegen/status.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -33,22 +35,13 @@
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/strerror.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 grpc_core::DebugOnlyTraceFlag grpc_trace_error_refcount(false,
                                                         "error_refcount");
 grpc_core::DebugOnlyTraceFlag grpc_trace_closure(false, "closure");
 
-static gpr_atm g_error_creation_allowed = true;
-
-void grpc_disable_error_creation() {
-  gpr_atm_no_barrier_store(&g_error_creation_allowed, false);
-}
-
-void grpc_enable_error_creation() {
-  gpr_atm_no_barrier_store(&g_error_creation_allowed, true);
-}
-
 absl::Status grpc_status_create(absl::StatusCode code, absl::string_view msg,
                                 const grpc_core::DebugLocation& location,
                                 size_t children_count, absl::Status* children) {
@@ -61,17 +54,14 @@ absl::Status grpc_status_create(absl::StatusCode code, absl::string_view msg,
   return s;
 }
 
-std::string grpc_error_std_string(absl::Status error) {
-  return grpc_core::StatusToString(error);
-}
-
 absl::Status grpc_os_error(const grpc_core::DebugLocation& location, int err,
                            const char* call_name) {
+  auto err_string = grpc_core::StrError(err);
   absl::Status s =
-      StatusCreate(absl::StatusCode::kUnknown, strerror(err), location, {});
+      StatusCreate(absl::StatusCode::kUnknown, err_string, location, {});
   grpc_core::StatusSetInt(&s, grpc_core::StatusIntProperty::kErrorNo, err);
   grpc_core::StatusSetStr(&s, grpc_core::StatusStrProperty::kOsError,
-                          strerror(err));
+                          err_string);
   grpc_core::StatusSetStr(&s, grpc_core::StatusStrProperty::kSyscall,
                           call_name);
   return s;
@@ -88,32 +78,32 @@ absl::Status grpc_wsa_error(const grpc_core::DebugLocation& location, int err,
                GRPC_STATUS_UNAVAILABLE);
   StatusSetStr(&s, grpc_core::StatusStrProperty::kOsError, utf8_message);
   StatusSetStr(&s, grpc_core::StatusStrProperty::kSyscall, call_name);
+  gpr_free(utf8_message);
   return s;
 }
 #endif
 
 grpc_error_handle grpc_error_set_int(grpc_error_handle src,
-                                     grpc_error_ints which, intptr_t value) {
-  if (GRPC_ERROR_IS_NONE(src)) {
+                                     grpc_core::StatusIntProperty which,
+                                     intptr_t value) {
+  if (src.ok()) {
     src = absl::UnknownError("");
     StatusSetInt(&src, grpc_core::StatusIntProperty::kRpcStatus,
                  GRPC_STATUS_OK);
   }
-  grpc_core::StatusSetInt(
-      &src, static_cast<grpc_core::StatusIntProperty>(which), value);
+  grpc_core::StatusSetInt(&src, which, value);
   return src;
 }
 
-bool grpc_error_get_int(grpc_error_handle error, grpc_error_ints which,
-                        intptr_t* p) {
-  absl::optional<intptr_t> value = grpc_core::StatusGetInt(
-      error, static_cast<grpc_core::StatusIntProperty>(which));
+bool grpc_error_get_int(grpc_error_handle error,
+                        grpc_core::StatusIntProperty which, intptr_t* p) {
+  absl::optional<intptr_t> value = grpc_core::StatusGetInt(error, which);
   if (value.has_value()) {
     *p = *value;
     return true;
   } else {
     // TODO(veblush): Remove this once absl::Status migration is done
-    if (which == GRPC_ERROR_INT_GRPC_STATUS) {
+    if (which == grpc_core::StatusIntProperty::kRpcStatus) {
       switch (error.code()) {
         case absl::StatusCode::kOk:
           *p = GRPC_STATUS_OK;
@@ -133,14 +123,14 @@ 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,
+                                     grpc_core::StatusStrProperty which,
                                      absl::string_view str) {
-  if (GRPC_ERROR_IS_NONE(src)) {
+  if (src.ok()) {
     src = absl::UnknownError("");
     StatusSetInt(&src, grpc_core::StatusIntProperty::kRpcStatus,
                  GRPC_STATUS_OK);
   }
-  if (which == GRPC_ERROR_STR_DESCRIPTION) {
+  if (which == grpc_core::StatusStrProperty::kDescription) {
     // To change the message of absl::Status, a new instance should be created
     // with a code and payload because it doesn't have a setter for it.
     absl::Status s = absl::Status(src.code(), str);
@@ -150,17 +140,16 @@ grpc_error_handle grpc_error_set_str(grpc_error_handle src,
         });
     return s;
   } else {
-    grpc_core::StatusSetStr(
-        &src, static_cast<grpc_core::StatusStrProperty>(which), str);
+    grpc_core::StatusSetStr(&src, which, str);
   }
   return src;
 }
 
-bool grpc_error_get_str(grpc_error_handle error, grpc_error_strs which,
-                        std::string* s) {
-  if (which == GRPC_ERROR_STR_DESCRIPTION) {
-    // absl::Status uses the message field for GRPC_ERROR_STR_DESCRIPTION
-    // instead of using payload.
+bool grpc_error_get_str(grpc_error_handle error,
+                        grpc_core::StatusStrProperty which, std::string* s) {
+  if (which == grpc_core::StatusStrProperty::kDescription) {
+    // absl::Status uses the message field for
+    // grpc_core::StatusStrProperty::kDescription instead of using payload.
     absl::string_view msg = error.message();
     if (msg.empty()) {
       return false;
@@ -169,21 +158,17 @@ bool grpc_error_get_str(grpc_error_handle error, grpc_error_strs which,
       return true;
     }
   } else {
-    absl::optional<std::string> value = grpc_core::StatusGetStr(
-        error, static_cast<grpc_core::StatusStrProperty>(which));
+    absl::optional<std::string> value = grpc_core::StatusGetStr(error, which);
     if (value.has_value()) {
       *s = std::move(*value);
       return true;
     } else {
       // TODO(veblush): Remove this once absl::Status migration is done
-      if (which == GRPC_ERROR_STR_GRPC_MESSAGE) {
+      if (which == grpc_core::StatusStrProperty::kGrpcMessage) {
         switch (error.code()) {
           case absl::StatusCode::kOk:
             *s = "";
             return true;
-          case absl::StatusCode::kResourceExhausted:
-            *s = "RESOURCE_EXHAUSTED";
-            return true;
           case absl::StatusCode::kCancelled:
             *s = "CANCELLED";
             return true;
@@ -210,7 +195,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(!GRPC_ERROR_IS_NONE(error));
+  GPR_DEBUG_ASSERT(!error.ok());
   gpr_log(file, line, GPR_LOG_SEVERITY_ERROR, "%s: %s", what,
           grpc_core::StatusToString(error).c_str());
   return false;