grpc 1.19.0 → 1.20.0.pre1

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_channel_secure.cc

@@ -33,55 +33,12 @@
 #include "src/core/lib/security/transport/target_authority_table.h"
 #include "src/core/lib/slice/slice_internal.h"
 
-namespace grpc_core {
-namespace {
-
-int BalancerNameCmp(const grpc_core::UniquePtr<char>& a,
-                    const grpc_core::UniquePtr<char>& b) {
-  return strcmp(a.get(), b.get());
-}
-
-RefCountedPtr<TargetAuthorityTable> CreateTargetAuthorityTable(
-    const ServerAddressList& addresses) {
-  TargetAuthorityTable::Entry* target_authority_entries =
-      static_cast<TargetAuthorityTable::Entry*>(
-          gpr_zalloc(sizeof(*target_authority_entries) * addresses.size()));
-  for (size_t i = 0; i < addresses.size(); ++i) {
-    char* addr_str;
-    GPR_ASSERT(
-        grpc_sockaddr_to_string(&addr_str, &addresses[i].address(), true) > 0);
-    target_authority_entries[i].key = grpc_slice_from_copied_string(addr_str);
-    gpr_free(addr_str);
-    char* balancer_name = grpc_channel_arg_get_string(grpc_channel_args_find(
-        addresses[i].args(), GRPC_ARG_ADDRESS_BALANCER_NAME));
-    target_authority_entries[i].value.reset(gpr_strdup(balancer_name));
-  }
-  RefCountedPtr<TargetAuthorityTable> target_authority_table =
-      TargetAuthorityTable::Create(addresses.size(), target_authority_entries,
-                                   BalancerNameCmp);
-  gpr_free(target_authority_entries);
-  return target_authority_table;
-}
-
-}  // namespace
-}  // namespace grpc_core
-
 grpc_channel_args* grpc_lb_policy_xds_modify_lb_channel_args(
     grpc_channel_args* args) {
   const char* args_to_remove[1];
   size_t num_args_to_remove = 0;
   grpc_arg args_to_add[2];
   size_t num_args_to_add = 0;
-  // Add arg for targets info table.
-  grpc_core::ServerAddressList* addresses =
-      grpc_core::FindServerAddressListChannelArg(args);
-  GPR_ASSERT(addresses != nullptr);
-  grpc_core::RefCountedPtr<grpc_core::TargetAuthorityTable>
-      target_authority_table =
-          grpc_core::CreateTargetAuthorityTable(*addresses);
-  args_to_add[num_args_to_add++] =
-      grpc_core::CreateTargetAuthorityTableChannelArg(
-          target_authority_table.get());
   // Substitute the channel credentials with a version without call
   // credentials: the load balancer is not necessarily trusted to handle
   // bearer token credentials.

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_load_balancer_api.cc

@@ -161,10 +161,10 @@ void xds_grpclb_request_destroy(xds_grpclb_request* request) {
 
 typedef grpc_lb_v1_LoadBalanceResponse xds_grpclb_response;
 xds_grpclb_initial_response* xds_grpclb_initial_response_parse(
-    grpc_slice encoded_xds_grpclb_response) {
-  pb_istream_t stream =
-      pb_istream_from_buffer(GRPC_SLICE_START_PTR(encoded_xds_grpclb_response),
-                             GRPC_SLICE_LENGTH(encoded_xds_grpclb_response));
+    const grpc_slice& encoded_xds_grpclb_response) {
+  pb_istream_t stream = pb_istream_from_buffer(
+      const_cast<uint8_t*>(GRPC_SLICE_START_PTR(encoded_xds_grpclb_response)),
+      GRPC_SLICE_LENGTH(encoded_xds_grpclb_response));
   xds_grpclb_response res;
   memset(&res, 0, sizeof(xds_grpclb_response));
   if (GPR_UNLIKELY(
@@ -185,10 +185,10 @@ xds_grpclb_initial_response* xds_grpclb_initial_response_parse(
 }
 
 xds_grpclb_serverlist* xds_grpclb_response_parse_serverlist(
-    grpc_slice encoded_xds_grpclb_response) {
-  pb_istream_t stream =
-      pb_istream_from_buffer(GRPC_SLICE_START_PTR(encoded_xds_grpclb_response),
-                             GRPC_SLICE_LENGTH(encoded_xds_grpclb_response));
+    const grpc_slice& encoded_xds_grpclb_response) {
+  pb_istream_t stream = pb_istream_from_buffer(
+      const_cast<uint8_t*>(GRPC_SLICE_START_PTR(encoded_xds_grpclb_response)),
+      GRPC_SLICE_LENGTH(encoded_xds_grpclb_response));
   pb_istream_t stream_at_start = stream;
   xds_grpclb_serverlist* sl = static_cast<xds_grpclb_serverlist*>(
       gpr_zalloc(sizeof(xds_grpclb_serverlist)));

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_load_balancer_api.h

@@ -55,11 +55,11 @@ void xds_grpclb_request_destroy(xds_grpclb_request* request);
 /** Parse (ie, decode) the bytes in \a encoded_xds_grpclb_response as a \a
  * xds_grpclb_initial_response */
 xds_grpclb_initial_response* xds_grpclb_initial_response_parse(
-    grpc_slice encoded_xds_grpclb_response);
+    const grpc_slice& encoded_xds_grpclb_response);
 
 /** Parse the list of servers from an encoded \a xds_grpclb_response */
 xds_grpclb_serverlist* xds_grpclb_response_parse_serverlist(
-    grpc_slice encoded_xds_grpclb_response);
+    const grpc_slice& encoded_xds_grpclb_response);
 
 /** Return a copy of \a sl. The caller is responsible for calling \a
  * xds_grpclb_destroy_serverlist on the returned copy. */

data/src/core/ext/filters/client_channel/lb_policy_factory.h

@@ -31,12 +31,7 @@ class LoadBalancingPolicyFactory {
  public:
   /// Returns a new LB policy instance.
   virtual OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
-      LoadBalancingPolicy::Args args) const {
-    std::move(args);  // Suppress clang-tidy complaint.
-    // The rest of this is copied from the GRPC_ABSTRACT macro.
-    gpr_log(GPR_ERROR, "Function marked GRPC_ABSTRACT was not implemented");
-    GPR_ASSERT(false);
-  }
+      LoadBalancingPolicy::Args) const GRPC_ABSTRACT;
 
   /// Returns the LB policy name that this factory provides.
   /// Caller does NOT take ownership of result.

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

@@ -26,10 +26,63 @@ grpc_core::DebugOnlyTraceFlag grpc_trace_resolver_refcount(false,
 
 namespace grpc_core {
 
-Resolver::Resolver(grpc_combiner* combiner)
+//
+// Resolver
+//
+
+Resolver::Resolver(grpc_combiner* combiner,
+                   UniquePtr<ResultHandler> result_handler)
     : InternallyRefCounted(&grpc_trace_resolver_refcount),
+      result_handler_(std::move(result_handler)),
       combiner_(GRPC_COMBINER_REF(combiner, "resolver")) {}
 
 Resolver::~Resolver() { GRPC_COMBINER_UNREF(combiner_, "resolver"); }
 
+//
+// Resolver::Result
+//
+
+Resolver::Result::~Result() {
+  GRPC_ERROR_UNREF(service_config_error);
+  grpc_channel_args_destroy(args);
+}
+
+Resolver::Result::Result(const Result& other) {
+  addresses = other.addresses;
+  service_config = other.service_config;
+  service_config_error = GRPC_ERROR_REF(other.service_config_error);
+  args = grpc_channel_args_copy(other.args);
+}
+
+Resolver::Result::Result(Result&& other) {
+  addresses = std::move(other.addresses);
+  service_config = std::move(other.service_config);
+  service_config_error = other.service_config_error;
+  other.service_config_error = GRPC_ERROR_NONE;
+  args = other.args;
+  other.args = nullptr;
+}
+
+Resolver::Result& Resolver::Result::operator=(const Result& other) {
+  addresses = other.addresses;
+  service_config = other.service_config;
+  GRPC_ERROR_UNREF(service_config_error);
+  service_config_error = GRPC_ERROR_REF(other.service_config_error);
+  grpc_channel_args_destroy(args);
+  args = grpc_channel_args_copy(other.args);
+  return *this;
+}
+
+Resolver::Result& Resolver::Result::operator=(Result&& other) {
+  addresses = std::move(other.addresses);
+  service_config = std::move(other.service_config);
+  GRPC_ERROR_UNREF(service_config_error);
+  service_config_error = other.service_config_error;
+  other.service_config_error = GRPC_ERROR_NONE;
+  grpc_channel_args_destroy(args);
+  args = other.args;
+  other.args = nullptr;
+  return *this;
+}
+
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/resolver.h

@@ -23,8 +23,11 @@
 
 #include <grpc/impl/codegen/grpc_types.h>
 
+#include "src/core/ext/filters/client_channel/server_address.h"
+#include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/lib/gprpp/abstract.h"
 #include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/iomgr.h"
 
@@ -46,27 +49,50 @@ namespace grpc_core {
 /// combiner passed to the constructor.
 class Resolver : public InternallyRefCounted<Resolver> {
  public:
+  /// Results returned by the resolver.
+  struct Result {
+    ServerAddressList addresses;
+    RefCountedPtr<ServiceConfig> service_config;
+    grpc_error* service_config_error = GRPC_ERROR_NONE;
+    const grpc_channel_args* args = nullptr;
+
+    // TODO(roth): Remove everything below once grpc_error and
+    // grpc_channel_args are convert to copyable and movable C++ objects.
+    Result() = default;
+    ~Result();
+    Result(const Result& other);
+    Result(Result&& other);
+    Result& operator=(const Result& other);
+    Result& operator=(Result&& other);
+  };
+
+  /// A proxy object used by the resolver to return results to the
+  /// client channel.
+  class ResultHandler {
+   public:
+    virtual ~ResultHandler() {}
+
+    /// Returns a result to the channel.
+    /// Takes ownership of \a result.args.
+    virtual void ReturnResult(Result result) GRPC_ABSTRACT;  // NOLINT
+
+    /// Returns a transient error to the channel.
+    /// If the resolver does not set the GRPC_ERROR_INT_GRPC_STATUS
+    /// attribute on the error, calls will be failed with status UNKNOWN.
+    virtual void ReturnError(grpc_error* error) GRPC_ABSTRACT;
+
+    // TODO(yashkt): As part of the service config error handling
+    // changes, add a method to parse the service config JSON string.
+
+    GRPC_ABSTRACT_BASE_CLASS
+  };
+
   // Not copyable nor movable.
   Resolver(const Resolver&) = delete;
   Resolver& operator=(const Resolver&) = delete;
 
-  /// Requests a callback when a new result becomes available.
-  /// When the new result is available, sets \a *result to the new result
-  /// and schedules \a on_complete for execution.
-  /// Upon transient failure, sets \a *result to nullptr and schedules
-  /// \a on_complete with no error.
-  /// If resolution is fatally broken, sets \a *result to nullptr and
-  /// schedules \a on_complete with an error.
-  /// TODO(roth): When we have time, improve the way this API represents
-  /// transient failure vs. shutdown.
-  ///
-  /// Note that the client channel will almost always have a request
-  /// to \a NextLocked() pending.  When it gets the callback, it will
-  /// process the new result and then immediately make another call to
-  /// \a NextLocked().  This allows push-based resolvers to provide new
-  /// data as soon as it becomes available.
-  virtual void NextLocked(grpc_channel_args** result,
-                          grpc_closure* on_complete) GRPC_ABSTRACT;
+  /// Starts resolving.
+  virtual void StartLocked() GRPC_ABSTRACT;
 
   /// Asks the resolver to obtain an updated resolver result, if
   /// applicable.
@@ -79,8 +105,8 @@ class Resolver : public InternallyRefCounted<Resolver> {
   ///
   /// For push-based implementations, this may be a no-op.
   ///
-  /// If this causes new data to become available, then the currently
-  /// pending call to \a NextLocked() will return the new result.
+  /// Note: Implementations must not invoke any method on the
+  /// ResultHandler from within this call.
   virtual void RequestReresolutionLocked() {}
 
   /// Resets the re-resolution backoff, if any.
@@ -108,16 +134,18 @@ class Resolver : public InternallyRefCounted<Resolver> {
   // TODO(roth): Once we have a C++-like interface for combiners, this
   // API should change to take a RefCountedPtr<>, so that we always take
   // ownership of a new ref.
-  explicit Resolver(grpc_combiner* combiner);
+  explicit Resolver(grpc_combiner* combiner,
+                    UniquePtr<ResultHandler> result_handler);
 
   virtual ~Resolver();
 
-  /// Shuts down the resolver.  If there is a pending call to
-  /// NextLocked(), the callback will be scheduled with an error.
+  /// Shuts down the resolver.
   virtual void ShutdownLocked() GRPC_ABSTRACT;
 
   grpc_combiner* combiner() const { return combiner_; }
 
+  ResultHandler* result_handler() const { return result_handler_.get(); }
+
  private:
   static void ShutdownAndUnrefLocked(void* arg, grpc_error* ignored) {
     Resolver* resolver = static_cast<Resolver*>(arg);
@@ -125,6 +153,7 @@ class Resolver : public InternallyRefCounted<Resolver> {
     resolver->Unref();
   }
 
+  UniquePtr<ResultHandler> result_handler_;
   grpc_combiner* combiner_;
 };
 

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

@@ -34,6 +34,7 @@
 #include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h"
 #include "src/core/ext/filters/client_channel/resolver_registry.h"
 #include "src/core/ext/filters/client_channel/server_address.h"
+#include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/env.h"
@@ -45,7 +46,6 @@
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/json/json.h"
-#include "src/core/lib/transport/service_config.h"
 
 #define GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS 1
 #define GRPC_DNS_RECONNECT_BACKOFF_MULTIPLIER 1.6
@@ -60,10 +60,9 @@ const char kDefaultPort[] = "https";
 
 class AresDnsResolver : public Resolver {
  public:
-  explicit AresDnsResolver(const ResolverArgs& args);
+  explicit AresDnsResolver(ResolverArgs args);
 
-  void NextLocked(grpc_channel_args** result,
-                  grpc_closure* on_complete) override;
+  void StartLocked() override;
 
   void RequestReresolutionLocked() override;
 
@@ -76,7 +75,6 @@ class AresDnsResolver : public Resolver {
 
   void MaybeStartResolvingLocked();
   void StartResolvingLocked();
-  void MaybeFinishNextLocked();
 
   static void OnNextResolutionLocked(void* arg, grpc_error* error);
   static void OnResolvedLocked(void* arg, grpc_error* error);
@@ -98,16 +96,6 @@ class AresDnsResolver : public Resolver {
   bool resolving_ = false;
   /// the pending resolving request
   grpc_ares_request* pending_request_ = nullptr;
-  /// which version of the result have we published?
-  int published_version_ = 0;
-  /// which version of the result is current?
-  int resolved_version_ = 0;
-  /// pending next completion, or NULL
-  grpc_closure* next_completion_ = nullptr;
-  /// target result address for next completion
-  grpc_channel_args** target_result_ = nullptr;
-  /// current (fully resolved) result
-  grpc_channel_args* resolved_result_ = nullptr;
   /// next resolution timer
   bool have_next_resolution_timer_ = false;
   grpc_timer next_resolution_timer_;
@@ -129,8 +117,8 @@ class AresDnsResolver : public Resolver {
   bool enable_srv_queries_;
 };
 
-AresDnsResolver::AresDnsResolver(const ResolverArgs& args)
-    : Resolver(args.combiner),
+AresDnsResolver::AresDnsResolver(ResolverArgs args)
+    : Resolver(args.combiner, std::move(args.result_handler)),
       backoff_(
           BackOff::Options()
               .set_initial_backoff(GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS *
@@ -177,27 +165,16 @@ AresDnsResolver::AresDnsResolver(const ResolverArgs& args)
 
 AresDnsResolver::~AresDnsResolver() {
   GRPC_CARES_TRACE_LOG("resolver:%p destroying AresDnsResolver", this);
-  if (resolved_result_ != nullptr) {
-    grpc_channel_args_destroy(resolved_result_);
-  }
   grpc_pollset_set_destroy(interested_parties_);
   gpr_free(dns_server_);
   gpr_free(name_to_resolve_);
   grpc_channel_args_destroy(channel_args_);
 }
 
-void AresDnsResolver::NextLocked(grpc_channel_args** target_result,
-                                 grpc_closure* on_complete) {
-  GRPC_CARES_TRACE_LOG("resolver:%p AresDnsResolver::NextLocked() is called.",
+void AresDnsResolver::StartLocked() {
+  GRPC_CARES_TRACE_LOG("resolver:%p AresDnsResolver::StartLocked() is called.",
                        this);
-  GPR_ASSERT(next_completion_ == nullptr);
-  next_completion_ = on_complete;
-  target_result_ = target_result;
-  if (resolved_version_ == 0 && !resolving_) {
-    MaybeStartResolvingLocked();
-  } else {
-    MaybeFinishNextLocked();
-  }
+  MaybeStartResolvingLocked();
 }
 
 void AresDnsResolver::RequestReresolutionLocked() {
@@ -221,12 +198,6 @@ void AresDnsResolver::ShutdownLocked() {
   if (pending_request_ != nullptr) {
     grpc_cancel_ares_request_locked(pending_request_);
   }
-  if (next_completion_ != nullptr) {
-    *target_result_ = nullptr;
-    GRPC_CLOSURE_SCHED(next_completion_, GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                                             "Resolver Shutdown"));
-    next_completion_ = nullptr;
-  }
 }
 
 void AresDnsResolver::OnNextResolutionLocked(void* arg, grpc_error* error) {
@@ -319,41 +290,42 @@ char* ChooseServiceConfig(char* service_config_choice_json) {
 
 void AresDnsResolver::OnResolvedLocked(void* arg, grpc_error* error) {
   AresDnsResolver* r = static_cast<AresDnsResolver*>(arg);
-  grpc_channel_args* result = nullptr;
   GPR_ASSERT(r->resolving_);
   r->resolving_ = false;
   gpr_free(r->pending_request_);
   r->pending_request_ = nullptr;
+  if (r->shutdown_initiated_) {
+    r->Unref(DEBUG_LOCATION, "OnResolvedLocked() shutdown");
+    return;
+  }
   if (r->addresses_ != nullptr) {
-    static const char* args_to_remove[1];
-    size_t num_args_to_remove = 0;
-    grpc_arg args_to_add[2];
-    size_t num_args_to_add = 0;
-    args_to_add[num_args_to_add++] =
-        CreateServerAddressListChannelArg(r->addresses_.get());
-    char* service_config_string = nullptr;
+    Result result;
+    result.addresses = std::move(*r->addresses_);
     if (r->service_config_json_ != nullptr) {
-      service_config_string = ChooseServiceConfig(r->service_config_json_);
+      char* service_config_string =
+          ChooseServiceConfig(r->service_config_json_);
       gpr_free(r->service_config_json_);
       if (service_config_string != nullptr) {
         GRPC_CARES_TRACE_LOG("resolver:%p selected service config choice: %s",
                              r, service_config_string);
-        args_to_remove[num_args_to_remove++] = GRPC_ARG_SERVICE_CONFIG;
-        args_to_add[num_args_to_add++] = grpc_channel_arg_string_create(
-            (char*)GRPC_ARG_SERVICE_CONFIG, service_config_string);
+        result.service_config = ServiceConfig::Create(service_config_string);
       }
+      gpr_free(service_config_string);
     }
-    result = grpc_channel_args_copy_and_add_and_remove(
-        r->channel_args_, args_to_remove, num_args_to_remove, args_to_add,
-        num_args_to_add);
-    gpr_free(service_config_string);
+    result.args = grpc_channel_args_copy(r->channel_args_);
+    r->result_handler()->ReturnResult(std::move(result));
     r->addresses_.reset();
     // Reset backoff state so that we start from the beginning when the
     // next request gets triggered.
     r->backoff_.Reset();
-  } else if (!r->shutdown_initiated_) {
-    const char* msg = grpc_error_string(error);
-    GRPC_CARES_TRACE_LOG("resolver:%p dns resolution failed: %s", r, msg);
+  } else {
+    GRPC_CARES_TRACE_LOG("resolver:%p dns resolution failed: %s", r,
+                         grpc_error_string(error));
+    r->result_handler()->ReturnError(grpc_error_set_int(
+        GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+            "DNS resolution failed", &error, 1),
+        GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE));
+    // Set retry timer.
     grpc_millis next_try = r->backoff_.NextAttemptTime();
     grpc_millis timeout = next_try - ExecCtx::Get()->Now();
     GRPC_CARES_TRACE_LOG("resolver:%p dns resolution failed (will retry): %s",
@@ -363,8 +335,7 @@ void AresDnsResolver::OnResolvedLocked(void* arg, grpc_error* error) {
     // TODO(roth): We currently deal with this ref manually.  Once the
     // new closure API is done, find a way to track this ref with the timer
     // callback as part of the type system.
-    RefCountedPtr<Resolver> self = r->Ref(DEBUG_LOCATION, "retry-timer");
-    self.release();
+    r->Ref(DEBUG_LOCATION, "retry-timer").release();
     if (timeout > 0) {
       GRPC_CARES_TRACE_LOG("resolver:%p retrying in %" PRId64 " milliseconds",
                            r, timeout);
@@ -374,12 +345,6 @@ void AresDnsResolver::OnResolvedLocked(void* arg, grpc_error* error) {
     grpc_timer_init(&r->next_resolution_timer_, next_try,
                     &r->on_next_resolution_);
   }
-  if (r->resolved_result_ != nullptr) {
-    grpc_channel_args_destroy(r->resolved_result_);
-  }
-  r->resolved_result_ = result;
-  ++r->resolved_version_;
-  r->MaybeFinishNextLocked();
   r->Unref(DEBUG_LOCATION, "dns-resolving");
 }
 
@@ -403,9 +368,7 @@ void AresDnsResolver::MaybeStartResolvingLocked() {
       // TODO(roth): We currently deal with this ref manually.  Once the
       // new closure API is done, find a way to track this ref with the timer
       // callback as part of the type system.
-      RefCountedPtr<Resolver> self =
-          Ref(DEBUG_LOCATION, "next_resolution_timer_cooldown");
-      self.release();
+      Ref(DEBUG_LOCATION, "next_resolution_timer_cooldown").release();
       grpc_timer_init(&next_resolution_timer_, ms_until_next_resolution,
                       &on_next_resolution_);
       return;
@@ -418,8 +381,7 @@ void AresDnsResolver::StartResolvingLocked() {
   // TODO(roth): We currently deal with this ref manually.  Once the
   // new closure API is done, find a way to track this ref with the timer
   // callback as part of the type system.
-  RefCountedPtr<Resolver> self = Ref(DEBUG_LOCATION, "dns-resolving");
-  self.release();
+  Ref(DEBUG_LOCATION, "dns-resolving").release();
   GPR_ASSERT(!resolving_);
   resolving_ = true;
   service_config_json_ = nullptr;
@@ -433,28 +395,14 @@ void AresDnsResolver::StartResolvingLocked() {
                        this, pending_request_);
 }
 
-void AresDnsResolver::MaybeFinishNextLocked() {
-  if (next_completion_ != nullptr && resolved_version_ != published_version_) {
-    *target_result_ = resolved_result_ == nullptr
-                          ? nullptr
-                          : grpc_channel_args_copy(resolved_result_);
-    GRPC_CARES_TRACE_LOG("resolver:%p AresDnsResolver::MaybeFinishNextLocked()",
-                         this);
-    GRPC_CLOSURE_SCHED(next_completion_, GRPC_ERROR_NONE);
-    next_completion_ = nullptr;
-    published_version_ = resolved_version_;
-  }
-}
-
 //
 // Factory
 //
 
 class AresDnsResolverFactory : public ResolverFactory {
  public:
-  OrphanablePtr<Resolver> CreateResolver(
-      const ResolverArgs& args) const override {
-    return OrphanablePtr<Resolver>(New<AresDnsResolver>(args));
+  OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
+    return OrphanablePtr<Resolver>(New<AresDnsResolver>(std::move(args)));
   }
 
   const char* scheme() const override { return "dns"; }
@@ -489,7 +437,7 @@ void grpc_resolver_dns_ares_init() {
     address_sorting_init();
     grpc_error* error = grpc_ares_init();
     if (error != GRPC_ERROR_NONE) {
-      GRPC_LOG_IF_ERROR("ares_library_init() failed", error);
+      GRPC_LOG_IF_ERROR("grpc_ares_init() failed", error);
       return;
     }
     if (default_resolver == nullptr) {