grpc 1.44.0.pre2 → 1.45.0

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

@@ -249,20 +249,20 @@ static fd_node* pop_fd_node_locked(fd_node** head, ares_socket_t as)
   return nullptr;
 }
 
-static grpc_millis calculate_next_ares_backup_poll_alarm_ms(
+static grpc_core::Timestamp calculate_next_ares_backup_poll_alarm(
     grpc_ares_ev_driver* driver)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(&grpc_ares_request::mu) {
   // An alternative here could be to use ares_timeout to try to be more
   // accurate, but that would require using "struct timeval"'s, which just makes
   // things a bit more complicated. So just poll every second, as suggested
   // by the c-ares code comments.
-  grpc_millis ms_until_next_ares_backup_poll_alarm = 1000;
+  grpc_core::Duration until_next_ares_backup_poll_alarm =
+      grpc_core::Duration::Seconds(1);
   GRPC_CARES_TRACE_LOG(
       "request:%p ev_driver=%p. next ares process poll time in "
       "%" PRId64 " ms",
-      driver->request, driver, ms_until_next_ares_backup_poll_alarm);
-  return ms_until_next_ares_backup_poll_alarm +
-         grpc_core::ExecCtx::Get()->Now();
+      driver->request, driver, until_next_ares_backup_poll_alarm.millis());
+  return grpc_core::ExecCtx::Get()->Now() + until_next_ares_backup_poll_alarm;
 }
 
 static void on_timeout(void* arg, grpc_error_handle error) {
@@ -317,8 +317,8 @@ static void on_ares_backup_poll_alarm(void* arg, grpc_error_handle error) {
       // in a loop while draining the currently-held WorkSerializer.
       // Also see https://github.com/grpc/grpc/issues/26079.
       grpc_core::ExecCtx::Get()->InvalidateNow();
-      grpc_millis next_ares_backup_poll_alarm =
-          calculate_next_ares_backup_poll_alarm_ms(driver);
+      grpc_core::Timestamp next_ares_backup_poll_alarm =
+          calculate_next_ares_backup_poll_alarm(driver);
       grpc_ares_ev_driver_ref(driver);
       GRPC_CLOSURE_INIT(&driver->on_ares_backup_poll_alarm_locked,
                         on_ares_backup_poll_alarm, driver,
@@ -462,22 +462,23 @@ void grpc_ares_ev_driver_start_locked(grpc_ares_ev_driver* ev_driver)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(&grpc_ares_request::mu) {
   grpc_ares_notify_on_event_locked(ev_driver);
   // Initialize overall DNS resolution timeout alarm
-  grpc_millis timeout =
+  grpc_core::Duration timeout =
       ev_driver->query_timeout_ms == 0
-          ? GRPC_MILLIS_INF_FUTURE
-          : ev_driver->query_timeout_ms + grpc_core::ExecCtx::Get()->Now();
+          ? grpc_core::Duration::Infinity()
+          : grpc_core::Duration::Milliseconds(ev_driver->query_timeout_ms);
   GRPC_CARES_TRACE_LOG(
       "request:%p ev_driver=%p grpc_ares_ev_driver_start_locked. timeout in "
       "%" PRId64 " ms",
-      ev_driver->request, ev_driver, timeout);
+      ev_driver->request, ev_driver, timeout.millis());
   grpc_ares_ev_driver_ref(ev_driver);
   GRPC_CLOSURE_INIT(&ev_driver->on_timeout_locked, on_timeout, ev_driver,
                     grpc_schedule_on_exec_ctx);
-  grpc_timer_init(&ev_driver->query_timeout, timeout,
+  grpc_timer_init(&ev_driver->query_timeout,
+                  grpc_core::ExecCtx::Get()->Now() + timeout,
                   &ev_driver->on_timeout_locked);
   // Initialize the backup poll alarm
-  grpc_millis next_ares_backup_poll_alarm =
-      calculate_next_ares_backup_poll_alarm_ms(ev_driver);
+  grpc_core::Timestamp next_ares_backup_poll_alarm =
+      calculate_next_ares_backup_poll_alarm(ev_driver);
   grpc_ares_ev_driver_ref(ev_driver);
   GRPC_CLOSURE_INIT(&ev_driver->on_ares_backup_poll_alarm_locked,
                     on_ares_backup_poll_alarm, ev_driver,
@@ -691,8 +692,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(std::move(error_msg));
+    grpc_error_handle error = GRPC_ERROR_CREATE_FROM_CPP_STRING(error_msg);
     r->error = grpc_error_add_child(error, r->error);
   }
   destroy_hostbyname_request_locked(hr);
@@ -739,8 +739,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(std::move(error_msg));
+    grpc_error_handle error = GRPC_ERROR_CREATE_FROM_CPP_STRING(error_msg);
     r->error = grpc_error_add_child(error, r->error);
   }
   delete q;
@@ -802,7 +801,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(std::move(error_msg));
+  error = GRPC_ERROR_CREATE_FROM_CPP_STRING(error_msg);
   r->error = grpc_error_add_child(error, r->error);
 }
 

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

@@ -31,6 +31,7 @@
 #include "src/core/ext/filters/client_channel/resolver/dns/dns_resolver_selection.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/iomgr/resolve_address.h"
@@ -90,9 +91,9 @@ class NativeClientChannelDNSResolver : public Resolver {
   grpc_timer next_resolution_timer_;
   grpc_closure on_next_resolution_;
   /// min time between DNS requests
-  grpc_millis min_time_between_resolutions_;
+  Duration min_time_between_resolutions_;
   /// timestamp of last DNS request
-  grpc_millis last_resolution_timestamp_ = -1;
+  absl::optional<Timestamp> last_resolution_timestamp_;
   /// retry backoff state
   BackOff backoff_;
   /// tracks pending resolutions
@@ -106,16 +107,17 @@ NativeClientChannelDNSResolver::NativeClientChannelDNSResolver(
       work_serializer_(std::move(args.work_serializer)),
       result_handler_(std::move(args.result_handler)),
       interested_parties_(grpc_pollset_set_create()),
-      min_time_between_resolutions_(grpc_channel_args_find_integer(
-          channel_args_, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS,
-          {1000 * 30, 0, INT_MAX})),
-      backoff_(
-          BackOff::Options()
-              .set_initial_backoff(GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS *
-                                   1000)
-              .set_multiplier(GRPC_DNS_RECONNECT_BACKOFF_MULTIPLIER)
-              .set_jitter(GRPC_DNS_RECONNECT_JITTER)
-              .set_max_backoff(GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS * 1000)) {
+      min_time_between_resolutions_(
+          Duration::Milliseconds(grpc_channel_args_find_integer(
+              channel_args_, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS,
+              {1000 * 30, 0, INT_MAX}))),
+      backoff_(BackOff::Options()
+                   .set_initial_backoff(Duration::Seconds(
+                       GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS))
+                   .set_multiplier(GRPC_DNS_RECONNECT_BACKOFF_MULTIPLIER)
+                   .set_jitter(GRPC_DNS_RECONNECT_JITTER)
+                   .set_max_backoff(Duration::Seconds(
+                       GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS))) {
   if (args.pollset_set != nullptr) {
     grpc_pollset_set_add_pollset_set(interested_parties_, args.pollset_set);
   }
@@ -215,16 +217,17 @@ void NativeClientChannelDNSResolver::OnResolvedLocked(
     // in a loop while draining the currently-held WorkSerializer.
     // Also see https://github.com/grpc/grpc/issues/26079.
     ExecCtx::Get()->InvalidateNow();
-    grpc_millis next_try = backoff_.NextAttemptTime();
-    grpc_millis timeout = next_try - ExecCtx::Get()->Now();
+    Timestamp next_try = backoff_.NextAttemptTime();
+    Duration timeout = next_try - ExecCtx::Get()->Now();
     GPR_ASSERT(!have_next_resolution_timer_);
     have_next_resolution_timer_ = true;
     // 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.
     Ref(DEBUG_LOCATION, "next_resolution_timer").release();
-    if (timeout > 0) {
-      gpr_log(GPR_DEBUG, "retrying in %" PRId64 " milliseconds", timeout);
+    if (timeout > Duration::Zero()) {
+      gpr_log(GPR_DEBUG, "retrying in %" PRId64 " milliseconds",
+              timeout.millis());
     } else {
       gpr_log(GPR_DEBUG, "retrying immediately");
     }
@@ -240,22 +243,23 @@ 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;
-  if (last_resolution_timestamp_ >= 0) {
+  if (last_resolution_timestamp_.has_value()) {
     // InvalidateNow to avoid getting stuck re-initializing this timer
     // in a loop while draining the currently-held WorkSerializer.
     // Also see https://github.com/grpc/grpc/issues/26079.
     ExecCtx::Get()->InvalidateNow();
-    const grpc_millis earliest_next_resolution =
-        last_resolution_timestamp_ + min_time_between_resolutions_;
-    const grpc_millis ms_until_next_resolution =
+    const Timestamp earliest_next_resolution =
+        *last_resolution_timestamp_ + min_time_between_resolutions_;
+    const Duration time_until_next_resolution =
         earliest_next_resolution - ExecCtx::Get()->Now();
-    if (ms_until_next_resolution > 0) {
-      const grpc_millis last_resolution_ago =
-          ExecCtx::Get()->Now() - last_resolution_timestamp_;
+    if (time_until_next_resolution > Duration::Zero()) {
+      const Duration last_resolution_ago =
+          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",
-              last_resolution_ago, ms_until_next_resolution);
+              last_resolution_ago.millis(),
+              time_until_next_resolution.millis());
       have_next_resolution_timer_ = true;
       // 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
@@ -265,7 +269,7 @@ void NativeClientChannelDNSResolver::MaybeStartResolvingLocked() {
                         NativeClientChannelDNSResolver::OnNextResolution, this,
                         grpc_schedule_on_exec_ctx);
       grpc_timer_init(&next_resolution_timer_,
-                      ExecCtx::Get()->Now() + ms_until_next_resolution,
+                      ExecCtx::Get()->Now() + time_until_next_resolution,
                       &on_next_resolution_);
       return;
     }
@@ -294,6 +298,8 @@ void NativeClientChannelDNSResolver::StartResolvingLocked() {
 
 class NativeClientChannelDNSResolverFactory : public ResolverFactory {
  public:
+  absl::string_view scheme() const override { return "dns"; }
+
   bool IsValidUri(const URI& uri) const override {
     if (GPR_UNLIKELY(!uri.authority().empty())) {
       gpr_log(GPR_ERROR, "authority based dns uri's not supported");
@@ -310,32 +316,24 @@ class NativeClientChannelDNSResolverFactory : public ResolverFactory {
     if (!IsValidUri(args.uri)) return nullptr;
     return MakeOrphanable<NativeClientChannelDNSResolver>(std::move(args));
   }
-
-  const char* scheme() const override { return "dns"; }
 };
 
 }  // namespace
 
-}  // namespace grpc_core
-
-void grpc_resolver_dns_native_init() {
-  grpc_core::UniquePtr<char> resolver =
-      GPR_GLOBAL_CONFIG_GET(grpc_dns_resolver);
-  if (gpr_stricmp(resolver.get(), "native") == 0) {
+void RegisterNativeDnsResolver(CoreConfiguration::Builder* builder) {
+  static const char* const resolver =
+      GPR_GLOBAL_CONFIG_GET(grpc_dns_resolver).release();
+  if (gpr_stricmp(resolver, "native") == 0) {
     gpr_log(GPR_DEBUG, "Using native dns resolver");
-    grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-        absl::make_unique<grpc_core::NativeClientChannelDNSResolverFactory>());
+    builder->resolver_registry()->RegisterResolverFactory(
+        absl::make_unique<NativeClientChannelDNSResolverFactory>());
   } else {
-    grpc_core::ResolverRegistry::Builder::InitRegistry();
-    grpc_core::ResolverFactory* existing_factory =
-        grpc_core::ResolverRegistry::LookupResolverFactory("dns");
-    if (existing_factory == nullptr) {
+    if (!builder->resolver_registry()->HasResolverFactory("dns")) {
       gpr_log(GPR_DEBUG, "Using native dns resolver");
-      grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-          absl::make_unique<
-              grpc_core::NativeClientChannelDNSResolverFactory>());
+      builder->resolver_registry()->RegisterResolverFactory(
+          absl::make_unique<NativeClientChannelDNSResolverFactory>());
     }
   }
 }
 
-void grpc_resolver_dns_native_shutdown() {}
+}  // namespace grpc_core

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

@@ -32,6 +32,7 @@
 
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -359,22 +360,22 @@ namespace {
 
 class FakeResolverFactory : public ResolverFactory {
  public:
+  absl::string_view scheme() const override { return "fake"; }
+
   bool IsValidUri(const URI& /*uri*/) const override { return true; }
 
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
     return MakeOrphanable<FakeResolver>(std::move(args));
   }
-
-  const char* scheme() const override { return "fake"; }
 };
 
 }  // namespace
 
-}  // namespace grpc_core
-
-void grpc_resolver_fake_init() {
-  grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-      absl::make_unique<grpc_core::FakeResolverFactory>());
+void RegisterFakeResolver(CoreConfiguration::Builder* builder) {
+  builder->resolver_registry()->RegisterResolverFactory(
+      absl::make_unique<FakeResolverFactory>());
 }
 
+}  // namespace grpc_core
+
 void grpc_resolver_fake_shutdown() {}

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

@@ -24,6 +24,7 @@
 #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/resource_quota/api.h"
 #include "src/core/lib/security/credentials/alts/check_gcp_environment.h"
 
 namespace grpc_core {
@@ -52,18 +53,15 @@ class GoogleCloud2ProdResolver : public Resolver {
    private:
     static void OnHttpRequestDone(void* arg, grpc_error_handle error);
 
-    // Calls OnDone() if not already called.  Releases a ref.
-    void MaybeCallOnDone(grpc_error_handle error);
-
     // If error is not GRPC_ERROR_NONE, then it's not safe to look at response.
     virtual void OnDone(GoogleCloud2ProdResolver* resolver,
                         const grpc_http_response* response,
                         grpc_error_handle error) = 0;
 
     RefCountedPtr<GoogleCloud2ProdResolver> resolver_;
-    grpc_httpcli_response response_;
+    OrphanablePtr<HttpRequest> http_request_;
+    grpc_http_response response_;
     grpc_closure on_done_;
-    std::atomic<bool> on_done_called_{false};
   };
 
   // A metadata server query to get the zone.
@@ -94,10 +92,13 @@ class GoogleCloud2ProdResolver : public Resolver {
   void IPv6QueryDone(bool ipv6_supported);
   void StartXdsResolver();
 
+  ResourceQuotaRefPtr resource_quota_;
   std::shared_ptr<WorkSerializer> work_serializer_;
   grpc_polling_entity pollent_;
   bool using_dns_ = false;
   OrphanablePtr<Resolver> child_resolver_;
+  std::string metadata_server_name_ = "metadata.google.internal.";
+  bool shutdown_ = false;
 
   OrphanablePtr<ZoneQuery> zone_query_;
   absl::optional<std::string> zone_;
@@ -117,18 +118,26 @@ GoogleCloud2ProdResolver::MetadataQuery::MetadataQuery(
   // Start HTTP request.
   GRPC_CLOSURE_INIT(&on_done_, OnHttpRequestDone, this, nullptr);
   Ref().release();  // Ref held by callback.
-  grpc_httpcli_request request;
-  memset(&request, 0, sizeof(grpc_httpcli_request));
+  grpc_http_request request;
+  memset(&request, 0, sizeof(grpc_http_request));
   grpc_http_header header = {const_cast<char*>("Metadata-Flavor"),
                              const_cast<char*>("Google")};
-  request.host = const_cast<char*>("metadata.google.internal");
-  request.http.path = const_cast<char*>(path);
-  request.http.hdr_count = 1;
-  request.http.hdrs = &header;
-  // 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_);
+  request.hdr_count = 1;
+  request.hdrs = &header;
+  auto uri = URI::Create("http", resolver_->metadata_server_name_, path,
+                         {} /* query params */, "" /* fragment */);
+  GPR_ASSERT(uri.ok());  // params are hardcoded
+  grpc_arg resource_quota_arg = grpc_channel_arg_pointer_create(
+      const_cast<char*>(GRPC_ARG_RESOURCE_QUOTA),
+      resolver_->resource_quota_.get(), grpc_resource_quota_arg_vtable());
+  grpc_channel_args args = {1, &resource_quota_arg};
+  http_request_ = HttpRequest::Get(
+      std::move(*uri), &args, pollent, &request,
+      ExecCtx::Get()->Now() + Duration::Seconds(10),  // 10s timeout
+      &on_done_, &response_,
+      RefCountedPtr<grpc_channel_credentials>(
+          grpc_insecure_credentials_create()));
+  http_request_->Start();
 }
 
 GoogleCloud2ProdResolver::MetadataQuery::~MetadataQuery() {
@@ -136,34 +145,20 @@ GoogleCloud2ProdResolver::MetadataQuery::~MetadataQuery() {
 }
 
 void GoogleCloud2ProdResolver::MetadataQuery::Orphan() {
-  // TODO(roth): Once the HTTP client library supports cancellation,
-  // use that here.
-  MaybeCallOnDone(GRPC_ERROR_CANCELLED);
+  http_request_.reset();
+  Unref();
 }
 
 void GoogleCloud2ProdResolver::MetadataQuery::OnHttpRequestDone(
     void* arg, grpc_error_handle error) {
   auto* self = static_cast<MetadataQuery*>(arg);
-  self->MaybeCallOnDone(GRPC_ERROR_REF(error));
-}
-
-void GoogleCloud2ProdResolver::MetadataQuery::MaybeCallOnDone(
-    grpc_error_handle error) {
-  bool expected = false;
-  if (!on_done_called_.compare_exchange_strong(expected, true,
-                                               std::memory_order_relaxed,
-                                               std::memory_order_relaxed)) {
-    // We've already called OnDone(), so just clean up.
-    GRPC_ERROR_UNREF(error);
-    Unref();
-    return;
-  }
   // Hop back into WorkSerializer to call OnDone().
   // Note: We implicitly pass our ref to the callback here.
-  resolver_->work_serializer_->Run(
-      [this, error]() {
-        OnDone(resolver_.get(), &response_, error);
-        Unref();
+  (void)GRPC_ERROR_REF(error);
+  self->resolver_->work_serializer_->Run(
+      [self, error]() {
+        self->OnDone(self->resolver_.get(), &self->response_, error);
+        self->Unref();
       },
       DEBUG_LOCATION);
 }
@@ -181,22 +176,31 @@ GoogleCloud2ProdResolver::ZoneQuery::ZoneQuery(
 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) {
-    gpr_log(GPR_ERROR, "error fetching zone from metadata server: %s",
-            grpc_error_std_string(error).c_str());
-  }
-  std::string zone;
-  if (error == GRPC_ERROR_NONE && response->status == 200) {
+    zone = absl::UnknownError(
+        absl::StrCat("error fetching zone from metadata server: ",
+                     grpc_error_std_string(error)));
+  } else if (response->status != 200) {
+    zone = absl::UnknownError(absl::StrFormat(
+        "zone query received non-200 status: %d", response->status));
+  } else {
     absl::string_view body(response->body, response->body_length);
     size_t i = body.find_last_of('/');
     if (i == body.npos) {
-      gpr_log(GPR_ERROR, "could not parse zone from metadata server: %s",
-              std::string(body).c_str());
+      zone = absl::UnknownError(
+          absl::StrCat("could not parse zone from metadata server: ", body));
     } else {
       zone = std::string(body.substr(i + 1));
     }
   }
-  resolver->ZoneQueryDone(std::move(zone));
+  if (!zone.ok()) {
+    gpr_log(GPR_ERROR, "zone query failed: %s",
+            zone.status().ToString().c_str());
+    resolver->ZoneQueryDone("");
+  } else {
+    resolver->ZoneQueryDone(std::move(*zone));
+  }
   GRPC_ERROR_UNREF(error);
 }
 
@@ -227,12 +231,18 @@ void GoogleCloud2ProdResolver::IPv6Query::OnDone(
 //
 
 GoogleCloud2ProdResolver::GoogleCloud2ProdResolver(ResolverArgs args)
-    : work_serializer_(std::move(args.work_serializer)),
+    : resource_quota_(ResourceQuotaFromChannelArgs(args.args)),
+      work_serializer_(std::move(args.work_serializer)),
       pollent_(grpc_polling_entity_create_from_pollset_set(args.pollset_set)) {
   absl::string_view name_to_resolve = absl::StripPrefix(args.uri.path(), "/");
   // If we're not running on GCP, we can't use DirectPath, so delegate
   // to the DNS resolver.
-  if (!grpc_alts_is_running_on_gcp() ||
+  bool test_only_pretend_running_on_gcp = grpc_channel_args_find_bool(
+      args.args, "grpc.testing.google_c2p_resolver_pretend_running_on_gcp",
+      false);
+  bool running_on_gcp =
+      test_only_pretend_running_on_gcp || grpc_alts_is_running_on_gcp();
+  if (!running_on_gcp ||
       // If the client is already using xDS, we can't use it here, because
       // they may be talking to a completely different xDS server than we
       // want to.
@@ -240,14 +250,24 @@ GoogleCloud2ProdResolver::GoogleCloud2ProdResolver(ResolverArgs args)
       UniquePtr<char>(gpr_getenv("GRPC_XDS_BOOTSTRAP")) != nullptr ||
       UniquePtr<char>(gpr_getenv("GRPC_XDS_BOOTSTRAP_CONFIG")) != nullptr) {
     using_dns_ = true;
-    child_resolver_ = ResolverRegistry::CreateResolver(
-        absl::StrCat("dns:", name_to_resolve).c_str(), args.args,
-        args.pollset_set, work_serializer_, std::move(args.result_handler));
+    child_resolver_ =
+        CoreConfiguration::Get().resolver_registry().CreateResolver(
+            absl::StrCat("dns:", name_to_resolve).c_str(), args.args,
+            args.pollset_set, work_serializer_, std::move(args.result_handler));
     GPR_ASSERT(child_resolver_ != nullptr);
     return;
   }
+  // Maybe override metadata server name for testing
+  const char* test_only_metadata_server_override =
+      grpc_channel_args_find_string(
+          args.args,
+          "grpc.testing.google_c2p_resolver_metadata_server_override");
+  if (test_only_metadata_server_override != nullptr &&
+      strlen(test_only_metadata_server_override) > 0) {
+    metadata_server_name_ = std::string(test_only_metadata_server_override);
+  }
   // Create xds resolver.
-  child_resolver_ = ResolverRegistry::CreateResolver(
+  child_resolver_ = CoreConfiguration::Get().resolver_registry().CreateResolver(
       absl::StrCat("xds:", name_to_resolve).c_str(), args.args,
       args.pollset_set, work_serializer_, std::move(args.result_handler));
   GPR_ASSERT(child_resolver_ != nullptr);
@@ -276,6 +296,7 @@ void GoogleCloud2ProdResolver::ResetBackoffLocked() {
 }
 
 void GoogleCloud2ProdResolver::ShutdownLocked() {
+  shutdown_ = true;
   zone_query_.reset();
   ipv6_query_.reset();
   child_resolver_.reset();
@@ -294,6 +315,9 @@ void GoogleCloud2ProdResolver::IPv6QueryDone(bool ipv6_supported) {
 }
 
 void GoogleCloud2ProdResolver::StartXdsResolver() {
+  if (shutdown_) {
+    return;
+  }
   // Construct bootstrap JSON.
   std::random_device rd;
   std::mt19937 mt(rd());
@@ -346,6 +370,12 @@ void GoogleCloud2ProdResolver::StartXdsResolver() {
 
 class GoogleCloud2ProdResolverFactory : public ResolverFactory {
  public:
+  // TODO(roth): Remove experimental suffix once this code is proven stable,
+  // and update the scheme in google_c2p_resolver_test.cc when doing so.
+  absl::string_view scheme() const override {
+    return "google-c2p-experimental";
+  }
+
   bool IsValidUri(const URI& uri) const override {
     if (GPR_UNLIKELY(!uri.authority().empty())) {
       gpr_log(GPR_ERROR, "google-c2p URI scheme does not support authorities");
@@ -358,18 +388,13 @@ class GoogleCloud2ProdResolverFactory : public ResolverFactory {
     if (!IsValidUri(args.uri)) return nullptr;
     return MakeOrphanable<GoogleCloud2ProdResolver>(std::move(args));
   }
-
-  // TODO(roth): Remove experimental suffix once this code is proven stable.
-  const char* scheme() const override { return "google-c2p-experimental"; }
 };
 
 }  // namespace
 
-void GoogleCloud2ProdResolverInit() {
-  ResolverRegistry::Builder::RegisterResolverFactory(
+void RegisterCloud2ProdResolver(CoreConfiguration::Builder* builder) {
+  builder->resolver_registry()->RegisterResolverFactory(
       absl::make_unique<GoogleCloud2ProdResolverFactory>());
 }
 
-void GoogleCloud2ProdResolverShutdown() {}
-
 }  // namespace grpc_core