grpc 1.41.1 → 1.44.0.pre2

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

@@ -23,11 +23,11 @@
 
 #include <ares.h>
 
-#include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/work_serializer.h"
+#include "src/core/lib/resolver/server_address.h"
 
 #define GRPC_DNS_ARES_DEFAULT_QUERY_TIMEOUT_MS 120000
 
@@ -42,37 +42,54 @@ extern grpc_core::TraceFlag grpc_trace_cares_resolver;
     }                                                               \
   } while (0)
 
-typedef struct grpc_ares_request grpc_ares_request;
-
-/* Asynchronously resolve \a name. Use \a default_port if a port isn't
-   designated in \a name, otherwise use the port in \a name. grpc_ares_init()
-   must be called at least once before this function. \a on_done may be
-   called directly in this function without being scheduled with \a exec_ctx,
-   so it must not try to acquire locks that are being held by the caller. */
-extern void (*grpc_resolve_address_ares)(const char* name,
-                                         const char* default_port,
-                                         grpc_pollset_set* interested_parties,
-                                         grpc_closure* on_done,
-                                         grpc_resolved_addresses** addresses);
+typedef struct grpc_ares_ev_driver grpc_ares_ev_driver;
+
+struct grpc_ares_request {
+  /** synchronizes access to this request, and also to associated
+   * ev_driver and fd_node objects */
+  grpc_core::Mutex mu;
+  /** indicates the DNS server to use, if specified */
+  struct ares_addr_port_node dns_server_addr ABSL_GUARDED_BY(mu);
+  /** following members are set in grpc_resolve_address_ares_impl */
+  /** closure to call when the request completes */
+  grpc_closure* on_done ABSL_GUARDED_BY(mu) = nullptr;
+  /** the pointer to receive the resolved addresses */
+  std::unique_ptr<grpc_core::ServerAddressList>* addresses_out
+      ABSL_GUARDED_BY(mu);
+  /** the pointer to receive the resolved balancer addresses */
+  std::unique_ptr<grpc_core::ServerAddressList>* balancer_addresses_out
+      ABSL_GUARDED_BY(mu);
+  /** the pointer to receive the service config in JSON */
+  char** service_config_json_out ABSL_GUARDED_BY(mu) = nullptr;
+  /** the evernt driver used by this request */
+  grpc_ares_ev_driver* ev_driver ABSL_GUARDED_BY(mu) = nullptr;
+  /** number of ongoing queries */
+  size_t pending_queries ABSL_GUARDED_BY(mu) = 0;
+  /** the errors explaining query failures, appended to in query callbacks */
+  grpc_error_handle error ABSL_GUARDED_BY(mu) = GRPC_ERROR_NONE;
+};
 
 /* Asynchronously resolve \a name. It will try to resolve grpclb SRV records in
   addition to the normal address records. For normal address records, it uses
   \a default_port if a port isn't designated in \a name, otherwise it uses the
   port in \a name. grpc_ares_init() must be called at least once before this
-  function. \a on_done may be called directly in this function without being
-  scheduled with \a exec_ctx, so it must not try to acquire locks that are
-  being held by the caller. The returned grpc_ares_request object is owned
-  by the caller and it is safe to free after on_done is called back. */
-extern grpc_ares_request* (*grpc_dns_lookup_ares_locked)(
+  function. The returned grpc_ares_request object is owned by the caller and it
+  is safe to free after on_done is called back.
+
+  Note on synchronization: \a as on_done might be called from another thread
+  ~immediately, access to the grpc_ares_request* return value must be
+  synchronized by the caller. TODO(apolcyn): we should remove this requirement
+  by changing this API to use two phase initialization - one API to create
+  the grpc_ares_request* and another to start the async work. */
+extern grpc_ares_request* (*grpc_dns_lookup_ares)(
     const char* dns_server, const char* name, const char* default_port,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
     std::unique_ptr<grpc_core::ServerAddressList>* addresses,
     std::unique_ptr<grpc_core::ServerAddressList>* balancer_addresses,
-    char** service_config_json, int query_timeout_ms,
-    std::shared_ptr<grpc_core::WorkSerializer> work_serializer);
+    char** service_config_json, int query_timeout_ms);
 
 /* Cancel the pending grpc_ares_request \a request */
-extern void (*grpc_cancel_ares_request_locked)(grpc_ares_request* request);
+extern void (*grpc_cancel_ares_request)(grpc_ares_request* request);
 
 /* Initialize gRPC ares wrapper. Must be called at least once before
    grpc_resolve_address_ares(). */
@@ -83,10 +100,6 @@ grpc_error_handle grpc_ares_init(void);
    it has been called the same number of times as grpc_ares_init(). */
 void grpc_ares_cleanup(void);
 
-/** Schedules the desired callback for request completion
- * and destroys the grpc_ares_request */
-void grpc_ares_complete_request_locked(grpc_ares_request* request);
-
 /* Indicates whether or not AAAA queries should be attempted. */
 /* E.g., return false if ipv6 is known to not be available. */
 bool grpc_ares_query_ipv6();

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

@@ -24,10 +24,10 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h"
-#include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/socket_windows.h"
+#include "src/core/lib/resolver/server_address.h"
 
 bool grpc_ares_query_ipv6() { return grpc_ipv6_loopback_available(); }
 

data/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc

@@ -1,20 +1,18 @@
-/*
- *
- * Copyright 2015 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 2015 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,6 +21,7 @@
 #include <climits>
 #include <cstring>
 
+#include "absl/functional/bind_front.h"
 #include "absl/strings/str_cat.h"
 
 #include <grpc/support/alloc.h>
@@ -30,8 +29,6 @@
 #include <grpc/support/time.h>
 
 #include "src/core/ext/filters/client_channel/resolver/dns/dns_resolver_selection.h"
-#include "src/core/ext/filters/client_channel/resolver_registry.h"
-#include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
@@ -39,6 +36,8 @@
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/work_serializer.h"
+#include "src/core/lib/resolver/resolver_registry.h"
+#include "src/core/lib/resolver/server_address.h"
 
 #define GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS 1
 #define GRPC_DNS_RECONNECT_BACKOFF_MULTIPLIER 1.6
@@ -49,9 +48,9 @@ namespace grpc_core {
 
 namespace {
 
-class NativeDnsResolver : public Resolver {
+class NativeClientChannelDNSResolver : public Resolver {
  public:
-  explicit NativeDnsResolver(ResolverArgs args);
+  explicit NativeClientChannelDNSResolver(ResolverArgs args);
 
   void StartLocked() override;
 
@@ -62,15 +61,17 @@ class NativeDnsResolver : public Resolver {
   void ShutdownLocked() override;
 
  private:
-  ~NativeDnsResolver() override;
+  ~NativeClientChannelDNSResolver() override;
 
   void MaybeStartResolvingLocked();
   void StartResolvingLocked();
 
   static void OnNextResolution(void* arg, grpc_error_handle error);
   void OnNextResolutionLocked(grpc_error_handle error);
-  static void OnResolved(void* arg, grpc_error_handle error);
-  void OnResolvedLocked(grpc_error_handle error);
+  void OnResolved(
+      absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or);
+  void OnResolvedLocked(
+      absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or);
 
   /// name to resolve
   std::string name_to_resolve_;
@@ -84,7 +85,6 @@ class NativeDnsResolver : public Resolver {
   bool shutdown_ = false;
   /// are we currently resolving?
   bool resolving_ = false;
-  grpc_closure on_resolved_;
   /// next resolution timer
   bool have_next_resolution_timer_ = false;
   grpc_timer next_resolution_timer_;
@@ -95,11 +95,12 @@ class NativeDnsResolver : public Resolver {
   grpc_millis last_resolution_timestamp_ = -1;
   /// retry backoff state
   BackOff backoff_;
-  /// currently resolving addresses
-  grpc_resolved_addresses* addresses_ = nullptr;
+  /// tracks pending resolutions
+  OrphanablePtr<DNSResolver::Request> dns_request_;
 };
 
-NativeDnsResolver::NativeDnsResolver(ResolverArgs args)
+NativeClientChannelDNSResolver::NativeClientChannelDNSResolver(
+    ResolverArgs args)
     : name_to_resolve_(absl::StripPrefix(args.uri.path(), "/")),
       channel_args_(grpc_channel_args_copy(args.args)),
       work_serializer_(std::move(args.work_serializer)),
@@ -120,41 +121,47 @@ NativeDnsResolver::NativeDnsResolver(ResolverArgs args)
   }
 }
 
-NativeDnsResolver::~NativeDnsResolver() {
+NativeClientChannelDNSResolver::~NativeClientChannelDNSResolver() {
   grpc_channel_args_destroy(channel_args_);
   grpc_pollset_set_destroy(interested_parties_);
 }
 
-void NativeDnsResolver::StartLocked() { MaybeStartResolvingLocked(); }
+void NativeClientChannelDNSResolver::StartLocked() {
+  MaybeStartResolvingLocked();
+}
 
-void NativeDnsResolver::RequestReresolutionLocked() {
+void NativeClientChannelDNSResolver::RequestReresolutionLocked() {
   if (!resolving_) {
     MaybeStartResolvingLocked();
   }
 }
 
-void NativeDnsResolver::ResetBackoffLocked() {
+void NativeClientChannelDNSResolver::ResetBackoffLocked() {
   if (have_next_resolution_timer_) {
     grpc_timer_cancel(&next_resolution_timer_);
   }
   backoff_.Reset();
 }
 
-void NativeDnsResolver::ShutdownLocked() {
+void NativeClientChannelDNSResolver::ShutdownLocked() {
   shutdown_ = true;
   if (have_next_resolution_timer_) {
     grpc_timer_cancel(&next_resolution_timer_);
   }
+  dns_request_.reset();
 }
 
-void NativeDnsResolver::OnNextResolution(void* arg, grpc_error_handle error) {
-  NativeDnsResolver* r = static_cast<NativeDnsResolver*>(arg);
-  GRPC_ERROR_REF(error);  // ref owned by lambda
+void NativeClientChannelDNSResolver::OnNextResolution(void* arg,
+                                                      grpc_error_handle error) {
+  NativeClientChannelDNSResolver* r =
+      static_cast<NativeClientChannelDNSResolver*>(arg);
+  (void)GRPC_ERROR_REF(error);  // ref owned by lambda
   r->work_serializer_->Run([r, error]() { r->OnNextResolutionLocked(error); },
                            DEBUG_LOCATION);
 }
 
-void NativeDnsResolver::OnNextResolutionLocked(grpc_error_handle error) {
+void NativeClientChannelDNSResolver::OnNextResolutionLocked(
+    grpc_error_handle error) {
   have_next_resolution_timer_ = false;
   if (error == GRPC_ERROR_NONE && !resolving_) {
     StartResolvingLocked();
@@ -163,44 +170,46 @@ void NativeDnsResolver::OnNextResolutionLocked(grpc_error_handle error) {
   GRPC_ERROR_UNREF(error);
 }
 
-void NativeDnsResolver::OnResolved(void* arg, grpc_error_handle error) {
-  NativeDnsResolver* r = static_cast<NativeDnsResolver*>(arg);
-  GRPC_ERROR_REF(error);  // owned by lambda
-  r->work_serializer_->Run([r, error]() { r->OnResolvedLocked(error); },
-                           DEBUG_LOCATION);
+void NativeClientChannelDNSResolver::OnResolved(
+    absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or) {
+  work_serializer_->Run(
+      [this, addresses_or]() mutable {
+        OnResolvedLocked(std::move(addresses_or));
+      },
+      DEBUG_LOCATION);
 }
 
-void NativeDnsResolver::OnResolvedLocked(grpc_error_handle error) {
+void NativeClientChannelDNSResolver::OnResolvedLocked(
+    absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or) {
   GPR_ASSERT(resolving_);
   resolving_ = false;
+  dns_request_.reset();
   if (shutdown_) {
     Unref(DEBUG_LOCATION, "dns-resolving");
-    GRPC_ERROR_UNREF(error);
     return;
   }
-  if (addresses_ != nullptr) {
-    Result result;
-    for (size_t i = 0; i < addresses_->naddrs; ++i) {
-      result.addresses.emplace_back(&addresses_->addrs[i].addr,
-                                    addresses_->addrs[i].len,
-                                    nullptr /* args */);
+  if (addresses_or.ok()) {
+    ServerAddressList addresses;
+    for (auto& addr : *addresses_or) {
+      addresses.emplace_back(addr, nullptr /* args */);
     }
-    grpc_resolved_addresses_destroy(addresses_);
+    Result result;
+    result.addresses = std::move(addresses);
     result.args = grpc_channel_args_copy(channel_args_);
-    result_handler_->ReturnResult(std::move(result));
+    result_handler_->ReportResult(std::move(result));
     // Reset backoff state so that we start from the beginning when the
     // next request gets triggered.
     backoff_.Reset();
   } else {
+    std::string error_message = addresses_or.status().ToString();
     gpr_log(GPR_INFO, "dns resolution failed (will retry): %s",
-            grpc_error_std_string(error).c_str());
+            error_message.c_str());
     // Return transient error.
-    std::string error_message =
-        absl::StrCat("DNS resolution failed for service: ", name_to_resolve_);
-    result_handler_->ReturnError(grpc_error_set_int(
-        GRPC_ERROR_CREATE_REFERENCING_FROM_COPIED_STRING(error_message.c_str(),
-                                                         &error, 1),
-        GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE));
+    Result result;
+    result.addresses = absl::UnavailableError(absl::StrCat(
+        "DNS resolution failed for ", name_to_resolve_, ": ", error_message));
+    result.args = grpc_channel_args_copy(channel_args_);
+    result_handler_->ReportResult(std::move(result));
     // Set up for retry.
     // InvalidateNow to avoid getting stuck re-initializing this timer
     // in a loop while draining the currently-held WorkSerializer.
@@ -219,15 +228,15 @@ void NativeDnsResolver::OnResolvedLocked(grpc_error_handle error) {
     } else {
       gpr_log(GPR_DEBUG, "retrying immediately");
     }
-    GRPC_CLOSURE_INIT(&on_next_resolution_, NativeDnsResolver::OnNextResolution,
-                      this, grpc_schedule_on_exec_ctx);
+    GRPC_CLOSURE_INIT(&on_next_resolution_,
+                      NativeClientChannelDNSResolver::OnNextResolution, this,
+                      grpc_schedule_on_exec_ctx);
     grpc_timer_init(&next_resolution_timer_, next_try, &on_next_resolution_);
   }
   Unref(DEBUG_LOCATION, "dns-resolving");
-  GRPC_ERROR_UNREF(error);
 }
 
-void NativeDnsResolver::MaybeStartResolvingLocked() {
+void NativeClientChannelDNSResolver::MaybeStartResolvingLocked() {
   // If there is an existing timer, the time it fires is the earliest time we
   // can start the next resolution.
   if (have_next_resolution_timer_) return;
@@ -239,10 +248,10 @@ void NativeDnsResolver::MaybeStartResolvingLocked() {
     const grpc_millis earliest_next_resolution =
         last_resolution_timestamp_ + min_time_between_resolutions_;
     const grpc_millis ms_until_next_resolution =
-        earliest_next_resolution - grpc_core::ExecCtx::Get()->Now();
+        earliest_next_resolution - ExecCtx::Get()->Now();
     if (ms_until_next_resolution > 0) {
       const grpc_millis last_resolution_ago =
-          grpc_core::ExecCtx::Get()->Now() - last_resolution_timestamp_;
+          ExecCtx::Get()->Now() - last_resolution_timestamp_;
       gpr_log(GPR_DEBUG,
               "In cooldown from last resolution (from %" PRId64
               " ms ago). Will resolve again in %" PRId64 " ms",
@@ -253,7 +262,7 @@ void NativeDnsResolver::MaybeStartResolvingLocked() {
       // callback as part of the type system.
       Ref(DEBUG_LOCATION, "next_resolution_timer_cooldown").release();
       GRPC_CLOSURE_INIT(&on_next_resolution_,
-                        NativeDnsResolver::OnNextResolution, this,
+                        NativeClientChannelDNSResolver::OnNextResolution, this,
                         grpc_schedule_on_exec_ctx);
       grpc_timer_init(&next_resolution_timer_,
                       ExecCtx::Get()->Now() + ms_until_next_resolution,
@@ -264,7 +273,7 @@ void NativeDnsResolver::MaybeStartResolvingLocked() {
   StartResolvingLocked();
 }
 
-void NativeDnsResolver::StartResolvingLocked() {
+void NativeClientChannelDNSResolver::StartResolvingLocked() {
   gpr_log(GPR_DEBUG, "Start resolving.");
   // 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
@@ -272,31 +281,34 @@ void NativeDnsResolver::StartResolvingLocked() {
   Ref(DEBUG_LOCATION, "dns-resolving").release();
   GPR_ASSERT(!resolving_);
   resolving_ = true;
-  addresses_ = nullptr;
-  GRPC_CLOSURE_INIT(&on_resolved_, NativeDnsResolver::OnResolved, this,
-                    grpc_schedule_on_exec_ctx);
-  grpc_resolve_address(name_to_resolve_.c_str(), kDefaultSecurePort,
-                       interested_parties_, &on_resolved_, &addresses_);
-  last_resolution_timestamp_ = grpc_core::ExecCtx::Get()->Now();
+  dns_request_ = GetDNSResolver()->ResolveName(
+      name_to_resolve_, kDefaultSecurePort, interested_parties_,
+      absl::bind_front(&NativeClientChannelDNSResolver::OnResolved, this));
+  dns_request_->Start();
+  last_resolution_timestamp_ = ExecCtx::Get()->Now();
 }
 
 //
 // Factory
 //
 
-class NativeDnsResolverFactory : public ResolverFactory {
+class NativeClientChannelDNSResolverFactory : public ResolverFactory {
  public:
   bool IsValidUri(const URI& uri) const override {
     if (GPR_UNLIKELY(!uri.authority().empty())) {
       gpr_log(GPR_ERROR, "authority based dns uri's not supported");
       return false;
     }
+    if (absl::StripPrefix(uri.path(), "/").empty()) {
+      gpr_log(GPR_ERROR, "no server name supplied in dns URI");
+      return false;
+    }
     return true;
   }
 
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
     if (!IsValidUri(args.uri)) return nullptr;
-    return MakeOrphanable<NativeDnsResolver>(std::move(args));
+    return MakeOrphanable<NativeClientChannelDNSResolver>(std::move(args));
   }
 
   const char* scheme() const override { return "dns"; }
@@ -312,7 +324,7 @@ void grpc_resolver_dns_native_init() {
   if (gpr_stricmp(resolver.get(), "native") == 0) {
     gpr_log(GPR_DEBUG, "Using native dns resolver");
     grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-        absl::make_unique<grpc_core::NativeDnsResolverFactory>());
+        absl::make_unique<grpc_core::NativeClientChannelDNSResolverFactory>());
   } else {
     grpc_core::ResolverRegistry::Builder::InitRegistry();
     grpc_core::ResolverFactory* existing_factory =
@@ -320,7 +332,8 @@ void grpc_resolver_dns_native_init() {
     if (existing_factory == nullptr) {
       gpr_log(GPR_DEBUG, "Using native dns resolver");
       grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-          absl::make_unique<grpc_core::NativeDnsResolverFactory>());
+          absl::make_unique<
+              grpc_core::NativeClientChannelDNSResolverFactory>());
     }
   }
 }

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

@@ -30,8 +30,6 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/ext/filters/client_channel/resolver_registry.h"
-#include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
@@ -40,6 +38,8 @@
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 #include "src/core/lib/iomgr/work_serializer.h"
+#include "src/core/lib/resolver/resolver_registry.h"
+#include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 
@@ -142,23 +142,23 @@ void FakeResolver::MaybeSendResultLocked() {
   if (!started_ || shutdown_) return;
   if (return_failure_) {
     // TODO(roth): Change resolver result generator to be able to inject
-    // the error to be returned.
-    result_handler_->ReturnError(grpc_error_set_int(
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Resolver transient failure"),
-        GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE));
+    // the error to be returned and to be able to independently set errors
+    // for addresses and service config.
+    Result result;
+    result.addresses = absl::UnavailableError("Resolver transient failure");
+    result.service_config = result.addresses.status();
+    result.args = grpc_channel_args_copy(channel_args_);
+    result_handler_->ReportResult(std::move(result));
     return_failure_ = false;
   } else if (has_next_result_) {
     Result result;
     result.addresses = std::move(next_result_.addresses);
     result.service_config = std::move(next_result_.service_config);
-    // TODO(roth): Use std::move() once grpc_error is converted to C++.
-    result.service_config_error = next_result_.service_config_error;
-    next_result_.service_config_error = GRPC_ERROR_NONE;
     // When both next_results_ and channel_args_ contain an arg with the same
     // name, only the one in next_results_ will be kept since next_results_ is
     // before channel_args_.
     result.args = grpc_channel_args_union(next_result_.args, channel_args_);
-    result_handler_->ReturnResult(std::move(result));
+    result_handler_->ReportResult(std::move(result));
     has_next_result_ = false;
   }
 }
@@ -324,7 +324,9 @@ void ResponseGeneratorChannelArgDestroy(void* p) {
   generator->Unref();
 }
 
-int ResponseGeneratorChannelArgCmp(void* a, void* b) { return GPR_ICMP(a, b); }
+int ResponseGeneratorChannelArgCmp(void* a, void* b) {
+  return QsortCompare(a, b);
+}
 
 }  // namespace
 

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

@@ -19,10 +19,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/resolver.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/resolver/resolver.h"
 
 #define GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR \
   "grpc.fake_resolver.response_generator"

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

@@ -18,12 +18,12 @@
 
 #include <random>
 
-#include "src/core/ext/filters/client_channel/resolver_registry.h"
 #include "src/core/ext/xds/xds_client.h"
 #include "src/core/lib/gpr/env.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/http/httpcli.h"
 #include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/lib/resolver/resolver_registry.h"
 #include "src/core/lib/security/credentials/alts/check_gcp_environment.h"
 
 namespace grpc_core {
@@ -61,7 +61,6 @@ class GoogleCloud2ProdResolver : public Resolver {
                         grpc_error_handle error) = 0;
 
     RefCountedPtr<GoogleCloud2ProdResolver> resolver_;
-    grpc_httpcli_context context_;
     grpc_httpcli_response response_;
     grpc_closure on_done_;
     std::atomic<bool> on_done_called_{false};
@@ -115,7 +114,6 @@ GoogleCloud2ProdResolver::MetadataQuery::MetadataQuery(
     RefCountedPtr<GoogleCloud2ProdResolver> resolver, const char* path,
     grpc_polling_entity* pollent)
     : resolver_(std::move(resolver)) {
-  grpc_httpcli_context_init(&context_);
   // Start HTTP request.
   GRPC_CLOSURE_INIT(&on_done_, OnHttpRequestDone, this, nullptr);
   Ref().release();  // Ref held by callback.
@@ -127,15 +125,13 @@ GoogleCloud2ProdResolver::MetadataQuery::MetadataQuery(
   request.http.path = const_cast<char*>(path);
   request.http.hdr_count = 1;
   request.http.hdrs = &header;
-  grpc_resource_quota* resource_quota =
-      grpc_resource_quota_create("c2p_resolver");
-  grpc_httpcli_get(&context_, pollent, resource_quota, &request,
+  // TODO(ctiller): share the quota from whomever instantiates this!
+  grpc_httpcli_get(pollent, ResourceQuota::Default(), &request,
                    ExecCtx::Get()->Now() + 10000,  // 10s timeout
                    &on_done_, &response_);
 }
 
 GoogleCloud2ProdResolver::MetadataQuery::~MetadataQuery() {
-  grpc_httpcli_context_destroy(&context_);
   grpc_http_response_destroy(&response_);
 }
 
@@ -363,20 +359,15 @@ class GoogleCloud2ProdResolverFactory : public ResolverFactory {
     return MakeOrphanable<GoogleCloud2ProdResolver>(std::move(args));
   }
 
-  const char* scheme() const override { return "google-c2p"; }
+  // TODO(roth): Remove experimental suffix once this code is proven stable.
+  const char* scheme() const override { return "google-c2p-experimental"; }
 };
 
 }  // namespace
 
 void GoogleCloud2ProdResolverInit() {
-  // TODO(roth): Remove env var protection once this code is proven stable.
-  UniquePtr<char> value(gpr_getenv("GRPC_EXPERIMENTAL_GOOGLE_C2P_RESOLVER"));
-  bool parsed_value;
-  bool parse_succeeded = gpr_parse_bool_value(value.get(), &parsed_value);
-  if (parse_succeeded && parsed_value) {
-    ResolverRegistry::Builder::RegisterResolverFactory(
-        absl::make_unique<GoogleCloud2ProdResolverFactory>());
-  }
+  ResolverRegistry::Builder::RegisterResolverFactory(
+      absl::make_unique<GoogleCloud2ProdResolverFactory>());
 }
 
 void GoogleCloud2ProdResolverShutdown() {}

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

@@ -28,13 +28,13 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/ext/filters/client_channel/resolver_registry.h"
-#include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
+#include "src/core/lib/resolver/resolver_registry.h"
+#include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 
@@ -73,7 +73,7 @@ void SockaddrResolver::StartLocked() {
   // TODO(roth): Use std::move() once channel args is converted to C++.
   result.args = channel_args_;
   channel_args_ = nullptr;
-  result_handler_->ReturnResult(std::move(result));
+  result_handler_->ReportResult(std::move(result));
 }
 
 //
@@ -91,9 +91,9 @@ bool ParseUri(const URI& uri,
   // Construct addresses.
   bool errors_found = false;
   for (absl::string_view ith_path : absl::StrSplit(uri.path(), ',')) {
-    URI ith_uri(uri.scheme(), "", std::string(ith_path), {}, "");
+    auto ith_uri = URI::Create(uri.scheme(), "", std::string(ith_path), {}, "");
     grpc_resolved_address addr;
-    if (!parse(ith_uri, &addr)) {
+    if (!ith_uri.ok() || !parse(*ith_uri, &addr)) {
       errors_found = true;
       break;
     }