grpc 1.84.1 → 1.85.0.pre1

data/src/core/load_balancing/weighted_round_robin/weighted_round_robin.cc

@@ -489,7 +489,7 @@ class WeightedRoundRobin final : public LoadBalancingPolicy {
 //
 
 WeightedRoundRobin::EndpointWeight::~EndpointWeight() {
-  MutexLock lock(&wrr_->endpoint_weight_map_mu_);
+  MutexLock lock(wrr_->endpoint_weight_map_mu_);
   auto it = wrr_->endpoint_weight_map_.find(key_);
   if (it != wrr_->endpoint_weight_map_.end() && it->second == this) {
     wrr_->endpoint_weight_map_.erase(it);
@@ -518,7 +518,7 @@ void WeightedRoundRobin::EndpointWeight::MaybeUpdateWeight(
   }
   Timestamp now = Timestamp::Now();
   // Grab the lock and update the data.
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   GRPC_TRACE_LOG(weighted_round_robin_lb, INFO)
       << "[WRR " << wrr_.get() << "] subchannel " << key_.ToString()
       << ": qps=" << qps << ", eps=" << eps << ", utilization=" << utilization
@@ -535,7 +535,7 @@ void WeightedRoundRobin::EndpointWeight::MaybeUpdateWeight(
 float WeightedRoundRobin::EndpointWeight::GetWeight(
     Timestamp now, Duration weight_expiration_period, Duration blackout_period,
     uint64_t* num_not_yet_usable, uint64_t* num_stale) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   GRPC_TRACE_LOG(weighted_round_robin_lb, INFO)
       << "[WRR " << wrr_.get() << "] subchannel " << key_.ToString()
       << ": getting weight: now=" << now.ToString()
@@ -563,7 +563,7 @@ float WeightedRoundRobin::EndpointWeight::GetWeight(
 }
 
 void WeightedRoundRobin::EndpointWeight::ResetNonEmptySince() {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   non_empty_since_ = Timestamp::InfFuture();
 }
 
@@ -612,7 +612,7 @@ WeightedRoundRobin::Picker::Picker(RefCountedPtr<WeightedRoundRobin> wrr,
       << endpoints_.size() << " subchannels";
   // Note: BuildSchedulerAndStartTimerLocked() passes out pointers to `this`,
   // so we need to ensure that we really hold timer_mu_.
-  MutexLock lock(&timer_mu_);
+  MutexLock lock(timer_mu_);
   BuildSchedulerAndStartTimerLocked();
 }
 
@@ -622,7 +622,7 @@ WeightedRoundRobin::Picker::~Picker() {
 }
 
 void WeightedRoundRobin::Picker::Orphaned() {
-  MutexLock lock(&timer_mu_);
+  MutexLock lock(timer_mu_);
   GRPC_TRACE_LOG(weighted_round_robin_lb, INFO)
       << "[WRR " << wrr_.get() << " picker " << this << "] cancelling timer";
   wrr_->channel_control_helper()->GetEventEngine()->Cancel(*timer_handle_);
@@ -655,7 +655,7 @@ size_t WeightedRoundRobin::Picker::PickIndex() {
   // Grab a ref to the scheduler.
   std::shared_ptr<StaticStrideScheduler> scheduler;
   {
-    MutexLock lock(&scheduler_mu_);
+    MutexLock lock(scheduler_mu_);
     scheduler = scheduler_;
   }
   // If we have a scheduler, use it to do a WRR pick.
@@ -711,7 +711,7 @@ void WeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
         {wrr_->locality_name_, wrr_->backend_service_name_});
   }
   {
-    MutexLock lock(&scheduler_mu_);
+    MutexLock lock(scheduler_mu_);
     scheduler_ = std::move(scheduler);
   }
   // Start timer.
@@ -729,7 +729,7 @@ void WeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
        work_serializer = wrr_->work_serializer()]() mutable {
         ExecCtx exec_ctx;
         {
-          MutexLock lock(&self->timer_mu_);
+          MutexLock lock(self->timer_mu_);
           if (self->timer_handle_.has_value()) {
             GRPC_TRACE_LOG(weighted_round_robin_lb, INFO)
                 << "[WRR " << self->wrr_.get() << " picker " << self.get()
@@ -860,7 +860,7 @@ RefCountedPtr<WeightedRoundRobin::EndpointWeight>
 WeightedRoundRobin::GetOrCreateWeight(
     const std::vector<grpc_resolved_address>& addresses) {
   EndpointAddressSet key(addresses);
-  MutexLock lock(&endpoint_weight_map_mu_);
+  MutexLock lock(endpoint_weight_map_mu_);
   auto it = endpoint_weight_map_.find(key);
   if (it != endpoint_weight_map_.end()) {
     auto weight = it->second->RefIfNonZero();

data/src/core/load_balancing/xds/cds.cc

@@ -184,7 +184,7 @@ class CdsLbConfig final : public LoadBalancingPolicy::Config {
 
   absl::string_view name() const override { return kCds; }
 
-  const std::string& cluster() const { return cluster_; }
+  const RefCountedStringValue& cluster() const { return cluster_; }
   bool is_dynamic() const { return is_dynamic_; }
 
   static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
@@ -197,7 +197,7 @@ class CdsLbConfig final : public LoadBalancingPolicy::Config {
   }
 
  private:
-  std::string cluster_;
+  RefCountedStringValue cluster_;
   bool is_dynamic_ = false;
 };
 
@@ -319,15 +319,16 @@ absl::Status CdsLb::UpdateLocked(UpdateArgs args) {
   auto new_config = args.config.TakeAsSubclass<CdsLbConfig>();
   GRPC_TRACE_LOG(cds_lb, INFO)
       << "[cdslb " << this
-      << "] received update: cluster=" << new_config->cluster()
+      << "] received update: cluster=" << new_config->cluster().as_string_view()
       << " is_dynamic=" << new_config->is_dynamic();
   GRPC_CHECK(new_config != nullptr);
   // Cluster name should never change, because we should use a different
   // child name in xds_cluster_manager in that case.
   if (cluster_name_.as_string_view().empty()) {
-    cluster_name_ = RefCountedStringValue(new_config->cluster());
+    cluster_name_ = new_config->cluster();
   } else {
-    GRPC_CHECK_EQ(cluster_name_.as_string_view(), new_config->cluster());
+    GRPC_CHECK_EQ(cluster_name_.as_string_view(),
+                  new_config->cluster().as_string_view());
   }
   // Start dynamic subscription if needed.
   if (new_config->is_dynamic() && subscription_ == nullptr) {

data/src/core/load_balancing/xds/xds_cluster_impl.cc

@@ -117,7 +117,7 @@ CircuitBreakerCallCounterMap::GetOrCreate(const std::string& cluster,
                                           const std::string& eds_service_name) {
   Key key(cluster, eds_service_name);
   RefCountedPtr<CallCounter> result;
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   auto it = map_.find(key);
   if (it == map_.end()) {
     it = map_.insert({key, nullptr}).first;
@@ -132,7 +132,7 @@ CircuitBreakerCallCounterMap::GetOrCreate(const std::string& cluster,
 }
 
 CircuitBreakerCallCounterMap::CallCounter::~CallCounter() {
-  MutexLock lock(&g_call_counter_map->mu_);
+  MutexLock lock(g_call_counter_map->mu_);
   auto it = g_call_counter_map->map_.find(key_);
   if (it != g_call_counter_map->map_.end() && it->second == this) {
     g_call_counter_map->map_.erase(it);

data/src/core/load_balancing/xds/xds_override_host.cc

@@ -435,7 +435,7 @@ XdsOverrideHostLb::Picker::PickOverriddenHost(
   RefCountedPtr<SubchannelWrapper> idle_subchannel;
   bool found_connecting = false;
   {
-    MutexLock lock(&policy_->mu_);
+    MutexLock lock(policy_->mu_);
     for (absl::string_view address : absl::StrSplit(cookie_address_list, ',')) {
       auto it = policy_->subchannel_map_.find(address);
       if (it == policy_->subchannel_map_.end()) continue;
@@ -532,7 +532,7 @@ LoadBalancingPolicy::PickResult XdsOverrideHostLb::Picker::Pick(PickArgs args) {
     // Populate the address list in the override host attribute so that
     // the StatefulSession filter can set the cookie.
     if (override_host_attr != nullptr) {
-      MutexLock lock(&wrapper->policy()->mu_);
+      MutexLock lock(wrapper->policy()->mu_);
       wrapper->set_last_used_time();
       override_host_attr->set_actual_address_list(wrapper->address_list());
     }
@@ -612,7 +612,7 @@ void XdsOverrideHostLb::ResetState() {
   {
     // Drop subchannel refs after releasing the lock to avoid deadlock.
     std::vector<RefCountedPtr<SubchannelWrapper>> subchannel_refs_to_drop;
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     subchannel_refs_to_drop.reserve(subchannel_map_.size());
     for (auto& [_, subchannel_entry] : subchannel_map_) {
       subchannel_entry->UnsetSubchannel(&subchannel_refs_to_drop);
@@ -834,7 +834,7 @@ void XdsOverrideHostLb::UpdateAddressMap(
   {
     // Drop subchannel refs after releasing the lock to avoid deadlock.
     std::vector<RefCountedPtr<SubchannelWrapper>> subchannel_refs_to_drop;
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     for (auto it = subchannel_map_.begin(); it != subchannel_map_.end();) {
       if (addresses_for_map.find(it->first) == addresses_for_map.end()) {
         GRPC_TRACE_LOG(xds_override_host_lb, INFO)
@@ -889,7 +889,7 @@ XdsOverrideHostLb::AdoptSubchannel(
     // Drop ref to previously owned subchannel (if any) after releasing
     // the lock.
     RefCountedPtr<SubchannelWrapper> subchannel_ref_to_drop;
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     auto it = subchannel_map_.find(*key);
     if (it != subchannel_map_.end()) {
       wrapper->set_subchannel_entry(it->second);
@@ -919,7 +919,7 @@ void XdsOverrideHostLb::CreateSubchannelForAddress(absl::string_view address) {
   // Step 1.
   ChannelArgs per_endpoint_args;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     auto it = subchannel_map_.find(address);
     // This can happen if the map entry was removed between the time that
     // the picker requested the subchannel creation and the time that we got
@@ -938,7 +938,7 @@ void XdsOverrideHostLb::CreateSubchannelForAddress(absl::string_view address) {
       std::move(subchannel), RefAsSubclass<XdsOverrideHostLb>());
   // Step 3.
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     auto it = subchannel_map_.find(address);
     // This can happen if the map entry was removed between the time that
     // the picker requested the subchannel creation and the time that we got
@@ -960,7 +960,7 @@ void XdsOverrideHostLb::CleanupSubchannels() {
   Duration next_time = connection_idle_timeout_;
   std::vector<RefCountedPtr<SubchannelWrapper>> subchannel_refs_to_drop;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     if (subchannel_map_.empty()) return;
     for (const auto& [address, subchannel_entry] : subchannel_map_) {
       if (subchannel_entry->last_used_time() <= idle_threshold) {
@@ -1050,7 +1050,7 @@ void XdsOverrideHostLb::SubchannelWrapper::Orphaned() {
         self->wrapped_subchannel()->CancelConnectivityStateWatch(
             self->watcher_);
         if (self->subchannel_entry_ != nullptr) {
-          MutexLock lock(&self->policy()->mu_);
+          MutexLock lock(self->policy()->mu_);
           self->subchannel_entry_->OnSubchannelWrapperOrphan(
               self.get(), self->policy()->connection_idle_timeout_);
         }
@@ -1061,7 +1061,7 @@ void XdsOverrideHostLb::SubchannelWrapper::UpdateConnectivityState(
     grpc_connectivity_state state, absl::Status status) {
   bool update_picker = false;
   if (subchannel_entry_ != nullptr) {
-    MutexLock lock(&policy()->mu_);
+    MutexLock lock(policy()->mu_);
     if (subchannel_entry_->connectivity_state() != state) {
       subchannel_entry_->set_connectivity_state(state);
       update_picker = subchannel_entry_->HasOwnedSubchannel() &&

data/src/core/mitigation_engine/mitigation_engine.h

@@ -28,6 +28,9 @@
 #include "src/core/util/useful.h"
 #include "absl/strings/string_view.h"
 
+struct grpc_auth_context;
+struct grpc_endpoint;
+
 namespace grpc_core {
 
 class MitigationEngine : public RefCounted<MitigationEngine> {
@@ -44,20 +47,41 @@ class MitigationEngine : public RefCounted<MitigationEngine> {
   }
   ~MitigationEngine() override = default;
 
-  // Evaluates an incoming connection based on the peer address.
+  struct EvaluateArgs {
+    EvaluateArgs() = default;
+    explicit EvaluateArgs(absl::string_view peer_address,
+                          grpc_endpoint* endpoint = nullptr,
+                          grpc_auth_context* auth_context = nullptr)
+        : peer_address(peer_address),
+          endpoint(endpoint),
+          auth_context(auth_context) {}
+    explicit EvaluateArgs(const char* peer_address,
+                          grpc_endpoint* endpoint = nullptr,
+                          grpc_auth_context* auth_context = nullptr)
+        : peer_address(peer_address),
+          endpoint(endpoint),
+          auth_context(auth_context) {}
+
+    absl::string_view peer_address;
+    grpc_endpoint* endpoint = nullptr;
+    grpc_auth_context* auth_context = nullptr;
+  };
+
+  // Evaluates an incoming connection based on the peer address and connection
+  // context.
   virtual std::optional<Action> EvaluateIncomingConnection(
-      absl::string_view peer_address) = 0;
+      const EvaluateArgs& args) = 0;
 
   // Evaluates an incoming metadata key/value pair. Please note that this
   // function only evaluates *new* key/value pairs; if an incoming header has
   // already been seen by the connection, it will not be evaluated again.
   virtual std::optional<Action> EvaluateIncomingMetadata(
       absl::string_view key, absl::string_view value,
-      absl::string_view peer_address) = 0;
+      const EvaluateArgs& args) = 0;
 
   // Evaluates all incoming metadata after they have been parsed.
   virtual std::optional<Action> EvaluateAllIncomingMetadata(
-      const grpc_metadata_batch& metadata, absl::string_view peer_address) = 0;
+      const grpc_metadata_batch& metadata, const EvaluateArgs& args) = 0;
 };
 
 class MitigationEngineProvider

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -66,6 +66,7 @@ extern void RegisterOutlierDetectionLbPolicy(
 extern void RegisterWeightedTargetLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterPickFirstLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterRingHashLbPolicy(CoreConfiguration::Builder* builder);
+extern void RegisterAutoShardingLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterRoundRobinLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterWeightedRoundRobinLbPolicy(
     CoreConfiguration::Builder* builder);
@@ -145,6 +146,7 @@ void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
 #ifndef GRPC_MINIMAL_LB_POLICY
   RegisterRoundRobinLbPolicy(builder);
   RegisterRingHashLbPolicy(builder);
+  RegisterAutoShardingLbPolicy(builder);
   RegisterWeightedRoundRobinLbPolicy(builder);
 #endif
   BuildClientChannelConfiguration(builder);

data/src/core/resolver/dns/dns_resolver.cc

@@ -213,7 +213,7 @@ ClientChannelDNSResolver::EventEngineDNSRequestWrapper::
     : resolver_(std::move(resolver)),
       event_engine_resolver_(std::move(event_engine_resolver)) {
   // Locking to prevent completion before all records are queried
-  MutexLock lock(&on_resolved_mu_);
+  MutexLock lock(on_resolved_mu_);
   GRPC_TRACE_VLOG(event_engine_client_channel_resolver, 2)
       << "(event_engine client channel resolver) DNSResolver::"
       << resolver_.get() << " Starting hostname resolution for "
@@ -278,7 +278,7 @@ ClientChannelDNSResolver::EventEngineDNSRequestWrapper::
 
 void ClientChannelDNSResolver::EventEngineDNSRequestWrapper::Orphan() {
   {
-    MutexLock lock(&on_resolved_mu_);
+    MutexLock lock(on_resolved_mu_);
     orphaned_ = true;
     if (timeout_handle_.has_value()) {
       resolver_->event_engine_->Cancel(*timeout_handle_);
@@ -292,7 +292,7 @@ void ClientChannelDNSResolver::EventEngineDNSRequestWrapper::Orphan() {
 }
 
 void ClientChannelDNSResolver::EventEngineDNSRequestWrapper::OnTimeout() {
-  MutexLock lock(&on_resolved_mu_);
+  MutexLock lock(on_resolved_mu_);
   GRPC_TRACE_VLOG(event_engine_client_channel_resolver, 2)
       << "(event_engine client channel resolver) DNSResolver::"
       << resolver_.get() << " OnTimeout";
@@ -304,7 +304,7 @@ void ClientChannelDNSResolver::EventEngineDNSRequestWrapper::OnHostnameResolved(
     absl::StatusOr<std::vector<EventEngine::ResolvedAddress>> new_addresses) {
   std::optional<Resolver::Result> result;
   {
-    MutexLock lock(&on_resolved_mu_);
+    MutexLock lock(on_resolved_mu_);
     // Make sure field destroys before cleanup.
     ValidationErrors::ScopedField field(&errors_, "hostname lookup");
     if (orphaned_) return;
@@ -333,7 +333,7 @@ void ClientChannelDNSResolver::EventEngineDNSRequestWrapper::OnSRVResolved(
       resolver_->OnRequestComplete(std::move(*result));
     }
   });
-  MutexLock lock(&on_resolved_mu_);
+  MutexLock lock(on_resolved_mu_);
   // Make sure field destroys before cleanup.
   ValidationErrors::ScopedField field(&errors_, "srv lookup");
   if (orphaned_) return;
@@ -387,7 +387,7 @@ void ClientChannelDNSResolver::EventEngineDNSRequestWrapper::
       resolver_->OnRequestComplete(std::move(*result));
     }
   });
-  MutexLock lock(&on_resolved_mu_);
+  MutexLock lock(on_resolved_mu_);
   // Make sure field destroys before cleanup.
   ValidationErrors::ScopedField field(
       &errors_, absl::StrCat("balancer lookup for ", authority));
@@ -414,7 +414,7 @@ void ClientChannelDNSResolver::EventEngineDNSRequestWrapper::OnTXTResolved(
     absl::StatusOr<std::vector<std::string>> service_config) {
   std::optional<Resolver::Result> result;
   {
-    MutexLock lock(&on_resolved_mu_);
+    MutexLock lock(on_resolved_mu_);
     // Make sure field destroys before cleanup.
     ValidationErrors::ScopedField field(&errors_, "txt lookup");
     if (orphaned_) return;

data/src/core/resolver/fake/fake_resolver.cc

@@ -129,7 +129,7 @@ void FakeResolverResponseGenerator::SetResponseAndNotify(
     Resolver::Result result, Notification* notify_when_set) {
   RefCountedPtr<FakeResolver> resolver;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     if (resolver_ == nullptr) {
       result_ = std::move(result);
       if (notify_when_set != nullptr) notify_when_set->Notify();
@@ -144,7 +144,7 @@ void FakeResolverResponseGenerator::SetFakeResolver(
     RefCountedPtr<FakeResolver> resolver) {
   Resolver::Result result;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     resolver_ = resolver;
     if (resolver_set_cv_ != nullptr) resolver_set_cv_->SignalAll();
     if (resolver == nullptr) return;
@@ -171,7 +171,7 @@ void FakeResolverResponseGenerator::SendResultToResolver(
 }
 
 bool FakeResolverResponseGenerator::WaitForResolverSet(absl::Duration timeout) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (resolver_ == nullptr) {
     CondVar condition;
     resolver_set_cv_ = &condition;
@@ -183,7 +183,7 @@ bool FakeResolverResponseGenerator::WaitForResolverSet(absl::Duration timeout) {
 
 bool FakeResolverResponseGenerator::WaitForReresolutionRequest(
     absl::Duration timeout) {
-  MutexLock lock(&reresolution_mu_);
+  MutexLock lock(reresolution_mu_);
   if (!reresolution_requested_) {
     CondVar condition;
     reresolution_cv_ = &condition;
@@ -194,7 +194,7 @@ bool FakeResolverResponseGenerator::WaitForReresolutionRequest(
 }
 
 void FakeResolverResponseGenerator::ReresolutionRequested() {
-  MutexLock lock(&reresolution_mu_);
+  MutexLock lock(reresolution_mu_);
   reresolution_requested_ = true;
   if (reresolution_cv_ != nullptr) reresolution_cv_->SignalAll();
 }

data/src/core/resolver/google_c2p/google_c2p_resolver.cc

@@ -15,7 +15,6 @@
 //
 
 #include <grpc/support/json.h>
-#include <grpc/support/port_platform.h>
 
 #include <cstdint>
 #include <memory>
@@ -77,6 +76,7 @@ class GoogleCloud2ProdResolver final : public Resolver {
   ResourceQuotaRefPtr resource_quota_;
   std::shared_ptr<WorkSerializer> work_serializer_;
   grpc_polling_entity pollent_;
+  const bool force_xds_;
   bool using_dns_ = false;
   OrphanablePtr<Resolver> child_resolver_;
   std::string metadata_server_name_ = "metadata.google.internal.";
@@ -103,38 +103,42 @@ GoogleCloud2ProdResolver::GoogleCloud2ProdResolver(ResolverArgs args)
     : resource_quota_(args.args.GetObjectRef<ResourceQuota>()),
       work_serializer_(std::move(args.work_serializer)),
       pollent_(grpc_polling_entity_create_from_pollset_set(args.pollset_set)),
+      force_xds_(args.uri.query_parameter_map().find("force-xds") !=
+                 args.uri.query_parameter_map().end()),
       args_(std::move(args.args)) {
   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.
-  const bool test_only_pretend_running_on_gcp =
-      args_.GetBool("grpc.testing.google_c2p_resolver_pretend_running_on_gcp")
-          .value_or(false);
-  const bool running_on_gcp =
-      test_only_pretend_running_on_gcp || grpc_alts_is_running_on_gcp();
   const bool federation_enabled = XdsFederationEnabled();
-  if (!running_on_gcp ||
-      // If the client is already using xDS and federation is not enabled,
-      // we can't use it here, because they may be talking to a completely
-      // different xDS server than we want to.
-      // TODO(roth): When we remove xDS federation env var protection,
-      // remove this constraint.
-      (!federation_enabled && XdsBootstrapConfigured())) {
-    using_dns_ = true;
-    child_resolver_ =
-        CoreConfiguration::Get().resolver_registry().CreateResolver(
-            absl::StrCat("dns:", name_to_resolve), args_, args.pollset_set,
-            work_serializer_, std::move(args.result_handler));
-    GRPC_CHECK(child_resolver_ != nullptr);
-    return;
-  }
-  // Maybe override metadata server name for testing
-  std::optional<std::string> test_only_metadata_server_override =
-      args_.GetOwnedString(
-          "grpc.testing.google_c2p_resolver_metadata_server_override");
-  if (test_only_metadata_server_override.has_value() &&
-      !test_only_metadata_server_override->empty()) {
-    metadata_server_name_ = std::move(*test_only_metadata_server_override);
+  if (!force_xds_) {
+    // If we're not running on GCP, we can't use DirectPath, so delegate
+    // to the DNS resolver.
+    const bool test_only_pretend_running_on_gcp =
+        args_.GetBool("grpc.testing.google_c2p_resolver_pretend_running_on_gcp")
+            .value_or(false);
+    const 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 and federation is not enabled,
+        // we can't use it here, because they may be talking to a completely
+        // different xDS server than we want to.
+        // TODO(roth): When we remove xDS federation env var protection,
+        // remove this constraint.
+        (!federation_enabled && XdsBootstrapConfigured())) {
+      using_dns_ = true;
+      child_resolver_ =
+          CoreConfiguration::Get().resolver_registry().CreateResolver(
+              absl::StrCat("dns:", name_to_resolve), args_, args.pollset_set,
+              work_serializer_, std::move(args.result_handler));
+      GRPC_CHECK(child_resolver_ != nullptr);
+      return;
+    }
+    // Maybe override metadata server name for testing
+    std::optional<std::string> test_only_metadata_server_override =
+        args_.GetOwnedString(
+            "grpc.testing.google_c2p_resolver_metadata_server_override");
+    if (test_only_metadata_server_override.has_value() &&
+        !test_only_metadata_server_override->empty()) {
+      metadata_server_name_ = std::move(*test_only_metadata_server_override);
+    }
   }
   // Create xds resolver.
   xds_uri_ = federation_enabled
@@ -147,6 +151,10 @@ GoogleCloud2ProdResolver::GoogleCloud2ProdResolver(ResolverArgs args)
 }
 
 void GoogleCloud2ProdResolver::StartLocked() {
+  if (force_xds_) {
+    StartXdsResolver();
+    return;
+  }
   if (using_dns_) {
     child_resolver_->StartLocked();
     return;