Added GRPC_ERROR_IS_NONE (#29937 An error occurred )

* Added GRPC_ERROR_IS_NONE

* Convert

* Fix

src/core/ext/filters/channel_idle/channel_idle_filter.cc

@@ -216,7 +216,7 @@ ArenaPromise<ServerMetadataHandle> ChannelIdleFilter::MakeCallPromise(
 
 bool ChannelIdleFilter::StartTransportOp(grpc_transport_op* op) {
   // Catch the disconnect_with_error transport op.
-  if (op->disconnect_with_error != GRPC_ERROR_NONE) Shutdown();
+  if (!GRPC_ERROR_IS_NONE(op->disconnect_with_error)) Shutdown();
   // Pass the op to the next filter.
   return false;
 }

src/core/ext/filters/client_channel/backup_poller.cc

@@ -117,7 +117,7 @@ static void g_poller_unref() {
 
 static void run_poller(void* arg, grpc_error_handle error) {
   backup_poller* p = static_cast<backup_poller*>(arg);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     if (error != GRPC_ERROR_CANCELLED) {
       GRPC_LOG_IF_ERROR("run_poller", GRPC_ERROR_REF(error));
     }

src/core/ext/filters/client_channel/channel_connectivity.cc

@@ -179,7 +179,7 @@ class StateWatcher : public DualRefCounted<StateWatcher> {
 
   static void TimeoutComplete(void* arg, grpc_error_handle error) {
     auto* self = static_cast<StateWatcher*>(arg);
-    self->timer_fired_ = error == GRPC_ERROR_NONE;
+    self->timer_fired_ = GRPC_ERROR_IS_NONE(error);
     // If this is a client channel (not a lame channel), cancel the watch.
     ClientChannel* client_channel =
         ClientChannel::GetFromChannel(self->channel_.get());

src/core/ext/filters/client_channel/client_channel.cc

@@ -954,7 +954,7 @@ class ClientChannel::ClientChannelControlHelper
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     if (chand_->resolver_ == nullptr) return;  // Shutting down.
     if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-      const char* extra = chand_->disconnect_error_ == GRPC_ERROR_NONE
+      const char* extra = GRPC_ERROR_IS_NONE(chand_->disconnect_error_)
                               ? ""
                               : " (ignoring -- channel shutting down)";
       gpr_log(GPR_INFO, "chand=%p: update: state=%s status=(%s) picker=%p%s",
@@ -962,7 +962,7 @@ class ClientChannel::ClientChannelControlHelper
               picker.get(), extra);
     }
     // Do update only if not shutting down.
-    if (chand_->disconnect_error_ == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(chand_->disconnect_error_)) {
       chand_->UpdateStateAndPickerLocked(state, status, "helper",
                                          std::move(picker));
     }
@@ -1080,7 +1080,7 @@ ClientChannel::ClientChannel(grpc_channel_element_args* args,
   *error = GRPC_ERROR_NONE;
   default_service_config_ =
       ServiceConfigImpl::Create(args->channel_args, service_config_json, error);
-  if (*error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(*error)) {
     default_service_config_.reset();
     return;
   }
@@ -1213,7 +1213,7 @@ RefCountedPtr<LoadBalancingPolicy::Config> ChooseLbPolicy(
   //   and accepts an empty config. If not, we revert to using pick_first
   //   lb_policy
   GPR_ASSERT(lb_policy_config != nullptr);
-  GPR_ASSERT(parse_error == GRPC_ERROR_NONE);
+  GPR_ASSERT(GRPC_ERROR_IS_NONE(parse_error));
   return lb_policy_config;
 }
 
@@ -1736,7 +1736,7 @@ void ClientChannel::StartTransportOpLocked(grpc_transport_op* op) {
   // Ping.
   if (op->send_ping.on_initiate != nullptr || op->send_ping.on_ack != nullptr) {
     grpc_error_handle error = DoPingLocked(op);
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
       ExecCtx::Run(DEBUG_LOCATION, op->send_ping.on_initiate,
                    GRPC_ERROR_REF(error));
       ExecCtx::Run(DEBUG_LOCATION, op->send_ping.on_ack, error);
@@ -1752,7 +1752,7 @@ void ClientChannel::StartTransportOpLocked(grpc_transport_op* op) {
     }
   }
   // Disconnect or enter IDLE.
-  if (op->disconnect_with_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(op->disconnect_with_error)) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
       gpr_log(GPR_INFO, "chand=%p: disconnect_with_error: %s", this,
               grpc_error_std_string(op->disconnect_with_error).c_str());
@@ -1762,7 +1762,7 @@ void ClientChannel::StartTransportOpLocked(grpc_transport_op* op) {
     if (grpc_error_get_int(op->disconnect_with_error,
                            GRPC_ERROR_INT_CHANNEL_CONNECTIVITY_STATE, &value) &&
         static_cast<grpc_connectivity_state>(value) == GRPC_CHANNEL_IDLE) {
-      if (disconnect_error_ == GRPC_ERROR_NONE) {
+      if (GRPC_ERROR_IS_NONE(disconnect_error_)) {
         // Enter IDLE state.
         UpdateStateAndPickerLocked(GRPC_CHANNEL_IDLE, absl::Status(),
                                    "channel entering IDLE", nullptr);
@@ -1770,7 +1770,7 @@ void ClientChannel::StartTransportOpLocked(grpc_transport_op* op) {
       GRPC_ERROR_UNREF(op->disconnect_with_error);
     } else {
       // Disconnect.
-      GPR_ASSERT(disconnect_error_ == GRPC_ERROR_NONE);
+      GPR_ASSERT(GRPC_ERROR_IS_NONE(disconnect_error_));
       disconnect_error_ = op->disconnect_with_error;
       UpdateStateAndPickerLocked(
           GRPC_CHANNEL_SHUTDOWN, absl::Status(), "shutdown from API",
@@ -1965,7 +1965,7 @@ void ClientChannel::CallData::StartTransportStreamOpBatch(
   // We do not yet have a dynamic call.
   //
   // If we've previously been cancelled, immediately fail any new batches.
-  if (GPR_UNLIKELY(calld->cancel_error_ != GRPC_ERROR_NONE)) {
+  if (GPR_UNLIKELY(!GRPC_ERROR_IS_NONE(calld->cancel_error_))) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
       gpr_log(GPR_INFO, "chand=%p calld=%p: failing batch with error: %s",
               chand, calld,
@@ -2077,7 +2077,7 @@ void ClientChannel::CallData::FailPendingBatchInCallCombiner(
 void ClientChannel::CallData::PendingBatchesFail(
     grpc_call_element* elem, grpc_error_handle error,
     YieldCallCombinerPredicate yield_call_combiner_predicate) {
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
   if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
     size_t num_batches = 0;
     for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
@@ -2181,7 +2181,8 @@ class ClientChannel::CallData::ResolverQueuedCallCanceller {
                 chand, calld, grpc_error_std_string(error).c_str(), self,
                 calld->resolver_call_canceller_);
       }
-      if (calld->resolver_call_canceller_ == self && error != GRPC_ERROR_NONE) {
+      if (calld->resolver_call_canceller_ == self &&
+          !GRPC_ERROR_IS_NONE(error)) {
         // Remove pick from list of queued picks.
         calld->MaybeRemoveCallFromResolverQueuedCallsLocked(self->elem_);
         // Fail pending batches on the call.
@@ -2239,7 +2240,7 @@ grpc_error_handle ClientChannel::CallData::ApplyServiceConfigToCallLocked(
     // Use the ConfigSelector to determine the config for the call.
     ConfigSelector::CallConfig call_config =
         config_selector->GetCallConfig({&path_, initial_metadata, arena_});
-    if (call_config.error != GRPC_ERROR_NONE) return call_config.error;
+    if (!GRPC_ERROR_IS_NONE(call_config.error)) return call_config.error;
     // Create a ClientChannelServiceConfigCallData for the call.  This stores
     // a ref to the ServiceConfig and caches the right set of parsed configs
     // to use for the call.  The ClientChannelServiceConfigCallData will store
@@ -2324,7 +2325,7 @@ void ClientChannel::CallData::ResolutionDone(void* arg,
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   ClientChannel* chand = static_cast<ClientChannel*>(elem->channel_data);
   CallData* calld = static_cast<CallData*>(elem->call_data);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
       gpr_log(GPR_INFO,
               "chand=%p calld=%p: error applying config to call: error=%s",
@@ -2443,7 +2444,7 @@ void ClientChannel::CallData::CreateDynamicCall(grpc_call_element* elem) {
         chand, this, channel_stack);
   }
   dynamic_call_ = channel_stack->CreateCall(std::move(args), &error);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
       gpr_log(GPR_INFO,
               "chand=%p calld=%p: failed to create dynamic call: error=%s",
@@ -2703,7 +2704,7 @@ void ClientChannel::LoadBalancedCall::FailPendingBatchInCallCombiner(
 void ClientChannel::LoadBalancedCall::PendingBatchesFail(
     grpc_error_handle error,
     YieldCallCombinerPredicate yield_call_combiner_predicate) {
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
   GRPC_ERROR_UNREF(failure_error_);
   failure_error_ = error;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
@@ -2859,7 +2860,7 @@ void ClientChannel::LoadBalancedCall::StartTransportStreamOpBatch(
   // We do not yet have a subchannel call.
   //
   // If we've previously been cancelled, immediately fail any new batches.
-  if (GPR_UNLIKELY(cancel_error_ != GRPC_ERROR_NONE)) {
+  if (GPR_UNLIKELY(!GRPC_ERROR_IS_NONE(cancel_error_))) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
       gpr_log(GPR_INFO, "chand=%p lb_call=%p: failing batch with error: %s",
               chand_, this, grpc_error_std_string(cancel_error_).c_str());
@@ -2936,7 +2937,7 @@ void ClientChannel::LoadBalancedCall::RecvInitialMetadataReady(
             "chand=%p lb_call=%p: got recv_initial_metadata_ready: error=%s",
             self->chand_, self, grpc_error_std_string(error).c_str());
   }
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     // recv_initial_metadata_flags is not populated for clients
     self->call_attempt_tracer_->RecordReceivedInitialMetadata(
         self->recv_initial_metadata_, 0 /* recv_initial_metadata_flags */);
@@ -2976,7 +2977,7 @@ void ClientChannel::LoadBalancedCall::RecvTrailingMetadataReady(
       self->lb_subchannel_call_tracker_ != nullptr) {
     // Get the call's status.
     absl::Status status;
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
       // Get status from error.
       grpc_status_code code;
       std::string message;
@@ -2999,7 +3000,7 @@ void ClientChannel::LoadBalancedCall::RecvTrailingMetadataReady(
     self->RecordCallCompletion(status);
   }
   // Chain to original callback.
-  if (self->failure_error_ != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(self->failure_error_)) {
     error = self->failure_error_;
     self->failure_error_ = GRPC_ERROR_NONE;
   } else {
@@ -3046,7 +3047,7 @@ void ClientChannel::LoadBalancedCall::CreateSubchannelCall() {
     subchannel_call_->SetAfterCallStackDestroy(on_call_destruction_complete_);
     on_call_destruction_complete_ = nullptr;
   }
-  if (GPR_UNLIKELY(error != GRPC_ERROR_NONE)) {
+  if (GPR_UNLIKELY(!GRPC_ERROR_IS_NONE(error))) {
     PendingBatchesFail(error, YieldCallCombiner);
   } else {
     PendingBatchesResume();
@@ -3083,7 +3084,7 @@ class ClientChannel::LoadBalancedCall::LbQueuedCallCanceller {
                 chand, lb_call, grpc_error_std_string(error).c_str(), self,
                 lb_call->lb_call_canceller_);
       }
-      if (lb_call->lb_call_canceller_ == self && error != GRPC_ERROR_NONE) {
+      if (lb_call->lb_call_canceller_ == self && !GRPC_ERROR_IS_NONE(error)) {
         lb_call->call_dispatch_controller_->Commit();
         // Remove pick from list of queued picks.
         lb_call->MaybeRemoveCallFromLbQueuedCallsLocked();
@@ -3134,7 +3135,7 @@ void ClientChannel::LoadBalancedCall::AsyncPickDone(grpc_error_handle error) {
 void ClientChannel::LoadBalancedCall::PickDone(void* arg,
                                                grpc_error_handle error) {
   auto* self = static_cast<LoadBalancedCall*>(arg);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
       gpr_log(GPR_INFO,
               "chand=%p lb_call=%p: failed to pick subchannel: error=%s",

src/core/ext/filters/client_channel/dynamic_filters.cc

@@ -63,7 +63,7 @@ DynamicFilters::Call::Call(Args args, grpc_error_handle* error)
   };
   *error = grpc_call_stack_init(channel_stack_->channel_stack_, 1, Destroy,
                                 this, &call_args);
-  if (GPR_UNLIKELY(*error != GRPC_ERROR_NONE)) {
+  if (GPR_UNLIKELY(!GRPC_ERROR_IS_NONE(*error))) {
     gpr_log(GPR_ERROR, "error: %s", grpc_error_std_string(*error).c_str());
     return;
   }
@@ -152,7 +152,7 @@ std::pair<grpc_channel_stack*, grpc_error_handle> CreateChannelStack(
   grpc_error_handle error = grpc_channel_stack_init(
       /*initial_refs=*/1, DestroyChannelStack, channel_stack, filters.data(),
       filters.size(), args, "DynamicFilters", channel_stack);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_ERROR, "error initializing client internal stack: %s",
             grpc_error_std_string(error).c_str());
     grpc_channel_stack_destroy(channel_stack);
@@ -169,7 +169,7 @@ RefCountedPtr<DynamicFilters> DynamicFilters::Create(
     std::vector<const grpc_channel_filter*> filters) {
   // Attempt to create channel stack from requested filters.
   auto p = CreateChannelStack(args, std::move(filters));
-  if (p.second != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(p.second)) {
     // Channel stack creation failed with requested filters.
     // Create with lame filter instead.
     grpc_error_handle error = p.second;
@@ -178,7 +178,7 @@ RefCountedPtr<DynamicFilters> DynamicFilters::Create(
         grpc_channel_args_copy_and_add(args, &error_arg, 1);
     GRPC_ERROR_UNREF(error);
     p = CreateChannelStack(new_args, {&LameClientFilter::kFilter});
-    GPR_ASSERT(p.second == GRPC_ERROR_NONE);
+    GPR_ASSERT(GRPC_ERROR_IS_NONE(p.second));
     grpc_channel_args_destroy(new_args);
   }
   return MakeRefCounted<DynamicFilters>(p.first);

src/core/ext/filters/client_channel/lb_policy/grpclb/client_load_reporting_filter.cc

@@ -61,7 +61,7 @@ struct call_data {
 
 static void on_complete_for_send(void* arg, grpc_error_handle error) {
   call_data* calld = static_cast<call_data*>(arg);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     calld->send_initial_metadata_succeeded = true;
   }
   grpc_core::Closure::Run(DEBUG_LOCATION, calld->original_on_complete_for_send,
@@ -70,7 +70,7 @@ static void on_complete_for_send(void* arg, grpc_error_handle error) {
 
 static void recv_initial_metadata_ready(void* arg, grpc_error_handle error) {
   call_data* calld = static_cast<call_data*>(arg);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     calld->recv_initial_metadata_succeeded = true;
   }
   grpc_core::Closure::Run(DEBUG_LOCATION,

src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb.cc

@@ -1089,7 +1089,7 @@ void GrpcLb::BalancerCallState::ClientLoadReportDoneLocked(
     grpc_error_handle error) {
   grpc_byte_buffer_destroy(send_message_payload_);
   send_message_payload_ = nullptr;
-  if (error != GRPC_ERROR_NONE || this != grpclb_policy()->lb_calld_.get()) {
+  if (!GRPC_ERROR_IS_NONE(error) || this != grpclb_policy()->lb_calld_.get()) {
     Unref(DEBUG_LOCATION, "client_load_report");
     GRPC_ERROR_UNREF(error);
     return;
@@ -1675,7 +1675,7 @@ void GrpcLb::OnBalancerCallRetryTimer(void* arg, grpc_error_handle error) {
 
 void GrpcLb::OnBalancerCallRetryTimerLocked(grpc_error_handle error) {
   retry_timer_callback_pending_ = false;
-  if (!shutting_down_ && error == GRPC_ERROR_NONE && lb_calld_ == nullptr) {
+  if (!shutting_down_ && GRPC_ERROR_IS_NONE(error) && lb_calld_ == nullptr) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_glb_trace)) {
       gpr_log(GPR_INFO, "[grpclb %p] Restarting call to LB server", this);
     }
@@ -1719,7 +1719,7 @@ void GrpcLb::OnFallbackTimerLocked(grpc_error_handle error) {
   // If we receive a serverlist after the timer fires but before this callback
   // actually runs, don't fall back.
   if (fallback_at_startup_checks_pending_ && !shutting_down_ &&
-      error == GRPC_ERROR_NONE) {
+      GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_INFO,
             "[grpclb %p] No response from balancer after fallback timeout; "
             "entering fallback mode",
@@ -1840,7 +1840,7 @@ void GrpcLb::OnSubchannelCacheTimer(void* arg, grpc_error_handle error) {
 }
 
 void GrpcLb::OnSubchannelCacheTimerLocked(grpc_error_handle error) {
-  if (subchannel_cache_timer_pending_ && error == GRPC_ERROR_NONE) {
+  if (subchannel_cache_timer_pending_ && GRPC_ERROR_IS_NONE(error)) {
     auto it = cached_subchannels_.begin();
     if (it != cached_subchannels_.end()) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_glb_trace)) {
@@ -1875,7 +1875,7 @@ class GrpcLbFactory : public LoadBalancingPolicyFactory {
 
   RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
       const Json& json, grpc_error_handle* error) const override {
-    GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+    GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
     if (json.type() == Json::Type::JSON_NULL) {
       return MakeRefCounted<GrpcLbConfig>(nullptr, "");
     }
@@ -1906,7 +1906,7 @@ class GrpcLbFactory : public LoadBalancingPolicyFactory {
     RefCountedPtr<LoadBalancingPolicy::Config> child_policy_config =
         LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
             *child_policy_config_json, &parse_error);
-    if (parse_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(parse_error)) {
       std::vector<grpc_error_handle> child_errors;
       child_errors.push_back(parse_error);
       error_list.push_back(

src/core/ext/filters/client_channel/lb_policy/outlier_detection/outlier_detection.cc

@@ -784,7 +784,7 @@ void OutlierDetectionLb::EjectionTimer::OnTimer(void* arg,
 }
 
 void OutlierDetectionLb::EjectionTimer::OnTimerLocked(grpc_error_handle error) {
-  if (error == GRPC_ERROR_NONE && timer_pending_) {
+  if (GRPC_ERROR_IS_NONE(error) && timer_pending_) {
     std::map<SubchannelState*, double> success_rate_ejection_candidates;
     std::map<SubchannelState*, double> failure_percentage_ejection_candidates;
     size_t ejected_host_count = 0;
@@ -917,7 +917,7 @@ class OutlierDetectionLbFactory : public LoadBalancingPolicyFactory {
 
   RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
       const Json& json, grpc_error_handle* error) const override {
-    GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+    GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
     if (json.type() == Json::Type::JSON_NULL) {
       // This policy was configured in the deprecated loadBalancingPolicy
       // field or in the client API.
@@ -1001,7 +1001,7 @@ class OutlierDetectionLbFactory : public LoadBalancingPolicyFactory {
       child_policy = LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
           it->second, &parse_error);
       if (child_policy == nullptr) {
-        GPR_DEBUG_ASSERT(parse_error != GRPC_ERROR_NONE);
+        GPR_DEBUG_ASSERT(!GRPC_ERROR_IS_NONE(parse_error));
         std::vector<grpc_error_handle> child_errors;
         child_errors.push_back(parse_error);
         error_list.push_back(

src/core/ext/filters/client_channel/lb_policy/priority/priority.cc

@@ -646,7 +646,7 @@ void PriorityLb::ChildPriority::DeactivationTimer::OnTimer(
 
 void PriorityLb::ChildPriority::DeactivationTimer::OnTimerLocked(
     grpc_error_handle error) {
-  if (error == GRPC_ERROR_NONE && timer_pending_) {
+  if (GRPC_ERROR_IS_NONE(error) && timer_pending_) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_priority_trace)) {
       gpr_log(GPR_INFO,
               "[priority_lb %p] child %s (%p): deactivation timer fired, "
@@ -710,7 +710,7 @@ void PriorityLb::ChildPriority::FailoverTimer::OnTimer(
 
 void PriorityLb::ChildPriority::FailoverTimer::OnTimerLocked(
     grpc_error_handle error) {
-  if (error == GRPC_ERROR_NONE && timer_pending_) {
+  if (GRPC_ERROR_IS_NONE(error) && timer_pending_) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_priority_trace)) {
       gpr_log(GPR_INFO,
               "[priority_lb %p] child %s (%p): failover timer fired, "
@@ -933,7 +933,7 @@ class PriorityLbFactory : public LoadBalancingPolicyFactory {
 
   RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
       const Json& json, grpc_error_handle* error) const override {
-    GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+    GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
     if (json.type() == Json::Type::JSON_NULL) {
       // priority was mentioned as a policy in the deprecated
       // loadBalancingPolicy field or in the client API.
@@ -988,7 +988,7 @@ class PriorityLbFactory : public LoadBalancingPolicyFactory {
               }
             }
             if (config == nullptr) {
-              GPR_DEBUG_ASSERT(parse_error != GRPC_ERROR_NONE);
+              GPR_DEBUG_ASSERT(!GRPC_ERROR_IS_NONE(parse_error));
               error_list.push_back(
                   GRPC_ERROR_CREATE_REFERENCING_FROM_COPIED_STRING(
                       absl::StrCat("field:children key:", child_name).c_str(),

src/core/ext/filters/client_channel/lb_policy/rls/rls.cc

@@ -783,7 +783,7 @@ void RlsLb::ChildPolicyWrapper::StartUpdate() {
   grpc_error_handle error = InsertOrUpdateChildPolicyField(
       lb_policy_->config_->child_policy_config_target_field_name(), target_,
       &child_policy_config);
-  GPR_ASSERT(error == GRPC_ERROR_NONE);
+  GPR_ASSERT(GRPC_ERROR_IS_NONE(error));
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(
         GPR_INFO,
@@ -794,7 +794,7 @@ void RlsLb::ChildPolicyWrapper::StartUpdate() {
   pending_config_ = LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
       child_policy_config, &error);
   // Returned RLS target fails the validation.
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
       gpr_log(GPR_INFO,
               "[rlslb %p] ChildPolicyWrapper=%p [%s]: config failed to parse: "
@@ -1777,7 +1777,7 @@ void RlsLb::RlsRequest::OnRlsCallCompleteLocked(grpc_error_handle error) {
   }
   // Parse response.
   ResponseInfo response;
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_status_code code;
     std::string message;
     grpc_error_get_status(error, deadline_, &code, &message,
@@ -2231,7 +2231,7 @@ grpc_error_handle ParseGrpcKeybuilder(
         grpc_error_handle child_error = GRPC_ERROR_NONE;
         std::string name =
             ParseJsonMethodName(name_idx++, name_json, &child_error);
-        if (child_error != GRPC_ERROR_NONE) {
+        if (!GRPC_ERROR_IS_NONE(child_error)) {
           error_list.push_back(child_error);
         } else {
           bool inserted = names.insert(name).second;
@@ -2267,7 +2267,7 @@ grpc_error_handle ParseGrpcKeybuilder(
       std::vector<std::string> headers;
       grpc_error_handle child_error =
           ParseJsonHeaders(header_idx++, header_json, &key, &headers);
-      if (child_error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(child_error)) {
         error_list.push_back(child_error);
       } else {
         duplicate_key_check_func(key);
@@ -2360,7 +2360,7 @@ RlsLbConfig::KeyBuilderMap ParseGrpcKeybuilders(
   for (const Json& key_builder : key_builder_list) {
     grpc_error_handle child_error =
         ParseGrpcKeybuilder(idx++, key_builder, &key_builder_map);
-    if (child_error != GRPC_ERROR_NONE) error_list.push_back(child_error);
+    if (!GRPC_ERROR_IS_NONE(child_error)) error_list.push_back(child_error);
   }
   *error = GRPC_ERROR_CREATE_FROM_VECTOR("field:grpcKeybuilders", &error_list);
   return key_builder_map;
@@ -2377,7 +2377,7 @@ RlsLbConfig::RouteLookupConfig ParseRouteLookupConfig(
     grpc_error_handle child_error = GRPC_ERROR_NONE;
     route_lookup_config.key_builder_map =
         ParseGrpcKeybuilders(*keybuilder_list, &child_error);
-    if (child_error != GRPC_ERROR_NONE) error_list.push_back(child_error);
+    if (!GRPC_ERROR_IS_NONE(child_error)) error_list.push_back(child_error);
   }
   // Parse lookupService.
   if (ParseJsonObjectField(json, "lookupService",
@@ -2453,12 +2453,12 @@ grpc_error_handle ValidateChildPolicyList(
       default_target.empty() ? kFakeTargetFieldValue : default_target;
   grpc_error_handle error = InsertOrUpdateChildPolicyField(
       child_policy_config_target_field_name, target, child_policy_config);
-  if (error != GRPC_ERROR_NONE) return error;
+  if (!GRPC_ERROR_IS_NONE(error)) return error;
   // Parse the config.
   RefCountedPtr<LoadBalancingPolicy::Config> parsed_config =
       LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
           *child_policy_config, &error);
-  if (error != GRPC_ERROR_NONE) return error;
+  if (!GRPC_ERROR_IS_NONE(error)) return error;
   // Find the chosen config and return it in JSON form.
   // We remove all non-selected configs, and in the selected config, we leave
   // the target field in place, set to the default value.  This slightly
@@ -2501,7 +2501,7 @@ class RlsLbFactory : public LoadBalancingPolicyFactory {
       grpc_error_handle child_error = GRPC_ERROR_NONE;
       route_lookup_config =
           ParseRouteLookupConfig(*route_lookup_config_json, &child_error);
-      if (child_error != GRPC_ERROR_NONE) error_list.push_back(child_error);
+      if (!GRPC_ERROR_IS_NONE(child_error)) error_list.push_back(child_error);
     }
     // Parse routeLookupChannelServiceConfig.
     std::string rls_channel_service_config;
@@ -2517,7 +2517,7 @@ class RlsLbFactory : public LoadBalancingPolicyFactory {
       auto service_config = MakeRefCounted<ServiceConfigImpl>(
           /*args=*/nullptr, rls_channel_service_config,
           std::move(rls_channel_service_config_json), &child_error);
-      if (child_error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(child_error)) {
         error_list.push_back(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
             "field:routeLookupChannelServiceConfig", &child_error, 1));
         GRPC_ERROR_UNREF(child_error);
@@ -2549,7 +2549,7 @@ class RlsLbFactory : public LoadBalancingPolicyFactory {
           it->second, child_policy_config_target_field_name,
           route_lookup_config.default_target, &child_policy_config,
           &default_child_policy_parsed_config);
-      if (child_error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(child_error)) {
         error_list.push_back(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
             "field:childPolicy", &child_error, 1));
         GRPC_ERROR_UNREF(child_error);

src/core/ext/filters/client_channel/lb_policy/weighted_target/weighted_target.cc

@@ -476,7 +476,7 @@ void WeightedTargetLb::WeightedChild::DelayedRemovalTimer::OnTimer(
 
 void WeightedTargetLb::WeightedChild::DelayedRemovalTimer::OnTimerLocked(
     grpc_error_handle error) {
-  if (error == GRPC_ERROR_NONE && timer_pending_) {
+  if (GRPC_ERROR_IS_NONE(error) && timer_pending_) {
     timer_pending_ = false;
     weighted_child_->weighted_target_policy_->targets_.erase(
         weighted_child_->name_);
@@ -695,7 +695,7 @@ class WeightedTargetLbFactory : public LoadBalancingPolicyFactory {
 
   RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
       const Json& json, grpc_error_handle* error) const override {
-    GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+    GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
     if (json.type() == Json::Type::JSON_NULL) {
       // weighted_target was mentioned as a policy in the deprecated
       // loadBalancingPolicy field or in the client API.
@@ -773,7 +773,7 @@ class WeightedTargetLbFactory : public LoadBalancingPolicyFactory {
           LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(it->second,
                                                                 &parse_error);
       if (child_config->config == nullptr) {
-        GPR_DEBUG_ASSERT(parse_error != GRPC_ERROR_NONE);
+        GPR_DEBUG_ASSERT(!GRPC_ERROR_IS_NONE(parse_error));
         std::vector<grpc_error_handle> child_errors;
         child_errors.push_back(parse_error);
         error_list.push_back(

src/core/ext/filters/client_channel/lb_policy/xds/cds.cc

@@ -521,7 +521,7 @@ void CdsLb::OnClusterChanged(const std::string& name,
     grpc_error_handle error = GRPC_ERROR_NONE;
     RefCountedPtr<LoadBalancingPolicy::Config> config =
         LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(json, &error);
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
       OnError(name, absl::UnavailableError(grpc_error_std_string(error)));
       GRPC_ERROR_UNREF(error);
       return;
@@ -733,7 +733,7 @@ class CdsLbFactory : public LoadBalancingPolicyFactory {
 
   RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
       const Json& json, grpc_error_handle* error) const override {
-    GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+    GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
     if (json.type() == Json::Type::JSON_NULL) {
       // xds was mentioned as a policy in the deprecated loadBalancingPolicy
       // field or in the client API.

src/core/ext/filters/client_channel/lb_policy/xds/xds_cluster_impl.cc

@@ -708,7 +708,7 @@ class XdsClusterImplLbFactory : public LoadBalancingPolicyFactory {
 
   RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
       const Json& json, grpc_error_handle* error) const override {
-    GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+    GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
     if (json.type() == Json::Type::JSON_NULL) {
       // This policy was configured in the deprecated loadBalancingPolicy
       // field or in the client API.
@@ -730,7 +730,7 @@ class XdsClusterImplLbFactory : public LoadBalancingPolicyFactory {
       child_policy = LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
           it->second, &parse_error);
       if (child_policy == nullptr) {
-        GPR_DEBUG_ASSERT(parse_error != GRPC_ERROR_NONE);
+        GPR_DEBUG_ASSERT(!GRPC_ERROR_IS_NONE(parse_error));
         std::vector<grpc_error_handle> child_errors;
         child_errors.push_back(parse_error);
         error_list.push_back(
@@ -771,7 +771,7 @@ class XdsClusterImplLbFactory : public LoadBalancingPolicyFactory {
         grpc_error_handle parser_error;
         lrs_load_reporting_server = XdsBootstrap::XdsServer::Parse(
             it->second.object_value(), &parser_error);
-        if (parser_error != GRPC_ERROR_NONE) {
+        if (!GRPC_ERROR_IS_NONE(parser_error)) {
           error_list.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
               absl::StrCat("errors parsing lrs_load_reporting_server")));
           error_list.push_back(parser_error);

src/core/ext/filters/client_channel/lb_policy/xds/xds_cluster_manager.cc

@@ -535,7 +535,7 @@ void XdsClusterManagerLb::ClusterChild::OnDelayedRemovalTimer(
 void XdsClusterManagerLb::ClusterChild::OnDelayedRemovalTimerLocked(
     grpc_error_handle error) {
   delayed_removal_timer_callback_pending_ = false;
-  if (error == GRPC_ERROR_NONE && !shutdown_) {
+  if (GRPC_ERROR_IS_NONE(error) && !shutdown_) {
     xds_cluster_manager_policy_->children_.erase(name_);
   }
   Unref(DEBUG_LOCATION, "ClusterChild+timer");
@@ -634,7 +634,7 @@ class XdsClusterManagerLbFactory : public LoadBalancingPolicyFactory {
 
   RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
       const Json& json, grpc_error_handle* error) const override {
-    GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+    GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
     if (json.type() == Json::Type::JSON_NULL) {
       // xds_cluster_manager was mentioned as a policy in the deprecated
       // loadBalancingPolicy field or in the client API.
@@ -705,7 +705,7 @@ class XdsClusterManagerLbFactory : public LoadBalancingPolicyFactory {
       *child_config = LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
           it->second, &parse_error);
       if (*child_config == nullptr) {
-        GPR_DEBUG_ASSERT(parse_error != GRPC_ERROR_NONE);
+        GPR_DEBUG_ASSERT(!GRPC_ERROR_IS_NONE(parse_error));
         std::vector<grpc_error_handle> child_errors;
         child_errors.push_back(parse_error);
         error_list.push_back(

src/core/ext/filters/client_channel/lb_policy/xds/xds_cluster_resolver.cc

@@ -933,7 +933,7 @@ XdsClusterResolverLb::CreateChildPolicyConfigLocked() {
   grpc_error_handle error = GRPC_ERROR_NONE;
   RefCountedPtr<LoadBalancingPolicy::Config> config =
       LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(json, &error);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     // This should never happen, but if it does, we basically have no
     // way to fix it, so we put the channel in TRANSIENT_FAILURE.
     gpr_log(GPR_ERROR,
@@ -1032,7 +1032,7 @@ class XdsClusterResolverLbFactory : public LoadBalancingPolicyFactory {
 
   RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
       const Json& json, grpc_error_handle* error) const override {
-    GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+    GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
     if (json.type() == Json::Type::JSON_NULL) {
       // xds_cluster_resolver was mentioned as a policy in the deprecated
       // loadBalancingPolicy field or in the client API.
@@ -1152,7 +1152,7 @@ class XdsClusterResolverLbFactory : public LoadBalancingPolicyFactory {
         grpc_error_handle parse_error;
         discovery_mechanism->lrs_load_reporting_server.emplace(
             XdsBootstrap::XdsServer::Parse(it->second, &parse_error));
-        if (parse_error != GRPC_ERROR_NONE) {
+        if (!GRPC_ERROR_IS_NONE(parse_error)) {
           error_list.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
               absl::StrCat("errors parsing lrs_load_reporting_server")));
           error_list.push_back(parse_error);

src/core/ext/filters/client_channel/lb_policy_registry.cc

@@ -170,11 +170,11 @@ grpc_error_handle ParseLoadBalancingConfigHelper(
 RefCountedPtr<LoadBalancingPolicy::Config>
 LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
     const Json& json, grpc_error_handle* error) {
-  GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+  GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
   GPR_ASSERT(g_state != nullptr);
   Json::Object::const_iterator policy;
   *error = ParseLoadBalancingConfigHelper(json, &policy);
-  if (*error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(*error)) {
     return nullptr;
   }
   // Find factory.

src/core/ext/filters/client_channel/resolver/binder/binder_resolver.cc

@@ -126,7 +126,7 @@ class BinderResolverFactory : public ResolverFactory {
         return false;
       }
       grpc_error_handle error = BinderAddrPopulate(uri.path(), &addr);
-      if (error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(error)) {
         gpr_log(GPR_ERROR, "%s", grpc_error_std_string(error).c_str());
         GRPC_ERROR_UNREF(error);
         return false;

src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc

@@ -200,7 +200,7 @@ bool ValueInJsonArray(const Json::Array& array, const char* value) {
 std::string ChooseServiceConfig(char* service_config_choice_json,
                                 grpc_error_handle* error) {
   Json json = Json::Parse(service_config_choice_json, error);
-  if (*error != GRPC_ERROR_NONE) return "";
+  if (!GRPC_ERROR_IS_NONE(*error)) return "";
   if (json.type() != Json::Type::ARRAY) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "Service Config Choices, error: should be of type array");
@@ -300,7 +300,7 @@ void AresClientChannelDNSResolver::AresRequestWrapper::OnResolved(
       std::string service_config_string =
           ChooseServiceConfig(service_config_json_, &service_config_error);
       RefCountedPtr<ServiceConfig> service_config;
-      if (service_config_error == GRPC_ERROR_NONE &&
+      if (GRPC_ERROR_IS_NONE(service_config_error) &&
           !service_config_string.empty()) {
         GRPC_CARES_TRACE_LOG("resolver:%p selected service config choice: %s",
                              this, service_config_string.c_str());
@@ -308,7 +308,7 @@ void AresClientChannelDNSResolver::AresRequestWrapper::OnResolved(
                                                    service_config_string,
                                                    &service_config_error);
       }
-      if (service_config_error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(service_config_error)) {
         result.service_config = absl::UnavailableError(
             absl::StrCat("failed to parse service config: ",
                          grpc_error_std_string(service_config_error)));
@@ -438,7 +438,7 @@ class AresDNSResolver : public DNSResolver {
       }
       grpc_pollset_set_del_pollset_set(request->pollset_set_,
                                        request->interested_parties_);
-      if (error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(error)) {
         request->on_resolve_address_done_(grpc_error_to_absl_status(error));
         return;
       }
@@ -563,7 +563,7 @@ void grpc_resolver_dns_ares_init() {
   if (grpc_core::UseAresDnsResolver()) {
     address_sorting_init();
     grpc_error_handle error = grpc_ares_init();
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
       GRPC_LOG_IF_ERROR("grpc_ares_init() failed", error);
       return;
     }

src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver_windows.cc

@@ -435,7 +435,7 @@ class GrpcPolledFdWindows {
     GPR_ASSERT(!connect_done_);
     connect_done_ = true;
     GPR_ASSERT(wsa_connect_error_ == 0);
-    if (error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(error)) {
       DWORD transferred_bytes = 0;
       DWORD flags;
       BOOL wsa_success =
@@ -579,7 +579,7 @@ class GrpcPolledFdWindows {
   // the entire resolution attempt. Doing so will allow the "inject broken
   // nameserver list" test to pass on Windows.
   void OnIocpReadableLocked(grpc_error_handle error) {
-    if (error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(error)) {
       if (winsocket_->read_info.wsa_error != 0) {
         /* WSAEMSGSIZE would be due to receiving more data
          * than our read buffer's fixed capacity. Assume that
@@ -596,7 +596,7 @@ class GrpcPolledFdWindows {
         }
       }
     }
-    if (error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(error)) {
       read_buf_ = grpc_slice_sub_no_ref(
           read_buf_, 0, winsocket_->read_info.bytes_transferred);
       read_buf_has_data_ = true;
@@ -620,7 +620,7 @@ class GrpcPolledFdWindows {
   void OnIocpWriteableLocked(grpc_error_handle error) {
     GRPC_CARES_TRACE_LOG("OnIocpWriteableInner. fd:|%s|", GetName());
     GPR_ASSERT(socket_type_ == SOCK_STREAM);
-    if (error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(error)) {
       if (winsocket_->write_info.wsa_error != 0) {
         error = GRPC_WSA_ERROR(winsocket_->write_info.wsa_error,
                                "OnIocpWriteableInner");
@@ -632,7 +632,7 @@ class GrpcPolledFdWindows {
       }
     }
     GPR_ASSERT(tcp_write_state_ == WRITE_PENDING);
-    if (error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(error)) {
       tcp_write_state_ = WRITE_WAITING_FOR_VERIFICATION_UPON_RETRY;
       write_buf_ = grpc_slice_sub_no_ref(
           write_buf_, 0, winsocket_->write_info.bytes_transferred);

src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.cc

@@ -289,7 +289,7 @@ static void on_timeout(void* arg, grpc_error_handle error) {
       "err=%s",
       driver->request, driver, driver->shutting_down,
       grpc_error_std_string(error).c_str());
-  if (!driver->shutting_down && error == GRPC_ERROR_NONE) {
+  if (!driver->shutting_down && GRPC_ERROR_IS_NONE(error)) {
     grpc_ares_ev_driver_shutdown_locked(driver);
   }
   grpc_ares_ev_driver_unref(driver);
@@ -315,7 +315,7 @@ static void on_ares_backup_poll_alarm(void* arg, grpc_error_handle error) {
       "err=%s",
       driver->request, driver, driver->shutting_down,
       grpc_error_std_string(error).c_str());
-  if (!driver->shutting_down && error == GRPC_ERROR_NONE) {
+  if (!driver->shutting_down && GRPC_ERROR_IS_NONE(error)) {
     fd_node* fdn = driver->fds;
     while (fdn != nullptr) {
       if (!fdn->already_shutdown) {
@@ -357,7 +357,7 @@ static void on_readable(void* arg, grpc_error_handle error) {
   fdn->readable_registered = false;
   GRPC_CARES_TRACE_LOG("request:%p readable on %s", fdn->ev_driver->request,
                        fdn->grpc_polled_fd->GetName());
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     do {
       ares_process_fd(ev_driver->channel, as, ARES_SOCKET_BAD);
     } while (fdn->grpc_polled_fd->IsFdStillReadableLocked());
@@ -383,7 +383,7 @@ static void on_writable(void* arg, grpc_error_handle error) {
   fdn->writable_registered = false;
   GRPC_CARES_TRACE_LOG("request:%p writable on %s", ev_driver->request,
                        fdn->grpc_polled_fd->GetName());
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     ares_process_fd(ev_driver->channel, ARES_SOCKET_BAD, as);
   } else {
     // If error is not GRPC_ERROR_NONE, it means the fd has been shutdown or
@@ -848,7 +848,7 @@ void grpc_dns_lookup_ares_continue_after_check_localhost_and_ip_literals_locked(
   }
   error = grpc_ares_ev_driver_create_locked(&r->ev_driver, interested_parties,
                                             query_timeout_ms, r);
-  if (error != GRPC_ERROR_NONE) goto error_cleanup;
+  if (!GRPC_ERROR_IS_NONE(error)) goto error_cleanup;
   // If dns_server is specified, use it.
   if (dns_server != nullptr && dns_server[0] != '\0') {
     GRPC_CARES_TRACE_LOG("request:%p Using DNS server %s", r, dns_server);

src/core/ext/filters/client_channel/resolver/google_c2p/google_c2p_resolver.cc

@@ -215,7 +215,7 @@ void GoogleCloud2ProdResolver::ZoneQuery::OnDone(
     GoogleCloud2ProdResolver* resolver, const grpc_http_response* response,
     grpc_error_handle error) {
   absl::StatusOr<std::string> zone;
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     zone = absl::UnknownError(
         absl::StrCat("error fetching zone from metadata server: ",
                      grpc_error_std_string(error)));
@@ -256,11 +256,11 @@ GoogleCloud2ProdResolver::IPv6Query::IPv6Query(
 void GoogleCloud2ProdResolver::IPv6Query::OnDone(
     GoogleCloud2ProdResolver* resolver, const grpc_http_response* response,
     grpc_error_handle error) {
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_ERROR, "error fetching IPv6 address from metadata server: %s",
             grpc_error_std_string(error).c_str());
   }
-  resolver->IPv6QueryDone(error == GRPC_ERROR_NONE && response->status == 200);
+  resolver->IPv6QueryDone(GRPC_ERROR_IS_NONE(error) && response->status == 200);
   GRPC_ERROR_UNREF(error);
 }
 

src/core/ext/filters/client_channel/resolver/polling_resolver.cc

@@ -107,7 +107,7 @@ void PollingResolver::OnNextResolutionLocked(grpc_error_handle error) {
             this, grpc_error_std_string(error).c_str(), shutdown_);
   }
   have_next_resolution_timer_ = false;
-  if (error == GRPC_ERROR_NONE && !shutdown_) {
+  if (GRPC_ERROR_IS_NONE(error) && !shutdown_) {
     StartResolvingLocked();
   }
   Unref(DEBUG_LOCATION, "retry-timer");

src/core/ext/filters/client_channel/resolver/xds/xds_resolver.cc

@@ -492,7 +492,7 @@ XdsResolver::XdsConfigSelector::XdsConfigSelector(
           Route::ClusterWeightState cluster_weight_state;
           *error = CreateMethodConfig(route_entry.route, &weighted_cluster,
                                       &cluster_weight_state.method_config);
-          if (*error != GRPC_ERROR_NONE) return;
+          if (!GRPC_ERROR_IS_NONE(*error)) return;
           end += weighted_cluster.weight;
           cluster_weight_state.range_end = end;
           cluster_weight_state.cluster = weighted_cluster.name;
@@ -596,7 +596,7 @@ grpc_error_handle XdsResolver::XdsConfigSelector::CreateMethodConfig(
           resolver_->current_listener_.http_connection_manager.http_filters,
           resolver_->current_virtual_host_, route, cluster_weight,
           grpc_channel_args_copy(resolver_->args_));
-  if (result.error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(result.error)) {
     return result.error;
   }
   for (const auto& p : result.per_filter_configs) {
@@ -788,7 +788,7 @@ ConfigSelector::CallConfig XdsResolver::XdsConfigSelector::GetCallConfig(
 void XdsResolver::StartLocked() {
   grpc_error_handle error = GRPC_ERROR_NONE;
   xds_client_ = XdsClient::GetOrCreate(args_, &error);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_ERROR,
             "Failed to create xds client -- channel will remain in "
             "TRANSIENT_FAILURE: %s",
@@ -1036,7 +1036,7 @@ XdsResolver::CreateServiceConfig() {
   grpc_error_handle error = GRPC_ERROR_NONE;
   absl::StatusOr<RefCountedPtr<ServiceConfig>> result =
       ServiceConfigImpl::Create(args_, json.c_str(), &error);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     result = grpc_error_to_absl_status(error);
     GRPC_ERROR_UNREF(error);
   }
@@ -1049,7 +1049,7 @@ void XdsResolver::GenerateResult() {
   // state map, and then CreateServiceConfig for LB policies.
   grpc_error_handle error = GRPC_ERROR_NONE;
   auto config_selector = MakeRefCounted<XdsConfigSelector>(Ref(), &error);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     OnError("could not create ConfigSelector",
             absl::UnavailableError(grpc_error_std_string(error)));
     GRPC_ERROR_UNREF(error);

src/core/ext/filters/client_channel/resolver_result_parsing.cc

@@ -54,7 +54,7 @@ namespace {
 
 absl::optional<std::string> ParseHealthCheckConfig(const Json& field,
                                                    grpc_error_handle* error) {
-  GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+  GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
   if (field.type() != Json::Type::OBJECT) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "field:healthCheckConfig error:should be of type object");
@@ -82,7 +82,7 @@ std::unique_ptr<ServiceConfigParser::ParsedConfig>
 ClientChannelServiceConfigParser::ParseGlobalParams(
     const grpc_channel_args* /*args*/, const Json& json,
     grpc_error_handle* error) {
-  GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+  GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
   std::vector<grpc_error_handle> error_list;
   // Parse LB config.
   RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config;
@@ -91,7 +91,7 @@ ClientChannelServiceConfigParser::ParseGlobalParams(
     grpc_error_handle parse_error = GRPC_ERROR_NONE;
     parsed_lb_config = LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
         it->second, &parse_error);
-    if (parse_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(parse_error)) {
       std::vector<grpc_error_handle> lb_errors;
       lb_errors.push_back(parse_error);
       error_list.push_back(GRPC_ERROR_CREATE_FROM_VECTOR(
@@ -130,13 +130,13 @@ ClientChannelServiceConfigParser::ParseGlobalParams(
     grpc_error_handle parsing_error = GRPC_ERROR_NONE;
     health_check_service_name =
         ParseHealthCheckConfig(it->second, &parsing_error);
-    if (parsing_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(parsing_error)) {
       error_list.push_back(parsing_error);
     }
   }
   *error = GRPC_ERROR_CREATE_FROM_VECTOR("Client channel global parser",
                                          &error_list);
-  if (*error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(*error)) {
     return absl::make_unique<ClientChannelGlobalParsedConfig>(
         std::move(parsed_lb_config), std::move(lb_policy_name),
         std::move(health_check_service_name));
@@ -148,7 +148,7 @@ std::unique_ptr<ServiceConfigParser::ParsedConfig>
 ClientChannelServiceConfigParser::ParsePerMethodParams(
     const grpc_channel_args* /*args*/, const Json& json,
     grpc_error_handle* error) {
-  GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+  GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
   std::vector<grpc_error_handle> error_list;
   // Parse waitForReady.
   absl::optional<bool> wait_for_ready;
@@ -169,7 +169,7 @@ ClientChannelServiceConfigParser::ParsePerMethodParams(
                                  &error_list, false);
   // Return result.
   *error = GRPC_ERROR_CREATE_FROM_VECTOR("Client channel parser", &error_list);
-  if (*error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(*error)) {
     return absl::make_unique<ClientChannelMethodParsedConfig>(timeout,
                                                               wait_for_ready);
   }

src/core/ext/filters/client_channel/retry_filter.cc

@@ -1280,7 +1280,7 @@ void RetryFilter::CallData::CallAttempt::OnPerAttemptRecvTimerLocked(
             call_attempt->per_attempt_recv_timer_pending_);
   }
   CallCombinerClosureList closures;
-  if (error == GRPC_ERROR_NONE &&
+  if (GRPC_ERROR_IS_NONE(error) &&
       call_attempt->per_attempt_recv_timer_pending_) {
     call_attempt->per_attempt_recv_timer_pending_ = false;
     // Cancel this attempt.
@@ -1452,7 +1452,7 @@ void RetryFilter::CallData::CallAttempt::BatchData::RecvInitialMetadataReady(
     // callback back to the surface.  We can evaluate whether to retry when
     // recv_trailing_metadata comes back.
     if (GPR_UNLIKELY((call_attempt->trailing_metadata_available_ ||
-                      error != GRPC_ERROR_NONE) &&
+                      !GRPC_ERROR_IS_NONE(error)) &&
                      !call_attempt->completed_recv_trailing_metadata_)) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_retry_trace)) {
         gpr_log(GPR_INFO,
@@ -1464,7 +1464,7 @@ void RetryFilter::CallData::CallAttempt::BatchData::RecvInitialMetadataReady(
           std::move(batch_data);
       call_attempt->recv_initial_metadata_error_ = GRPC_ERROR_REF(error);
       CallCombinerClosureList closures;
-      if (error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(error)) {
         call_attempt->MaybeAddBatchForCancelOp(GRPC_ERROR_REF(error),
                                                &closures);
       }
@@ -1557,7 +1557,7 @@ void RetryFilter::CallData::CallAttempt::BatchData::RecvMessageReady(
     // callback back to the surface.  We can evaluate whether to retry when
     // recv_trailing_metadata comes back.
     if (GPR_UNLIKELY((!call_attempt->recv_message_.has_value() ||
-                      error != GRPC_ERROR_NONE) &&
+                      !GRPC_ERROR_IS_NONE(error)) &&
                      !call_attempt->completed_recv_trailing_metadata_)) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_retry_trace)) {
         gpr_log(GPR_INFO,
@@ -1568,7 +1568,7 @@ void RetryFilter::CallData::CallAttempt::BatchData::RecvMessageReady(
       call_attempt->recv_message_ready_deferred_batch_ = std::move(batch_data);
       call_attempt->recv_message_error_ = GRPC_ERROR_REF(error);
       CallCombinerClosureList closures;
-      if (error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(error)) {
         call_attempt->MaybeAddBatchForCancelOp(GRPC_ERROR_REF(error),
                                                &closures);
       }
@@ -1606,7 +1606,7 @@ void GetCallStatus(
     grpc_status_code* status, absl::optional<Duration>* server_pushback,
     bool* is_lb_drop,
     absl::optional<GrpcStreamNetworkState::ValueType>* stream_network_state) {
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_error_get_status(error, deadline, status, nullptr, nullptr, nullptr);
     intptr_t value = 0;
     if (grpc_error_get_int(error, GRPC_ERROR_INT_LB_POLICY_DROP, &value) &&
@@ -1801,7 +1801,7 @@ void RetryFilter::CallData::CallAttempt::BatchData::RecvTrailingMetadataReady(
       CallCombinerClosureList closures;
       // Cancel call attempt.
       call_attempt->MaybeAddBatchForCancelOp(
-          error == GRPC_ERROR_NONE
+          GRPC_ERROR_IS_NONE(error)
               ? grpc_error_set_int(
                     GRPC_ERROR_CREATE_FROM_STATIC_STRING("call attempt failed"),
                     GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_CANCELLED)
@@ -1919,7 +1919,7 @@ void RetryFilter::CallData::CallAttempt::BatchData::OnComplete(
   // recv_trailing_metadata_ready callback, then defer propagating this
   // callback back to the surface.  We can evaluate whether to retry when
   // recv_trailing_metadata comes back.
-  if (GPR_UNLIKELY(!calld->retry_committed_ && error != GRPC_ERROR_NONE &&
+  if (GPR_UNLIKELY(!calld->retry_committed_ && !GRPC_ERROR_IS_NONE(error) &&
                    !call_attempt->completed_recv_trailing_metadata_)) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_retry_trace)) {
       gpr_log(GPR_INFO, "chand=%p calld=%p attempt=%p: deferring on_complete",
@@ -2219,7 +2219,7 @@ void RetryFilter::CallData::StartTransportStreamOpBatch(
   }
   // If we were previously cancelled from the surface, fail this
   // batch immediately.
-  if (cancelled_from_surface_ != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(cancelled_from_surface_)) {
     // Note: This will release the call combiner.
     grpc_transport_stream_op_batch_finish_with_failure(
         batch, GRPC_ERROR_REF(cancelled_from_surface_), call_combiner_);
@@ -2532,7 +2532,7 @@ void RetryFilter::CallData::FailPendingBatchInCallCombiner(
 
 // This is called via the call combiner, so access to calld is synchronized.
 void RetryFilter::CallData::PendingBatchesFail(grpc_error_handle error) {
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
   if (GRPC_TRACE_FLAG_ENABLED(grpc_retry_trace)) {
     size_t num_batches = 0;
     for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
@@ -2641,7 +2641,7 @@ void RetryFilter::CallData::OnRetryTimer(void* arg, grpc_error_handle error) {
 void RetryFilter::CallData::OnRetryTimerLocked(void* arg,
                                                grpc_error_handle error) {
   auto* calld = static_cast<CallData*>(arg);
-  if (error == GRPC_ERROR_NONE && calld->retry_timer_pending_) {
+  if (GRPC_ERROR_IS_NONE(error) && calld->retry_timer_pending_) {
     calld->retry_timer_pending_ = false;
     calld->CreateCallAttempt(/*is_transparent_retry=*/false);
   } else {
@@ -2664,7 +2664,7 @@ void RetryFilter::CallData::AddClosureToStartTransparentRetry(
 void RetryFilter::CallData::StartTransparentRetry(void* arg,
                                                   grpc_error_handle /*error*/) {
   auto* calld = static_cast<CallData*>(arg);
-  if (calld->cancelled_from_surface_ == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(calld->cancelled_from_surface_)) {
     calld->CreateCallAttempt(/*is_transparent_retry=*/true);
   } else {
     GRPC_CALL_COMBINER_STOP(calld->call_combiner_,

src/core/ext/filters/client_channel/retry_service_config.cc

@@ -141,14 +141,14 @@ std::unique_ptr<ServiceConfigParser::ParsedConfig>
 RetryServiceConfigParser::ParseGlobalParams(const grpc_channel_args* /*args*/,
                                             const Json& json,
                                             grpc_error_handle* error) {
-  GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+  GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
   auto it = json.object_value().find("retryThrottling");
   if (it == json.object_value().end()) return nullptr;
   intptr_t max_milli_tokens = 0;
   intptr_t milli_token_ratio = 0;
   *error =
       ParseRetryThrottling(it->second, &max_milli_tokens, &milli_token_ratio);
-  if (*error != GRPC_ERROR_NONE) return nullptr;
+  if (!GRPC_ERROR_IS_NONE(*error)) return nullptr;
   return absl::make_unique<RetryGlobalConfig>(max_milli_tokens,
                                               milli_token_ratio);
 }
@@ -290,7 +290,7 @@ std::unique_ptr<ServiceConfigParser::ParsedConfig>
 RetryServiceConfigParser::ParsePerMethodParams(const grpc_channel_args* args,
                                                const Json& json,
                                                grpc_error_handle* error) {
-  GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+  GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
   // Parse retry policy.
   auto it = json.object_value().find("retryPolicy");
   if (it == json.object_value().end()) return nullptr;
@@ -303,7 +303,7 @@ RetryServiceConfigParser::ParsePerMethodParams(const grpc_channel_args* args,
   *error = ParseRetryPolicy(args, it->second, &max_attempts, &initial_backoff,
                             &max_backoff, &backoff_multiplier,
                             &retryable_status_codes, &per_attempt_recv_timeout);
-  if (*error != GRPC_ERROR_NONE) return nullptr;
+  if (!GRPC_ERROR_IS_NONE(*error)) return nullptr;
   return absl::make_unique<RetryMethodConfig>(
       max_attempts, initial_backoff, max_backoff, backoff_multiplier,
       retryable_status_codes, per_attempt_recv_timeout);

src/core/ext/filters/client_channel/service_config_channel_arg_filter.cc

@@ -58,7 +58,7 @@ class ServiceConfigChannelArgChannelData {
       grpc_error_handle service_config_error = GRPC_ERROR_NONE;
       auto service_config = ServiceConfigImpl::Create(
           args->channel_args, service_config_str, &service_config_error);
-      if (service_config_error == GRPC_ERROR_NONE) {
+      if (GRPC_ERROR_IS_NONE(service_config_error)) {
         service_config_ = std::move(service_config);
       } else {
         gpr_log(GPR_ERROR, "%s",

src/core/ext/filters/client_channel/subchannel.cc

@@ -165,7 +165,7 @@ SubchannelCall::SubchannelCall(Args args, grpc_error_handle* error)
   };
   *error = grpc_call_stack_init(connected_subchannel_->channel_stack(), 1,
                                 SubchannelCall::Destroy, this, &call_args);
-  if (GPR_UNLIKELY(*error != GRPC_ERROR_NONE)) {
+  if (GPR_UNLIKELY(!GRPC_ERROR_IS_NONE(*error))) {
     gpr_log(GPR_ERROR, "error: %s", grpc_error_std_string(*error).c_str());
     return;
   }
@@ -262,7 +262,7 @@ namespace {
 // Sets *status based on the rest of the parameters.
 void GetCallStatus(grpc_status_code* status, Timestamp deadline,
                    grpc_metadata_batch* md_batch, grpc_error_handle error) {
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_error_get_status(error, deadline, status, nullptr, nullptr, nullptr);
   } else {
     *status = md_batch->get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN);

src/core/ext/filters/client_channel/subchannel_stream_client.cc

@@ -146,7 +146,7 @@ void SubchannelStreamClient::OnRetryTimer(void* arg, grpc_error_handle error) {
   {
     MutexLock lock(&self->mu_);
     self->retry_timer_callback_pending_ = false;
-    if (self->event_handler_ != nullptr && error == GRPC_ERROR_NONE &&
+    if (self->event_handler_ != nullptr && GRPC_ERROR_IS_NONE(error) &&
         self->call_state_ == nullptr) {
       if (GPR_UNLIKELY(self->tracer_ != nullptr)) {
         gpr_log(GPR_INFO,
@@ -218,7 +218,7 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
                     this, grpc_schedule_on_exec_ctx);
   call_->SetAfterCallStackDestroy(&after_call_stack_destruction_);
   // Check if creation failed.
-  if (error != GRPC_ERROR_NONE ||
+  if (!GRPC_ERROR_IS_NONE(error) ||
       subchannel_stream_client_->event_handler_ == nullptr) {
     gpr_log(GPR_ERROR,
             "SubchannelStreamClient %p CallState %p: error creating "
@@ -240,7 +240,7 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
   send_initial_metadata_.Set(
       HttpPathMetadata(),
       subchannel_stream_client_->event_handler_->GetPathLocked());
-  GPR_ASSERT(error == GRPC_ERROR_NONE);
+  GPR_ASSERT(GRPC_ERROR_IS_NONE(error));
   payload_.send_initial_metadata.send_initial_metadata =
       &send_initial_metadata_;
   payload_.send_initial_metadata.send_initial_metadata_flags = 0;
@@ -420,7 +420,7 @@ void SubchannelStreamClient::CallState::RecvTrailingMetadataReady(
   grpc_status_code status =
       self->recv_trailing_metadata_.get(GrpcStatusMetadata())
           .value_or(GRPC_STATUS_UNKNOWN);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_error_get_status(error, Timestamp::InfFuture(), &status,
                           nullptr /* slice */, nullptr /* http_error */,
                           nullptr /* error_string */);

src/core/ext/filters/fault_injection/service_config_parser.cc

@@ -144,7 +144,7 @@ ParseFaultInjectionPolicy(const Json::Array& policies_json_array,
 std::unique_ptr<ServiceConfigParser::ParsedConfig>
 FaultInjectionServiceConfigParser::ParsePerMethodParams(
     const grpc_channel_args* args, const Json& json, grpc_error_handle* error) {
-  GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+  GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
   // Only parse fault injection policy if the following channel arg is present.
   if (!grpc_channel_args_find_bool(
           args, GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG, false)) {
@@ -161,7 +161,7 @@ FaultInjectionServiceConfigParser::ParsePerMethodParams(
         ParseFaultInjectionPolicy(*policies_json_array, &error_list);
   }
   *error = GRPC_ERROR_CREATE_FROM_VECTOR("Fault injection parser", &error_list);
-  if (*error != GRPC_ERROR_NONE || fault_injection_policies.empty()) {
+  if (!GRPC_ERROR_IS_NONE(*error) || fault_injection_policies.empty()) {
     return nullptr;
   }
   return absl::make_unique<FaultInjectionMethodParsedConfig>(

src/core/ext/filters/http/message_compress/message_compress_filter.cc

@@ -241,7 +241,7 @@ void CallData::CompressStartTransportStreamOpBatch(
             GRPC_ERROR_REF(cancel_error_), "failing send_message op");
       }
     }
-  } else if (cancel_error_ != GRPC_ERROR_NONE) {
+  } else if (!GRPC_ERROR_IS_NONE(cancel_error_)) {
     grpc_transport_stream_op_batch_finish_with_failure(
         batch, GRPC_ERROR_REF(cancel_error_), call_combiner_);
     return;

src/core/ext/filters/http/message_compress/message_decompress_filter.cc

@@ -131,7 +131,7 @@ class CallData {
 
 void CallData::OnRecvInitialMetadataReady(void* arg, grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(arg);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     calld->algorithm_ =
         calld->recv_initial_metadata_->get(GrpcEncodingMetadata())
             .value_or(GRPC_COMPRESS_NONE);
@@ -154,7 +154,7 @@ void CallData::MaybeResumeOnRecvMessageReady() {
 
 void CallData::OnRecvMessageReady(void* arg, grpc_error_handle error) {
   CallData* calld = static_cast<CallData*>(arg);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     if (calld->original_recv_initial_metadata_ready_ != nullptr) {
       calld->seen_recv_message_ready_ = true;
       GRPC_CALL_COMBINER_STOP(calld->call_combiner_,
@@ -173,7 +173,7 @@ void CallData::OnRecvMessageReady(void* arg, grpc_error_handle error) {
       if (calld->max_recv_message_length_ >= 0 &&
           (*calld->recv_message_)->Length() >
               static_cast<uint32_t>(calld->max_recv_message_length_)) {
-        GPR_DEBUG_ASSERT(calld->error_ == GRPC_ERROR_NONE);
+        GPR_DEBUG_ASSERT(GRPC_ERROR_IS_NONE(calld->error_));
         calld->error_ = grpc_error_set_int(
             GRPC_ERROR_CREATE_FROM_CPP_STRING(
                 absl::StrFormat("Received message larger than max (%u vs. %d)",
@@ -187,7 +187,7 @@ void CallData::OnRecvMessageReady(void* arg, grpc_error_handle error) {
       if (grpc_msg_decompress(calld->algorithm_,
                               (*calld->recv_message_)->c_slice_buffer(),
                               decompressed_slices.c_slice_buffer()) == 0) {
-        GPR_DEBUG_ASSERT(calld->error_ == GRPC_ERROR_NONE);
+        GPR_DEBUG_ASSERT(GRPC_ERROR_IS_NONE(calld->error_));
         calld->error_ = GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
             "Unexpected error decompressing data for algorithm with "
             "enum value ",

src/core/ext/filters/message_size/message_size_filter.cc

@@ -76,7 +76,7 @@ std::unique_ptr<ServiceConfigParser::ParsedConfig>
 MessageSizeParser::ParsePerMethodParams(const grpc_channel_args* /*args*/,
                                         const Json& json,
                                         grpc_error_handle* error) {
-  GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+  GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
   std::vector<grpc_error_handle> error_list;
   // Max request size.
   int max_request_message_bytes = -1;

src/core/ext/filters/rbac/rbac_filter.cc

@@ -82,7 +82,7 @@ void RbacFilter::CallData::RecvInitialMetadataReady(void* user_data,
   grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
   CallData* calld = static_cast<CallData*>(elem->call_data);
   RbacFilter* filter = static_cast<RbacFilter*>(elem->channel_data);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     // Fetch and apply the rbac policy from the service config.
     auto* service_config_call_data = static_cast<ServiceConfigCallData*>(
         calld->call_context_[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value);
@@ -103,7 +103,7 @@ void RbacFilter::CallData::RecvInitialMetadataReady(void* user_data,
             GRPC_ERROR_CREATE_FROM_STATIC_STRING("Unauthorized RPC rejected");
       }
     }
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
       error = grpc_error_set_int(error, GRPC_ERROR_INT_GRPC_STATUS,
                                  GRPC_STATUS_PERMISSION_DENIED);
     }

src/core/ext/filters/rbac/rbac_service_config_parser.cc

@@ -584,7 +584,7 @@ std::unique_ptr<ServiceConfigParser::ParsedConfig>
 RbacServiceConfigParser::ParsePerMethodParams(const grpc_channel_args* args,
                                               const Json& json,
                                               grpc_error_handle* error) {
-  GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+  GPR_DEBUG_ASSERT(error != nullptr && GRPC_ERROR_IS_NONE(*error));
   // Only parse rbac policy if the channel arg is present
   if (!grpc_channel_args_find_bool(args, GRPC_ARG_PARSE_RBAC_METHOD_CONFIG,
                                    false)) {
@@ -598,7 +598,7 @@ RbacServiceConfigParser::ParsePerMethodParams(const grpc_channel_args* args,
     rbac_policies = ParseRbacArray(*policies_json_array, &error_list);
   }
   *error = GRPC_ERROR_CREATE_FROM_VECTOR("Rbac parser", &error_list);
-  if (*error != GRPC_ERROR_NONE || rbac_policies.empty()) {
+  if (!GRPC_ERROR_IS_NONE(*error) || rbac_policies.empty()) {
     return nullptr;
   }
   return absl::make_unique<RbacMethodParsedConfig>(std::move(rbac_policies));

src/core/ext/filters/server_config_selector/server_config_selector_filter.cc

@@ -136,7 +136,7 @@ ArenaPromise<ServerMetadataHandle> ServerConfigSelectorFilter::MakeCallPromise(
   if (!sel.ok()) return Immediate(ServerMetadataHandle(sel.status()));
   auto call_config =
       sel.value()->GetCallConfig(call_args.client_initial_metadata.get());
-  if (call_config.error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(call_config.error)) {
     auto r = Immediate(ServerMetadataHandle(
         absl::UnavailableError(grpc_error_std_string(call_config.error))));
     GRPC_ERROR_UNREF(call_config.error);

src/core/ext/transport/binder/transport/binder_transport.cc

@@ -151,7 +151,7 @@ static void cancel_stream_locked(grpc_binder_transport* gbt,
                                  grpc_error_handle error) {
   gpr_log(GPR_INFO, "cancel_stream_locked");
   if (!gbs->is_closed) {
-    GPR_ASSERT(gbs->cancel_self_error == GRPC_ERROR_NONE);
+    GPR_ASSERT(GRPC_ERROR_IS_NONE(gbs->cancel_self_error));
     gbs->is_closed = true;
     gbs->cancel_self_error = GRPC_ERROR_REF(error);
     gbt->transport_stream_receiver->CancelStream(gbs->tx_code);
@@ -262,7 +262,7 @@ static void recv_message_locked(void* arg, grpc_error_handle /*error*/) {
       return GRPC_ERROR_NONE;
     }();
 
-    if (error != GRPC_ERROR_NONE &&
+    if (!GRPC_ERROR_IS_NONE(error) &&
         gbs->call_failed_before_recv_message != nullptr) {
       *gbs->call_failed_before_recv_message = true;
     }
@@ -609,11 +609,11 @@ static void perform_transport_op_locked(void* transport_op,
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, op->on_consumed, GRPC_ERROR_NONE);
   }
   bool do_close = false;
-  if (op->disconnect_with_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(op->disconnect_with_error)) {
     do_close = true;
     GRPC_ERROR_UNREF(op->disconnect_with_error);
   }
-  if (op->goaway_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(op->goaway_error)) {
     do_close = true;
     GRPC_ERROR_UNREF(op->goaway_error);
   }

src/core/ext/transport/chttp2/client/chttp2_connector.cc

@@ -148,8 +148,8 @@ void Chttp2Connector::OnHandshakeDone(void* arg, grpc_error_handle error) {
   Chttp2Connector* self = static_cast<Chttp2Connector*>(args->user_data);
   {
     MutexLock lock(&self->mu_);
-    if (error != GRPC_ERROR_NONE || self->shutdown_) {
+    if (!GRPC_ERROR_IS_NONE(error) || self->shutdown_) {
-      if (error == GRPC_ERROR_NONE) {
+      if (GRPC_ERROR_IS_NONE(error)) {
         error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("connector shutdown");
         // We were shut down after handshaking completed successfully, so
         // destroy the endpoint here.
@@ -206,7 +206,7 @@ void Chttp2Connector::OnReceiveSettings(void* arg, grpc_error_handle error) {
     if (!self->notify_error_.has_value()) {
       grpc_endpoint_delete_from_pollset_set(self->endpoint_,
                                             self->args_.interested_parties);
-      if (error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(error)) {
         // Transport got an error while waiting on SETTINGS frame.
         // TODO(yashykt): The following two lines should be moved to
         // SubchannelConnector::Result::Reset()

src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -325,7 +325,7 @@ void Chttp2ServerListener::ConfigFetcherWatcher::UpdateConnectionManager(
   int port_temp;
   grpc_error_handle error = grpc_tcp_server_add_port(
       listener_->tcp_server_, &listener_->resolved_address_, &port_temp);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     GRPC_ERROR_UNREF(error);
     gpr_log(GPR_ERROR, "Error adding port to server: %s",
             grpc_error_std_string(error).c_str());
@@ -446,11 +446,11 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
   bool cleanup_connection = false;
   {
     MutexLock connection_lock(&self->connection_->mu_);
-    if (error != GRPC_ERROR_NONE || self->connection_->shutdown_) {
+    if (!GRPC_ERROR_IS_NONE(error) || self->connection_->shutdown_) {
       std::string error_str = grpc_error_std_string(error);
       gpr_log(GPR_DEBUG, "Handshaking failed: %s", error_str.c_str());
       cleanup_connection = true;
-      if (error == GRPC_ERROR_NONE && args->endpoint != nullptr) {
+      if (GRPC_ERROR_IS_NONE(error) && args->endpoint != nullptr) {
         // We were shut down or stopped serving after handshaking completed
         // successfully, so destroy the endpoint here.
         // TODO(ctiller): It is currently necessary to shutdown endpoints
@@ -474,7 +474,7 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
             self->connection_->listener_->server_->SetupTransport(
                 transport, self->accepting_pollset_, args->args,
                 grpc_chttp2_transport_get_socket_node(transport));
-        if (channel_init_err == GRPC_ERROR_NONE) {
+        if (GRPC_ERROR_IS_NONE(channel_init_err)) {
           // Use notify_on_receive_settings callback to enforce the
           // handshake deadline.
           // Note: The reinterpret_cast<>s here are safe, because
@@ -653,7 +653,7 @@ void Chttp2ServerListener::ActiveConnection::OnDrainGraceTimeExpiry(
   ActiveConnection* self = static_cast<ActiveConnection*>(arg);
   // If the drain_grace_timer_ was not cancelled, disconnect the transport
   // immediately.
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     grpc_chttp2_transport* transport = nullptr;
     {
       MutexLock lock(&self->mu_);
@@ -683,14 +683,14 @@ grpc_error_handle Chttp2ServerListener::Create(
     listener = new Chttp2ServerListener(server, args, args_modifier);
     error = grpc_tcp_server_create(&listener->tcp_server_shutdown_complete_,
                                    args, &listener->tcp_server_);
-    if (error != GRPC_ERROR_NONE) return error;
+    if (!GRPC_ERROR_IS_NONE(error)) return error;
     if (server->config_fetcher() != nullptr) {
       listener->resolved_address_ = *addr;
       // TODO(yashykt): Consider binding so as to be able to return the port
       // number.
     } else {
       error = grpc_tcp_server_add_port(listener->tcp_server_, addr, port_num);
-      if (error != GRPC_ERROR_NONE) return error;
+      if (!GRPC_ERROR_IS_NONE(error)) return error;
     }
     // Create channelz node.
     if (grpc_channel_args_find_bool(args, GRPC_ARG_ENABLE_CHANNELZ,
@@ -709,7 +709,7 @@ grpc_error_handle Chttp2ServerListener::Create(
     server->AddListener(OrphanablePtr<Server::ListenerInterface>(listener));
     return GRPC_ERROR_NONE;
   }();
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     if (listener != nullptr) {
       if (listener->tcp_server_ != nullptr) {
         // listener is deleted when tcp_server_ is shutdown.
@@ -731,7 +731,7 @@ grpc_error_handle Chttp2ServerListener::CreateWithAcceptor(
       new Chttp2ServerListener(server, args, args_modifier);
   grpc_error_handle error = grpc_tcp_server_create(
       &listener->tcp_server_shutdown_complete_, args, &listener->tcp_server_);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     delete listener;
     return error;
   }
@@ -832,7 +832,7 @@ void Chttp2ServerListener::OnAccept(void* arg, grpc_endpoint* tcp,
     }
     grpc_error_handle error = GRPC_ERROR_NONE;
     args = self->args_modifier_(*args_result, &error);
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
       gpr_log(GPR_DEBUG, "Closing connection: %s",
               grpc_error_std_string(error).c_str());
       endpoint_cleanup(error);
@@ -959,7 +959,7 @@ grpc_error_handle Chttp2ServerAddPort(Server* server, const char* addr,
       error = Chttp2ServerListener::Create(server, &addr,
                                            grpc_channel_args_copy(args),
                                            args_modifier, &port_temp);
-      if (error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(error)) {
         error_list.push_back(error);
       } else {
         if (*port_num == -1) {
@@ -992,7 +992,7 @@ grpc_error_handle Chttp2ServerAddPort(Server* server, const char* addr,
     GRPC_ERROR_UNREF(error);
   }
   grpc_channel_args_destroy(args);
-  if (error != GRPC_ERROR_NONE) *port_num = 0;
+  if (!GRPC_ERROR_IS_NONE(error)) *port_num = 0;
   return error;
 }
 
@@ -1076,7 +1076,7 @@ int grpc_server_add_http2_port(grpc_server* server, const char* addr,
                                        ModifyArgsForConnection, &port_num);
 done:
   sc.reset(DEBUG_LOCATION, "server");
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     gpr_log(GPR_ERROR, "%s", grpc_error_std_string(err).c_str());
 
     GRPC_ERROR_UNREF(err);
@@ -1107,7 +1107,7 @@ void grpc_server_add_channel_from_fd(grpc_server* server, int fd,
   );
   grpc_error_handle error =
       core_server->SetupTransport(transport, nullptr, server_args, nullptr);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     for (grpc_pollset* pollset : core_server->pollsets()) {
       grpc_endpoint_add_to_pollset(server_endpoint, pollset);
     }

src/core/ext/transport/chttp2/transport/chttp2_transport.cc

@@ -584,13 +584,13 @@ static void close_transport_locked(grpc_chttp2_transport* t,
                                    grpc_error_handle error) {
   end_all_the_calls(t, GRPC_ERROR_REF(error));
   cancel_pings(t, GRPC_ERROR_REF(error));
-  if (t->closed_with_error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(t->closed_with_error)) {
     if (!grpc_error_has_clear_grpc_status(error)) {
       error = grpc_error_set_int(error, GRPC_ERROR_INT_GRPC_STATUS,
                                  GRPC_STATUS_UNAVAILABLE);
     }
     if (t->write_state != GRPC_CHTTP2_WRITE_STATE_IDLE) {
-      if (t->close_transport_on_writes_finished == GRPC_ERROR_NONE) {
+      if (GRPC_ERROR_IS_NONE(t->close_transport_on_writes_finished)) {
         t->close_transport_on_writes_finished =
             GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                 "Delayed close due to in-progress write");
@@ -599,7 +599,7 @@ static void close_transport_locked(grpc_chttp2_transport* t,
           grpc_error_add_child(t->close_transport_on_writes_finished, error);
       return;
     }
-    GPR_ASSERT(error != GRPC_ERROR_NONE);
+    GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
     t->closed_with_error = GRPC_ERROR_REF(error);
     connectivity_state_set(t, GRPC_CHANNEL_SHUTDOWN, absl::Status(),
                            "close_transport");
@@ -797,7 +797,7 @@ static void set_write_state(grpc_chttp2_transport* t,
   // from peer while we had some pending writes)
   if (st == GRPC_CHTTP2_WRITE_STATE_IDLE) {
     grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &t->run_after_write);
-    if (t->close_transport_on_writes_finished != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(t->close_transport_on_writes_finished)) {
       grpc_error_handle err = t->close_transport_on_writes_finished;
       t->close_transport_on_writes_finished = GRPC_ERROR_NONE;
       close_transport_locked(t, err);
@@ -919,7 +919,7 @@ void grpc_chttp2_initiate_write(grpc_chttp2_transport* t,
 
 void grpc_chttp2_mark_stream_writable(grpc_chttp2_transport* t,
                                       grpc_chttp2_stream* s) {
-  if (t->closed_with_error == GRPC_ERROR_NONE &&
+  if (GRPC_ERROR_IS_NONE(t->closed_with_error) &&
       grpc_chttp2_list_add_writable_stream(t, s)) {
     GRPC_CHTTP2_STREAM_REF(s, "chttp2_writing:become");
   }
@@ -939,7 +939,7 @@ static void write_action_begin_locked(void* gt,
   grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(gt);
   GPR_ASSERT(t->write_state != GRPC_CHTTP2_WRITE_STATE_IDLE);
   grpc_chttp2_begin_write_result r;
-  if (t->closed_with_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(t->closed_with_error)) {
     r.writing = false;
   } else {
     r = grpc_chttp2_begin_write(t);
@@ -999,7 +999,7 @@ static void write_action_end_locked(void* tp, grpc_error_handle error) {
   grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(tp);
 
   bool closed = false;
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     close_transport_locked(t, GRPC_ERROR_REF(error));
     closed = true;
   }
@@ -1078,7 +1078,7 @@ void grpc_chttp2_add_incoming_goaway(grpc_chttp2_transport* t,
                                      uint32_t last_stream_id,
                                      absl::string_view goaway_text) {
   // Discard the error from a previous goaway frame (if any)
-  if (t->goaway_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(t->goaway_error)) {
     GRPC_ERROR_UNREF(t->goaway_error);
   }
   t->goaway_error = grpc_error_set_str(
@@ -1148,7 +1148,7 @@ static void maybe_start_some_streams(grpc_chttp2_transport* t) {
   grpc_chttp2_stream* s;
   // maybe cancel out streams that haven't yet started if we have received a
   // GOAWAY
-  if (t->goaway_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(t->goaway_error)) {
     cancel_unstarted_streams(t, GRPC_ERROR_REF(t->goaway_error));
     return;
   }
@@ -1240,7 +1240,7 @@ void grpc_chttp2_complete_closure_step(grpc_chttp2_transport* t,
         desc, grpc_error_std_string(error).c_str(),
         write_state_name(t->write_state));
   }
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
 #ifdef GRPC_ERROR_IS_ABSEIL_STATUS
     grpc_error_handle cl_err =
         grpc_core::internal::StatusMoveFromHeapPtr(closure->error_data.error);
@@ -1248,7 +1248,7 @@ void grpc_chttp2_complete_closure_step(grpc_chttp2_transport* t,
     grpc_error_handle cl_err =
         reinterpret_cast<grpc_error_handle>(closure->error_data.error);
 #endif
-    if (cl_err == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(cl_err)) {
       cl_err = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "Error in HTTP transport completing operation");
       cl_err = grpc_error_set_str(cl_err, GRPC_ERROR_STR_TARGET_ADDRESS,
@@ -1361,7 +1361,7 @@ static void perform_stream_op_locked(void* stream_op,
     }
     if (!s->write_closed) {
       if (t->is_client) {
-        if (t->closed_with_error == GRPC_ERROR_NONE) {
+        if (GRPC_ERROR_IS_NONE(t->closed_with_error)) {
           GPR_ASSERT(s->id == 0);
           grpc_chttp2_list_add_waiting_for_concurrency(t, s);
           maybe_start_some_streams(t);
@@ -1593,7 +1593,7 @@ static void cancel_pings(grpc_chttp2_transport* t, grpc_error_handle error) {
   // callback remaining pings: they're not allowed to call into the transport,
   //   and maybe they hold resources that need to be freed
   grpc_chttp2_ping_queue* pq = &t->ping_queue;
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
   for (size_t j = 0; j < GRPC_CHTTP2_PCL_COUNT; j++) {
     grpc_closure_list_fail_all(&pq->lists[j], GRPC_ERROR_REF(error));
     grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &pq->lists[j]);
@@ -1603,7 +1603,7 @@ static void cancel_pings(grpc_chttp2_transport* t, grpc_error_handle error) {
 
 static void send_ping_locked(grpc_chttp2_transport* t,
                              grpc_closure* on_initiate, grpc_closure* on_ack) {
-  if (t->closed_with_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(t->closed_with_error)) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_initiate,
                             GRPC_ERROR_REF(t->closed_with_error));
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_ack,
@@ -1621,7 +1621,7 @@ static void send_ping_locked(grpc_chttp2_transport* t,
 // a ping in progress, the keepalive ping would piggyback onto that ping,
 // instead of waiting for that ping to complete and then starting a new ping.
 static void send_keepalive_ping_locked(grpc_chttp2_transport* t) {
-  if (t->closed_with_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(t->closed_with_error)) {
     t->combiner->Run(GRPC_CLOSURE_INIT(&t->start_keepalive_ping_locked,
                                        start_keepalive_ping_locked, t, nullptr),
                      GRPC_ERROR_REF(t->closed_with_error));
@@ -1666,7 +1666,7 @@ void grpc_chttp2_retry_initiate_ping(void* tp, grpc_error_handle error) {
 static void retry_initiate_ping_locked(void* tp, grpc_error_handle error) {
   grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(tp);
   t->ping_state.is_delayed_ping_timer_set = false;
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RETRY_SEND_PING);
   }
   GRPC_CHTTP2_UNREF_TRANSPORT(t, "retry_initiate_ping_locked");
@@ -1723,7 +1723,7 @@ class GracefulGoaway : public grpc_core::RefCounted<GracefulGoaway> {
       // We already sent the final GOAWAY.
       return;
     }
-    if (t_->destroying || t_->closed_with_error != GRPC_ERROR_NONE) {
+    if (t_->destroying || !GRPC_ERROR_IS_NONE(t_->closed_with_error)) {
       GRPC_CHTTP2_IF_TRACING(gpr_log(
           GPR_INFO,
           "transport:%p %s peer:%s Transport already shutting down. "
@@ -1760,7 +1760,7 @@ class GracefulGoaway : public grpc_core::RefCounted<GracefulGoaway> {
 
   static void OnTimer(void* arg, grpc_error_handle error) {
     auto* self = static_cast<GracefulGoaway*>(arg);
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
       self->Unref();
       return;
     }
@@ -1844,7 +1844,7 @@ static void perform_transport_op_locked(void* stream_op,
   grpc_chttp2_transport* t =
       static_cast<grpc_chttp2_transport*>(op->handler_private.extra_arg);
 
-  if (op->goaway_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(op->goaway_error)) {
     send_goaway(t, op->goaway_error, /*immediate_disconnect_hint=*/false);
   }
 
@@ -1874,7 +1874,7 @@ static void perform_transport_op_locked(void* stream_op,
     t->state_tracker.RemoveWatcher(op->stop_connectivity_watch);
   }
 
-  if (op->disconnect_with_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(op->disconnect_with_error)) {
     send_goaway(t, GRPC_ERROR_REF(op->disconnect_with_error),
                 /*immediate_disconnect_hint=*/true);
     close_transport_locked(t, op->disconnect_with_error);
@@ -1951,7 +1951,7 @@ void grpc_chttp2_maybe_complete_recv_message(grpc_chttp2_transport* t,
             }
           } else {
             error = absl::get<grpc_error_handle>(r);
-            if (error != GRPC_ERROR_NONE) {
+            if (!GRPC_ERROR_IS_NONE(error)) {
               s->seen_error = true;
               grpc_slice_buffer_reset_and_unref_internal(&s->frame_storage);
               break;
@@ -1973,7 +1973,7 @@ void grpc_chttp2_maybe_complete_recv_message(grpc_chttp2_transport* t,
     }
     // save the length of the buffer before handing control back to application
     // threads. Needed to support correct flow control bookkeeping
-    if (error == GRPC_ERROR_NONE && s->recv_message->has_value()) {
+    if (GRPC_ERROR_IS_NONE(error) && s->recv_message->has_value()) {
       null_then_sched_closure(&s->recv_message_ready);
     } else if (s->published_metadata[1] != GRPC_METADATA_NOT_PUBLISHED) {
       if (s->call_failed_before_recv_message != nullptr) {
@@ -2052,7 +2052,7 @@ void grpc_chttp2_cancel_stream(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
       grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
     }
   }
-  if (due_to_error != GRPC_ERROR_NONE && !s->seen_error) {
+  if (!GRPC_ERROR_IS_NONE(due_to_error) && !s->seen_error) {
     s->seen_error = true;
   }
   grpc_chttp2_mark_stream_closed(t, s, 1, 1, due_to_error);
@@ -2090,7 +2090,7 @@ void grpc_chttp2_fake_status(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
 
 static void add_error(grpc_error_handle error, grpc_error_handle* refs,
                       size_t* nrefs) {
-  if (error == GRPC_ERROR_NONE) return;
+  if (GRPC_ERROR_IS_NONE(error)) return;
   for (size_t i = 0; i < *nrefs; i++) {
     if (error == refs[i]) {
       return;
@@ -2160,7 +2160,7 @@ void grpc_chttp2_mark_stream_closed(grpc_chttp2_transport* t,
   if (s->read_closed && s->write_closed) {
     // already closed, but we should still fake the status if needed.
     grpc_error_handle overall_error = removal_error(error, s, "Stream removed");
-    if (overall_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(overall_error)) {
       grpc_chttp2_fake_status(t, s, overall_error);
     }
     grpc_chttp2_maybe_complete_recv_trailing_metadata(t, s);
@@ -2188,7 +2188,7 @@ void grpc_chttp2_mark_stream_closed(grpc_chttp2_transport* t,
       // Purge streams waiting on concurrency still waiting for id assignment
       grpc_chttp2_list_remove_waiting_for_concurrency(t, s);
     }
-    if (overall_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(overall_error)) {
       grpc_chttp2_fake_status(t, s, overall_error);
     }
   }
@@ -2446,11 +2446,11 @@ static grpc_error_handle try_http_parsing(grpc_chttp2_transport* t) {
   grpc_http_parser_init(&parser, GRPC_HTTP_RESPONSE, &response);
 
   grpc_error_handle parse_error = GRPC_ERROR_NONE;
-  for (; i < t->read_buffer.count && parse_error == GRPC_ERROR_NONE; i++) {
+  for (; i < t->read_buffer.count && GRPC_ERROR_IS_NONE(parse_error); i++) {
     parse_error =
         grpc_http_parser_parse(&parser, t->read_buffer.slices[i], nullptr);
   }
-  if (parse_error == GRPC_ERROR_NONE &&
+  if (GRPC_ERROR_IS_NONE(parse_error) &&
       (parse_error = grpc_http_parser_eof(&parser)) == GRPC_ERROR_NONE) {
     error = grpc_error_set_int(
         grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
@@ -2481,7 +2481,7 @@ static void read_action_locked(void* tp, grpc_error_handle error) {
   (void)GRPC_ERROR_REF(error);
 
   grpc_error_handle err = error;
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     err = grpc_error_set_int(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                                  "Endpoint read failed", &err, 1),
                              GRPC_ERROR_INT_OCCURRED_DURING_WRITE,
@@ -2489,7 +2489,7 @@ static void read_action_locked(void* tp, grpc_error_handle error) {
   }
   std::swap(err, error);
   GRPC_ERROR_UNREF(err);
-  if (t->closed_with_error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(t->closed_with_error)) {
     GPR_TIMER_SCOPE("reading_action.parse", 0);
     size_t i = 0;
     grpc_error_handle errors[3] = {GRPC_ERROR_REF(error), GRPC_ERROR_NONE,
@@ -2523,20 +2523,20 @@ static void read_action_locked(void* tp, grpc_error_handle error) {
 
   GPR_TIMER_SCOPE("post_reading_action_locked", 0);
   bool keep_reading = false;
-  if (error == GRPC_ERROR_NONE && t->closed_with_error != GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error) && !GRPC_ERROR_IS_NONE(t->closed_with_error)) {
     error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
         "Transport closed", &t->closed_with_error, 1);
   }
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     // If a goaway frame was received, this might be the reason why the read
     // failed. Add this info to the error
-    if (t->goaway_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(t->goaway_error)) {
       error = grpc_error_add_child(error, GRPC_ERROR_REF(t->goaway_error));
     }
 
     close_transport_locked(t, GRPC_ERROR_REF(error));
     t->endpoint_reading = 0;
-  } else if (t->closed_with_error == GRPC_ERROR_NONE) {
+  } else if (GRPC_ERROR_IS_NONE(t->closed_with_error)) {
     keep_reading = true;
     // Since we have read a byte, reset the keepalive timer
     if (t->keepalive_state == GRPC_CHTTP2_KEEPALIVE_STATE_WAITING) {
@@ -2564,7 +2564,7 @@ static void read_action_locked(void* tp, grpc_error_handle error) {
 }
 
 static void continue_read_action_locked(grpc_chttp2_transport* t) {
-  const bool urgent = t->goaway_error != GRPC_ERROR_NONE;
+  const bool urgent = !GRPC_ERROR_IS_NONE(t->goaway_error);
   GRPC_CLOSURE_INIT(&t->read_action_locked, read_action, t,
                     grpc_schedule_on_exec_ctx);
   grpc_endpoint_read(t->ep, &t->read_buffer, &t->read_action_locked, urgent,
@@ -2598,7 +2598,7 @@ static void start_bdp_ping_locked(void* tp, grpc_error_handle error) {
     gpr_log(GPR_INFO, "%s: Start BDP ping err=%s", t->peer_string.c_str(),
             grpc_error_std_string(error).c_str());
   }
-  if (error != GRPC_ERROR_NONE || t->closed_with_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error) || !GRPC_ERROR_IS_NONE(t->closed_with_error)) {
     return;
   }
   // Reset the keepalive ping timer
@@ -2622,7 +2622,7 @@ static void finish_bdp_ping_locked(void* tp, grpc_error_handle error) {
     gpr_log(GPR_INFO, "%s: Complete BDP ping err=%s", t->peer_string.c_str(),
             grpc_error_std_string(error).c_str());
   }
-  if (error != GRPC_ERROR_NONE || t->closed_with_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error) || !GRPC_ERROR_IS_NONE(t->closed_with_error)) {
     GRPC_CHTTP2_UNREF_TRANSPORT(t, "bdp_ping");
     return;
   }
@@ -2660,7 +2660,7 @@ static void next_bdp_ping_timer_expired_locked(void* tp,
   grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(tp);
   GPR_ASSERT(t->have_next_bdp_ping_timer);
   t->have_next_bdp_ping_timer = false;
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     GRPC_CHTTP2_UNREF_TRANSPORT(t, "bdp_ping");
     return;
   }
@@ -2742,9 +2742,9 @@ static void init_keepalive_ping(void* arg, grpc_error_handle error) {
 static void init_keepalive_ping_locked(void* arg, grpc_error_handle error) {
   grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(arg);
   GPR_ASSERT(t->keepalive_state == GRPC_CHTTP2_KEEPALIVE_STATE_WAITING);
-  if (t->destroying || t->closed_with_error != GRPC_ERROR_NONE) {
+  if (t->destroying || !GRPC_ERROR_IS_NONE(t->closed_with_error)) {
     t->keepalive_state = GRPC_CHTTP2_KEEPALIVE_STATE_DYING;
-  } else if (error == GRPC_ERROR_NONE) {
+  } else if (GRPC_ERROR_IS_NONE(error)) {
     if (t->keepalive_permit_without_calls ||
         grpc_chttp2_stream_map_size(&t->stream_map) > 0) {
       t->keepalive_state = GRPC_CHTTP2_KEEPALIVE_STATE_PINGING;
@@ -2781,7 +2781,7 @@ static void start_keepalive_ping(void* arg, grpc_error_handle error) {
 
 static void start_keepalive_ping_locked(void* arg, grpc_error_handle error) {
   grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(arg);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     return;
   }
   if (t->channelz_socket != nullptr) {
@@ -2810,7 +2810,7 @@ static void finish_keepalive_ping(void* arg, grpc_error_handle error) {
 static void finish_keepalive_ping_locked(void* arg, grpc_error_handle error) {
   grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(arg);
   if (t->keepalive_state == GRPC_CHTTP2_KEEPALIVE_STATE_PINGING) {
-    if (error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(error)) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
           GRPC_TRACE_FLAG_ENABLED(grpc_keepalive_trace)) {
         gpr_log(GPR_INFO, "%s: Finish keepalive ping", t->peer_string.c_str());
@@ -2850,7 +2850,7 @@ static void keepalive_watchdog_fired_locked(void* arg,
                                             grpc_error_handle error) {
   grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(arg);
   if (t->keepalive_state == GRPC_CHTTP2_KEEPALIVE_STATE_PINGING) {
-    if (error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(error)) {
       gpr_log(GPR_INFO, "%s: Keepalive watchdog fired. Closing transport.",
               t->peer_string.c_str());
       t->keepalive_state = GRPC_CHTTP2_KEEPALIVE_STATE_DYING;
@@ -2946,7 +2946,7 @@ static void post_destructive_reclaimer(grpc_chttp2_transport* t) {
 
 static void benign_reclaimer_locked(void* arg, grpc_error_handle error) {
   grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(arg);
-  if (error == GRPC_ERROR_NONE &&
+  if (GRPC_ERROR_IS_NONE(error) &&
       grpc_chttp2_stream_map_size(&t->stream_map) == 0) {
     // Channel with no active streams: send a goaway to try and make it
     // disconnect cleanly
@@ -2959,7 +2959,7 @@ static void benign_reclaimer_locked(void* arg, grpc_error_handle error) {
                     GRPC_ERROR_CREATE_FROM_STATIC_STRING("Buffers full"),
                     GRPC_ERROR_INT_HTTP2_ERROR, GRPC_HTTP2_ENHANCE_YOUR_CALM),
                 /*immediate_disconnect_hint=*/true);
-  } else if (error == GRPC_ERROR_NONE &&
+  } else if (GRPC_ERROR_IS_NONE(error) &&
              GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
     gpr_log(GPR_INFO,
             "HTTP2: %s - skip benign reclamation, there are still %" PRIdPTR
@@ -2978,7 +2978,7 @@ static void destructive_reclaimer_locked(void* arg, grpc_error_handle error) {
   grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(arg);
   size_t n = grpc_chttp2_stream_map_size(&t->stream_map);
   t->destructive_reclaimer_registered = false;
-  if (error == GRPC_ERROR_NONE && n > 0) {
+  if (GRPC_ERROR_IS_NONE(error) && n > 0) {
     grpc_chttp2_stream* s = static_cast<grpc_chttp2_stream*>(
         grpc_chttp2_stream_map_rand(&t->stream_map));
     if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {

src/core/ext/transport/chttp2/transport/hpack_parser.cc

@@ -600,7 +600,7 @@ class HPackParser::Input {
   // Set the current error - allows the rest of the code not to need to pass
   // around StatusOr<> which would be prohibitive here.
   GPR_ATTRIBUTE_NOINLINE void SetError(grpc_error_handle error) {
-    if (error_ != GRPC_ERROR_NONE || eof_error_) {
+    if (!GRPC_ERROR_IS_NONE(error_) || eof_error_) {
       GRPC_ERROR_UNREF(error);
       return;
     }
@@ -613,7 +613,7 @@ class HPackParser::Input {
   template <typename F, typename T>
   GPR_ATTRIBUTE_NOINLINE T MaybeSetErrorAndReturn(F error_factory,
                                                   T return_value) {
-    if (error_ != GRPC_ERROR_NONE || eof_error_) return return_value;
+    if (!GRPC_ERROR_IS_NONE(error_) || eof_error_) return return_value;
     error_ = error_factory();
     begin_ = end_;
     return return_value;
@@ -623,7 +623,7 @@ class HPackParser::Input {
   // is a common case)
   template <typename T>
   T UnexpectedEOF(T return_value) {
-    if (error_ != GRPC_ERROR_NONE) return return_value;
+    if (!GRPC_ERROR_IS_NONE(error_)) return return_value;
     eof_error_ = true;
     return return_value;
   }
@@ -1089,7 +1089,7 @@ class HPackParser::Parser {
     auto r = EmitHeader(*md);
     // Add to the hpack table
     grpc_error_handle err = table_->Add(std::move(*md));
-    if (GPR_UNLIKELY(err != GRPC_ERROR_NONE)) {
+    if (GPR_UNLIKELY(!GRPC_ERROR_IS_NONE(err))) {
       input_->SetError(err);
       return false;
     };
@@ -1185,7 +1185,7 @@ class HPackParser::Parser {
     }
     (*dynamic_table_updates_allowed_)--;
     grpc_error_handle err = table_->SetCurrentTableSize(*size);
-    if (err != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(err)) {
       input_->SetError(err);
       return false;
     }
@@ -1360,7 +1360,7 @@ grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
     s->stats.incoming.header_bytes += GRPC_SLICE_LENGTH(slice);
   }
   grpc_error_handle error = parser->Parse(slice, is_last != 0);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     return error;
   }
   if (is_last) {

src/core/ext/transport/chttp2/transport/parsing.cc

@@ -204,12 +204,12 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur));
       t->deframe_state = GRPC_DTS_FRAME;
       err = init_frame_parser(t);
-      if (err != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(err)) {
         return err;
       }
       if (t->incoming_frame_size == 0) {
         err = parse_frame_slice(t, grpc_empty_slice(), 1);
-        if (err != GRPC_ERROR_NONE) {
+        if (!GRPC_ERROR_IS_NONE(err)) {
           return err;
         }
         t->incoming_stream = nullptr;
@@ -239,7 +239,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
             grpc_slice_sub_no_ref(slice, static_cast<size_t>(cur - beg),
                                   static_cast<size_t>(end - beg)),
             1);
-        if (err != GRPC_ERROR_NONE) {
+        if (!GRPC_ERROR_IS_NONE(err)) {
           return err;
         }
         t->deframe_state = GRPC_DTS_FH_0;
@@ -252,7 +252,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
             grpc_slice_sub_no_ref(slice, cur_offset,
                                   cur_offset + t->incoming_frame_size),
             1);
-        if (err != GRPC_ERROR_NONE) {
+        if (!GRPC_ERROR_IS_NONE(err)) {
           return err;
         }
         cur += t->incoming_frame_size;
@@ -264,7 +264,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
             grpc_slice_sub_no_ref(slice, static_cast<size_t>(cur - beg),
                                   static_cast<size_t>(end - beg)),
             0);
-        if (err != GRPC_ERROR_NONE) {
+        if (!GRPC_ERROR_IS_NONE(err)) {
           return err;
         }
         t->incoming_frame_size -= static_cast<uint32_t>(end - cur);
@@ -582,7 +582,7 @@ static grpc_error_handle init_window_update_frame_parser(
   grpc_error_handle err = grpc_chttp2_window_update_parser_begin_frame(
       &t->simple.window_update, t->incoming_frame_size,
       t->incoming_frame_flags);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   if (t->incoming_stream_id != 0) {
     grpc_chttp2_stream* s = t->incoming_stream =
         grpc_chttp2_parsing_lookup_stream(t, t->incoming_stream_id);
@@ -599,7 +599,7 @@ static grpc_error_handle init_window_update_frame_parser(
 static grpc_error_handle init_ping_parser(grpc_chttp2_transport* t) {
   grpc_error_handle err = grpc_chttp2_ping_parser_begin_frame(
       &t->simple.ping, t->incoming_frame_size, t->incoming_frame_flags);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   t->parser = grpc_chttp2_ping_parser_parse;
   t->parser_data = &t->simple.ping;
   return GRPC_ERROR_NONE;
@@ -608,7 +608,7 @@ static grpc_error_handle init_ping_parser(grpc_chttp2_transport* t) {
 static grpc_error_handle init_rst_stream_parser(grpc_chttp2_transport* t) {
   grpc_error_handle err = grpc_chttp2_rst_stream_parser_begin_frame(
       &t->simple.rst_stream, t->incoming_frame_size, t->incoming_frame_flags);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   grpc_chttp2_stream* s = t->incoming_stream =
       grpc_chttp2_parsing_lookup_stream(t, t->incoming_stream_id);
   if (!t->incoming_stream) {
@@ -623,7 +623,7 @@ static grpc_error_handle init_rst_stream_parser(grpc_chttp2_transport* t) {
 static grpc_error_handle init_goaway_parser(grpc_chttp2_transport* t) {
   grpc_error_handle err = grpc_chttp2_goaway_parser_begin_frame(
       &t->goaway_parser, t->incoming_frame_size, t->incoming_frame_flags);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   t->parser = grpc_chttp2_goaway_parser_parse;
   t->parser_data = &t->goaway_parser;
   return GRPC_ERROR_NONE;
@@ -638,7 +638,7 @@ static grpc_error_handle init_settings_frame_parser(grpc_chttp2_transport* t) {
   grpc_error_handle err = grpc_chttp2_settings_parser_begin_frame(
       &t->simple.settings, t->incoming_frame_size, t->incoming_frame_flags,
       t->settings[GRPC_PEER_SETTINGS]);
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     return err;
   }
   if (t->incoming_frame_flags & GRPC_CHTTP2_FLAG_ACK) {
@@ -664,7 +664,7 @@ static grpc_error_handle parse_frame_slice(grpc_chttp2_transport* t,
   grpc_chttp2_stream* s = t->incoming_stream;
   grpc_error_handle err = t->parser(t->parser_data, t, s, slice, is_last);
   intptr_t unused;
-  if (GPR_LIKELY(err == GRPC_ERROR_NONE)) {
+  if (GPR_LIKELY(GRPC_ERROR_IS_NONE(err))) {
     return err;
   } else if (grpc_error_get_int(err, GRPC_ERROR_INT_STREAM_ID, &unused)) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {

src/core/ext/transport/chttp2/transport/writing.cc

@@ -334,7 +334,7 @@ class WriteContext {
   void UpdateStreamsNoLongerStalled() {
     grpc_chttp2_stream* s;
     while (grpc_chttp2_list_pop_stalled_by_transport(t_, &s)) {
-      if (t_->closed_with_error == GRPC_ERROR_NONE &&
+      if (GRPC_ERROR_IS_NONE(t_->closed_with_error) &&
           grpc_chttp2_list_add_writable_stream(t_, s)) {
         if (!s->refcount->refs.RefIfNonZero()) {
           grpc_chttp2_list_remove_writable_stream(t_, s);

src/core/ext/transport/cronet/transport/cronet_transport.cc

@@ -1326,7 +1326,7 @@ static enum e_op_result execute_stream_op(struct op_and_state* oas) {
       result = ACTION_TAKEN_NO_CALLBACK;
     }
     stream_state->state_op_done[OP_CANCEL_ERROR] = true;
-    if (stream_state->cancel_error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(stream_state->cancel_error)) {
       stream_state->cancel_error =
           GRPC_ERROR_REF(stream_op->payload->cancel_stream.cancel_error);
     }

src/core/ext/transport/inproc/inproc_transport.cc

@@ -210,7 +210,7 @@ struct inproc_stream {
         cs->write_buffer_trailing_md.Clear();
         cs->write_buffer_trailing_md_filled = false;
       }
-      if (cs->write_buffer_cancel_error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(cs->write_buffer_cancel_error)) {
         cancel_other_error = cs->write_buffer_cancel_error;
         cs->write_buffer_cancel_error = GRPC_ERROR_NONE;
         maybe_process_ops_locked(this, cancel_other_error);
@@ -433,7 +433,7 @@ void complete_if_batch_end_locked(inproc_stream* s, grpc_error_handle error,
 }
 
 void maybe_process_ops_locked(inproc_stream* s, grpc_error_handle error) {
-  if (s && (error != GRPC_ERROR_NONE || s->ops_needed)) {
+  if (s && (!GRPC_ERROR_IS_NONE(error) || s->ops_needed)) {
     s->ops_needed = false;
     op_state_machine_locked(s, error);
   }
@@ -457,11 +457,11 @@ void fail_helper_locked(inproc_stream* s, grpc_error_handle error) {
     (void)fill_in_metadata(s, &fake_md, 0, dest, nullptr, destfilled);
 
     if (other != nullptr) {
-      if (other->cancel_other_error == GRPC_ERROR_NONE) {
+      if (GRPC_ERROR_IS_NONE(other->cancel_other_error)) {
         other->cancel_other_error = GRPC_ERROR_REF(error);
       }
       maybe_process_ops_locked(other, error);
-    } else if (s->write_buffer_cancel_error == GRPC_ERROR_NONE) {
+    } else if (GRPC_ERROR_IS_NONE(s->write_buffer_cancel_error)) {
       s->write_buffer_cancel_error = GRPC_ERROR_REF(error);
     }
   }
@@ -606,13 +606,13 @@ void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
   // cancellation takes precedence
   inproc_stream* other = s->other_side;
 
-  if (s->cancel_self_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(s->cancel_self_error)) {
     fail_helper_locked(s, GRPC_ERROR_REF(s->cancel_self_error));
     goto done;
-  } else if (s->cancel_other_error != GRPC_ERROR_NONE) {
+  } else if (!GRPC_ERROR_IS_NONE(s->cancel_other_error)) {
     fail_helper_locked(s, GRPC_ERROR_REF(s->cancel_other_error));
     goto done;
-  } else if (error != GRPC_ERROR_NONE) {
+  } else if (!GRPC_ERROR_IS_NONE(error)) {
     fail_helper_locked(s, GRPC_ERROR_REF(error));
     goto done;
   }
@@ -885,7 +885,7 @@ bool cancel_stream_locked(inproc_stream* s, grpc_error_handle error) {
   bool ret = false;  // was the cancel accepted
   INPROC_LOG(GPR_INFO, "cancel_stream %p with %s", s,
              grpc_error_std_string(error).c_str());
-  if (s->cancel_self_error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(s->cancel_self_error)) {
     ret = true;
     s->cancel_self_error = GRPC_ERROR_REF(error);
     // Catch current value of other before it gets closed off
@@ -905,11 +905,11 @@ bool cancel_stream_locked(inproc_stream* s, grpc_error_handle error) {
     (void)fill_in_metadata(s, &cancel_md, 0, dest, nullptr, destfilled);
 
     if (other != nullptr) {
-      if (other->cancel_other_error == GRPC_ERROR_NONE) {
+      if (GRPC_ERROR_IS_NONE(other->cancel_other_error)) {
         other->cancel_other_error = GRPC_ERROR_REF(s->cancel_self_error);
       }
       maybe_process_ops_locked(other, other->cancel_other_error);
-    } else if (s->write_buffer_cancel_error == GRPC_ERROR_NONE) {
+    } else if (GRPC_ERROR_IS_NONE(s->write_buffer_cancel_error)) {
       s->write_buffer_cancel_error = GRPC_ERROR_REF(s->cancel_self_error);
     }
 
@@ -972,7 +972,7 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
     // this function is responsible to make sure that that field gets unref'ed
     cancel_stream_locked(s, op->payload->cancel_stream.cancel_error);
     // this op can complete without an error
-  } else if (s->cancel_self_error != GRPC_ERROR_NONE) {
+  } else if (!GRPC_ERROR_IS_NONE(s->cancel_self_error)) {
     // already self-canceled so still give it an error
     error = GRPC_ERROR_REF(s->cancel_self_error);
   } else {
@@ -987,12 +987,12 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
   }
 
   inproc_stream* other = s->other_side;
-  if (error == GRPC_ERROR_NONE &&
+  if (GRPC_ERROR_IS_NONE(error) &&
       (op->send_initial_metadata || op->send_trailing_metadata)) {
     if (s->t->is_closed) {
       error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Endpoint already shutdown");
     }
-    if (error == GRPC_ERROR_NONE && op->send_initial_metadata) {
+    if (GRPC_ERROR_IS_NONE(error) && op->send_initial_metadata) {
       grpc_metadata_batch* dest = (other == nullptr)
                                       ? &s->write_buffer_initial_md
                                       : &other->to_read_initial_md;
@@ -1026,7 +1026,7 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
     }
   }
 
-  if (error == GRPC_ERROR_NONE &&
+  if (GRPC_ERROR_IS_NONE(error) &&
       (op->send_message || op->send_trailing_metadata ||
        op->recv_initial_metadata || op->recv_message ||
        op->recv_trailing_metadata)) {
@@ -1066,7 +1066,7 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
       s->ops_needed = true;
     }
   } else {
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
       // Consume any send message that was sent here but that we are not
       // pushing to the other side
       if (op->send_message) {
@@ -1162,11 +1162,11 @@ void perform_transport_op(grpc_transport* gt, grpc_transport_op* op) {
   }
 
   bool do_close = false;
-  if (op->goaway_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(op->goaway_error)) {
     do_close = true;
     GRPC_ERROR_UNREF(op->goaway_error);
   }
-  if (op->disconnect_with_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(op->disconnect_with_error)) {
     do_close = true;
     GRPC_ERROR_UNREF(op->disconnect_with_error);
   }
@@ -1280,7 +1280,7 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
   grpc_error_handle error = core_server->SetupTransport(
       server_transport, nullptr, server_args, nullptr);
   grpc_channel* channel = nullptr;
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     auto new_channel = grpc_core::Channel::Create(
         "inproc", grpc_core::ChannelArgs::FromC(client_args),
         GRPC_CLIENT_DIRECT_CHANNEL, client_transport);

src/core/ext/xds/xds_api.cc

@@ -302,7 +302,7 @@ grpc_slice XdsApi::CreateAdsRequest(
   }
   // Set error_detail if it's a NACK.
   std::string error_string_storage;
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     google_rpc_Status* error_detail =
         envoy_service_discovery_v3_DiscoveryRequest_mutable_error_detail(
             request, arena.ptr());

src/core/ext/xds/xds_bootstrap.cc

@@ -92,7 +92,7 @@ grpc_error_handle ParseChannelCredsArray(const Json::Array& json,
     } else {
       grpc_error_handle parse_error =
           ParseChannelCreds(child.object_value(), i, server);
-      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+      if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
     }
   }
   if (server->channel_creds_type.empty()) {
@@ -121,7 +121,7 @@ XdsBootstrap::XdsServer XdsBootstrap::XdsServer::Parse(
   if (creds_array != nullptr) {
     grpc_error_handle parse_error =
         ParseChannelCredsArray(*creds_array, &server);
-    if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+    if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
   }
   const Json::Array* server_features_array = nullptr;
   ParseJsonObjectField(json.object_value(), "server_features",
@@ -169,7 +169,7 @@ bool XdsBootstrap::XdsServer::ShouldUseV3() const {
 std::unique_ptr<XdsBootstrap> XdsBootstrap::Create(
     absl::string_view json_string, grpc_error_handle* error) {
   Json json = Json::Parse(json_string, error);
-  if (*error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(*error)) {
     grpc_error_handle error_out =
         GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
             "Failed to parse bootstrap JSON string", error, 1);
@@ -196,7 +196,7 @@ XdsBootstrap::XdsBootstrap(Json json, grpc_error_handle* error) {
         "\"xds_servers\" field is not an array"));
   } else {
     grpc_error_handle parse_error = ParseXdsServerList(&it->second, &servers_);
-    if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+    if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
   }
   it = json.mutable_object()->find("node");
   if (it != json.mutable_object()->end()) {
@@ -205,7 +205,7 @@ XdsBootstrap::XdsBootstrap(Json json, grpc_error_handle* error) {
           "\"node\" field is not an object"));
     } else {
       grpc_error_handle parse_error = ParseNode(&it->second);
-      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+      if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
     }
   }
   if (XdsFederationEnabled()) {
@@ -216,7 +216,7 @@ XdsBootstrap::XdsBootstrap(Json json, grpc_error_handle* error) {
             "\"authorities\" field is not an object"));
       } else {
         grpc_error_handle parse_error = ParseAuthorities(&it->second);
-        if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+        if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
       }
     }
     it = json.mutable_object()->find(
@@ -249,7 +249,7 @@ XdsBootstrap::XdsBootstrap(Json json, grpc_error_handle* error) {
           "\"certificate_providers\" field is not an object"));
     } else {
       grpc_error_handle parse_error = ParseCertificateProviders(&it->second);
-      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+      if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
     }
   }
   *error = GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing xds bootstrap file",
@@ -287,7 +287,7 @@ grpc_error_handle XdsBootstrap::ParseXdsServerList(
     } else {
       grpc_error_handle parse_error;
       servers->emplace_back(XdsServer::Parse(child, &parse_error));
-      if (parse_error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(parse_error)) {
         error_list.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
             absl::StrCat("errors parsing index ", i)));
         error_list.push_back(parse_error);
@@ -307,7 +307,7 @@ grpc_error_handle XdsBootstrap::ParseAuthorities(Json* json) {
       continue;
     }
     grpc_error_handle parse_error = ParseAuthority(&p.second, p.first);
-    if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+    if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
   }
   return GRPC_ERROR_CREATE_FROM_VECTOR("errors parsing \"authorities\"",
                                        &error_list);
@@ -344,7 +344,7 @@ grpc_error_handle XdsBootstrap::ParseAuthority(Json* json,
     } else {
       grpc_error_handle parse_error =
           ParseXdsServerList(&it->second, &authority.xds_servers);
-      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+      if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
     }
   }
   if (error_list.empty()) {
@@ -382,7 +382,7 @@ grpc_error_handle XdsBootstrap::ParseNode(Json* json) {
           "\"locality\" field is not an object"));
     } else {
       grpc_error_handle parse_error = ParseLocality(&it->second);
-      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+      if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
     }
   }
   it = json->mutable_object()->find("metadata");
@@ -440,7 +440,7 @@ grpc_error_handle XdsBootstrap::ParseCertificateProviders(Json* json) {
     } else {
       grpc_error_handle parse_error = ParseCertificateProvider(
           certificate_provider.first, &certificate_provider.second);
-      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+      if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
     }
   }
   return GRPC_ERROR_CREATE_FROM_VECTOR(
@@ -476,14 +476,16 @@ grpc_error_handle XdsBootstrap::ParseCertificateProvider(
           grpc_error_handle parse_error = GRPC_ERROR_NONE;
           config = factory->CreateCertificateProviderConfig(it->second,
                                                             &parse_error);
-          if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+          if (!GRPC_ERROR_IS_NONE(parse_error)) {
+            error_list.push_back(parse_error);
+          }
         }
       } else {
         // "config" is an optional field, so create an empty JSON object.
         grpc_error_handle parse_error = GRPC_ERROR_NONE;
         config = factory->CreateCertificateProviderConfig(Json::Object(),
                                                           &parse_error);
-        if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+        if (!GRPC_ERROR_IS_NONE(parse_error)) error_list.push_back(parse_error);
       }
       certificate_providers_.insert(
           {instance_name, {std::move(plugin_name), std::move(config)}});

src/core/ext/xds/xds_certificate_provider.cc

@@ -60,7 +60,7 @@ class RootCertificatesWatcher
 
   void OnError(grpc_error_handle root_cert_error,
                grpc_error_handle identity_cert_error) override {
-    if (root_cert_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(root_cert_error)) {
       parent_->SetErrorForCert(cert_name_, root_cert_error /* pass the ref */,
                                absl::nullopt);
     }
@@ -95,7 +95,7 @@ class IdentityCertificatesWatcher
 
   void OnError(grpc_error_handle root_cert_error,
                grpc_error_handle identity_cert_error) override {
-    if (identity_cert_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(identity_cert_error)) {
       parent_->SetErrorForCert(cert_name_, absl::nullopt,
                                identity_cert_error /* pass the ref */);
     }

src/core/ext/xds/xds_client.cc

@@ -271,7 +271,7 @@ class XdsClient::ChannelState::AdsCallState
 
     void OnTimerLocked(grpc_error_handle error)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_) {
-      if (error == GRPC_ERROR_NONE && timer_pending_) {
+      if (GRPC_ERROR_IS_NONE(error) && timer_pending_) {
         timer_pending_ = false;
         if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
           gpr_log(GPR_INFO,
@@ -744,7 +744,7 @@ template <typename T>
 void XdsClient::ChannelState::RetryableCall<T>::OnRetryTimerLocked(
     grpc_error_handle error) {
   retry_timer_callback_pending_ = false;
-  if (!shutting_down_ && error == GRPC_ERROR_NONE) {
+  if (!shutting_down_ && GRPC_ERROR_IS_NONE(error)) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
       gpr_log(GPR_INFO,
               "[xds_client %p] xds server %s: retry timer fired (retryable "
@@ -1143,7 +1143,7 @@ void XdsClient::ChannelState::AdsCallState::OnRequestSent(
 
 void XdsClient::ChannelState::AdsCallState::OnRequestSentLocked(
     grpc_error_handle error) {
-  if (IsCurrentCallOnChannel() && error == GRPC_ERROR_NONE) {
+  if (IsCurrentCallOnChannel() && GRPC_ERROR_IS_NONE(error)) {
     // Clean up the sent message.
     grpc_byte_buffer_destroy(send_message_payload_);
     send_message_payload_ = nullptr;
@@ -1382,7 +1382,7 @@ void XdsClient::ChannelState::LrsCallState::Reporter::OnNextReportTimer(
 bool XdsClient::ChannelState::LrsCallState::Reporter::OnNextReportTimerLocked(
     grpc_error_handle error) {
   next_report_timer_callback_pending_ = false;
-  if (error != GRPC_ERROR_NONE || !IsCurrentReporterOnCall()) {
+  if (!GRPC_ERROR_IS_NONE(error) || !IsCurrentReporterOnCall()) {
     GRPC_ERROR_UNREF(error);
     return true;
   }
@@ -1474,7 +1474,7 @@ bool XdsClient::ChannelState::LrsCallState::Reporter::OnReportDoneLocked(
     GRPC_ERROR_UNREF(error);
     return true;
   }
-  if (error != GRPC_ERROR_NONE || !IsCurrentReporterOnCall()) {
+  if (!GRPC_ERROR_IS_NONE(error) || !IsCurrentReporterOnCall()) {
     GRPC_ERROR_UNREF(error);
     // If this reporter is no longer the current one on the call, the reason
     // might be that it was orphaned for a new one due to config update.
@@ -1684,7 +1684,7 @@ bool XdsClient::ChannelState::LrsCallState::OnResponseReceivedLocked() {
     grpc_error_handle parse_error = xds_client()->api_.ParseLrsResponse(
         response_slice, &send_all_clusters, &new_cluster_names,
         &new_load_reporting_interval);
-    if (parse_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(parse_error)) {
       gpr_log(GPR_ERROR,
               "[xds_client %p] xds server %s: LRS response parsing failed: %s",
               xds_client(), chand()->server_.server_uri.c_str(),
@@ -2399,7 +2399,7 @@ std::string GetBootstrapContents(const char* fallback_config,
     grpc_slice contents;
     *error =
         grpc_load_file(path.get(), /*add_null_terminator=*/true, &contents);
-    if (*error != GRPC_ERROR_NONE) return "";
+    if (!GRPC_ERROR_IS_NONE(*error)) return "";
     std::string contents_str(StringViewFromSlice(contents));
     grpc_slice_unref_internal(contents);
     return contents_str;
@@ -2440,7 +2440,7 @@ RefCountedPtr<XdsClient> XdsClient::GetOrCreate(const grpc_channel_args* args,
   if (bootstrap_config != nullptr) {
     std::unique_ptr<XdsBootstrap> bootstrap =
         XdsBootstrap::Create(bootstrap_config, error);
-    if (*error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(*error)) {
       grpc_channel_args* xds_channel_args =
           grpc_channel_args_find_pointer<grpc_channel_args>(
               args,
@@ -2459,7 +2459,7 @@ RefCountedPtr<XdsClient> XdsClient::GetOrCreate(const grpc_channel_args* args,
     // Find bootstrap contents.
     std::string bootstrap_contents =
         GetBootstrapContents(g_fallback_bootstrap_config, error);
-    if (*error != GRPC_ERROR_NONE) return nullptr;
+    if (!GRPC_ERROR_IS_NONE(*error)) return nullptr;
     if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
       gpr_log(GPR_INFO, "xDS bootstrap contents: %s",
               bootstrap_contents.c_str());
@@ -2467,7 +2467,7 @@ RefCountedPtr<XdsClient> XdsClient::GetOrCreate(const grpc_channel_args* args,
     // Parse bootstrap.
     std::unique_ptr<XdsBootstrap> bootstrap =
         XdsBootstrap::Create(bootstrap_contents, error);
-    if (*error != GRPC_ERROR_NONE) return nullptr;
+    if (!GRPC_ERROR_IS_NONE(*error)) return nullptr;
     // Instantiate XdsClient.
     xds_client =
         MakeRefCounted<XdsClient>(std::move(bootstrap), g_channel_args);
@@ -2544,7 +2544,7 @@ grpc_slice grpc_dump_xds_configs() {
   grpc_core::ExecCtx exec_ctx;
   grpc_error_handle error = GRPC_ERROR_NONE;
   auto xds_client = grpc_core::XdsClient::GetOrCreate(nullptr, &error);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     // If we isn't using xDS, just return an empty string.
     GRPC_ERROR_UNREF(error);
     return grpc_empty_slice();

src/core/ext/xds/xds_cluster.cc

@@ -135,7 +135,7 @@ grpc_error_handle UpstreamTlsContextParse(
     if (common_tls_context_proto != nullptr) {
       grpc_error_handle error = CommonTlsContext::Parse(
           context, common_tls_context_proto, common_tls_context);
-      if (error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(error)) {
         return grpc_error_add_child(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                                         "Error parsing UpstreamTlsContext"),
                                     error);
@@ -253,7 +253,7 @@ grpc_error_handle CdsResourceParse(
              envoy_config_cluster_v3_Cluster_LOGICAL_DNS) {
     cds_update->cluster_type = XdsClusterResource::ClusterType::LOGICAL_DNS;
     grpc_error_handle error = CdsLogicalDnsParse(cluster, cds_update);
-    if (error != GRPC_ERROR_NONE) errors.push_back(error);
+    if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
   } else {
     if (!envoy_config_cluster_v3_Cluster_has_cluster_type(cluster)) {
       errors.push_back(
@@ -354,7 +354,7 @@ grpc_error_handle CdsResourceParse(
   if (transport_socket != nullptr) {
     grpc_error_handle error = UpstreamTlsContextParse(
         context, transport_socket, &cds_update->common_tls_context);
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
       errors.push_back(
           grpc_error_add_child(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                                    "Error parsing security configuration"),
@@ -534,7 +534,7 @@ absl::StatusOr<XdsResourceType::DecodeResult> XdsClusterResourceType::Decode(
   auto cluster_data = absl::make_unique<ResourceDataSubclass>();
   grpc_error_handle error =
       CdsResourceParse(context, resource, is_v2, &cluster_data->resource);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     std::string error_str = grpc_error_std_string(error);
     GRPC_ERROR_UNREF(error);
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {

src/core/ext/xds/xds_cluster_specifier_plugin.cc

@@ -81,7 +81,7 @@ XdsRouteLookupClusterSpecifierPlugin::GenerateLoadBalancingPolicyConfig(
   grpc_error_handle error = GRPC_ERROR_NONE;
   rls_policy["routeLookupConfig"] =
       Json::Parse(reinterpret_cast<char*>(buf), &error);
-  GPR_ASSERT(error == GRPC_ERROR_NONE);
+  GPR_ASSERT(GRPC_ERROR_IS_NONE(error));
   Json::Object cds_policy;
   cds_policy["cds_experimental"] = Json::Object();
   Json::Array child_policy;
@@ -100,7 +100,7 @@ XdsRouteLookupClusterSpecifierPlugin::GenerateLoadBalancingPolicyConfig(
   // itself.
   LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(lb_policy_config,
                                                         &parse_error);
-  if (parse_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(parse_error)) {
     absl::Status status = absl::InvalidArgumentError(absl::StrCat(
         kXdsRouteLookupClusterSpecifierPluginConfigName,
         " ClusterSpecifierPlugin returned invalid LB policy config: ",

src/core/ext/xds/xds_common_types.cc

@@ -230,7 +230,7 @@ grpc_error_handle CertificateValidationContextParse(
     grpc_error_handle error = CertificateProviderPluginInstanceParse(
         context, ca_certificate_provider_instance,
         &certificate_validation_context->ca_certificate_provider_instance);
-    if (error != GRPC_ERROR_NONE) errors.push_back(error);
+    if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
   }
   if (envoy_extensions_transport_sockets_tls_v3_CertificateValidationContext_verify_certificate_spki(
           certificate_validation_context_proto, nullptr) != nullptr) {
@@ -290,7 +290,7 @@ grpc_error_handle CommonTlsContext::Parse(
       grpc_error_handle error = CertificateValidationContextParse(
           context, default_validation_context,
           &common_tls_context->certificate_validation_context);
-      if (error != GRPC_ERROR_NONE) errors.push_back(error);
+      if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
     }
     // If after parsing default_validation_context,
     // common_tls_context->certificate_validation_context.ca_certificate_provider_instance
@@ -309,7 +309,7 @@ grpc_error_handle CommonTlsContext::Parse(
           context, validation_context_certificate_provider_instance,
           &common_tls_context->certificate_validation_context
                .ca_certificate_provider_instance);
-      if (error != GRPC_ERROR_NONE) errors.push_back(error);
+      if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
     }
   } else {
     auto* validation_context =
@@ -319,7 +319,7 @@ grpc_error_handle CommonTlsContext::Parse(
       grpc_error_handle error = CertificateValidationContextParse(
           context, validation_context,
           &common_tls_context->certificate_validation_context);
-      if (error != GRPC_ERROR_NONE) errors.push_back(error);
+      if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
     } else if (
         envoy_extensions_transport_sockets_tls_v3_CommonTlsContext_has_validation_context_sds_secret_config(
             common_tls_context_proto)) {
@@ -334,7 +334,7 @@ grpc_error_handle CommonTlsContext::Parse(
     grpc_error_handle error = CertificateProviderPluginInstanceParse(
         context, tls_certificate_provider_instance,
         &common_tls_context->tls_certificate_provider_instance);
-    if (error != GRPC_ERROR_NONE) errors.push_back(error);
+    if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
   } else {
     // Fall back onto 'tls_certificate_certificate_provider_instance'. Note that
     // this way of fetching identity certificates is deprecated and will be
@@ -347,7 +347,7 @@ grpc_error_handle CommonTlsContext::Parse(
       grpc_error_handle error = CertificateProviderInstanceParse(
           context, tls_certificate_certificate_provider_instance,
           &common_tls_context->tls_certificate_provider_instance);
-      if (error != GRPC_ERROR_NONE) errors.push_back(error);
+      if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
     } else {
       if (envoy_extensions_transport_sockets_tls_v3_CommonTlsContext_has_tls_certificates(
               common_tls_context_proto)) {

src/core/ext/xds/xds_endpoint.cc

@@ -178,7 +178,7 @@ grpc_error_handle ServerAddressParseAndAppend(
   grpc_resolved_address addr;
   grpc_error_handle error =
       grpc_string_to_sockaddr(&addr, address_str.c_str(), port);
-  if (error != GRPC_ERROR_NONE) return error;
+  if (!GRPC_ERROR_IS_NONE(error)) return error;
   // Append the address to the list.
   std::map<const char*, std::unique_ptr<ServerAddress::AttributeInterface>>
       attributes;
@@ -225,7 +225,7 @@ grpc_error_handle LocalityParse(
   for (size_t i = 0; i < size; ++i) {
     grpc_error_handle error = ServerAddressParseAndAppend(
         lb_endpoints[i], &output_locality->endpoints);
-    if (error != GRPC_ERROR_NONE) return error;
+    if (!GRPC_ERROR_IS_NONE(error)) return error;
   }
   // Parse the priority.
   *priority = envoy_config_endpoint_v3_LocalityLbEndpoints_priority(
@@ -287,7 +287,7 @@ grpc_error_handle EdsResourceParse(
     size_t priority;
     XdsEndpointResource::Priority::Locality locality;
     grpc_error_handle error = LocalityParse(endpoints[j], &locality, &priority);
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
       errors.push_back(error);
       continue;
     }
@@ -328,7 +328,7 @@ grpc_error_handle EdsResourceParse(
     for (size_t j = 0; j < drop_size; ++j) {
       grpc_error_handle error =
           DropParseAndAppend(drop_overload[j], eds_update->drop_config.get());
-      if (error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(error)) {
         errors.push_back(
             grpc_error_add_child(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                                      "drop config validation error"),
@@ -359,7 +359,7 @@ absl::StatusOr<XdsResourceType::DecodeResult> XdsEndpointResourceType::Decode(
   auto endpoint_data = absl::make_unique<ResourceDataSubclass>();
   grpc_error_handle error =
       EdsResourceParse(context, resource, is_v2, &endpoint_data->resource);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     std::string error_str = grpc_error_std_string(error);
     GRPC_ERROR_UNREF(error);
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {

src/core/ext/xds/xds_lb_policy_registry.cc

@@ -168,7 +168,7 @@ absl::StatusOr<Json> ParseStructToJson(const XdsEncodingContext& context,
                  reinterpret_cast<char*>(buf), json_size + 1, status.ptr());
   grpc_error_handle error = GRPC_ERROR_NONE;
   auto json = Json::Parse(reinterpret_cast<char*>(buf), &error);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     // This should not happen
     auto ret_status = absl::InternalError(
         absl::StrCat("Error parsing JSON form of google::Protobuf::Struct "

src/core/ext/xds/xds_listener.cc

@@ -433,7 +433,7 @@ grpc_error_handle HttpConnectionManagerParse(
       XdsRouteConfigResource rds_update;
       grpc_error_handle error =
           XdsRouteConfigResource::Parse(context, route_config, &rds_update);
-      if (error != GRPC_ERROR_NONE) return error;
+      if (!GRPC_ERROR_IS_NONE(error)) return error;
       http_connection_manager->rds_update = std::move(rds_update);
       return GRPC_ERROR_NONE;
     }
@@ -517,7 +517,7 @@ grpc_error_handle DownstreamTlsContextParse(
       grpc_error_handle error =
           CommonTlsContext::Parse(context, common_tls_context,
                                   &downstream_tls_context->common_tls_context);
-      if (error != GRPC_ERROR_NONE) errors.push_back(error);
+      if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
     }
     auto* require_client_certificate =
         envoy_extensions_transport_sockets_tls_v3_DownstreamTlsContext_require_client_certificate(
@@ -570,7 +570,7 @@ grpc_error_handle CidrRangeParse(
       envoy_config_core_v3_CidrRange_address_prefix(cidr_range_proto));
   grpc_error_handle error =
       grpc_string_to_sockaddr(&cidr_range->address, address_prefix.c_str(), 0);
-  if (error != GRPC_ERROR_NONE) return error;
+  if (!GRPC_ERROR_IS_NONE(error)) return error;
   cidr_range->prefix_len = 0;
   auto* prefix_len_proto =
       envoy_config_core_v3_CidrRange_prefix_len(cidr_range_proto);
@@ -604,7 +604,7 @@ grpc_error_handle FilterChainMatchParse(
   for (size_t i = 0; i < size; i++) {
     XdsListenerResource::FilterChainMap::CidrRange cidr_range;
     grpc_error_handle error = CidrRangeParse(prefix_ranges[i], &cidr_range);
-    if (error != GRPC_ERROR_NONE) return error;
+    if (!GRPC_ERROR_IS_NONE(error)) return error;
     filter_chain_match->prefix_ranges.push_back(cidr_range);
   }
   filter_chain_match->source_type =
@@ -619,7 +619,7 @@ grpc_error_handle FilterChainMatchParse(
     XdsListenerResource::FilterChainMap::CidrRange cidr_range;
     grpc_error_handle error =
         CidrRangeParse(source_prefix_ranges[i], &cidr_range);
-    if (error != GRPC_ERROR_NONE) return error;
+    if (!GRPC_ERROR_IS_NONE(error)) return error;
     filter_chain_match->source_prefix_ranges.push_back(cidr_range);
   }
   auto* source_ports = envoy_config_listener_v3_FilterChainMatch_source_ports(
@@ -658,7 +658,7 @@ grpc_error_handle FilterChainParse(
   if (filter_chain_match != nullptr) {
     grpc_error_handle error = FilterChainMatchParse(
         filter_chain_match, &filter_chain->filter_chain_match);
-    if (error != GRPC_ERROR_NONE) errors.push_back(error);
+    if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
   }
   filter_chain->filter_chain_data =
       std::make_shared<XdsListenerResource::FilterChainData>();
@@ -700,7 +700,7 @@ grpc_error_handle FilterChainParse(
           grpc_error_handle error = HttpConnectionManagerParse(
               false /* is_client */, context, http_connection_manager, is_v2,
               &filter_chain->filter_chain_data->http_connection_manager);
-          if (error != GRPC_ERROR_NONE) errors.push_back(error);
+          if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
         }
       }
     }
@@ -711,7 +711,7 @@ grpc_error_handle FilterChainParse(
     grpc_error_handle error = DownstreamTlsContextParse(
         context, transport_socket,
         &filter_chain->filter_chain_data->downstream_tls_context);
-    if (error != GRPC_ERROR_NONE) errors.push_back(error);
+    if (!GRPC_ERROR_IS_NONE(error)) errors.push_back(error);
   }
   return GRPC_ERROR_CREATE_FROM_VECTOR("Error parsing FilterChain", &errors);
 }
@@ -780,7 +780,7 @@ grpc_error_handle AddFilterChainDataForSourcePorts(
     for (uint32_t port : filter_chain.filter_chain_match.source_ports) {
       grpc_error_handle error =
           AddFilterChainDataForSourcePort(filter_chain, ports_map, port);
-      if (error != GRPC_ERROR_NONE) return error;
+      if (!GRPC_ERROR_IS_NONE(error)) return error;
     }
   }
   return GRPC_ERROR_NONE;
@@ -809,7 +809,7 @@ grpc_error_handle AddFilterChainDataForSourceIpRange(
       }
       grpc_error_handle error = AddFilterChainDataForSourcePorts(
           filter_chain, &insert_result.first->second.ports_map);
-      if (error != GRPC_ERROR_NONE) return error;
+      if (!GRPC_ERROR_IS_NONE(error)) return error;
     }
   }
   return GRPC_ERROR_NONE;
@@ -896,7 +896,7 @@ grpc_error_handle AddFilterChainDataForDestinationIpRange(
       }
       grpc_error_handle error = AddFilterChainDataForServerNames(
           filter_chain, &insert_result.first->second);
-      if (error != GRPC_ERROR_NONE) return error;
+      if (!GRPC_ERROR_IS_NONE(error)) return error;
     }
   }
   return GRPC_ERROR_NONE;
@@ -930,7 +930,7 @@ grpc_error_handle BuildFilterChainMap(
     if (filter_chain.filter_chain_match.destination_port != 0) continue;
     grpc_error_handle error = AddFilterChainDataForDestinationIpRange(
         filter_chain, &internal_filter_chain_map.destination_ip_map);
-    if (error != GRPC_ERROR_NONE) return error;
+    if (!GRPC_ERROR_IS_NONE(error)) return error;
   }
   *filter_chain_map =
       BuildFromInternalFilterChainMap(&internal_filter_chain_map);
@@ -945,7 +945,7 @@ grpc_error_handle LdsResourceParseServer(
   grpc_error_handle error =
       AddressParse(envoy_config_listener_v3_Listener_address(listener),
                    &lds_update->address);
-  if (error != GRPC_ERROR_NONE) return error;
+  if (!GRPC_ERROR_IS_NONE(error)) return error;
   const auto* use_original_dst =
       envoy_config_listener_v3_Listener_use_original_dst(listener);
   if (use_original_dst != nullptr) {
@@ -962,19 +962,19 @@ grpc_error_handle LdsResourceParseServer(
   for (size_t i = 0; i < size; i++) {
     FilterChain filter_chain;
     error = FilterChainParse(context, filter_chains[i], is_v2, &filter_chain);
-    if (error != GRPC_ERROR_NONE) return error;
+    if (!GRPC_ERROR_IS_NONE(error)) return error;
     parsed_filter_chains.push_back(std::move(filter_chain));
   }
   error =
       BuildFilterChainMap(parsed_filter_chains, &lds_update->filter_chain_map);
-  if (error != GRPC_ERROR_NONE) return error;
+  if (!GRPC_ERROR_IS_NONE(error)) return error;
   auto* default_filter_chain =
       envoy_config_listener_v3_Listener_default_filter_chain(listener);
   if (default_filter_chain != nullptr) {
     FilterChain filter_chain;
     error =
         FilterChainParse(context, default_filter_chain, is_v2, &filter_chain);
-    if (error != GRPC_ERROR_NONE) return error;
+    if (!GRPC_ERROR_IS_NONE(error)) return error;
     if (filter_chain.filter_chain_data != nullptr) {
       lds_update->default_filter_chain =
           std::move(*filter_chain.filter_chain_data);
@@ -1046,7 +1046,7 @@ absl::StatusOr<XdsResourceType::DecodeResult> XdsListenerResourceType::Decode(
   auto listener_data = absl::make_unique<ResourceDataSubclass>();
   grpc_error_handle error =
       LdsResourceParse(context, resource, is_v2, &listener_data->resource);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     std::string error_str = grpc_error_std_string(error);
     GRPC_ERROR_UNREF(error);
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {

src/core/ext/xds/xds_route_config.cc

@@ -796,7 +796,7 @@ grpc_error_handle RouteActionParse(
             envoy_config_route_v3_WeightedCluster_ClusterWeight_TypedPerFilterConfigEntry_key,
             envoy_config_route_v3_WeightedCluster_ClusterWeight_TypedPerFilterConfigEntry_value,
             &cluster.typed_per_filter_config);
-        if (error != GRPC_ERROR_NONE) return error;
+        if (!GRPC_ERROR_IS_NONE(error)) return error;
       }
       action_weighted_clusters.emplace_back(std::move(cluster));
     }
@@ -935,7 +935,7 @@ grpc_error_handle RouteActionParse(
   if (retry_policy != nullptr) {
     absl::optional<XdsRouteConfigResource::RetryPolicy> retry;
     grpc_error_handle error = RetryPolicyParse(context, retry_policy, &retry);
-    if (error != GRPC_ERROR_NONE) return error;
+    if (!GRPC_ERROR_IS_NONE(error)) return error;
     route->retry_policy = retry;
   }
   return GRPC_ERROR_NONE;
@@ -951,7 +951,7 @@ grpc_error_handle XdsRouteConfigResource::Parse(
   if (XdsRlsEnabled()) {
     grpc_error_handle error =
         ClusterSpecifierPluginParse(context, route_config, rds_update);
-    if (error != GRPC_ERROR_NONE) return error;
+    if (!GRPC_ERROR_IS_NONE(error)) return error;
   }
   // Get the virtual hosts.
   size_t num_virtual_hosts;
@@ -987,7 +987,7 @@ grpc_error_handle XdsRouteConfigResource::Parse(
           envoy_config_route_v3_VirtualHost_TypedPerFilterConfigEntry_key,
           envoy_config_route_v3_VirtualHost_TypedPerFilterConfigEntry_value,
           &vhost.typed_per_filter_config);
-      if (error != GRPC_ERROR_NONE) return error;
+      if (!GRPC_ERROR_IS_NONE(error)) return error;
     }
     // Parse retry policy.
     absl::optional<XdsRouteConfigResource::RetryPolicy>
@@ -997,7 +997,7 @@ grpc_error_handle XdsRouteConfigResource::Parse(
     if (retry_policy != nullptr) {
       grpc_error_handle error =
           RetryPolicyParse(context, retry_policy, &virtual_host_retry_policy);
-      if (error != GRPC_ERROR_NONE) return error;
+      if (!GRPC_ERROR_IS_NONE(error)) return error;
     }
     // Parse routes.
     size_t num_routes;
@@ -1030,12 +1030,12 @@ grpc_error_handle XdsRouteConfigResource::Parse(
       bool ignore_route = false;
       grpc_error_handle error =
           RoutePathMatchParse(match, &route, &ignore_route);
-      if (error != GRPC_ERROR_NONE) return error;
+      if (!GRPC_ERROR_IS_NONE(error)) return error;
       if (ignore_route) continue;
       error = RouteHeaderMatchersParse(match, &route);
-      if (error != GRPC_ERROR_NONE) return error;
+      if (!GRPC_ERROR_IS_NONE(error)) return error;
       error = RouteRuntimeFractionParse(match, &route);
-      if (error != GRPC_ERROR_NONE) return error;
+      if (!GRPC_ERROR_IS_NONE(error)) return error;
       if (envoy_config_route_v3_Route_has_route(routes[j])) {
         route.action.emplace<XdsRouteConfigResource::Route::RouteAction>();
         auto& route_action =
@@ -1043,7 +1043,7 @@ grpc_error_handle XdsRouteConfigResource::Parse(
         error = RouteActionParse(context, routes[j],
                                  rds_update->cluster_specifier_plugin_map,
                                  &route_action, &ignore_route);
-        if (error != GRPC_ERROR_NONE) return error;
+        if (!GRPC_ERROR_IS_NONE(error)) return error;
         if (ignore_route) continue;
         if (route_action.retry_policy == absl::nullopt &&
             retry_policy != nullptr) {
@@ -1071,7 +1071,7 @@ grpc_error_handle XdsRouteConfigResource::Parse(
             envoy_config_route_v3_Route_TypedPerFilterConfigEntry_key,
             envoy_config_route_v3_Route_TypedPerFilterConfigEntry_value,
             &route.typed_per_filter_config);
-        if (error != GRPC_ERROR_NONE) return error;
+        if (!GRPC_ERROR_IS_NONE(error)) return error;
       }
       vhost.routes.emplace_back(std::move(route));
     }
@@ -1129,7 +1129,7 @@ XdsRouteConfigResourceType::Decode(const XdsEncodingContext& context,
   auto route_config_data = absl::make_unique<ResourceDataSubclass>();
   grpc_error_handle error = XdsRouteConfigResource::Parse(
       context, resource, &route_config_data->resource);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     std::string error_str = grpc_error_std_string(error);
     GRPC_ERROR_UNREF(error);
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {

src/core/ext/xds/xds_server_config_fetcher.cc

@@ -950,7 +950,7 @@ const XdsListenerResource::FilterChainData* FindFilterChainDataForSourceType(
   grpc_resolved_address source_addr;
   grpc_error_handle error = grpc_string_to_sockaddr(
       &source_addr, host.c_str(), 0 /* port doesn't matter here */);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_DEBUG, "Could not parse string to socket address: %s",
             host.c_str());
     GRPC_ERROR_UNREF(error);
@@ -1001,7 +1001,7 @@ const XdsListenerResource::FilterChainData* FindFilterChainDataForDestinationIp(
   grpc_resolved_address destination_addr;
   grpc_error_handle error = grpc_string_to_sockaddr(
       &destination_addr, host.c_str(), 0 /* port doesn't matter here */);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_DEBUG, "Could not parse string to socket address: %s",
             host.c_str());
     GRPC_ERROR_UNREF(error);
@@ -1146,7 +1146,7 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
       XdsRouting::GeneratePerHttpFilterConfigsResult result =
           XdsRouting::GeneratePerHTTPFilterConfigs(http_filters, vhost, route,
                                                    nullptr, nullptr);
-      if (result.error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(result.error)) {
         return grpc_error_to_absl_status(result.error);
       }
       std::vector<std::string> fields;
@@ -1170,7 +1170,7 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
         grpc_error_handle error = GRPC_ERROR_NONE;
         config_selector_route.method_config =
             ServiceConfigImpl::Create(result.args, json.c_str(), &error);
-        GPR_ASSERT(error == GRPC_ERROR_NONE);
+        GPR_ASSERT(GRPC_ERROR_IS_NONE(error));
       }
       grpc_channel_args_destroy(result.args);
     }
@@ -1347,7 +1347,7 @@ grpc_server_config_fetcher* grpc_server_config_fetcher_xds_create(
   grpc_core::RefCountedPtr<grpc_core::XdsClient> xds_client =
       grpc_core::XdsClient::GetOrCreate(args, &error);
   grpc_channel_args_destroy(args);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_ERROR, "Failed to create xds client: %s",
             grpc_error_std_string(error).c_str());
     GRPC_ERROR_UNREF(error);

src/core/lib/address_utils/parse_address.cc

@@ -55,7 +55,7 @@ bool grpc_parse_unix(const grpc_core::URI& uri,
   }
   grpc_error_handle error =
       grpc_core::UnixSockaddrPopulate(uri.path(), resolved_addr);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_ERROR, "%s", grpc_error_std_string(error).c_str());
     GRPC_ERROR_UNREF(error);
     return false;
@@ -72,7 +72,7 @@ bool grpc_parse_unix_abstract(const grpc_core::URI& uri,
   }
   grpc_error_handle error =
       grpc_core::UnixAbstractSockaddrPopulate(uri.path(), resolved_addr);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_ERROR, "%s", grpc_error_std_string(error).c_str());
     GRPC_ERROR_UNREF(error);
     return false;

src/core/lib/channel/channel_stack.cc

@@ -143,8 +143,8 @@ grpc_error_handle grpc_channel_stack_init(
     elems[i].channel_data = user_data;
     grpc_error_handle error =
         elems[i].filter->init_channel_elem(&elems[i], &args);
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
-      if (first_error == GRPC_ERROR_NONE) {
+      if (GRPC_ERROR_IS_NONE(first_error)) {
         first_error = error;
       } else {
         GRPC_ERROR_UNREF(error);
@@ -205,8 +205,8 @@ grpc_error_handle grpc_call_stack_init(
   for (size_t i = 0; i < count; i++) {
     grpc_error_handle error =
         call_elems[i].filter->init_call_elem(&call_elems[i], elem_args);
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
-      if (first_error == GRPC_ERROR_NONE) {
+      if (GRPC_ERROR_IS_NONE(first_error)) {
         first_error = error;
       } else {
         GRPC_ERROR_UNREF(error);

src/core/lib/channel/channel_stack_builder_impl.cc

@@ -77,7 +77,7 @@ ChannelStackBuilderImpl::Build() {
       channel_stack);
   grpc_channel_args_destroy(c_args);
 
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_channel_stack_destroy(channel_stack);
     gpr_free(channel_stack);
     auto status = grpc_error_to_absl_status(error);

src/core/lib/channel/channelz.cc

@@ -437,7 +437,7 @@ void PopulateSocketAddressJson(Json::Object* json, const char* name,
     grpc_resolved_address resolved_host;
     grpc_error_handle error =
         grpc_string_to_sockaddr(&resolved_host, host.c_str(), port_num);
-    if (error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(error)) {
       std::string packed_host = grpc_sockaddr_get_packed_host(&resolved_host);
       std::string b64_host = absl::Base64Escape(packed_host);
       data["tcpip_address"] = Json::Object{

src/core/lib/channel/promise_based_filter.cc

@@ -587,7 +587,7 @@ void ClientCallData::StartBatch(grpc_transport_stream_op_batch* b) {
       recv_trailing_state_ = RecvTrailingState::kForwarded;
       HookRecvTrailingMetadata(batch);
     }
-  } else if (cancelled_error_ != GRPC_ERROR_NONE) {
+  } else if (!GRPC_ERROR_IS_NONE(cancelled_error_)) {
     batch.CancelWith(GRPC_ERROR_REF(cancelled_error_), &flusher);
   }
 
@@ -698,7 +698,7 @@ void ClientCallData::RecvInitialMetadataReady(grpc_error_handle error) {
       abort();  // unreachable
   }
   Flusher flusher(this);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     recv_initial_metadata_->state = RecvInitialMetadata::kResponded;
     flusher.AddClosure(
         absl::exchange(recv_initial_metadata_->original_on_ready, nullptr),
@@ -835,7 +835,7 @@ void ClientCallData::RecvTrailingMetadataReady(grpc_error_handle error) {
   }
   // If there was an error, we'll put that into the trailing metadata and
   // proceed as if there was not.
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     SetStatusFromError(recv_trailing_metadata_, error);
   }
   // Record that we've got the callback.
@@ -1155,7 +1155,7 @@ void ServerCallData::RecvInitialMetadataReady(grpc_error_handle error) {
   Flusher flusher(this);
   GPR_ASSERT(recv_initial_state_ == RecvInitialState::kForwarded);
   // If there was an error we just propagate that through
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     recv_initial_state_ = RecvInitialState::kResponded;
     flusher.AddClosure(
         absl::exchange(original_recv_initial_metadata_ready_, nullptr),

src/core/lib/http/httpcli.cc

@@ -234,7 +234,7 @@ void HttpRequest::Orphan() {
 }
 
 void HttpRequest::AppendError(grpc_error_handle error) {
-  if (overall_error_ == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(overall_error_)) {
     overall_error_ =
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed HTTP/1 client request");
   }
@@ -253,7 +253,7 @@ void HttpRequest::OnReadInternal(grpc_error_handle error) {
       have_read_byte_ = 1;
       grpc_error_handle err =
           grpc_http_parser_parse(&parser_, incoming_.slices[i], nullptr);
-      if (err != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(err)) {
         Finish(err);
         return;
       }
@@ -262,7 +262,7 @@ void HttpRequest::OnReadInternal(grpc_error_handle error) {
   if (cancelled_) {
     Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
         "HTTP1 request cancelled during read", &overall_error_, 1));
-  } else if (error == GRPC_ERROR_NONE) {
+  } else if (GRPC_ERROR_IS_NONE(error)) {
     DoRead();
   } else if (!have_read_byte_) {
     NextAddress(GRPC_ERROR_REF(error));
@@ -275,7 +275,7 @@ void HttpRequest::ContinueDoneWriteAfterScheduleOnExecCtx(
     void* arg, grpc_error_handle error) {
   RefCountedPtr<HttpRequest> req(static_cast<HttpRequest*>(arg));
   MutexLock lock(&req->mu_);
-  if (error == GRPC_ERROR_NONE && !req->cancelled_) {
+  if (GRPC_ERROR_IS_NONE(error) && !req->cancelled_) {
     req->OnWritten();
   } else {
     req->NextAddress(GRPC_ERROR_REF(error));
@@ -300,7 +300,7 @@ void HttpRequest::OnHandshakeDone(void* arg, grpc_error_handle error) {
   }
   MutexLock lock(&req->mu_);
   req->own_endpoint_ = true;
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     req->handshake_mgr_.reset();
     req->NextAddress(GRPC_ERROR_REF(error));
     return;
@@ -364,7 +364,7 @@ void HttpRequest::DoHandshake(const grpc_resolved_address* addr) {
 }
 
 void HttpRequest::NextAddress(grpc_error_handle error) {
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     AppendError(error);
   }
   if (cancelled_) {

src/core/lib/http/parser.cc

@@ -236,7 +236,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 +249,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 +264,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 +449,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;

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

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 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, int min_progress_size);
 

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

src/core/lib/iomgr/error.cc

@@ -97,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);
@@ -138,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);
@@ -213,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;
@@ -564,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);
@@ -677,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 (!GRPC_ERROR_IS_NONE(src)) {
-    if (child == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(child)) {
       /* \a child is empty. Simply return the ref to \a src */
       return src;
     } else if (child != src) {
@@ -908,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;
 
@@ -980,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);

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
+  return GRPC_ERROR_IS_NONE(error) ? true
-                                  : grpc_log_error(what, error, file, line);
+                                   : 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;
   }

src/core/lib/iomgr/ev_epoll1_linux.cc

@@ -242,8 +242,8 @@ struct grpc_pollset_set {
 
 static bool append_error(grpc_error_handle* composite, grpc_error_handle error,
                          const char* desc) {
-  if (error == GRPC_ERROR_NONE) return true;
+  if (GRPC_ERROR_IS_NONE(error)) return true;
-  if (*composite == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(*composite)) {
     *composite = GRPC_ERROR_CREATE_FROM_COPIED_STRING(desc);
   }
   *composite = grpc_error_add_child(*composite, error);
@@ -517,7 +517,7 @@ static grpc_error_handle pollset_global_init(void) {
   gpr_atm_no_barrier_store(&g_active_poller, 0);
   global_wakeup_fd.read_fd = -1;
   grpc_error_handle err = grpc_wakeup_fd_init(&global_wakeup_fd);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   struct epoll_event ev;
   ev.events = static_cast<uint32_t>(EPOLLIN | EPOLLET);
   ev.data.ptr = &global_wakeup_fd;

src/core/lib/iomgr/ev_poll_posix.cc

@@ -757,8 +757,8 @@ static void push_front_worker(grpc_pollset* p, grpc_pollset_worker* worker) {
 
 static void kick_append_error(grpc_error_handle* composite,
                               grpc_error_handle error) {
-  if (error == GRPC_ERROR_NONE) return;
+  if (GRPC_ERROR_IS_NONE(error)) return;
-  if (*composite == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(*composite)) {
     *composite = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Kick Failure");
   }
   *composite = grpc_error_add_child(*composite, error);
@@ -904,8 +904,8 @@ static void finish_shutdown(grpc_pollset* pollset) {
 
 static void work_combine_error(grpc_error_handle* composite,
                                grpc_error_handle error) {
-  if (error == GRPC_ERROR_NONE) return;
+  if (GRPC_ERROR_IS_NONE(error)) return;
-  if (*composite == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(*composite)) {
     *composite = GRPC_ERROR_CREATE_FROM_STATIC_STRING("pollset_work");
   }
   *composite = grpc_error_add_child(*composite, error);
@@ -940,7 +940,7 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
         gpr_malloc(sizeof(*worker.wakeup_fd)));
     error = grpc_wakeup_fd_init(&worker.wakeup_fd->fd);
     fork_fd_list_add_wakeup_fd(worker.wakeup_fd);
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
       GRPC_LOG_IF_ERROR("pollset_work", GRPC_ERROR_REF(error));
       return error;
     }
@@ -1100,7 +1100,7 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
     /* If we're forced to re-evaluate polling (via pollset_kick with
        GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP) then we land here and force
        a loop */
-    if (worker.reevaluate_polling_on_wakeup && error == GRPC_ERROR_NONE) {
+    if (worker.reevaluate_polling_on_wakeup && GRPC_ERROR_IS_NONE(error)) {
       worker.reevaluate_polling_on_wakeup = 0;
       pollset->kicked_without_pollers = 0;
       if (queued_work || worker.kicked_specifically) {

src/core/lib/iomgr/load_file.cc

@@ -66,7 +66,7 @@ grpc_error_handle grpc_load_file(const char* filename, int add_null_terminator,
 end:
   *output = result;
   if (file != nullptr) fclose(file);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_error_handle error_out =
         grpc_error_set_str(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                                "Failed to load file", &error, 1),

src/core/lib/iomgr/resolve_address_posix.cc

@@ -165,7 +165,7 @@ done:
   if (result) {
     freeaddrinfo(result);
   }
-  if (err == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(err)) {
     return addresses;
   }
   auto error_result = grpc_error_to_absl_status(err);

src/core/lib/iomgr/resolve_address_windows.cc

@@ -149,7 +149,7 @@ done:
   if (result) {
     freeaddrinfo(result);
   }
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     return addresses;
   }
   auto error_result = grpc_error_to_absl_status(error);

src/core/lib/iomgr/tcp_client_cfstream.cc

@@ -116,7 +116,7 @@ static void OnOpen(void* arg, grpc_error_handle error) {
     gpr_mu_unlock(&connect->mu);
     CFStreamConnectCleanup(connect);
   } else {
-    if (error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(error)) {
       CFErrorRef stream_error = CFReadStreamCopyError(connect->read_stream);
       if (stream_error == NULL) {
         stream_error = CFWriteStreamCopyError(connect->write_stream);
@@ -125,7 +125,7 @@ static void OnOpen(void* arg, grpc_error_handle error) {
         error = GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "connect() error");
         CFRelease(stream_error);
       }
-      if (error == GRPC_ERROR_NONE) {
+      if (GRPC_ERROR_IS_NONE(error)) {
         *endpoint = grpc_cfstream_endpoint_create(
             connect->read_stream, connect->write_stream,
             connect->addr_name.c_str(), connect->stream_handle);

src/core/lib/iomgr/tcp_client_posix.cc

@@ -72,24 +72,24 @@ static grpc_error_handle prepare_socket(const grpc_resolved_address* addr,
   GPR_ASSERT(fd >= 0);
 
   err = grpc_set_socket_nonblocking(fd, 1);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
   err = grpc_set_socket_cloexec(fd, 1);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
   if (!grpc_is_unix_socket(addr)) {
     err = grpc_set_socket_low_latency(fd, 1);
-    if (err != GRPC_ERROR_NONE) goto error;
+    if (!GRPC_ERROR_IS_NONE(err)) goto error;
     err = grpc_set_socket_reuse_addr(fd, 1);
-    if (err != GRPC_ERROR_NONE) goto error;
+    if (!GRPC_ERROR_IS_NONE(err)) goto error;
     err = grpc_set_socket_tcp_user_timeout(fd, channel_args,
                                            true /* is_client */);
-    if (err != GRPC_ERROR_NONE) goto error;
+    if (!GRPC_ERROR_IS_NONE(err)) goto error;
   }
   err = grpc_set_socket_no_sigpipe_if_possible(fd);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
 
   err = grpc_apply_socket_mutator_in_args(fd, GRPC_FD_CLIENT_CONNECTION_USAGE,
                                           channel_args);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
 
   goto done;
 
@@ -155,7 +155,7 @@ static void on_writable(void* acp, grpc_error_handle error) {
   grpc_timer_cancel(&ac->alarm);
 
   gpr_mu_lock(&ac->mu);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     error =
         grpc_error_set_str(error, GRPC_ERROR_STR_OS_ERROR, "Timeout occurred");
     goto finish;
@@ -215,7 +215,7 @@ finish:
   }
   done = (--ac->refs == 0);
   gpr_mu_unlock(&ac->mu);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     std::string str;
     bool ret = grpc_error_get_str(error, GRPC_ERROR_STR_DESCRIPTION, &str);
     GPR_ASSERT(ret);
@@ -251,7 +251,7 @@ grpc_error_handle grpc_tcp_client_prepare_fd(
   }
   error =
       grpc_create_dualstack_socket(mapped_addr, SOCK_STREAM, 0, &dsmode, fd);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     return error;
   }
   if (dsmode == GRPC_DSMODE_IPV4) {

src/core/lib/iomgr/tcp_client_windows.cc

@@ -93,7 +93,7 @@ static void on_connect(void* acp, grpc_error_handle error) {
 
   gpr_mu_lock(&ac->mu);
 
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     if (socket != NULL) {
       DWORD transfered_bytes = 0;
       DWORD flags;
@@ -161,7 +161,7 @@ static void tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
   }
 
   error = grpc_tcp_prepare_socket(sock);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     goto failure;
   }
 
@@ -219,7 +219,7 @@ static void tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
   return;
 
 failure:
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
   grpc_error_handle final_error = grpc_error_set_str(
       GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING("Failed to connect",
                                                        &error, 1),

src/core/lib/iomgr/tcp_posix.cc

@@ -889,7 +889,7 @@ static void tcp_handle_read(void* arg /* grpc_tcp */, grpc_error_handle error) {
   }
   tcp->read_mu.Lock();
   grpc_error_handle tcp_read_error;
-  if (GPR_LIKELY(error == GRPC_ERROR_NONE)) {
+  if (GPR_LIKELY(GRPC_ERROR_IS_NONE(error))) {
     maybe_make_read_slices(tcp);
     if (!tcp_do_read(tcp, &tcp_read_error)) {
       /* We've consumed the edge, request a new one */
@@ -1231,7 +1231,7 @@ static void tcp_handle_error(void* arg /* grpc_tcp */,
             grpc_error_std_string(error).c_str());
   }
 
-  if (error != GRPC_ERROR_NONE ||
+  if (!GRPC_ERROR_IS_NONE(error) ||
       static_cast<bool>(gpr_atm_acq_load(&tcp->stop_error_notification))) {
     /* We aren't going to register to hear on error anymore, so it is safe to
      * unref. */
@@ -1537,7 +1537,7 @@ static void tcp_handle_write(void* arg /* grpc_tcp */,
   grpc_tcp* tcp = static_cast<grpc_tcp*>(arg);
   grpc_closure* cb;
 
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     cb = tcp->write_cb;
     tcp->write_cb = nullptr;
     if (tcp->current_zerocopy_send != nullptr) {
@@ -1560,7 +1560,7 @@ static void tcp_handle_write(void* arg /* grpc_tcp */,
     }
     notify_on_write(tcp);
     // tcp_flush does not populate error if it has returned false.
-    GPR_DEBUG_ASSERT(error == GRPC_ERROR_NONE);
+    GPR_DEBUG_ASSERT(GRPC_ERROR_IS_NONE(error));
   } else {
     cb = tcp->write_cb;
     tcp->write_cb = nullptr;

src/core/lib/iomgr/tcp_server_posix.cc

@@ -191,7 +191,7 @@ static void tcp_server_destroy(grpc_tcp_server* s) {
 static void on_read(void* arg, grpc_error_handle err) {
   grpc_tcp_listener* sp = static_cast<grpc_tcp_listener*>(arg);
   grpc_pollset* read_notifier_pollset;
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     goto error;
   }
 
@@ -253,7 +253,7 @@ static void on_read(void* arg, grpc_error_handle err) {
 
     err = grpc_apply_socket_mutator_in_args(fd, GRPC_FD_SERVER_CONNECTION_USAGE,
                                             sp->server->channel_args);
-    if (err != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(err)) {
       goto error;
     }
 
@@ -344,14 +344,14 @@ static grpc_error_handle add_wildcard_addrs_to_server(grpc_tcp_server* s,
     }
   }
   if (*out_port > 0) {
-    if (v6_err != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(v6_err)) {
       gpr_log(GPR_INFO,
               "Failed to add :: listener, "
               "the environment may not support IPv6: %s",
               grpc_error_std_string(v6_err).c_str());
       GRPC_ERROR_UNREF(v6_err);
     }
-    if (v4_err != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(v4_err)) {
       gpr_log(GPR_INFO,
               "Failed to add 0.0.0.0 listener, "
               "the environment may not support IPv4: %s",
@@ -362,7 +362,7 @@ static grpc_error_handle add_wildcard_addrs_to_server(grpc_tcp_server* s,
   } else {
     grpc_error_handle root_err = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "Failed to add any wildcard listeners");
-    GPR_ASSERT(v6_err != GRPC_ERROR_NONE && v4_err != GRPC_ERROR_NONE);
+    GPR_ASSERT(!GRPC_ERROR_IS_NONE(v6_err) && !GRPC_ERROR_IS_NONE(v4_err));
     root_err = grpc_error_add_child(root_err, v6_err);
     root_err = grpc_error_add_child(root_err, v4_err);
     return root_err;
@@ -385,10 +385,10 @@ static grpc_error_handle clone_port(grpc_tcp_listener* listener,
     grpc_dualstack_mode dsmode;
     err = grpc_create_dualstack_socket(&listener->addr, SOCK_STREAM, 0, &dsmode,
                                        &fd);
-    if (err != GRPC_ERROR_NONE) return err;
+    if (!GRPC_ERROR_IS_NONE(err)) return err;
     err = grpc_tcp_server_prepare_socket(listener->server, fd, &listener->addr,
                                          true, &port);
-    if (err != GRPC_ERROR_NONE) return err;
+    if (!GRPC_ERROR_IS_NONE(err)) return err;
     listener->server->nports++;
     addr_str = grpc_sockaddr_to_string(&listener->addr, true);
     if (!addr_str.ok()) {

src/core/lib/iomgr/tcp_server_utils_posix_common.cc

@@ -90,7 +90,7 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, int fd,
 
   grpc_error_handle err =
       grpc_tcp_server_prepare_socket(s, fd, addr, s->so_reuseport, &port);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   GPR_ASSERT(port > 0);
   absl::StatusOr<std::string> addr_str = grpc_sockaddr_to_string(addr, true);
   if (!addr_str.ok()) {
@@ -137,7 +137,7 @@ grpc_error_handle grpc_tcp_server_add_addr(grpc_tcp_server* s,
   int fd;
   grpc_error_handle err =
       grpc_create_dualstack_socket(addr, SOCK_STREAM, 0, dsmode, &fd);
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     return err;
   }
   if (*dsmode == GRPC_DSMODE_IPV4 &&
@@ -158,36 +158,36 @@ grpc_error_handle grpc_tcp_server_prepare_socket(
 
   if (so_reuseport && !grpc_is_unix_socket(addr)) {
     err = grpc_set_socket_reuse_port(fd, 1);
-    if (err != GRPC_ERROR_NONE) goto error;
+    if (!GRPC_ERROR_IS_NONE(err)) goto error;
   }
 
 #ifdef GRPC_LINUX_ERRQUEUE
   err = grpc_set_socket_zerocopy(fd);
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     /* it's not fatal, so just log it. */
     gpr_log(GPR_DEBUG, "Node does not support SO_ZEROCOPY, continuing.");
     GRPC_ERROR_UNREF(err);
   }
 #endif
   err = grpc_set_socket_nonblocking(fd, 1);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
   err = grpc_set_socket_cloexec(fd, 1);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
   if (!grpc_is_unix_socket(addr)) {
     err = grpc_set_socket_low_latency(fd, 1);
-    if (err != GRPC_ERROR_NONE) goto error;
+    if (!GRPC_ERROR_IS_NONE(err)) goto error;
     err = grpc_set_socket_reuse_addr(fd, 1);
-    if (err != GRPC_ERROR_NONE) goto error;
+    if (!GRPC_ERROR_IS_NONE(err)) goto error;
     err = grpc_set_socket_tcp_user_timeout(fd, s->channel_args,
                                            false /* is_client */);
-    if (err != GRPC_ERROR_NONE) goto error;
+    if (!GRPC_ERROR_IS_NONE(err)) goto error;
   }
   err = grpc_set_socket_no_sigpipe_if_possible(fd);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
 
   err = grpc_apply_socket_mutator_in_args(fd, GRPC_FD_SERVER_LISTENER_USAGE,
                                           s->channel_args);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
 
   if (bind(fd, reinterpret_cast<grpc_sockaddr*>(const_cast<char*>(addr->addr)),
            addr->len) < 0) {
@@ -212,7 +212,7 @@ grpc_error_handle grpc_tcp_server_prepare_socket(
   return GRPC_ERROR_NONE;
 
 error:
-  GPR_ASSERT(err != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(err));
   if (fd >= 0) {
     close(fd);
   }

src/core/lib/iomgr/tcp_server_utils_posix_ifaddrs.cc

@@ -65,7 +65,7 @@ static grpc_error_handle get_unused_port(int* port) {
   int fd;
   grpc_error_handle err =
       grpc_create_dualstack_socket(&wild, SOCK_STREAM, 0, &dsmode, &fd);
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     return err;
   }
   if (dsmode == GRPC_DSMODE_IPV4) {
@@ -164,7 +164,7 @@ grpc_error_handle grpc_tcp_server_add_all_local_addrs(grpc_tcp_server* s,
     }
   }
   freeifaddrs(ifa);
-  if (err != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(err)) {
     return err;
   } else if (sp == nullptr) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("No local addresses");

src/core/lib/iomgr/tcp_server_windows.cc

@@ -197,7 +197,7 @@ static grpc_error_handle prepare_socket(SOCKET sock,
   int sockname_temp_len;
 
   error = grpc_tcp_prepare_socket(sock);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     goto failure;
   }
 
@@ -224,7 +224,7 @@ static grpc_error_handle prepare_socket(SOCKET sock,
   return GRPC_ERROR_NONE;
 
 failure:
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
   auto addr_uri = grpc_sockaddr_to_uri(addr);
   grpc_error_set_int(
       grpc_error_set_str(
@@ -267,7 +267,7 @@ static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
   }
 
   error = grpc_tcp_prepare_socket(sock);
-  if (error != GRPC_ERROR_NONE) goto failure;
+  if (!GRPC_ERROR_IS_NONE(error)) goto failure;
 
   /* Start the "accept" asynchronously. */
   success = port->AcceptEx(port->socket->socket, sock, port->addresses, 0,
@@ -292,7 +292,7 @@ static grpc_error_handle start_accept_locked(grpc_tcp_listener* port) {
   return error;
 
 failure:
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
   if (sock != INVALID_SOCKET) closesocket(sock);
   return error;
 }
@@ -316,7 +316,7 @@ static void on_accept(void* arg, grpc_error_handle error) {
   /* The general mechanism for shutting down is to queue abortion calls. While
      this is necessary in the read/write case, it's useless for the accept
      case. We only need to adjust the pending callback count */
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_INFO, "Skipping on_accept due to error: %s",
             grpc_error_std_string(error).c_str());
 
@@ -419,7 +419,7 @@ static grpc_error_handle add_socket_to_server(grpc_tcp_server* s, SOCKET sock,
   }
 
   error = prepare_socket(sock, addr, &port);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     return error;
   }
 
@@ -511,7 +511,7 @@ static grpc_error_handle tcp_server_add_port(grpc_tcp_server* s,
 done:
   gpr_free(allocated_addr);
 
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_error_handle error_out =
         GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
             "Failed to add port to server", &error, 1);

src/core/lib/iomgr/tcp_windows.cc

@@ -89,11 +89,11 @@ static grpc_error_handle enable_socket_low_latency(SOCKET sock) {
 grpc_error_handle grpc_tcp_prepare_socket(SOCKET sock) {
   grpc_error_handle err;
   err = grpc_tcp_set_non_block(sock);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   err = set_dualstack(sock);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   err = enable_socket_low_latency(sock);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   return GRPC_ERROR_NONE;
 }
 
@@ -186,7 +186,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
 
   (void)GRPC_ERROR_REF(error);
 
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     if (info->wsa_error != 0 && !tcp->shutting_down) {
       char* utf8_message = gpr_format_message(info->wsa_error);
       error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(utf8_message);
@@ -331,7 +331,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
   tcp->write_cb = NULL;
   gpr_mu_unlock(&tcp->mu);
 
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     if (info->wsa_error != 0) {
       error = GRPC_WSA_ERROR(info->wsa_error, "WSASend");
     } else {

src/core/lib/iomgr/unix_sockets_posix.cc

@@ -45,7 +45,7 @@ absl::StatusOr<std::vector<grpc_resolved_address>>
 grpc_resolve_unix_domain_address(absl::string_view name) {
   grpc_resolved_address addr;
   grpc_error_handle error = grpc_core::UnixSockaddrPopulate(name, &addr);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     return std::vector<grpc_resolved_address>({addr});
   }
   auto result = grpc_error_to_absl_status(error);
@@ -58,7 +58,7 @@ grpc_resolve_unix_abstract_domain_address(const absl::string_view name) {
   grpc_resolved_address addr;
   grpc_error_handle error =
       grpc_core::UnixAbstractSockaddrPopulate(name, &addr);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     return std::vector<grpc_resolved_address>({addr});
   }
   auto result = grpc_error_to_absl_status(error);

src/core/lib/iomgr/wakeup_fd_pipe.cc

@@ -41,9 +41,9 @@ static grpc_error_handle pipe_init(grpc_wakeup_fd* fd_info) {
   }
   grpc_error_handle err;
   err = grpc_set_socket_nonblocking(pipefd[0], 1);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   err = grpc_set_socket_nonblocking(pipefd[1], 1);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   fd_info->read_fd = pipefd[0];
   fd_info->write_fd = pipefd[1];
   return GRPC_ERROR_NONE;

src/core/lib/security/authorization/evaluate_args.cc

@@ -50,7 +50,7 @@ EvaluateArgs::PerChannelArgs::Address ParseEndpointUri(
   address.address_str = std::string(host_view);
   grpc_error_handle error = grpc_string_to_sockaddr(
       &address.address, address.address_str.c_str(), address.port);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_DEBUG, "Address %s is not IPv4/IPv6. Error: %s",
             address.address_str.c_str(), grpc_error_std_string(error).c_str());
   }

src/core/lib/security/authorization/grpc_authorization_policy_provider.cc

@@ -50,7 +50,7 @@ absl::StatusOr<std::string> ReadPolicyFromFile(absl::string_view policy_path) {
   grpc_slice policy_slice = grpc_empty_slice();
   grpc_error_handle error =
       grpc_load_file(std::string(policy_path).c_str(), 0, &policy_slice);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     absl::Status status =
         absl::InvalidArgumentError(grpc_error_std_string(error));
     GRPC_ERROR_UNREF(error);

src/core/lib/security/authorization/matchers.cc

@@ -145,7 +145,7 @@ IpAuthorizationMatcher::IpAuthorizationMatcher(Type type, Rbac::CidrRange range)
   grpc_error_handle error =
       grpc_string_to_sockaddr(&subnet_address_, range.address_prefix.c_str(),
                               /*port does not matter here*/ 0);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     grpc_sockaddr_mask_bits(&subnet_address_, prefix_len_);
   } else {
     gpr_log(GPR_DEBUG, "CidrRange address %s is not IPv4/IPv6. Error: %s",

src/core/lib/security/authorization/rbac_translator.cc

@@ -317,7 +317,7 @@ absl::StatusOr<RbacPolicies> GenerateRbacPolicies(
     absl::string_view authz_policy) {
   grpc_error_handle error = GRPC_ERROR_NONE;
   Json json = Json::Parse(authz_policy, &error);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     absl::Status status = absl::InvalidArgumentError(
         absl::StrCat("Failed to parse gRPC authorization policy. Error: ",
                      grpc_error_std_string(error)));

src/core/lib/security/credentials/external/aws_external_account_credentials.cc

@@ -64,7 +64,7 @@ AwsExternalAccountCredentials::Create(Options options,
                                       grpc_error_handle* error) {
   auto creds = MakeRefCounted<AwsExternalAccountCredentials>(
       std::move(options), std::move(scopes), error);
-  if (*error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(*error)) {
     return creds;
   } else {
     return nullptr;
@@ -191,7 +191,7 @@ void AwsExternalAccountCredentials::OnRetrieveImdsV2SessionToken(
 
 void AwsExternalAccountCredentials::OnRetrieveImdsV2SessionTokenInternal(
     grpc_error_handle error) {
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     FinishRetrieveSubjectToken("", error);
     return;
   }
@@ -269,7 +269,7 @@ void AwsExternalAccountCredentials::OnRetrieveRegion(void* arg,
 
 void AwsExternalAccountCredentials::OnRetrieveRegionInternal(
     grpc_error_handle error) {
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     FinishRetrieveSubjectToken("", error);
     return;
   }
@@ -323,7 +323,7 @@ void AwsExternalAccountCredentials::OnRetrieveRoleName(
 
 void AwsExternalAccountCredentials::OnRetrieveRoleNameInternal(
     grpc_error_handle error) {
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     FinishRetrieveSubjectToken("", error);
     return;
   }
@@ -389,14 +389,14 @@ void AwsExternalAccountCredentials::OnRetrieveSigningKeys(
 
 void AwsExternalAccountCredentials::OnRetrieveSigningKeysInternal(
     grpc_error_handle error) {
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     FinishRetrieveSubjectToken("", error);
     return;
   }
   absl::string_view response_body(ctx_->response.body,
                                   ctx_->response.body_length);
   Json json = Json::Parse(response_body, &error);
-  if (error != GRPC_ERROR_NONE || json.type() != Json::Type::OBJECT) {
+  if (!GRPC_ERROR_IS_NONE(error) || json.type() != Json::Type::OBJECT) {
     FinishRetrieveSubjectToken(
         "", GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                 "Invalid retrieve signing keys response.", &error, 1));
@@ -445,7 +445,7 @@ void AwsExternalAccountCredentials::BuildSubjectToken() {
         access_key_id_, secret_access_key_, token_, "POST",
         cred_verification_url_, region_, "",
         std::map<std::string, std::string>(), &error);
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
       FinishRetrieveSubjectToken(
           "", GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                   "Creating aws request signer failed.", &error, 1));
@@ -454,7 +454,7 @@ void AwsExternalAccountCredentials::BuildSubjectToken() {
     }
   }
   auto signed_headers = signer_->GetSignedRequestHeaders();
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     FinishRetrieveSubjectToken("",
                                GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                                    "Invalid getting signed request"
@@ -490,7 +490,7 @@ void AwsExternalAccountCredentials::FinishRetrieveSubjectToken(
   auto cb = cb_;
   cb_ = nullptr;
   // Invoke the callback.
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     cb("", error);
   } else {
     cb(subject_token, GRPC_ERROR_NONE);

src/core/lib/security/credentials/external/external_account_credentials.cc

@@ -87,7 +87,7 @@ bool MatchWorkforcePoolAudience(absl::string_view audience) {
 RefCountedPtr<ExternalAccountCredentials> ExternalAccountCredentials::Create(
     const Json& json, std::vector<std::string> scopes,
     grpc_error_handle* error) {
-  GPR_ASSERT(*error == GRPC_ERROR_NONE);
+  GPR_ASSERT(GRPC_ERROR_IS_NONE(*error));
   Options options;
   options.type = GRPC_AUTH_JSON_TYPE_INVALID;
   if (json.type() != Json::Type::OBJECT) {
@@ -203,7 +203,7 @@ RefCountedPtr<ExternalAccountCredentials> ExternalAccountCredentials::Create(
         "Invalid options credential source to create "
         "ExternalAccountCredentials.");
   }
-  if (*error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(*error)) {
     return creds;
   } else {
     return nullptr;
@@ -255,7 +255,7 @@ void ExternalAccountCredentials::fetch_oauth2(
 
 void ExternalAccountCredentials::OnRetrieveSubjectTokenInternal(
     absl::string_view subject_token, grpc_error_handle error) {
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     FinishTokenFetch(error);
   } else {
     ExchangeToken(subject_token);
@@ -355,7 +355,7 @@ void ExternalAccountCredentials::OnExchangeToken(void* arg,
 void ExternalAccountCredentials::OnExchangeTokenInternal(
     grpc_error_handle error) {
   http_request_.reset();
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     FinishTokenFetch(error);
   } else {
     if (options_.service_account_impersonation_url.empty()) {
@@ -382,7 +382,7 @@ void ExternalAccountCredentials::ImpersenateServiceAccount() {
   absl::string_view response_body(ctx_->response.body,
                                   ctx_->response.body_length);
   Json json = Json::Parse(response_body, &error);
-  if (error != GRPC_ERROR_NONE || json.type() != Json::Type::OBJECT) {
+  if (!GRPC_ERROR_IS_NONE(error) || json.type() != Json::Type::OBJECT) {
     FinishTokenFetch(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
         "Invalid token exchange response.", &error, 1));
     GRPC_ERROR_UNREF(error);
@@ -449,14 +449,14 @@ void ExternalAccountCredentials::OnImpersenateServiceAccount(
 void ExternalAccountCredentials::OnImpersenateServiceAccountInternal(
     grpc_error_handle error) {
   http_request_.reset();
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     FinishTokenFetch(error);
     return;
   }
   absl::string_view response_body(ctx_->response.body,
                                   ctx_->response.body_length);
   Json json = Json::Parse(response_body, &error);
-  if (error != GRPC_ERROR_NONE || json.type() != Json::Type::OBJECT) {
+  if (!GRPC_ERROR_IS_NONE(error) || json.type() != Json::Type::OBJECT) {
     FinishTokenFetch(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
         "Invalid service account impersonation response.", &error, 1));
     GRPC_ERROR_UNREF(error);
@@ -525,7 +525,7 @@ grpc_call_credentials* grpc_external_account_credentials_create(
     const char* json_string, const char* scopes_string) {
   grpc_error_handle error = GRPC_ERROR_NONE;
   grpc_core::Json json = grpc_core::Json::Parse(json_string, &error);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_ERROR,
             "External account credentials creation failed. Error: %s.",
             grpc_error_std_string(error).c_str());
@@ -536,7 +536,7 @@ grpc_call_credentials* grpc_external_account_credentials_create(
   auto creds = grpc_core::ExternalAccountCredentials::Create(
                    json, std::move(scopes), &error)
                    .release();
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_ERROR,
             "External account credentials creation failed. Error: %s.",
             grpc_error_std_string(error).c_str());

src/core/lib/security/credentials/external/file_external_account_credentials.cc

@@ -30,7 +30,7 @@ FileExternalAccountCredentials::Create(Options options,
                                        grpc_error_handle* error) {
   auto creds = MakeRefCounted<FileExternalAccountCredentials>(
       std::move(options), std::move(scopes), error);
-  if (*error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(*error)) {
     return creds;
   } else {
     return nullptr;
@@ -101,14 +101,15 @@ void FileExternalAccountCredentials::RetrieveSubjectToken(
   // request because it may have changed since the last request.
   grpc_error_handle error =
       grpc_load_file(file_.c_str(), 0, &content_slice.slice);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     cb("", error);
     return;
   }
   absl::string_view content = StringViewFromSlice(content_slice.slice);
   if (format_type_ == "json") {
     Json content_json = Json::Parse(content, &error);
-    if (error != GRPC_ERROR_NONE || content_json.type() != Json::Type::OBJECT) {
+    if (!GRPC_ERROR_IS_NONE(error) ||
+        content_json.type() != Json::Type::OBJECT) {
       cb("", GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                  "The content of the file is not a valid json object."));
       GRPC_ERROR_UNREF(error);

src/core/lib/security/credentials/external/url_external_account_credentials.cc

@@ -34,7 +34,7 @@ UrlExternalAccountCredentials::Create(Options options,
                                       grpc_error_handle* error) {
   auto creds = MakeRefCounted<UrlExternalAccountCredentials>(
       std::move(options), std::move(scopes), error);
-  if (*error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(*error)) {
     return creds;
   } else {
     return nullptr;
@@ -179,7 +179,7 @@ void UrlExternalAccountCredentials::OnRetrieveSubjectToken(
 void UrlExternalAccountCredentials::OnRetrieveSubjectTokenInternal(
     grpc_error_handle error) {
   http_request_.reset();
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     FinishRetrieveSubjectToken("", error);
     return;
   }
@@ -188,7 +188,7 @@ void UrlExternalAccountCredentials::OnRetrieveSubjectTokenInternal(
   if (format_type_ == "json") {
     grpc_error_handle error = GRPC_ERROR_NONE;
     Json response_json = Json::Parse(response_body, &error);
-    if (error != GRPC_ERROR_NONE ||
+    if (!GRPC_ERROR_IS_NONE(error) ||
         response_json.type() != Json::Type::OBJECT) {
       FinishRetrieveSubjectToken(
           "", GRPC_ERROR_CREATE_FROM_STATIC_STRING(
@@ -222,7 +222,7 @@ void UrlExternalAccountCredentials::FinishRetrieveSubjectToken(
   auto cb = cb_;
   cb_ = nullptr;
   // Invoke the callback.
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     cb("", error);
   } else {
     cb(subject_token, GRPC_ERROR_NONE);

src/core/lib/security/credentials/google_default/google_default_credentials.cc

@@ -157,7 +157,7 @@ static void on_metadata_server_detection_http_response(
     void* user_data, grpc_error_handle error) {
   metadata_server_detector* detector =
       static_cast<metadata_server_detector*>(user_data);
-  if (error == GRPC_ERROR_NONE && detector->response.status == 200 &&
+  if (GRPC_ERROR_IS_NONE(error) && detector->response.status == 200 &&
       detector->response.hdr_count > 0) {
     /* Internet providers can return a generic response to all requests, so
        it is necessary to check that metadata header is present also. */
@@ -300,9 +300,9 @@ static grpc_error_handle create_default_creds_from_path(
     goto end;
   }
   error = grpc_load_file(creds_path.c_str(), 0, &creds_data);
-  if (error != GRPC_ERROR_NONE) goto end;
+  if (!GRPC_ERROR_IS_NONE(error)) goto end;
   json = Json::Parse(grpc_core::StringViewFromSlice(creds_data), &error);
-  if (error != GRPC_ERROR_NONE) goto end;
+  if (!GRPC_ERROR_IS_NONE(error)) goto end;
   if (json.type() != Json::Type::OBJECT) {
     error = grpc_error_set_str(
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to parse JSON"),
@@ -346,7 +346,7 @@ static grpc_error_handle create_default_creds_from_path(
   result = grpc_core::ExternalAccountCredentials::Create(json, {}, &error);
 
 end:
-  GPR_ASSERT((result == nullptr) + (error == GRPC_ERROR_NONE) == 1);
+  GPR_ASSERT((result == nullptr) + (GRPC_ERROR_IS_NONE(error)) == 1);
   grpc_slice_unref_internal(creds_data);
   *creds = result;
   return error;
@@ -383,14 +383,14 @@ static grpc_core::RefCountedPtr<grpc_call_credentials> make_default_call_creds(
   if (path_from_env != nullptr) {
     err = create_default_creds_from_path(path_from_env, &call_creds);
     gpr_free(path_from_env);
-    if (err == GRPC_ERROR_NONE) return call_creds;
+    if (GRPC_ERROR_IS_NONE(err)) return call_creds;
     *error = grpc_error_add_child(*error, err);
   }
 
   /* Then the well-known file. */
   err = create_default_creds_from_path(
       grpc_get_well_known_google_credentials_file_path(), &call_creds);
-  if (err == GRPC_ERROR_NONE) return call_creds;
+  if (GRPC_ERROR_IS_NONE(err)) return call_creds;
   *error = grpc_error_add_child(*error, err);
 
   update_tenancy();

src/core/lib/security/credentials/jwt/jwt_credentials.cc

@@ -137,7 +137,7 @@ grpc_service_account_jwt_access_credentials_create_from_auth_json_key(
 static char* redact_private_key(const char* json_key) {
   grpc_error_handle error = GRPC_ERROR_NONE;
   Json json = Json::Parse(json_key, &error);
-  if (error != GRPC_ERROR_NONE || json.type() != Json::Type::OBJECT) {
+  if (!GRPC_ERROR_IS_NONE(error) || json.type() != Json::Type::OBJECT) {
     GRPC_ERROR_UNREF(error);
     return gpr_strdup("<Json failed to parse.>");
   }

src/core/lib/security/credentials/jwt/jwt_verifier.cc

@@ -88,7 +88,7 @@ static Json parse_json_part_from_jwt(const char* str, size_t len) {
   absl::string_view string = grpc_core::StringViewFromSlice(slice);
   grpc_error_handle error = GRPC_ERROR_NONE;
   Json json = Json::Parse(string, &error);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_ERROR, "JSON parse error: %s",
             grpc_error_std_string(error).c_str());
     GRPC_ERROR_UNREF(error);
@@ -413,7 +413,7 @@ static Json json_from_http(const grpc_http_response* response) {
   grpc_error_handle error = GRPC_ERROR_NONE;
   Json json = Json::Parse(
       absl::string_view(response->body, response->body_length), &error);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_ERROR, "Invalid JSON found in response.");
     return Json();  // JSON null
   }

src/core/lib/security/credentials/oauth2/oauth2_credentials.cc

@@ -103,7 +103,7 @@ grpc_auth_refresh_token grpc_auth_refresh_token_create_from_string(
     const char* json_string) {
   grpc_error_handle error = GRPC_ERROR_NONE;
   Json json = Json::Parse(json_string, &error);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_ERROR, "JSON parsing failed: %s",
             grpc_error_std_string(error).c_str());
     GRPC_ERROR_UNREF(error);
@@ -173,7 +173,7 @@ grpc_oauth2_token_fetcher_credentials_parse_server_response(
     Json::Object::const_iterator it;
     grpc_error_handle error = GRPC_ERROR_NONE;
     json = Json::Parse(null_terminated_body, &error);
-    if (error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error)) {
       gpr_log(GPR_ERROR, "Could not parse JSON from %s: %s",
               null_terminated_body, grpc_error_std_string(error).c_str());
       GRPC_ERROR_UNREF(error);
@@ -237,7 +237,7 @@ void grpc_oauth2_token_fetcher_credentials::on_http_response(
   absl::optional<grpc_core::Slice> access_token_value;
   grpc_core::Duration token_lifetime;
   grpc_credentials_status status =
-      error == GRPC_ERROR_NONE
+      GRPC_ERROR_IS_NONE(error)
           ? grpc_oauth2_token_fetcher_credentials_parse_server_response(
                 &r->response, &access_token_value, &token_lifetime)
           : GRPC_CREDENTIALS_ERROR;
@@ -523,7 +523,7 @@ void MaybeAddToBody(const char* field_name, const char* field,
 
 grpc_error_handle LoadTokenFile(const char* path, gpr_slice* token) {
   grpc_error_handle err = grpc_load_file(path, 1, token);
-  if (err != GRPC_ERROR_NONE) return err;
+  if (!GRPC_ERROR_IS_NONE(err)) return err;
   if (GRPC_SLICE_LENGTH(*token) == 0) {
     gpr_log(GPR_ERROR, "Token file %s is empty", path);
     err = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Token file is empty.");
@@ -561,7 +561,7 @@ class StsTokenFetcherCredentials
     grpc_http_request request;
     memset(&request, 0, sizeof(grpc_http_request));
     grpc_error_handle err = FillBody(&request.body, &request.body_length);
-    if (err != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(err)) {
       response_cb(metadata_req, err);
       GRPC_ERROR_UNREF(err);
       return;
@@ -599,7 +599,7 @@ class StsTokenFetcherCredentials
 
     auto cleanup = [&body, &body_length, &body_parts, &subject_token,
                     &actor_token, &err]() {
-      if (err == GRPC_ERROR_NONE) {
+      if (GRPC_ERROR_IS_NONE(err)) {
         std::string body_str = absl::StrJoin(body_parts, "");
         *body = gpr_strdup(body_str.c_str());
         *body_length = body_str.size();
@@ -610,7 +610,7 @@ class StsTokenFetcherCredentials
     };
 
     err = LoadTokenFile(subject_token_path_.get(), &subject_token);
-    if (err != GRPC_ERROR_NONE) return cleanup();
+    if (!GRPC_ERROR_IS_NONE(err)) return cleanup();
     body_parts.push_back(absl::StrFormat(
         GRPC_STS_POST_MINIMAL_BODY_FORMAT_STRING,
         reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(subject_token)),
@@ -622,7 +622,7 @@ class StsTokenFetcherCredentials
                    &body_parts);
     if ((actor_token_path_ != nullptr) && *actor_token_path_ != '\0') {
       err = LoadTokenFile(actor_token_path_.get(), &actor_token);
-      if (err != GRPC_ERROR_NONE) return cleanup();
+      if (!GRPC_ERROR_IS_NONE(err)) return cleanup();
       MaybeAddToBody(
           "actor_token",
           reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(actor_token)),

src/core/lib/security/credentials/tls/grpc_tls_certificate_distributor.cc

@@ -154,7 +154,7 @@ void grpc_tls_certificate_distributor::SetErrorForCert(
 };
 
 void grpc_tls_certificate_distributor::SetError(grpc_error_handle error) {
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
   grpc_core::MutexLock lock(&mu_);
   for (const auto& watcher : watchers_) {
     const auto watcher_ptr = watcher.first;
@@ -232,7 +232,8 @@ void grpc_tls_certificate_distributor::WatchTlsCertificates(
                                          std::move(updated_identity_pairs));
     }
     // Notify this watcher if the certs it is watching already had some errors.
-    if (root_error != GRPC_ERROR_NONE || identity_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(root_error) ||
+        !GRPC_ERROR_IS_NONE(identity_error)) {
       watcher_ptr->OnError(GRPC_ERROR_REF(root_error),
                            GRPC_ERROR_REF(identity_error));
     }

src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.cc

@@ -71,8 +71,8 @@ StaticDataCertificateProvider::StaticDataCertificateProvider(
       identity_cert_error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "Unable to get latest identity certificates.");
     }
-    if (root_cert_error != GRPC_ERROR_NONE ||
+    if (!GRPC_ERROR_IS_NONE(root_cert_error) ||
-        identity_cert_error != GRPC_ERROR_NONE) {
+        !GRPC_ERROR_IS_NONE(identity_cert_error)) {
       distributor_->SetErrorForCert(cert_name, root_cert_error,
                                     identity_cert_error);
     }
@@ -166,8 +166,8 @@ FileWatcherCertificateProvider::FileWatcherCertificateProvider(
       identity_cert_error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "Unable to get latest identity certificates.");
     }
-    if (root_cert_error != GRPC_ERROR_NONE ||
+    if (!GRPC_ERROR_IS_NONE(root_cert_error) ||
-        identity_cert_error != GRPC_ERROR_NONE) {
+        !GRPC_ERROR_IS_NONE(identity_cert_error)) {
       distributor_->SetErrorForCert(cert_name, root_cert_error,
                                     identity_cert_error);
     }
@@ -270,7 +270,7 @@ FileWatcherCertificateProvider::ReadRootCertificatesFromFile(
   grpc_slice root_slice = grpc_empty_slice();
   grpc_error_handle root_error =
       grpc_load_file(root_cert_full_path.c_str(), 0, &root_slice);
-  if (root_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(root_error)) {
     gpr_log(GPR_ERROR, "Reading file %s failed: %s",
             root_cert_full_path.c_str(),
             grpc_error_std_string(root_error).c_str());
@@ -329,7 +329,7 @@ FileWatcherCertificateProvider::ReadIdentityKeyCertPairFromFiles(
     SliceWrapper key_slice, cert_slice;
     grpc_error_handle key_error =
         grpc_load_file(private_key_path.c_str(), 0, &key_slice.slice);
-    if (key_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(key_error)) {
       gpr_log(GPR_ERROR, "Reading file %s failed: %s. Start retrying...",
               private_key_path.c_str(),
               grpc_error_std_string(key_error).c_str());
@@ -338,7 +338,7 @@ FileWatcherCertificateProvider::ReadIdentityKeyCertPairFromFiles(
     }
     grpc_error_handle cert_error =
         grpc_load_file(identity_certificate_path.c_str(), 0, &cert_slice.slice);
-    if (cert_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(cert_error)) {
       gpr_log(GPR_ERROR, "Reading file %s failed: %s. Start retrying...",
               identity_certificate_path.c_str(),
               grpc_error_std_string(cert_error).c_str());

src/core/lib/security/security_connector/load_system_roots_linux.cc

@@ -71,7 +71,7 @@ grpc_slice GetSystemRootCerts() {
   for (size_t i = 0; i < num_cert_files_; i++) {
     grpc_error_handle error =
         grpc_load_file(kCertFiles[i], 1, &valid_bundle_slice);
-    if (error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(error)) {
       return valid_bundle_slice;
     } else {
       GRPC_ERROR_UNREF(error);