grpc 1.50.0.pre1 → 1.52.0.pre2

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2016 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -23,8 +23,12 @@
 
 #include "absl/strings/string_view.h"
 
+#include <grpc/grpc.h>
+
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 
+// IWYU pragma: no_include <arpa/inet.h>
 // IWYU pragma: no_include <arpa/nameser.h>
 // IWYU pragma: no_include <inttypes.h>
 // IWYU pragma: no_include <netdb.h>
@@ -43,13 +47,11 @@
 #include <address_sorting/address_sorting.h>
 #include <ares.h>
 
-#include "absl/memory/memory.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -79,61 +81,61 @@ grpc_core::TraceFlag grpc_trace_cares_address_sorting(false,
 grpc_core::TraceFlag grpc_trace_cares_resolver(false, "cares_resolver");
 
 typedef struct fd_node {
-  /* default constructor exists only for linked list manipulation */
+  // default constructor exists only for linked list manipulation
   fd_node() : ev_driver(nullptr) {}
 
   explicit fd_node(grpc_ares_ev_driver* ev_driver) : ev_driver(ev_driver) {}
 
-  /** the owner of this fd node */
+  /// the owner of this fd node
   grpc_ares_ev_driver* const ev_driver;
-  /** a closure wrapping on_readable_locked, which should be
-     invoked when the grpc_fd in this node becomes readable. */
+  /// a closure wrapping on_readable_locked, which should be
+  /// invoked when the grpc_fd in this node becomes readable.
   grpc_closure read_closure ABSL_GUARDED_BY(&grpc_ares_request::mu);
-  /** a closure wrapping on_writable_locked, which should be
-     invoked when the grpc_fd in this node becomes writable. */
+  /// a closure wrapping on_writable_locked, which should be
+  /// invoked when the grpc_fd in this node becomes writable.
   grpc_closure write_closure ABSL_GUARDED_BY(&grpc_ares_request::mu);
-  /** next fd node in the list */
+  /// next fd node in the list
   struct fd_node* next ABSL_GUARDED_BY(&grpc_ares_request::mu);
 
-  /** wrapped fd that's polled by grpc's poller for the current platform */
+  /// wrapped fd that's polled by grpc's poller for the current platform
   grpc_core::GrpcPolledFd* grpc_polled_fd
       ABSL_GUARDED_BY(&grpc_ares_request::mu);
-  /** if the readable closure has been registered */
+  /// if the readable closure has been registered
   bool readable_registered ABSL_GUARDED_BY(&grpc_ares_request::mu);
-  /** if the writable closure has been registered */
+  /// if the writable closure has been registered
   bool writable_registered ABSL_GUARDED_BY(&grpc_ares_request::mu);
-  /** if the fd has been shutdown yet from grpc iomgr perspective */
+  /// if the fd has been shutdown yet from grpc iomgr perspective
   bool already_shutdown ABSL_GUARDED_BY(&grpc_ares_request::mu);
 } fd_node;
 
 struct grpc_ares_ev_driver {
   explicit grpc_ares_ev_driver(grpc_ares_request* request) : request(request) {}
 
-  /** the ares_channel owned by this event driver */
+  /// the ares_channel owned by this event driver
   ares_channel channel ABSL_GUARDED_BY(&grpc_ares_request::mu);
-  /** pollset set for driving the IO events of the channel */
+  /// pollset set for driving the IO events of the channel
   grpc_pollset_set* pollset_set ABSL_GUARDED_BY(&grpc_ares_request::mu);
-  /** refcount of the event driver */
+  /// refcount of the event driver
   gpr_refcount refs;
 
-  /** a list of grpc_fd that this event driver is currently using. */
+  /// a list of grpc_fd that this event driver is currently using.
   fd_node* fds ABSL_GUARDED_BY(&grpc_ares_request::mu);
-  /** is this event driver being shut down */
+  /// is this event driver being shut down
   bool shutting_down ABSL_GUARDED_BY(&grpc_ares_request::mu);
-  /** request object that's using this ev driver */
+  /// request object that's using this ev driver
   grpc_ares_request* const request;
-  /** Owned by the ev_driver. Creates new GrpcPolledFd's */
+  /// Owned by the ev_driver. Creates new GrpcPolledFd's
   std::unique_ptr<grpc_core::GrpcPolledFdFactory> polled_fd_factory
       ABSL_GUARDED_BY(&grpc_ares_request::mu);
-  /** query timeout in milliseconds */
+  /// query timeout in milliseconds
   int query_timeout_ms ABSL_GUARDED_BY(&grpc_ares_request::mu);
-  /** alarm to cancel active queries */
+  /// alarm to cancel active queries
   grpc_timer query_timeout ABSL_GUARDED_BY(&grpc_ares_request::mu);
-  /** cancels queries on a timeout */
+  /// cancels queries on a timeout
   grpc_closure on_timeout_locked ABSL_GUARDED_BY(&grpc_ares_request::mu);
-  /** alarm to poll ares_process on in case fd events don't happen */
+  /// alarm to poll ares_process on in case fd events don't happen
   grpc_timer ares_backup_poll_alarm ABSL_GUARDED_BY(&grpc_ares_request::mu);
-  /** polls ares_process on a periodic timer */
+  /// polls ares_process on a periodic timer
   grpc_closure on_ares_backup_poll_alarm_locked
       ABSL_GUARDED_BY(&grpc_ares_request::mu);
 };
@@ -141,17 +143,17 @@ struct grpc_ares_ev_driver {
 // TODO(apolcyn): make grpc_ares_hostbyname_request a sub-class
 // of GrpcAresQuery.
 typedef struct grpc_ares_hostbyname_request {
-  /** following members are set in create_hostbyname_request_locked
-   */
-  /** the top-level request instance */
+  /// following members are set in create_hostbyname_request_locked
+  ///
+  /// the top-level request instance
   grpc_ares_request* parent_request;
-  /** host to resolve, parsed from the name to resolve */
+  /// host to resolve, parsed from the name to resolve
   char* host;
-  /** port to fill in sockaddr_in, parsed from the name to resolve */
+  /// port to fill in sockaddr_in, parsed from the name to resolve
   uint16_t port;
-  /** is it a grpclb address */
+  /// is it a grpclb address
   bool is_balancer;
-  /** for logging and errors: the query type ("A" or "AAAA") */
+  /// for logging and errors: the query type ("A" or "AAAA")
   const char* qtype;
 } grpc_ares_hostbyname_request;
 
@@ -178,9 +180,9 @@ class GrpcAresQuery {
   const std::string& name() { return name_; }
 
  private:
-  /* the top level request instance */
+  // the top level request instance
   grpc_ares_request* r_;
-  /** for logging and errors */
+  /// for logging and errors
   const std::string name_;
 };
 
@@ -225,8 +227,7 @@ static void fd_node_shutdown_locked(fd_node* fdn, const char* reason)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(&grpc_ares_request::mu) {
   if (!fdn->already_shutdown) {
     fdn->already_shutdown = true;
-    fdn->grpc_polled_fd->ShutdownLocked(
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING(reason));
+    fdn->grpc_polled_fd->ShutdownLocked(GRPC_ERROR_CREATE(reason));
   }
 }
 
@@ -294,8 +295,8 @@ static void on_timeout(void* arg, grpc_error_handle error) {
       "request:%p ev_driver=%p on_timeout_locked. driver->shutting_down=%d. "
       "err=%s",
       driver->request, driver, driver->shutting_down,
-      grpc_error_std_string(error).c_str());
-  if (!driver->shutting_down && GRPC_ERROR_IS_NONE(error)) {
+      grpc_core::StatusToString(error).c_str());
+  if (!driver->shutting_down && error.ok()) {
     grpc_ares_ev_driver_shutdown_locked(driver);
   }
   grpc_ares_ev_driver_unref(driver);
@@ -304,14 +305,14 @@ static void on_timeout(void* arg, grpc_error_handle error) {
 static void grpc_ares_notify_on_event_locked(grpc_ares_ev_driver* ev_driver)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(&grpc_ares_request::mu);
 
-/* In case of non-responsive DNS servers, dropped packets, etc., c-ares has
- * intelligent timeout and retry logic, which we can take advantage of by
- * polling ares_process_fd on time intervals. Overall, the c-ares library is
- * meant to be called into and given a chance to proceed name resolution:
- *   a) when fd events happen
- *   b) when some time has passed without fd events having happened
- * For the latter, we use this backup poller. Also see
- * https://github.com/grpc/grpc/pull/17688 description for more details. */
+// In case of non-responsive DNS servers, dropped packets, etc., c-ares has
+// intelligent timeout and retry logic, which we can take advantage of by
+// polling ares_process_fd on time intervals. Overall, the c-ares library is
+// meant to be called into and given a chance to proceed name resolution:
+//   a) when fd events happen
+//   b) when some time has passed without fd events having happened
+// For the latter, we use this backup poller. Also see
+// https://github.com/grpc/grpc/pull/17688 description for more details.
 static void on_ares_backup_poll_alarm(void* arg, grpc_error_handle error) {
   grpc_ares_ev_driver* driver = static_cast<grpc_ares_ev_driver*>(arg);
   grpc_core::MutexLock lock(&driver->request->mu);
@@ -320,8 +321,8 @@ static void on_ares_backup_poll_alarm(void* arg, grpc_error_handle error) {
       "driver->shutting_down=%d. "
       "err=%s",
       driver->request, driver, driver->shutting_down,
-      grpc_error_std_string(error).c_str());
-  if (!driver->shutting_down && GRPC_ERROR_IS_NONE(error)) {
+      grpc_core::StatusToString(error).c_str());
+  if (!driver->shutting_down && error.ok()) {
     fd_node* fdn = driver->fds;
     while (fdn != nullptr) {
       if (!fdn->already_shutdown) {
@@ -363,17 +364,17 @@ 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 (GRPC_ERROR_IS_NONE(error)) {
+  if (error.ok() && !ev_driver->shutting_down) {
     do {
       ares_process_fd(ev_driver->channel, as, ARES_SOCKET_BAD);
     } while (fdn->grpc_polled_fd->IsFdStillReadableLocked());
   } else {
-    // If error is not GRPC_ERROR_NONE, it means the fd has been shutdown or
-    // timed out. The pending lookups made on this ev_driver will be cancelled
-    // by the following ares_cancel() and the on_done callbacks will be invoked
-    // with a status of ARES_ECANCELLED. The remaining file descriptors in this
-    // ev_driver will be cleaned up in the follwing
-    // grpc_ares_notify_on_event_locked().
+    // If error is not absl::OkStatus() or the resolution was cancelled, it
+    // means the fd has been shutdown or timed out. The pending lookups made on
+    // this ev_driver will be cancelled by the following ares_cancel() and the
+    // on_done callbacks will be invoked with a status of ARES_ECANCELLED. The
+    // remaining file descriptors in this ev_driver will be cleaned up in the
+    // follwing grpc_ares_notify_on_event_locked().
     ares_cancel(ev_driver->channel);
   }
   grpc_ares_notify_on_event_locked(ev_driver);
@@ -389,15 +390,15 @@ 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 (GRPC_ERROR_IS_NONE(error)) {
+  if (error.ok() && !ev_driver->shutting_down) {
     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
-    // timed out. The pending lookups made on this ev_driver will be cancelled
-    // by the following ares_cancel() and the on_done callbacks will be invoked
-    // with a status of ARES_ECANCELLED. The remaining file descriptors in this
-    // ev_driver will be cleaned up in the follwing
-    // grpc_ares_notify_on_event_locked().
+    // If error is not absl::OkStatus() or the resolution was cancelled, it
+    // means the fd has been shutdown or timed out. The pending lookups made on
+    // this ev_driver will be cancelled by the following ares_cancel() and the
+    // on_done callbacks will be invoked with a status of ARES_ECANCELLED. The
+    // remaining file descriptors in this ev_driver will be cleaned up in the
+    // follwing grpc_ares_notify_on_event_locked().
     ares_cancel(ev_driver->channel);
   }
   grpc_ares_notify_on_event_locked(ev_driver);
@@ -527,7 +528,7 @@ grpc_error_handle grpc_ares_ev_driver_create_locked(
   grpc_ares_test_only_inject_config((*ev_driver)->channel);
   GRPC_CARES_TRACE_LOG("request:%p grpc_ares_ev_driver_create_locked", request);
   if (status != ARES_SUCCESS) {
-    grpc_error_handle err = GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+    grpc_error_handle err = GRPC_ERROR_CREATE(absl::StrCat(
         "Failed to init ares channel. C-ares error: ", ares_strerror(status)));
     delete *ev_driver;
     return err;
@@ -541,7 +542,7 @@ grpc_error_handle grpc_ares_ev_driver_create_locked(
   (*ev_driver)
       ->polled_fd_factory->ConfigureAresChannelLocked((*ev_driver)->channel);
   (*ev_driver)->query_timeout_ms = query_timeout_ms;
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 static void log_address_sorting_list(const grpc_ares_request* r,
@@ -603,8 +604,7 @@ void grpc_ares_complete_request_locked(grpc_ares_request* r)
   r->ev_driver = nullptr;
   if (r->addresses_out != nullptr && *r->addresses_out != nullptr) {
     grpc_cares_wrapper_address_sorting_sort(r, r->addresses_out->get());
-    GRPC_ERROR_UNREF(r->error);
-    r->error = GRPC_ERROR_NONE;
+    r->error = absl::OkStatus();
     // TODO(apolcyn): allow c-ares to return a service config
     // with no addresses along side it
   }
@@ -617,8 +617,8 @@ void grpc_ares_complete_request_locked(grpc_ares_request* r)
   grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, r->error);
 }
 
-/* Note that the returned object takes a reference to qtype, so
- * qtype must outlive it. */
+// Note that the returned object takes a reference to qtype, so
+// qtype must outlive it.
 static grpc_ares_hostbyname_request* create_hostbyname_request_locked(
     grpc_ares_request* parent_request, const char* host, uint16_t port,
     bool is_balancer, const char* qtype)
@@ -659,7 +659,7 @@ static void on_hostbyname_done_locked(void* arg, int status, int /*timeouts*/,
     std::unique_ptr<ServerAddressList>* address_list_ptr =
         hr->is_balancer ? r->balancer_addresses_out : r->addresses_out;
     if (*address_list_ptr == nullptr) {
-      *address_list_ptr = absl::make_unique<ServerAddressList>();
+      *address_list_ptr = std::make_unique<ServerAddressList>();
     }
     ServerAddressList& addresses = **address_list_ptr;
     for (size_t i = 0; hostent->h_addr_list[i] != nullptr; ++i) {
@@ -710,7 +710,7 @@ static void on_hostbyname_done_locked(void* arg, int status, int /*timeouts*/,
         hr->qtype, hr->host, hr->is_balancer, ares_strerror(status));
     GRPC_CARES_TRACE_LOG("request:%p on_hostbyname_done_locked: %s", r,
                          error_msg.c_str());
-    grpc_error_handle error = GRPC_ERROR_CREATE_FROM_CPP_STRING(error_msg);
+    grpc_error_handle error = GRPC_ERROR_CREATE(error_msg);
     r->error = grpc_error_add_child(error, r->error);
   }
   destroy_hostbyname_request_locked(hr);
@@ -745,7 +745,6 @@ static void on_srv_query_done_locked(void* arg, int status, int /*timeouts*/,
             r, srv_it->host, htons(srv_it->port), true /* is_balancer */, "A");
         ares_gethostbyname(r->ev_driver->channel, hr->host, AF_INET,
                            on_hostbyname_done_locked, hr);
-        grpc_ares_notify_on_event_locked(r->ev_driver);
       }
     }
     if (reply != nullptr) {
@@ -757,7 +756,7 @@ static void on_srv_query_done_locked(void* arg, int status, int /*timeouts*/,
         ares_strerror(status));
     GRPC_CARES_TRACE_LOG("request:%p on_srv_query_done_locked: %s", r,
                          error_msg.c_str());
-    grpc_error_handle error = GRPC_ERROR_CREATE_FROM_CPP_STRING(error_msg);
+    grpc_error_handle error = GRPC_ERROR_CREATE(error_msg);
     r->error = grpc_error_add_child(error, r->error);
   }
   delete q;
@@ -776,7 +775,7 @@ static void on_txt_done_locked(void* arg, int status, int /*timeouts*/,
   const size_t prefix_len = sizeof(g_service_config_attribute_prefix) - 1;
   struct ares_txt_ext* result = nullptr;
   struct ares_txt_ext* reply = nullptr;
-  grpc_error_handle error = GRPC_ERROR_NONE;
+  grpc_error_handle error;
   if (status != ARES_SUCCESS) goto fail;
   GRPC_CARES_TRACE_LOG("request:%p on_txt_done_locked name=%s ARES_SUCCESS", r,
                        q->name().c_str());
@@ -820,7 +819,7 @@ fail:
                       q->name(), ares_strerror(status));
   GRPC_CARES_TRACE_LOG("request:%p on_txt_done_locked %s", r,
                        error_msg.c_str());
-  error = GRPC_ERROR_CREATE_FROM_CPP_STRING(error_msg);
+  error = GRPC_ERROR_CREATE(error_msg);
   r->error = grpc_error_add_child(error, r->error);
 }
 
@@ -848,17 +847,17 @@ grpc_error_handle set_request_dns_server(grpc_ares_request* r,
       r->dns_server_addr.tcp_port = grpc_sockaddr_get_port(&addr);
       r->dns_server_addr.udp_port = grpc_sockaddr_get_port(&addr);
     } else {
-      return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+      return GRPC_ERROR_CREATE(
           absl::StrCat("cannot parse authority ", dns_server));
     }
     int status =
         ares_set_servers_ports(r->ev_driver->channel, &r->dns_server_addr);
     if (status != ARES_SUCCESS) {
-      return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+      return GRPC_ERROR_CREATE(absl::StrCat(
           "C-ares status is not ARES_SUCCESS: ", ares_strerror(status)));
     }
   }
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 // Common logic for all lookup methods.
@@ -868,26 +867,26 @@ grpc_error_handle grpc_dns_lookup_ares_continued(
     const char* default_port, grpc_pollset_set* interested_parties,
     int query_timeout_ms, std::string* host, std::string* port, bool check_port)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(r->mu) {
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  /* parse name, splitting it into host and port parts */
+  grpc_error_handle error;
+  // parse name, splitting it into host and port parts
   grpc_core::SplitHostPort(name, host, port);
   if (host->empty()) {
-    error = grpc_error_set_str(
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("unparseable host:port"),
-        GRPC_ERROR_STR_TARGET_ADDRESS, name);
+    error =
+        grpc_error_set_str(GRPC_ERROR_CREATE("unparseable host:port"),
+                           grpc_core::StatusStrProperty::kTargetAddress, name);
     return error;
   } else if (check_port && port->empty()) {
     if (default_port == nullptr || strlen(default_port) == 0) {
-      error = grpc_error_set_str(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("no port in name"),
-          GRPC_ERROR_STR_TARGET_ADDRESS, name);
+      error = grpc_error_set_str(GRPC_ERROR_CREATE("no port in name"),
+                                 grpc_core::StatusStrProperty::kTargetAddress,
+                                 name);
       return error;
     }
     *port = default_port;
   }
   error = grpc_ares_ev_driver_create_locked(&r->ev_driver, interested_parties,
                                             query_timeout_ms, r);
-  if (!GRPC_ERROR_IS_NONE(error)) return error;
+  if (!error.ok()) return error;
   // If dns_server is specified, use it.
   error = set_request_dns_server(r, dns_server);
   return error;
@@ -921,7 +920,7 @@ static bool inner_resolve_as_ip_literal_locked(
       grpc_parse_ipv6_hostport(hostport->c_str(), &addr,
                                false /* log errors */)) {
     GPR_ASSERT(*addrs == nullptr);
-    *addrs = absl::make_unique<ServerAddressList>();
+    *addrs = std::make_unique<ServerAddressList>();
     (*addrs)->emplace_back(addr.addr, addr.len, grpc_core::ChannelArgs());
     return true;
   }
@@ -979,7 +978,7 @@ static bool inner_maybe_resolve_localhost_manually_locked(
   }
   if (gpr_stricmp(host->c_str(), "localhost") == 0) {
     GPR_ASSERT(*addrs == nullptr);
-    *addrs = absl::make_unique<grpc_core::ServerAddressList>();
+    *addrs = std::make_unique<grpc_core::ServerAddressList>();
     uint16_t numeric_port = grpc_strhtons(port->c_str());
     // Append the ipv6 loopback address.
     struct sockaddr_in6 ipv6_loopback_addr;
@@ -1013,14 +1012,14 @@ static bool grpc_ares_maybe_resolve_localhost_manually_locked(
   return inner_maybe_resolve_localhost_manually_locked(r, name, default_port,
                                                        addrs, &host, &port);
 }
-#else  /* GRPC_ARES_RESOLVE_LOCALHOST_MANUALLY */
+#else   // GRPC_ARES_RESOLVE_LOCALHOST_MANUALLY
 static bool grpc_ares_maybe_resolve_localhost_manually_locked(
     const grpc_ares_request* /*r*/, const char* /*name*/,
     const char* /*default_port*/,
     std::unique_ptr<grpc_core::ServerAddressList>* /*addrs*/) {
   return false;
 }
-#endif /* GRPC_ARES_RESOLVE_LOCALHOST_MANUALLY */
+#endif  // GRPC_ARES_RESOLVE_LOCALHOST_MANUALLY
 
 static grpc_ares_request* grpc_dns_lookup_hostname_ares_impl(
     const char* dns_server, const char* name, const char* default_port,
@@ -1053,7 +1052,7 @@ static grpc_ares_request* grpc_dns_lookup_hostname_ares_impl(
   grpc_error_handle error = grpc_dns_lookup_ares_continued(
       r, dns_server, name, default_port, interested_parties, query_timeout_ms,
       &host, &port, true);
-  if (!GRPC_ERROR_IS_NONE(error)) {
+  if (!error.ok()) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
     return r;
   }
@@ -1088,7 +1087,7 @@ grpc_ares_request* grpc_dns_lookup_srv_ares_impl(
   r->balancer_addresses_out = balancer_addresses;
   GRPC_CARES_TRACE_LOG(
       "request:%p c-ares grpc_dns_lookup_srv_ares_impl name=%s", r, name);
-  grpc_error_handle error = GRPC_ERROR_NONE;
+  grpc_error_handle error;
   // Don't query for SRV records if the target is "localhost"
   if (target_matches_localhost(name)) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
@@ -1100,12 +1099,12 @@ grpc_ares_request* grpc_dns_lookup_srv_ares_impl(
   error = grpc_dns_lookup_ares_continued(r, dns_server, name, nullptr,
                                          interested_parties, query_timeout_ms,
                                          &host, &port, false);
-  if (!GRPC_ERROR_IS_NONE(error)) {
+  if (!error.ok()) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
     return r;
   }
   r->pending_queries = 1;
-  /* Query the SRV record */
+  // Query the SRV record
   std::string service_name = absl::StrCat("_grpclb._tcp.", host);
   GrpcAresQuery* srv_query = new GrpcAresQuery(r, service_name);
   ares_query(r->ev_driver->channel, service_name.c_str(), ns_c_in, ns_t_srv,
@@ -1126,7 +1125,7 @@ grpc_ares_request* grpc_dns_lookup_txt_ares_impl(
   r->service_config_json_out = service_config_json;
   GRPC_CARES_TRACE_LOG(
       "request:%p c-ares grpc_dns_lookup_txt_ares_impl name=%s", r, name);
-  grpc_error_handle error = GRPC_ERROR_NONE;
+  grpc_error_handle error;
   // Don't query for TXT records if the target is "localhost"
   if (target_matches_localhost(name)) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
@@ -1138,12 +1137,12 @@ grpc_ares_request* grpc_dns_lookup_txt_ares_impl(
   error = grpc_dns_lookup_ares_continued(r, dns_server, name, nullptr,
                                          interested_parties, query_timeout_ms,
                                          &host, &port, false);
-  if (!GRPC_ERROR_IS_NONE(error)) {
+  if (!error.ok()) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
     return r;
   }
   r->pending_queries = 1;
-  /* Query the TXT record */
+  // Query the TXT record
   std::string config_name = absl::StrCat("_grpc_config.", host);
   GrpcAresQuery* txt_query = new GrpcAresQuery(r, config_name);
   ares_search(r->ev_driver->channel, config_name.c_str(), ns_c_in, ns_t_txt,
@@ -1191,16 +1190,16 @@ void (*grpc_cancel_ares_request)(grpc_ares_request* r) =
 grpc_error_handle grpc_ares_init(void) {
   int status = ares_library_init(ARES_LIB_INIT_ALL);
   if (status != ARES_SUCCESS) {
-    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+    return GRPC_ERROR_CREATE(
         absl::StrCat("ares_library_init failed: ", ares_strerror(status)));
   }
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 void grpc_ares_cleanup(void) { ares_library_cleanup(); }
 #else
-grpc_error_handle grpc_ares_init(void) { return GRPC_ERROR_NONE; }
+grpc_error_handle grpc_ares_init(void) { return absl::OkStatus(); }
 void grpc_ares_cleanup(void) {}
 #endif  // GPR_WINDOWS
 
-#endif /* GRPC_ARES == 1 */
+#endif  // GRPC_ARES == 1