grpc 1.26.0 → 1.27.0.pre1

data/src/core/ext/filters/client_channel/lb_policy/subchannel_list.h

@@ -370,13 +370,6 @@ SubchannelList<SubchannelListType, SubchannelDataType>::SubchannelList(
                                          GRPC_ARG_SERVICE_CONFIG};
   // Create a subchannel for each address.
   for (size_t i = 0; i < addresses.size(); i++) {
-    // TODO(roth): we should ideally hide this from the LB policy code. In
-    // principle, if we're dealing with this special case in the client_channel
-    // code for selecting grpclb, then we should also strip out these addresses
-    // there if we're not using grpclb.
-    if (addresses[i].IsBalancer()) {
-      continue;
-    }
     InlinedVector<grpc_arg, 3> args_to_add;
     const size_t subchannel_address_arg_index = args_to_add.size();
     args_to_add.emplace_back(

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

@@ -39,13 +39,13 @@ constexpr char kCds[] = "cds_experimental";
 // Parsed config for this LB policy.
 class ParsedCdsConfig : public LoadBalancingPolicy::Config {
  public:
-  explicit ParsedCdsConfig(grpc_core::UniquePtr<char> cluster)
+  explicit ParsedCdsConfig(std::string cluster)
       : cluster_(std::move(cluster)) {}
-  const char* cluster() const { return cluster_.get(); }
+  const char* cluster() const { return cluster_.c_str(); }
   const char* name() const override { return kCds; }
 
  private:
-  grpc_core::UniquePtr<char> cluster_;
+  std::string cluster_;
 };
 
 // CDS LB policy.
@@ -119,9 +119,9 @@ void CdsLb::ClusterWatcher::OnClusterChanged(CdsUpdate cluster_data) {
   }
   // Construct config for child policy.
   char* lrs_str = nullptr;
-  if (cluster_data.lrs_load_reporting_server_name != nullptr) {
+  if (cluster_data.lrs_load_reporting_server_name.has_value()) {
     gpr_asprintf(&lrs_str, "    \"lrsLoadReportingServerName\": \"%s\",\n",
-                 cluster_data.lrs_load_reporting_server_name.get());
+                 cluster_data.lrs_load_reporting_server_name.value().c_str());
   }
   char* json_str;
   gpr_asprintf(&json_str,
@@ -132,9 +132,9 @@ void CdsLb::ClusterWatcher::OnClusterChanged(CdsUpdate cluster_data) {
                "  }\n"
                "}]",
                (lrs_str == nullptr ? "" : lrs_str),
-               (cluster_data.eds_service_name == nullptr
+               (cluster_data.eds_service_name.empty()
                     ? parent_->config_->cluster()
-                    : cluster_data.eds_service_name.get()));
+                    : cluster_data.eds_service_name.c_str()));
   gpr_free(lrs_str);
   grpc_core::UniquePtr<char> json_str_deleter(json_str);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_cds_lb_trace)) {
@@ -342,8 +342,7 @@ class CdsFactory : public LoadBalancingPolicyFactory {
           "required field 'cluster' not present"));
     }
     if (error_list.empty()) {
-      return MakeRefCounted<ParsedCdsConfig>(
-          grpc_core::UniquePtr<char>(gpr_strdup(cluster)));
+      return MakeRefCounted<ParsedCdsConfig>(cluster);
     } else {
       *error = GRPC_ERROR_CREATE_FROM_VECTOR("Cds Parser", &error_list);
       return nullptr;

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

@@ -78,8 +78,8 @@ class ParsedXdsConfig : public LoadBalancingPolicy::Config {
  public:
   ParsedXdsConfig(RefCountedPtr<LoadBalancingPolicy::Config> child_policy,
                   RefCountedPtr<LoadBalancingPolicy::Config> fallback_policy,
-                  grpc_core::UniquePtr<char> eds_service_name,
-                  grpc_core::UniquePtr<char> lrs_load_reporting_server_name)
+                  std::string eds_service_name,
+                  Optional<std::string> lrs_load_reporting_server_name)
       : child_policy_(std::move(child_policy)),
         fallback_policy_(std::move(fallback_policy)),
         eds_service_name_(std::move(eds_service_name)),
@@ -96,17 +96,19 @@ class ParsedXdsConfig : public LoadBalancingPolicy::Config {
     return fallback_policy_;
   }
 
-  const char* eds_service_name() const { return eds_service_name_.get(); };
+  const char* eds_service_name() const {
+    return eds_service_name_.empty() ? nullptr : eds_service_name_.c_str();
+  };
 
-  const char* lrs_load_reporting_server_name() const {
-    return lrs_load_reporting_server_name_.get();
+  const Optional<std::string>& lrs_load_reporting_server_name() const {
+    return lrs_load_reporting_server_name_;
   };
 
  private:
   RefCountedPtr<LoadBalancingPolicy::Config> child_policy_;
   RefCountedPtr<LoadBalancingPolicy::Config> fallback_policy_;
-  grpc_core::UniquePtr<char> eds_service_name_;
-  grpc_core::UniquePtr<char> lrs_load_reporting_server_name_;
+  std::string eds_service_name_;
+  Optional<std::string> lrs_load_reporting_server_name_;
 };
 
 class XdsLb : public LoadBalancingPolicy {
@@ -160,6 +162,8 @@ class XdsLb : public LoadBalancingPolicy {
           pickers_(std::move(pickers)),
           drop_config_(xds_policy_->drop_config_) {}
 
+    ~LocalityPicker() { xds_policy_.reset(DEBUG_LOCATION, "LocalityPicker"); }
+
     PickResult Pick(PickArgs args) override;
 
    private:
@@ -285,6 +289,8 @@ class XdsLb : public LoadBalancingPolicy {
 
       LocalityMap(RefCountedPtr<XdsLb> xds_policy, uint32_t priority);
 
+      ~LocalityMap() { xds_policy_.reset(DEBUG_LOCATION, "LocalityMap"); }
+
       void UpdateLocked(
           const XdsPriorityListUpdate::LocalityMap& locality_map_update);
       void ResetBackoffLocked();
@@ -397,7 +403,7 @@ class XdsLb : public LoadBalancingPolicy {
     if (config_ != nullptr && config_->eds_service_name() != nullptr) {
       return config_->eds_service_name();
     }
-    return server_name_.get();
+    return server_name_.c_str();
   }
 
   XdsClient* xds_client() const {
@@ -406,7 +412,7 @@ class XdsLb : public LoadBalancingPolicy {
   }
 
   // Server name from target URI.
-  grpc_core::UniquePtr<char> server_name_;
+  std::string server_name_;
 
   // Current channel args and config from the resolver.
   const grpc_channel_args* args_ = nullptr;
@@ -495,7 +501,7 @@ LoadBalancingPolicy::PickResult XdsLb::EndpointPickerWrapper::Pick(
 
 XdsLb::PickResult XdsLb::LocalityPicker::Pick(PickArgs args) {
   // Handle drop.
-  const grpc_core::UniquePtr<char>* drop_category;
+  const std::string* drop_category;
   if (drop_config_->ShouldDrop(&drop_category)) {
     xds_policy_->client_stats_.AddCallDropped(*drop_category);
     PickResult result;
@@ -612,6 +618,8 @@ class XdsLb::EndpointWatcher : public XdsClient::EndpointWatcherInterface {
   explicit EndpointWatcher(RefCountedPtr<XdsLb> xds_policy)
       : xds_policy_(std::move(xds_policy)) {}
 
+  ~EndpointWatcher() { xds_policy_.reset(DEBUG_LOCATION, "EndpointWatcher"); }
+
   void OnEndpointChanged(EdsUpdate update) override {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
       gpr_log(GPR_INFO, "[xdslb %p] Received EDS update from xds client",
@@ -706,11 +714,10 @@ XdsLb::XdsLb(Args args)
   GPR_ASSERT(server_uri != nullptr);
   grpc_uri* uri = grpc_uri_parse(server_uri, true);
   GPR_ASSERT(uri->path[0] != '\0');
-  server_name_.reset(
-      gpr_strdup(uri->path[0] == '/' ? uri->path + 1 : uri->path));
+  server_name_ = uri->path[0] == '/' ? uri->path + 1 : uri->path;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
     gpr_log(GPR_INFO, "[xdslb %p] server name from channel: %s", this,
-            server_name_.get());
+            server_name_.c_str());
   }
   grpc_uri_destroy(uri);
 }
@@ -743,9 +750,12 @@ void XdsLb::ShutdownLocked() {
   // watcher holds a ref to us.
   xds_client()->CancelEndpointDataWatch(StringView(eds_service_name()),
                                         endpoint_watcher_);
-  if (config_->lrs_load_reporting_server_name() != nullptr) {
+  if (config_->lrs_load_reporting_server_name().has_value()) {
+    // TODO(roth): We should pass the cluster name (in addition to the
+    // eds_service_name) when adding the client stats. To do so, we need to
+    // first find a way to plumb the cluster name down into this LB policy.
     xds_client()->RemoveClientStats(
-        StringView(config_->lrs_load_reporting_server_name()),
+        StringView(config_->lrs_load_reporting_server_name().value().c_str()),
         StringView(eds_service_name()), &client_stats_);
   }
   xds_client_from_channel_.reset();
@@ -820,7 +830,8 @@ void XdsLb::UpdateLocked(UpdateArgs args) {
       xds_client()->CancelEndpointDataWatch(StringView(old_eds_service_name),
                                             endpoint_watcher_);
     }
-    auto watcher = MakeUnique<EndpointWatcher>(Ref());
+    auto watcher =
+        MakeUnique<EndpointWatcher>(Ref(DEBUG_LOCATION, "EndpointWatcher"));
     endpoint_watcher_ = watcher.get();
     xds_client()->WatchEndpointData(StringView(eds_service_name()),
                                     std::move(watcher));
@@ -831,21 +842,25 @@ void XdsLb::UpdateLocked(UpdateArgs args) {
   // all of the pickers whenever load reporting is enabled or disabled
   // here.
   if (is_initial_update ||
-      (config_->lrs_load_reporting_server_name() == nullptr) !=
-          (old_config->lrs_load_reporting_server_name() == nullptr) ||
-      (config_->lrs_load_reporting_server_name() != nullptr &&
-       old_config->lrs_load_reporting_server_name() != nullptr &&
-       strcmp(config_->lrs_load_reporting_server_name(),
-              old_config->lrs_load_reporting_server_name()) != 0)) {
+      (config_->lrs_load_reporting_server_name().has_value()) !=
+          (old_config->lrs_load_reporting_server_name().has_value()) ||
+      (config_->lrs_load_reporting_server_name().has_value() &&
+       old_config->lrs_load_reporting_server_name().has_value() &&
+       config_->lrs_load_reporting_server_name().value() !=
+           old_config->lrs_load_reporting_server_name().value())) {
     if (old_config != nullptr &&
-        old_config->lrs_load_reporting_server_name() != nullptr) {
+        old_config->lrs_load_reporting_server_name().has_value()) {
       xds_client()->RemoveClientStats(
-          StringView(old_config->lrs_load_reporting_server_name()),
+          StringView(
+              old_config->lrs_load_reporting_server_name().value().c_str()),
           StringView(old_eds_service_name), &client_stats_);
     }
-    if (config_->lrs_load_reporting_server_name() != nullptr) {
+    if (config_->lrs_load_reporting_server_name().has_value()) {
+      // TODO(roth): We should pass the cluster name (in addition to the
+      // eds_service_name) when adding the client stats. To do so, we need to
+      // first find a way to plumb the cluster name down into this LB policy.
       xds_client()->AddClientStats(
-          StringView(config_->lrs_load_reporting_server_name()),
+          StringView(config_->lrs_load_reporting_server_name().value().c_str()),
           StringView(eds_service_name()), &client_stats_);
     }
   }
@@ -1083,7 +1098,7 @@ void XdsLb::PriorityList::MaybeCreateLocalityMapLocked(uint32_t priority) {
   // Exhausted priorities in the update.
   if (!priority_list_update().Contains(priority)) return;
   auto new_locality_map = new LocalityMap(
-      xds_policy_->Ref(DEBUG_LOCATION, "XdsLb+LocalityMap"), priority);
+      xds_policy_->Ref(DEBUG_LOCATION, "LocalityMap"), priority);
   priorities_.emplace_back(OrphanablePtr<LocalityMap>(new_locality_map));
   new_locality_map->UpdateLocked(*priority_list_update().Find(priority));
 }
@@ -1152,7 +1167,6 @@ XdsLb::PriorityList::LocalityMap::LocalityMap(RefCountedPtr<XdsLb> xds_policy,
     gpr_log(GPR_INFO, "[xdslb %p] Creating priority %" PRIu32,
             xds_policy_.get(), priority_);
   }
-
   GRPC_CLOSURE_INIT(&on_failover_timer_, OnFailoverTimer, this,
                     grpc_schedule_on_exec_ctx);
   // Start the failover timer.
@@ -1239,9 +1253,10 @@ void XdsLb::PriorityList::LocalityMap::UpdateXdsPickerLocked() {
     picker_list.push_back(std::make_pair(end, locality->picker_wrapper()));
   }
   xds_policy()->channel_control_helper()->UpdateState(
-      GRPC_CHANNEL_READY, MakeUnique<LocalityPicker>(
-                              xds_policy_->Ref(DEBUG_LOCATION, "XdsLb+Picker"),
-                              std::move(picker_list)));
+      GRPC_CHANNEL_READY,
+      grpc_core::MakeUnique<LocalityPicker>(
+          xds_policy_->Ref(DEBUG_LOCATION, "LocalityPicker"),
+          std::move(picker_list)));
 }
 
 OrphanablePtr<XdsLb::PriorityList::LocalityMap::Locality>
@@ -1869,11 +1884,15 @@ class XdsFactory : public LoadBalancingPolicyFactory {
       }
     }
     if (error_list.empty()) {
+      Optional<std::string> optional_lrs_load_reporting_server_name;
+      if (lrs_load_reporting_server_name != nullptr) {
+        optional_lrs_load_reporting_server_name.set(
+            std::string(lrs_load_reporting_server_name));
+      }
       return MakeRefCounted<ParsedXdsConfig>(
           std::move(child_policy), std::move(fallback_policy),
-          grpc_core::UniquePtr<char>(gpr_strdup(eds_service_name)),
-          grpc_core::UniquePtr<char>(
-              gpr_strdup(lrs_load_reporting_server_name)));
+          eds_service_name == nullptr ? "" : eds_service_name,
+          std::move(optional_lrs_load_reporting_server_name));
     } else {
       *error = GRPC_ERROR_CREATE_FROM_VECTOR("Xds Parser", &error_list);
       return nullptr;

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

@@ -30,6 +30,7 @@
 #include <address_sorting/address_sorting.h>
 
 #include "src/core/ext/filters/client_channel/http_connect_handshaker.h"
+#include "src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_balancer_addresses.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
 #include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h"
 #include "src/core/ext/filters/client_channel/resolver/dns/dns_resolver_selection.h"
@@ -107,8 +108,10 @@ class AresDnsResolver : public Resolver {
   grpc_millis last_resolution_timestamp_ = -1;
   /// retry backoff state
   BackOff backoff_;
-  /// currently resolving addresses
+  /// currently resolving backend addresses
   std::unique_ptr<ServerAddressList> addresses_;
+  /// currently resolving balancer addresses
+  std::unique_ptr<ServerAddressList> balancer_addresses_;
   /// currently resolving service config
   char* service_config_json_ = nullptr;
   // has shutdown been initiated
@@ -340,9 +343,11 @@ void AresDnsResolver::OnResolvedLocked(void* arg, grpc_error* error) {
     r->Unref(DEBUG_LOCATION, "OnResolvedLocked() shutdown");
     return;
   }
-  if (r->addresses_ != nullptr) {
+  if (r->addresses_ != nullptr || r->balancer_addresses_ != nullptr) {
     Result result;
-    result.addresses = std::move(*r->addresses_);
+    if (r->addresses_ != nullptr) {
+      result.addresses = std::move(*r->addresses_);
+    }
     if (r->service_config_json_ != nullptr) {
       char* service_config_string = ChooseServiceConfig(
           r->service_config_json_, &result.service_config_error);
@@ -356,9 +361,16 @@ void AresDnsResolver::OnResolvedLocked(void* arg, grpc_error* error) {
       }
       gpr_free(service_config_string);
     }
-    result.args = grpc_channel_args_copy(r->channel_args_);
+    InlinedVector<grpc_arg, 1> new_args;
+    if (r->balancer_addresses_ != nullptr) {
+      new_args.push_back(
+          CreateGrpclbBalancerAddressesArg(r->balancer_addresses_.get()));
+    }
+    result.args = grpc_channel_args_copy_and_add(
+        r->channel_args_, new_args.data(), new_args.size());
     r->result_handler()->ReturnResult(std::move(result));
     r->addresses_.reset();
+    r->balancer_addresses_.reset();
     // Reset backoff state so that we start from the beginning when the
     // next request gets triggered.
     r->backoff_.Reset();
@@ -437,7 +449,8 @@ void AresDnsResolver::StartResolvingLocked() {
   GRPC_CLOSURE_INIT(&on_resolved_, OnResolved, this, grpc_schedule_on_exec_ctx);
   pending_request_ = grpc_dns_lookup_ares_locked(
       dns_server_, name_to_resolve_, kDefaultPort, interested_parties_,
-      &on_resolved_, &addresses_, enable_srv_queries_ /* check_grpclb */,
+      &on_resolved_, &addresses_,
+      enable_srv_queries_ ? &balancer_addresses_ : nullptr,
       request_service_config_ ? &service_config_json_ : nullptr,
       query_timeout_ms_, combiner());
   last_resolution_timestamp_ = grpc_core::ExecCtx::Get()->Now();

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

@@ -33,6 +33,7 @@
 #include <grpc/support/time.h>
 
 #include <address_sorting/address_sorting.h>
+#include "src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_balancer_addresses.h"
 #include "src/core/ext/filters/client_channel/parse_address.h"
 #include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver.h"
 #include "src/core/lib/gpr/string.h"
@@ -60,6 +61,8 @@ struct grpc_ares_request {
   grpc_closure* on_done;
   /** the pointer to receive the resolved addresses */
   std::unique_ptr<grpc_core::ServerAddressList>* addresses_out;
+  /** the pointer to receive the resolved balancer addresses */
+  std::unique_ptr<grpc_core::ServerAddressList>* balancer_addresses_out;
   /** the pointer to receive the service config in JSON */
   char** service_config_json_out;
   /** the evernt driver used by this request */
@@ -184,17 +187,17 @@ static void on_hostbyname_done_locked(void* arg, int status, int /*timeouts*/,
     GRPC_CARES_TRACE_LOG(
         "request:%p on_hostbyname_done_locked host=%s ARES_SUCCESS", r,
         hr->host);
-    if (*r->addresses_out == nullptr) {
-      *r->addresses_out = grpc_core::MakeUnique<ServerAddressList>();
+    std::unique_ptr<ServerAddressList>* address_list_ptr =
+        hr->is_balancer ? r->balancer_addresses_out : r->addresses_out;
+    if (*address_list_ptr == nullptr) {
+      *address_list_ptr = grpc_core::MakeUnique<ServerAddressList>();
     }
-    ServerAddressList& addresses = **r->addresses_out;
+    ServerAddressList& addresses = **address_list_ptr;
     for (size_t i = 0; hostent->h_addr_list[i] != nullptr; ++i) {
-      grpc_core::InlinedVector<grpc_arg, 2> args_to_add;
+      grpc_core::InlinedVector<grpc_arg, 1> args_to_add;
       if (hr->is_balancer) {
-        args_to_add.emplace_back(grpc_channel_arg_integer_create(
-            const_cast<char*>(GRPC_ARG_ADDRESS_IS_BALANCER), 1));
-        args_to_add.emplace_back(grpc_channel_arg_string_create(
-            const_cast<char*>(GRPC_ARG_ADDRESS_BALANCER_NAME), hr->host));
+        args_to_add.emplace_back(
+            grpc_core::CreateGrpclbBalancerNameArg(hr->host));
       }
       grpc_channel_args* args = grpc_channel_args_copy_and_add(
           nullptr, args_to_add.data(), args_to_add.size());
@@ -350,7 +353,7 @@ done:
 void grpc_dns_lookup_ares_continue_after_check_localhost_and_ip_literals_locked(
     grpc_ares_request* r, const char* dns_server, const char* name,
     const char* default_port, grpc_pollset_set* interested_parties,
-    bool check_grpclb, int query_timeout_ms, grpc_core::Combiner* combiner) {
+    int query_timeout_ms, grpc_core::Combiner* combiner) {
   grpc_error* error = GRPC_ERROR_NONE;
   grpc_ares_hostbyname_request* hr = nullptr;
   ares_channel* channel = nullptr;
@@ -425,7 +428,7 @@ void grpc_dns_lookup_ares_continue_after_check_localhost_and_ip_literals_locked(
                                        /*is_balancer=*/false);
   ares_gethostbyname(*channel, hr->host, AF_INET, on_hostbyname_done_locked,
                      hr);
-  if (check_grpclb) {
+  if (r->balancer_addresses_out != nullptr) {
     /* Query the SRV record */
     grpc_ares_request_ref_locked(r);
     char* service_name;
@@ -588,7 +591,8 @@ static bool grpc_ares_maybe_resolve_localhost_manually_locked(
 static grpc_ares_request* grpc_dns_lookup_ares_locked_impl(
     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>* addrs, bool check_grpclb,
+    std::unique_ptr<grpc_core::ServerAddressList>* addrs,
+    std::unique_ptr<grpc_core::ServerAddressList>* balancer_addrs,
     char** service_config_json, int query_timeout_ms,
     grpc_core::Combiner* combiner) {
   grpc_ares_request* r =
@@ -596,6 +600,7 @@ static grpc_ares_request* grpc_dns_lookup_ares_locked_impl(
   r->ev_driver = nullptr;
   r->on_done = on_done;
   r->addresses_out = addrs;
+  r->balancer_addresses_out = balancer_addrs;
   r->service_config_json_out = service_config_json;
   r->error = GRPC_ERROR_NONE;
   r->pending_queries = 0;
@@ -618,20 +623,21 @@ static grpc_ares_request* grpc_dns_lookup_ares_locked_impl(
   // as to cut down on lookups over the network, especially in tests:
   // https://github.com/grpc/proposal/pull/79
   if (target_matches_localhost(name)) {
-    check_grpclb = false;
+    r->balancer_addresses_out = nullptr;
     r->service_config_json_out = nullptr;
   }
   // Look up name using c-ares lib.
   grpc_dns_lookup_ares_continue_after_check_localhost_and_ip_literals_locked(
-      r, dns_server, name, default_port, interested_parties, check_grpclb,
-      query_timeout_ms, combiner);
+      r, dns_server, name, default_port, interested_parties, query_timeout_ms,
+      combiner);
   return r;
 }
 
 grpc_ares_request* (*grpc_dns_lookup_ares_locked)(
     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>* addrs, bool check_grpclb,
+    std::unique_ptr<grpc_core::ServerAddressList>* addrs,
+    std::unique_ptr<grpc_core::ServerAddressList>* balancer_addrs,
     char** service_config_json, int query_timeout_ms,
     grpc_core::Combiner* combiner) = grpc_dns_lookup_ares_locked_impl;
 
@@ -709,7 +715,6 @@ static void on_dns_lookup_done_locked(void* arg, grpc_error* error) {
         static_cast<grpc_resolved_address*>(gpr_zalloc(
             sizeof(grpc_resolved_address) * (*resolved_addresses)->naddrs));
     for (size_t i = 0; i < (*resolved_addresses)->naddrs; ++i) {
-      GPR_ASSERT(!(*r->addresses)[i].IsBalancer());
       memcpy(&(*resolved_addresses)->addrs[i], &(*r->addresses)[i].address(),
              sizeof(grpc_resolved_address));
     }
@@ -736,9 +741,9 @@ static void grpc_resolve_address_invoke_dns_lookup_ares_locked(
                     grpc_schedule_on_exec_ctx);
   r->ares_request = grpc_dns_lookup_ares_locked(
       nullptr /* dns_server */, r->name, r->default_port, r->interested_parties,
-      &r->on_dns_lookup_done_locked, &r->addresses, false /* check_grpclb */,
-      nullptr /* service_config_json */, GRPC_DNS_ARES_DEFAULT_QUERY_TIMEOUT_MS,
-      r->combiner);
+      &r->on_dns_lookup_done_locked, &r->addresses,
+      nullptr /* balancer_addresses */, nullptr /* service_config_json */,
+      GRPC_DNS_ARES_DEFAULT_QUERY_TIMEOUT_MS, r->combiner);
 }
 
 static void grpc_resolve_address_ares_impl(const char* name,